Windows DHCP Server - otrzymuj powiadomienie, gdy urządzenie inne niż AD otrzyma adres IP

SCENARIUSZ

Aby uprościć to do najłatwiejszego przykładu:

Mam standardowy kontroler domeny Windows 2008 R2 z rolą serwera DHCP. Rozdaje adresy IP za pomocą różnych zakresów IPv4, nie ma problemu.

CO CHCĘ

Chciałbym utworzyć sposób na powiadomienie / wpis w dzienniku zdarzeń / podobny, ilekroć urządzenie uzyska dzierżawę adresu DHCP, a NIE JEST to komputer przyłączony do domeny w usłudze Active Directory. Nie ma dla mnie znaczenia, czy jest to niestandardowy PowerShell itp.

Konkluzja = Chciałbym wiedzieć, kiedy urządzenia niebędące domenami są w sieci bez korzystania z 802.1X w tej chwili. Wiem, że to nie będzie uwzględniać statycznych urządzeń IP. Mam oprogramowanie monitorujące, które skanuje sieć i wyszukuje urządzenia, ale nie jest to tak szczegółowe.

WYKONANE BADANIA / ROZWAŻONE OPCJE

Nie widzę takich możliwości z wbudowanym logowaniem.

Tak, znam standard 802.1X i mam możliwość jego długoterminowej implementacji w tym miejscu, ale jesteśmy trochę wolni od takiego projektu, i choć rozwiązałoby to problemy z uwierzytelnianiem sieci, nadal jest to pomocne dla mnie na zewnątrz celów 802.1X.

Rozejrzałem się za bitami skryptu itp., Które mogą okazać się przydatne, ale rzeczy, które znajduję, doprowadziły mnie do przekonania, że ​​moje google-fu zawiodło mnie w tej chwili.

Uważam, że poniższa logika jest rozsądna ( zakładając, że nie istnieje jakieś istniejące rozwiązanie ):

