సర్టిఫికేట్ల చెల్లుబాటును పర్యవేక్షించడం Windows NetXMSలో

ఇటీవల మేము సర్వర్‌లలోని సర్టిఫికేట్‌ల చెల్లుబాటు వ్యవధిని పర్యవేక్షించే పనిని ఎదుర్కొన్నాము. Windowsసరే, సర్టిఫికెట్లు పదేపదే గుమ్మడికాయలుగా మారిపోతుండటంతో నేను నిద్రలేచాను, సరిగ్గా వాటి పునరుద్ధరణలకు బాధ్యత వహించే గడ్డం ఉన్న సహోద్యోగి సెలవులో ఉన్నప్పుడే ఇది జరిగింది. ఆ తర్వాత, నాకూ అతనికీ అనుమానం వచ్చి, దాని గురించి ఆలోచించాలని నిర్ణయించుకున్నాము. మేము నెమ్మదిగా NetXMS పర్యవేక్షణ వ్యవస్థను అమలు చేస్తున్నందున, ఈ పనికి అదే ప్రాథమిక మరియు, తప్పనిసరిగా, ఏకైక ఎంపికగా మారింది.

ఫలితం చివరకు క్రింది రూపంలో పొందబడింది:

మరియు ప్రక్రియ కూడా కొనసాగుతుంది.

మనం ప్రారంభిద్దాం. NetXMSలో అంతర్నిర్మిత సర్టిఫికేట్ గడువు ముగింపు కౌంటర్ లేదు, కాబట్టి మీరు మీ స్వంతంగా ఒకదాన్ని సృష్టించుకుని, దానికి డేటాను అందించడానికి స్క్రిప్ట్‌లను ఉపయోగించాల్సి ఉంటుంది. వాస్తవానికి, పవర్‌షెల్‌లో కూడా ఇదే పద్ధతి. Windowsస్క్రిప్ట్ ఆపరేటింగ్ సిస్టమ్‌లోని అన్ని సర్టిఫికేట్‌లను చదివి, వాటి గడువు తేదీని రోజులలో తీసుకొని, ఆ సంఖ్యను దాని ఏజెంట్ ద్వారా NetXMSకు పంపాలి. మనం అక్కడి నుంచే ప్రారంభిద్దాం.

ఎంపిక ఒకటి, సరళమైనది. కేవలం సమీప తేదీతో సర్టిఫికేట్ గడువు తేదీ వరకు రోజుల సంఖ్యను పొందండి.

NetXMS సర్వర్ మా అనుకూల పారామీటర్ ఉనికి గురించి తెలుసుకోవాలంటే, అది తప్పనిసరిగా ఏజెంట్ నుండి అందుకోవాలి. లేకపోతే, ఈ పరామితి లేకపోవడం వల్ల జోడించబడదు. కాబట్టి, ఏజెంట్ కాన్ఫిగరేషన్ ఫైల్‌లో nxagend.conf మేము అనే బాహ్య పారామితి స్ట్రింగ్‌ని జోడిస్తాము HTTPS.సర్టిఫికేట్ గడువు ముగిసిన తేదీ సింపుల్, దీనిలో మేము స్క్రిప్ట్ యొక్క ప్రారంభాన్ని నమోదు చేస్తాము:

ExternalParameter = HTTPS.CertificateExpireDateSimple: powershell.exe -File "servershareNetXMS_CertExpireDateSimple.ps1"

స్క్రిప్ట్ నెట్‌వర్క్‌లో ప్రారంభించబడిందని పరిగణనలోకి తీసుకుంటే, మీరు దాని గురించి గుర్తుంచుకోవాలి అమలు విధానం, మరియు ఇతర “-NoLogo -NoProfile -NonInteractive”ని కూడా మర్చిపోవద్దు, మెరుగైన కోడ్ రీడబిలిటీ కోసం నేను విస్మరించాను.

ఫలితంగా, ఏజెంట్ కాన్ఫిగరేషన్ ఇలా కనిపిస్తుంది:

#
# NetXMS agent configuration file
# Created by agent installer at Thu Jun 13 11:24:43 2019
#
 
MasterServers = netxms.corp.testcompany.ru
ConfigIncludeDir = C:NetXMSetcnxagentd.conf.d
LogFile = {syslog}
FileStore = C:NetXMSvar
SubAgent = ecs.nsm
SubAgent = filemgr.nsm
SubAgent = ping.nsm
SubAgent = logwatch.nsm
SubAgent = portcheck.nsm
SubAgent = winperf.nsm
SubAgent = wmi.nsm
 