1. Urządzenie otrzymuje adres DHCP
2. Zapis dziennika zdarzeń jest rejestrowany (identyfikator zdarzenia 10 w dzienniku kontroli DHCP powinien działać (ponieważ najbardziej interesuje mnie nowa dzierżawa, a nie odnawianie): http://technet.microsoft.com/en-us/library /dd759178.aspx )
3. W tym momencie pewien skrypt prawdopodobnie musiałby przejąć pozostałe „KROKI” poniżej.
4. W jakiś sposób przeszukuj ten dziennik DHCP w poszukiwaniu tych zdarzeń o identyfikatorze 10 (chciałbym wypchnąć, ale zgaduję, że jedynym rozwiązaniem jest ściągnięcie)
5. Przeanalizuj zapytanie o nazwę urządzenia, któremu przypisano nową dzierżawę
6. Zapytanie AD o nazwę urządzenia
7. JEŻELI nie znaleziono w AD, wyślij wiadomość e-mail z powiadomieniem

Jeśli ktoś ma jakieś pomysły, jak właściwie to zrobić, bardzo bym to docenił. Nie szukam „daj mi kod”, ale chciałbym wiedzieć, czy istnieją alternatywy dla powyższej listy lub czy nie myślę jasno i istnieje inna metoda gromadzenia tych informacji. Jeśli masz fragmenty kodu / polecenia PS, które chcesz udostępnić, aby to osiągnąć, tym lepiej.

Z podziękowaniami dla ErikE i innych tutaj, poszedłem ścieżką ... Nie powiem, że to właściwa ścieżka, ale skrypt Powershell, który wymyśliłem, załatwia sprawę.

Kod jest poniżej, jeśli ktoś tego chce. Wystarczy uruchomić go ręcznie, wskazując na każdy serwer DHCP lub zaplanować (ponownie wskazując każdy serwer DHCP w skrypcie).

Co robi skrypt:

1. Pobiera informacje o dzierżawie z serwera DHCP (dzierżawa ipv4)
2. Wysyła dzierżawy do pliku csv
3. Odczytuje z powrotem w tym pliku CSV do zapytania AD
4. Zapytania AD dotyczące komputera
5. Jeśli nie znaleziono, wyświetla dane wyjściowe w nowym pliku txt
6. Tworzy unikalny końcowy plik txt z pliku utworzonego w punkcie 5 powyżej (ponieważ mogą wystąpić duplikaty, jeśli klient zarejestruje się więcej niż raz lub z więcej niż jednym adapterem)
7. przesyła zawartość końcową pliku wyjściowego do administratora

Co będziesz potrzebował:

Skrypt korzysta z modułu AD ( import-module activedirectory), więc najlepiej jest go uruchomić na AD DC z DHCP. Jeśli tak nie jest, możesz zainstalować moduł AD PowerShell: http://blogs.msdn.com/b/rkramesh/archive/2012/01/17/how-to-add-active-directory- module-in-powershell-in-windows-7.aspx

Będziesz także potrzebować poleceń cmdlet Powershell AD, które można znaleźć tutaj: http://www.quest.com/powershell/activeroles-server.aspx . Zainstaluj TE PRZED uruchomieniem skryptu, inaczej się nie powiedzie.

Sam skrypt (zdezynfekowany, musisz skonfigurować niektóre zmienne, aby dostosować je do swoich potrzeb, takie jak nazwy plików wejściowych, domena, z którą chcesz się połączyć, serwer dhcp, z którym chcesz się połączyć, ustawienia poczty e-mail pod koniec itp.):

# Get-nonADclientsOnDHCP.ps1

# Author : TheCleaner http://serverfault.com/users/7861/thecleaner with a big thanks for a lot of the lease grab code to Assaf Miron on code.google.com

# Description : This Script grabs the current leases on a Windows DHCP server, outputs it to a csv
# then takes that csv file as input and determines if the lease is from a non-AD joined computer.  It then emails
# an administrator notification.  Set it up on a schedule of your choosing in Task Scheduler.
# This helps non-802.1X shops keep track of rogue DHCP clients that aren't part of the domain.

#

# Input : leaselog.csv

# Output: Lease log = leaselog.csv
# Output: Rogue Clients with dupes = RogueClients.txt
# Output: Rogue Clients - unique = RogueClientsFinal.txt

$DHCP_SERVER = "PUT YOUR SERVER NAME OR IP HERE" # The DHCP Server Name

$LOG_FOLDER = "C:\DHCP" # A Folder to save all the Logs

# Create Log File Paths

$LeaseLog = $LOG_FOLDER+"\LeaseLog.csv"

#region Create Scope Object

# Create a New Object

$Scope = New-Object psobject

# Add new members to the Object

$Scope | Add-Member noteproperty "Address" ""

$Scope | Add-Member noteproperty "Mask" ""

$Scope | Add-Member noteproperty "State" ""

$Scope | Add-Member noteproperty "Name" ""

$Scope | Add-Member noteproperty "LeaseDuration" ""

# Create Each Member in the Object as an Array

$Scope.Address = @()

$Scope.Mask = @()

$Scope.State = @()

$Scope.Name = @()

$Scope.LeaseDuration = @()

#endregion


#region Create Lease Object

# Create a New Object

$LeaseClients = New-Object psObject

# Add new members to the Object

$LeaseClients | Add-Member noteproperty "IP" ""

$LeaseClients | Add-Member noteproperty "Name" ""

$LeaseClients | Add-Member noteproperty "Mask" ""

$LeaseClients | Add-Member noteproperty "MAC" ""

$LeaseClients | Add-Member noteproperty "Expires" ""

$LeaseClients | Add-Member noteproperty "Type" ""

# Create Each Member in the Object as an Array

$LeaseClients.IP = @()

$LeaseClients.Name = @()

$LeaseClients.MAC = @()

$LeaseClients.Mask = @()

$LeaseClients.Expires = @()

$LeaseClients.Type = @()

#endregion


#region Create Reserved Object

# Create a New Object

$LeaseReserved = New-Object psObject

# Add new members to the Object

$LeaseReserved | Add-Member noteproperty "IP" ""

$LeaseReserved | Add-Member noteproperty "MAC" ""

# Create Each Member in the Object as an Array

$LeaseReserved.IP = @()

$LeaseReserved.MAC = @()

#endregion


#region Define Commands

#Commad to Connect to DHCP Server

$NetCommand = "netsh dhcp server \\$DHCP_SERVER"

#Command to get all Scope details on the Server

$ShowScopes = "$NetCommand show scope"

#endregion


function Get-LeaseType( $LeaseType )

{

# Input : The Lease type in one Char

# Output : The Lease type description

# Description : This function translates a Lease type Char to it's relevant Description


Switch($LeaseType){

"N" { return "None" }

"D" { return "DHCP" }

"B" { return "BOOTP" }

"U" { return "UNSPECIFIED" }

"R" { return "RESERVATION IP" }

}

}


function Check-Empty( $Object ){

# Input : An Object with values.

# Output : A Trimmed String of the Object or '-' if it's Null.

# Description : Check the object if its null or not and return it's value.

If($Object -eq $null)

{

return "-"

}

else

{

return $Object.ToString().Trim()

}

}


function out-CSV ( $LogFile, $Append = $false) {

# Input : An Object with values, Boolean value if to append the file or not, a File path to a Log File

# Output : Export of the object values to a CSV File

# Description : This Function Exports all the Values and Headers of an object to a CSV File.

#  The Object is recieved with the Input Const (Used with Pipelineing) or the $inputObject

Foreach ($item in $input){

# Get all the Object Properties

$Properties = $item.PsObject.get_properties()

# Create Empty Strings - Start Fresh

$Headers = ""

$Values = ""

# Go over each Property and get it's Name and value

$Properties | %{ 

$Headers += $_.Name + ","

$Values += $_.Value

}

# Output the Object Values and Headers to the Log file

If($Append -and (Test-Path $LogFile)) {

$Values | Out-File -Append -FilePath $LogFile -Encoding Unicode

}

else {

# Used to mark it as an Powershell Custum object - you can Import it later and use it

# "#TYPE System.Management.Automation.PSCustomObject" | Out-File -FilePath $LogFile

$Headers | Out-File -FilePath $LogFile -Encoding Unicode

$Values | Out-File -Append -FilePath $LogFile -Encoding Unicode

}

}

}


#region Get all Scopes in the Server 

# Run the Command in the Show Scopes var

$AllScopes = Invoke-Expression $ShowScopes

# Go over all the Results, start from index 5 and finish in last index -3

for($i=5;$i -lt $AllScopes.Length-3;$i++)

{

# Split the line and get the strings

$line = $AllScopes[$i].Split("-")

$Scope.Address += Check-Empty $line[0]

$Scope.Mask += Check-Empty $line[1]

$Scope.State += Check-Empty $line[2]

# Line 3 and 4 represent the Name and Comment of the Scope

# If the name is empty, try taking the comment

If (Check-Empty $line[3] -eq "-") {

$Scope.Name += Check-Empty $line[4]

}

else { $Scope.Name += Check-Empty $line[3] }

}

# Get all the Active Scopes IP Address

$ScopesIP = $Scope | Where { $_.State -eq "Active" } | Select Address

# Go over all the Adresses to collect Scope Client Lease Details

Foreach($ScopeAddress in $ScopesIP.Address){

# Define some Commands to run later - these commands need to be here because we use the ScopeAddress var that changes every loop

#Command to get all Lease Details from a specific Scope - when 1 is amitted the output includes the computer name

$ShowLeases = "$NetCommand scope "+$ScopeAddress+" show clients 1"

#Command to get all Reserved IP Details from a specific Scope

$ShowReserved = "$NetCommand scope "+$ScopeAddress+" show reservedip"

#Command to get all the Scopes Options (Including the Scope Lease Duration)

$ShowScopeDuration = "$NetCommand scope "+$ScopeAddress+" show option"

# Run the Commands and save the output in the accourding var

$AllLeases = Invoke-Expression $ShowLeases 

$AllReserved = Invoke-Expression $ShowReserved 

$AllOptions = Invoke-Expression $ShowScopeDuration

# Get the Lease Duration from Each Scope

for($i=0; $i -lt $AllOptions.count;$i++) 

{ 

# Find a Scope Option ID number 51 - this Option ID Represents  the Scope Lease Duration

if($AllOptions[$i] -match "OptionId : 51")

{ 

# Get the Lease Duration from the Specified line

$tmpLease = $AllOptions[$i+4].Split("=")[1].Trim()

# The Lease Duration is recieved in Ticks / 10000000

$tmpLease = [int]$tmpLease * 10000000; # Need to Convert to Int and Multiply by 10000000 to get Ticks

# Create a TimeSpan Object

$TimeSpan = New-Object -TypeName TimeSpan -ArgumentList $tmpLease

# Calculate the $tmpLease Ticks to Days and put it in the Scope Lease Duration

$Scope.LeaseDuration += $TimeSpan.TotalDays

# After you found one Exit the For

break;

} 

}

# Get all Client Leases from Each Scope

for($i=8;$i -lt $AllLeases.Length-4;$i++)

{

# Split the line and get the strings

$line = [regex]::split($AllLeases[$i],"\s{2,}")

# Check if you recieve all the lines that you need

$LeaseClients.IP += Check-Empty $line[0]

$LeaseClients.Mask += Check-Empty $line[1].ToString().replace("-","").Trim()

$LeaseClients.MAC += $line[2].ToString().substring($line[2].ToString().indexOf("-")+1,$line[2].toString().Length-1).Trim()

$LeaseClients.Expires += $(Check-Empty $line[3]).replace("-","").Trim()

$LeaseClients.Type += Get-LeaseType $(Check-Empty $line[4]).replace("-","").Trim()

$LeaseClients.Name += Check-Empty $line[5]

}

# Get all Client Lease Reservations from Each Scope

for($i=7;$i -lt $AllReserved.Length-5;$i++)

{

# Split the line and get the strings

$line = [regex]::split($AllReserved[$i],"\s{2,}")

$LeaseReserved.IP += Check-Empty $line[0]

$LeaseReserved.MAC += Check-Empty $line[2]

}

}

#endregion 


#region Create a Temp Scope Object

# Create a New Object

$tmpScope = New-Object psobject

# Add new members to the Object

$tmpScope | Add-Member noteproperty "Address" ""

$tmpScope | Add-Member noteproperty "Mask" ""

$tmpScope | Add-Member noteproperty "State" ""

$tmpScope | Add-Member noteproperty "Name" ""

$tmpScope | Add-Member noteproperty "LeaseDuration" ""

#endregion

#region Create a Temp Lease Object

# Create a New Object

$tmpLeaseClients = New-Object psObject

# Add new members to the Object

$tmpLeaseClients | Add-Member noteproperty "IP" ""

$tmpLeaseClients | Add-Member noteproperty "Name" ""

$tmpLeaseClients | Add-Member noteproperty "Mask" ""

$tmpLeaseClients | Add-Member noteproperty "MAC" ""

$tmpLeaseClients | Add-Member noteproperty "Expires" ""

$tmpLeaseClients | Add-Member noteproperty "Type" ""

#endregion

#region Create a Temp Reserved Object

# Create a New Object

$tmpLeaseReserved = New-Object psObject

# Add new members to the Object

$tmpLeaseReserved | Add-Member noteproperty "IP" ""

$tmpLeaseReserved | Add-Member noteproperty "MAC" ""

#endregion

# Go over all the Client Lease addresses and export each detail to a temporary var and out to the log file

For($l=0; $l -lt $LeaseClients.IP.Length;$l++)

{

# Get all Scope details to a temp var

$tmpLeaseClients.IP = $LeaseClients.IP[$l] + ","

$tmpLeaseClients.Name = $LeaseClients.Name[$l] + ","

$tmpLeaseClients.Mask =  $LeaseClients.Mask[$l] + ","

$tmpLeaseClients.MAC = $LeaseClients.MAC[$l] + ","

$tmpLeaseClients.Expires = $LeaseClients.Expires[$l] + ","

$tmpLeaseClients.Type = $LeaseClients.Type[$l]

# Export with the Out-CSV Function to the Log File

$tmpLeaseClients | out-csv $LeaseLog -append $true

}



#Continue on figuring out if the DHCP lease clients are in AD or not

#Import the Active Directory module
import-module activedirectory

#import Quest AD module
Add-PSSnapin Quest.ActiveRoles.ADManagement

#connect to AD
Connect-QADService PUTTHEFQDNOFYOURDOMAINHERE_LIKE_DOMAIN.LOCAL | Out-Null

# get input CSV
$leaselogpath = "c:\DHCP\LeaseLog.csv"
Import-csv -path $leaselogpath | 
#query AD for computer name based on csv log
foreach-object `
{ 
   $NameResult = Get-QADComputer -DnsName $_.Name
   If ($NameResult -eq $null) {$RogueSystem = $_.Name}
   $RogueSystem | Out-File C:\DHCP\RogueClients.txt -Append
   $RogueSystem = $null

}
Get-Content C:\DHCP\RogueClients.txt | Select-Object -Unique | Out-File C:\DHCP\RogueClientsFinal.txt
Remove-Item C:\DHCP\RogueClients.txt

#send email to netadmin
$smtpserver = "SMTP SERVER IP"
$from="DHCPSERVER@domain.com"
$to="TheCleaner@domain.com"
$subject="Non-AD joined DHCP clients"
$body= (Get-Content C:\DHCP\RogueClientsFinal.txt) -join '<BR>&nbsp;<BR>'
$mailer = new-object Net.Mail.SMTPclient($smtpserver)
$msg = new-object Net.Mail.MailMessage($from,$to,$subject,$body)
$msg.IsBodyHTML = $true
$mailer.send($msg)

Mam nadzieję, że pomoże to komuś innemu!

OK, nie jestem pewien, czy przestrzegam etykiety, ale zamieszczam drugą odpowiedź zamiast edytować moją poprzednią, ponieważ zawierała ona pewne informacje, które mogą być przydatne dla kogoś, nawet jeśli okażą się nieistotne w tym przypadku. Jeśli to czyni mnie idiotą na tym forum, możesz poinformować mnie o moich błędnych sposobach.

Problem jest podzielony na kilka części, oto sugestie dla tych, które uważam za najbardziej interesujące. Bez przykładów z dziennika jest to najlepsze, co mogę zrobić, więc to tylko sugestie, a nie rozwiązania.

Do analizowania wykorzystania dziennika get-contentz -waitparametrem. W moim przypadku użycia wystarczy znaleźć błąd w dzienniku błędów.

Oto, co zadziałało w moim przypadku użycia, wybacz formatowanie:

get-content E:\temp13\log.txt -tail(1) -wait | where {$_ -match "ERROR"} |
    foreach {
        send-mailmessage `
        -port 25 `
        -smtpserver my.mail.server `
        -from logmon@a.b `
        -to erike@a.b `
        -subject "test logmonitor" `
        -body "ERROR found: $_" `
        }