ExternalParameter = HTTPS.CertificateExpireDateSimple: powershell.exe -File "servershareNetXMS_CertExpireDateSimple.ps1"

దీని తరువాత, మీరు కాన్ఫిగరేషన్‌ను సేవ్ చేసి, ఏజెంట్‌ను పునఃప్రారంభించాలి. మీరు దీన్ని NetXMS కన్సోల్ నుండి చేయవచ్చు: కాన్ఫిగరేషన్ తెరవండి (ఏజెంట్ యొక్క కాన్ఫిగరేషన్ ఫైల్‌ని సవరించండి), దాన్ని సవరించండి, సేవ్&వర్తింపజేయండి, దీని ఫలితంగా, వాస్తవానికి అదే జరుగుతుంది. మీకు వేచి ఉండే శక్తి లేకుంటే, కాన్ఫిగరేషన్ (పోల్ > కాన్ఫిగరేషన్)ని మళ్లీ చదవండి. ఈ దశల తర్వాత, మీరు మా అనుకూల పరామితిని జోడించగలరు.

NetXMS కన్సోల్‌లో వెళ్ళండి డేటా సేకరణ కాన్ఫిగరేషన్ మేము సర్టిఫికేట్‌లను పర్యవేక్షించబోతున్న ప్రయోగాత్మక సర్వర్ మరియు అక్కడ కొత్త పరామితిని సృష్టించబోతున్నాము (భవిష్యత్తులో, కాన్ఫిగరేషన్ తర్వాత, దానిని టెంప్లేట్‌లకు బదిలీ చేయడం అర్ధమే). జాబితా నుండి HTTPS.CertificateExpireDateSimpleని ఎంచుకోండి, స్పష్టమైన పేరుతో వివరణను నమోదు చేయండి, రకాన్ని పూర్ణాంకానికి సెట్ చేయండి మరియు పోలింగ్ విరామాన్ని కాన్ఫిగర్ చేయండి. డీబగ్గింగ్ ప్రయోజనాల కోసం, ఉదాహరణకు, 30 సెకన్లు తక్కువగా చేయడానికి ఇది అర్ధమే. అంతా సిద్ధంగా ఉంది, ప్రస్తుతానికి ఇది సరిపోతుంది.

మీరు తనిఖీ చేయవచ్చు... లేదు, ఇది చాలా తొందరగా ఉంది. ఇప్పుడు, వాస్తవానికి, మేము ఏమీ పొందలేము. ఎందుకంటే స్క్రిప్ట్ ఇంకా రాయలేదు. ఈ లోపాన్ని సరిచేద్దాం. స్క్రిప్ట్ కేవలం సంఖ్యను ప్రదర్శిస్తుంది, సర్టిఫికేట్ గడువు ముగిసే వరకు ఎన్ని రోజులు మిగిలి ఉన్నాయి. అందుబాటులో ఉన్న అన్నింటిలో అతి తక్కువ. ఉదాహరణ స్క్రిప్ట్:

try {
    # Получаем все сертификаты из хранилища сертификатов
    $lmCertificates = @( Get-ChildItem -Recurse -path 'Cert:LocalMachineMy' -ErrorAction Stop )
     
    # Если сертификатов нет, вернуть "10 лет"
    if ($lmCertificates.Count -eq 0) { return 3650 }
 
    # Получаем Expiration Date всех сертификатов
    $expirationDates = @( $lmCertificates | ForEach-Object { return $_.NotAfter } )
 
    # Получаем наиболее близкий Expiration Date из всех
    $minExpirationDate = ($expirationDates | Measure-Object -Minimum -ErrorAction Stop ).Minimum
 
    # Конвертируем наиболее близкий Expiration Date в количество оставшихся дней с округлением в меньшую сторону
    $daysLeft = [Math]::Floor( ($minExpirationDate - [DateTime]::Now).TotalDays )
 
    # Возвращаем значение
    return $daysLeft
}
catch {
    return -1
}

ఇది ఇలా మారుతుంది:

723 రోజులు, సర్టిఫికేట్ గడువు ముగియడానికి దాదాపు రెండు సంవత్సరాలు మిగిలి ఉన్నాయి. ఇది లాజికల్‌గా ఉంది, ఎందుకంటే నేను ఇటీవలే ఎక్స్ఛేంజ్ టెస్ట్ బెంచ్ కోసం సర్టిఫికెట్‌లను మళ్లీ జారీ చేసాను.

ఇది సులభమైన ఎంపిక. బహుశా, ఎవరైనా దీనితో సంతృప్తి చెందుతారు, కానీ మేము మరింత కోరుకుంటున్నాము. మేము సర్వర్‌లోని అన్ని సర్టిఫికేట్‌ల జాబితాను, పేరు ద్వారా పొందడం మరియు ప్రతి ఒక్కరికి సర్టిఫికేట్ గడువు ముగిసే వరకు ఎన్ని రోజులు మిగిలి ఉన్నాయో చూసే పనిని సెట్ చేసుకున్నాము.

రెండవ ఎంపిక, కొంత క్లిష్టంగా ఉంటుంది.

మళ్ళీ మేము ఏజెంట్ కాన్ఫిగరేషన్‌ని సవరించాము మరియు అక్కడ, ExternalParameterతో లైన్‌కు బదులుగా, మేము మరో రెండింటిని వ్రాస్తాము:

ExternalList = HTTPS.CertificateNames: powershell.exe -File "serversharenetxms_CertExternalNames.ps1"
ExternalParameter = HTTPS.CertificateExpireDate(*): powershell.exe -File "serversharenetxms_CertExternalParameter.ps1" -CertificateId "$1"

В బాహ్య జాబితా మేము తీగల జాబితాను పొందుతాము. మా విషయంలో, సర్టిఫికేట్ పేర్లతో స్ట్రింగ్‌ల జాబితా. మేము స్క్రిప్ట్‌ని ఉపయోగించి ఈ లైన్‌ల జాబితాను అందుకుంటాము. జాబితా పేరు - HTTPS.సర్టిఫికేట్ పేర్లు.

స్క్రిప్ట్ NetXMS_CertNames.ps1:

#Список возможных имен сертификатов
$nameTypeList = @(
        [System.Security.Cryptography.X509Certificates.X509NameType]::SimpleName,
        [System.Security.Cryptography.X509Certificates.X509NameType]::DnsName,
        [System.Security.Cryptography.X509Certificates.X509NameType]::DnsFromAlternativeName,
        [System.Security.Cryptography.X509Certificates.X509NameType]::UrlName,
        [System.Security.Cryptography.X509Certificates.X509NameType]::EmailName,
        [System.Security.Cryptography.X509Certificates.X509NameType]::UpnName
)
 
#Ищем все сертификаты, имеющие закрытый ключ
$certList = @( Get-ChildItem -Path 'Cert:LocalMachineMy' | Where-Object { $_.HasPrivateKey -eq $true } )
 
#Проходим по списку сертификатов, формируем строку "Имя сертификата - Дата - Thumbprint" и возвращаем её
foreach ($cert in $certList) {
    $name = '(unknown name)'
    try {
        $thumbprint = $cert.Thumbprint
        $dateExpire = $cert.NotAfter
        foreach ($nameType in $nameTypeList) {
            $name_temp = $cert.GetNameInfo( $nameType, $false)
            if ($name_temp -ne $null -and $name_temp -ne '') {
                $name = $name_temp;
                break;
            }
        }
        Write-Output "$($name) - $($dateExpire.ToString('dd.MM.yyyy')) - [T:$($thumbprint)]"
    }
    catch {
        Write-Error -Message "Error processing certificate list: $($_.Exception.Message)"
    }
}

మరియు ఇప్పటికే బాహ్య పరామితి మేము ఎక్స్‌టర్నల్‌లిస్ట్ జాబితా నుండి వరుసలను ఇన్‌పుట్ చేస్తాము మరియు అవుట్‌పుట్‌లో ప్రతిదానికి ఒకే సంఖ్యలో రోజులను పొందుతాము. ఐడెంటిఫైయర్ అనేది సర్టిఫికేట్ యొక్క థంబ్ ప్రింట్. HTTPS.CertificateExpireDate ఈ వేరియంట్‌లో నక్షత్రం (*)ని కలిగి ఉందని గమనించండి. ఇది మా సర్టిఫికేట్ ఐడిని మాత్రమే, బాహ్య వేరియబుల్స్‌ని ఆమోదించడానికి ఇది అవసరం.

స్క్రిప్ట్ NetXMS_CertExpireDate.ps1:

#Определяем входящий параметр $CertificateId
param (
    [Parameter(Mandatory=$false)]
    [String]$CertificateId
)
 