Zamiast tego $_ -match "ERROR"musisz jakoś oddzielić pole identyfikatora dziennika i nazwę komputera. Nie jestem pewien, jak to zrobić w najlepszy sposób, ale ponieważ where-object -matchzapewnia obsługę wyrażeń regularnych, myślę, że może to być opcja. Możesz także rozpocząć od zapisania zmiennej $ _ w innej nowej zmiennej, aby móc ją później wygodnie odebrać w rurociągu, w zagnieżdżonych pętlach foreach itp.

Zakładając, że możesz dostać się do nazwy komputera, myślę, że get-adcomputercmdlet byłby najprostszym sposobem na zapytanie AD ( import-module activedirectory) i domyślam się, że błąd wysłał wiadomość?

Korzystanie z tego import-csvbyłoby oczywiście znacznie bardziej eleganckie w twoim przypadku, ale nie jestem świadomy żadnego sposobu na dostosowanie go (jeśli ktoś to przeczyta i zna sztuczkę, ale proszę, podziel się).

Zakładając, że masz pewność co do identyfikatora zdarzenia i że żadne inne zdarzenia nie logują się do tego identyfikatora w dzienniku DHCP, ale te, które Cię interesują, wypychanie jest rzeczywiście opcją.

1) Otwórz Menedżera serwera, przejdź do dziennika DHCP w Podglądzie zdarzeń.