#Проверка на существование
if ($CertificateId -eq $null) {
    Write-Error -Message "CertificateID parameter is required!"
    return
}
 
#По Thumbprint из строки в $CertificateId ищем сертификат и определяем его Expiration Date 
$certId = $CertificateId;
try {
    if ($certId -match '^.*[T:(?<Thumbprint>[A-Z0-9]+)]$') {
        $thumbprint = $Matches['Thumbprint']
        $certificatePath = "Cert:LocalMachineMy$($thumbprint)"
         
        if (Test-Path -PathType Leaf -Path $certificatePath ) {
            $certificate = Get-Item -Path $certificatePath;
            $certificateExpirationDate = $certificate.NotAfter
            $certificateDayToLive = [Math]::Floor( ($certificateExpirationDate - [DateTime]::Now).TotalDays )
            Write-Output "$($certificateDayToLive)";
        }
        else {
            Write-Error -Message "No certificate matching this thumbprint found on this server $($certId)"
        }
    }
    else {
        Write-Error -Message "CertificateID provided in wrong format. Must be FriendlyName [T:<thumbprint>]"
    }
}
catch {
    Write-Error -Message "Error while executing script: $($_.Exception.Message)"
}

సర్వర్ యొక్క డేటా కలెక్షన్ కాన్ఫిగరేషన్‌లో, మేము కొత్త పరామితిని సృష్టిస్తాము. పరామితిలో మనము ఎంచుకుంటాము HTTPS.సర్టిఫికెట్ గడువు తేదీ(*) జాబితా నుండి, మరియు (శ్రద్ధ!) నక్షత్రాన్ని మార్చండి {instance}. ఈ ముఖ్యమైన అంశం ప్రతి ఉదాహరణ (సర్టిఫికేట్) కోసం ప్రత్యేక కౌంటర్‌ని సృష్టించడానికి మిమ్మల్ని అనుమతిస్తుంది. మిగిలినవి మునుపటి సంస్కరణలో వలె పూరించబడ్డాయి:

ఏదైనా కౌంటర్‌లను సృష్టించడానికి, ఇన్‌స్టాన్స్ డిస్కవరీ ట్యాబ్‌లో మీరు జాబితా నుండి ఏజెంట్ జాబితాను ఎంచుకోవాలి మరియు జాబితా పేరు ఫీల్డ్‌లో స్క్రిప్ట్ నుండి మా బాహ్య జాబితా పేరును నమోదు చేయాలి - HTTPS.CertificateNames.

దాదాపు సిద్ధంగా ఉంది, వేచి ఉండటం పూర్తిగా అసాధ్యమైతే కొంచెం వేచి ఉండండి లేదా పోల్ > కాన్ఫిగరేషన్ మరియు పోల్ > ఇన్‌స్టాన్స్ డిస్కవరీని బలవంతం చేయండి. ఫలితంగా, మేము మా అన్ని సర్టిఫికేట్‌లను చెల్లుబాటు వ్యవధితో పొందుతాము:

మీకు ఏమి కావాలి? సరే, అవును, పరిపూర్ణత అనే పురుగు మాత్రమే కౌంటర్ పేరుతో ఈ అనవసరమైన బొటనవేలు ముద్రను విచారకరమైన కళ్ళతో చూస్తుంది మరియు కథనాన్ని పూర్తి చేయడానికి నన్ను అనుమతించదు. దీన్ని ఫీడ్ చేయడానికి, కౌంటర్ ప్రాపర్టీలను మళ్లీ తెరవండి మరియు ఇన్‌స్టాన్స్ డిస్కవరీ ట్యాబ్‌లో, “ఇన్‌స్టాన్స్ డిస్కవరీ ఫిల్టర్ స్క్రిప్ట్” ఫీల్డ్‌లో, వ్రాయబడిన దాన్ని జోడించండి NXSL (NetXMS అంతర్గత భాష) స్క్రిప్ట్:

instance = $1;
 if (instance ~= "^(.*)s-s[T:[a-zA-Z0-9]+]$")
 {
 return %(true, instance, $1);
 }
 return true;

ఇది థంబ్‌ప్రింట్‌ను ఫిల్టర్ చేస్తుంది:

మరియు దానిని ఫిల్టర్ చేసి ప్రదర్శించడానికి, వివరణ ఫీల్డ్‌లోని జనరల్ ట్యాబ్‌లో, CertificateExpireDate: {instance}కి మార్చండి CertificateExpireDate: {instance-name}:

అంతే, చివరకు KDPV నుండి ముగింపు రేఖ:

అందం కాదా?

సర్టిఫికేట్ గడువు ముగిసినప్పుడు అవి ఇమెయిల్ ద్వారా వచ్చేలా హెచ్చరికలను సెటప్ చేయడం మాత్రమే మిగిలి ఉంది.

1. ముందుగా మనం సెట్ చేసిన కొంత థ్రెషోల్డ్‌కి కౌంటర్ విలువ తగ్గినప్పుడు దాన్ని యాక్టివేట్ చేయడానికి ఈవెంట్ టెంప్లేట్‌ను సృష్టించాలి. IN ఈవెంట్ కాన్ఫిగరేషన్ వంటి పేర్లతో రెండు కొత్త టెంప్లేట్‌లను రూపొందిద్దాం CertificateExpireDate_Threshold_Activate హెచ్చరిక స్థితితో:

మరియు ఇలాంటివి CertificateExpireDate_Threshold_Deactivate సాధారణ స్థితితో.

2. తర్వాత, కౌంటర్ ప్రాపర్టీలకు వెళ్లి, ట్రెషోల్డ్స్ ట్యాబ్‌లో థ్రెషోల్డ్‌ని సెట్ చేయండి:

మేము సృష్టించిన ఈవెంట్‌లను ఎంచుకునే చోట CertificateExpireDate_Threshold_Activate మరియు CertificateExpireDate_Threshold_Deactivate, నమూనాల సంఖ్యను (నమూనాలు) 1కి సెట్ చేయండి (ప్రత్యేకంగా ఈ కౌంటర్‌కు ఎక్కువ సెట్ చేయడంలో అర్థం లేదు), విలువ 30 (రోజులు), ఉదాహరణకు, ఏది ముఖ్యమైనది , మేము ఈవెంట్ పునరావృత సమయాన్ని సెట్ చేసాము. ఉత్పత్తిలో సర్టిఫికేట్‌ల కోసం, నేను దానిని రోజుకు ఒకసారి (86400 సెకన్లు) సెట్ చేసాను, లేకపోతే మీరు నోటిఫికేషన్‌లలో మునిగిపోవచ్చు (ఇది ఒకసారి జరిగింది, వారాంతంలో మెయిల్‌బాక్స్ నిండిపోయింది). డీబగ్గింగ్ సమయం కోసం, ఉదాహరణకు, 60 సెకన్లు తక్కువగా సెట్ చేయడం అర్ధమే.

3. యాక్షన్ కాన్ఫిగరేషన్ నోటిఫికేషన్ లెటర్ టెంప్లేట్‌ను ఇలా సృష్టించండి:

ఇవన్నీ %m, %S మొదలైనవి. - మా పరామితి నుండి విలువలు భర్తీ చేయబడే మాక్రోలు. అవి లో మరింత వివరంగా వివరించబడ్డాయి మాన్యువల్ NetXMS.

4. చివరకు, మునుపటి పాయింట్లను కలపడం ఈవెంట్ ప్రాసెసింగ్ విధానం అలారం సృష్టించబడే నియమాన్ని రూపొందించండి మరియు ఒక లేఖ పంపబడుతుంది:

మేము విధానాన్ని సేవ్ చేస్తాము, ప్రతిదీ పరీక్షించవచ్చు. తనిఖీ చేయడానికి థ్రెషోల్డ్‌ని ఎక్కువగా సెట్ చేద్దాం. నా సమీప సర్టిఫికెట్ గడువు 723 రోజుల్లో ముగుస్తుంది, నేను దాన్ని తనిఖీ చేయడానికి 724కి సెట్ చేసాను. ఫలితంగా, మేము ఈ క్రింది అలారం పొందుతాము:

మరియు ఈ ఇమెయిల్ నోటిఫికేషన్:

ఇప్పుడు ఖచ్చితంగా అంతే. వాస్తవానికి, డ్యాష్‌బోర్డ్‌ను సెటప్ చేయడం మరియు గ్రాఫ్‌లను రూపొందించడం సాధ్యమవుతుంది, అయితే సర్టిఫికేట్‌ల కోసం ఇవి కొంతవరకు అర్థరహితంగా మరియు బోరింగ్ సరళరేఖలుగా ఉంటాయి, ఉదాహరణకు ప్రాసెసర్ లేదా మెమరీ లోడ్ యొక్క గ్రాఫ్‌ల వలె కాకుండా. కానీ, దీని గురించి మరికొంత సమయం.

మూలం: www.habr.com