2) Znajdź reprezentatywny wpis, do którego chcesz dołączyć swoje działanie. Wybierz i kliknij prawym przyciskiem myszy.

3) Wybierz „Dołącz zadanie do tego wydarzenia”.

4) Otwiera się Kreator tworzenia zadań, zabierz go stąd ...

W rzeczywistości istnieje wyraźna opcja wiadomości e-mail, ale jeśli potrzebujesz więcej logiki, możesz oczywiście skorzystać z opcji uruchomienia programu, aby uruchomić program powershell.exe i dołączyć do niego skrypt. Istnieje wiele doskonałych wskazówek Google, jak pozwolić Menedżerowi zadań uruchamiać skrypty PowerShell, jeśli potrzebujesz wskazówek.

Bezpośrednią alternatywą, jaką widzę, jest użycie metody pull przez parsowanie dziennika zdarzeń za pomocą programu PowerShell w zaplanowanych odstępach czasu. „The Microsoft Scripting Guy”, znany również jako Ed Wilson, napisał kilka niesamowitych postów na blogu, w jaki sposób parsować dziennik zdarzeń za pomocą poleceń cmdlet dostępnych w różnych wersjach programu PowerShell, więc moją propozycją byłoby rozpoczęcie jego blogu.

Jeśli chodzi o rzeczywiste polecenia cmdlet, nie mam teraz czasu, aby wyciągnąć mój zapas przydatnych porcji, ale zajrzę do niego ponownie za dzień lub dwa i może się przydać, jeśli nikt inny nie przyłączy się do niektórych dobrze wybranych, albo nie macie Nie rozwiązałeś tego wszystkiego sam :-)

Chociaż nie dotyczy to pożądanego rozwiązania, opcją, która może osiągnąć twój cel, jest wykorzystanie arpwatch( link ), aby powiadomić cię, gdy nowy (wcześniej niewidoczny) host zostanie wyświetlony w sieci.

Alternatywą dla systemu Windows arpwatchwydaje się być bezkofeinowa, ale nigdy jej nie używałem, więc nie mogę mówić za nią dobrze ani źle.