Windows DHCP Server - Benachrichtigung erhalten, wenn ein nicht AD-verbundenes Gerät eine IP-Adresse erhält

SZENARIO

Um dies auf das einfachste Beispiel zu vereinfachen:

Ich habe einen Windows 2008 R2-Standard-DC mit der DHCP-Serverrolle. IPs werden über verschiedene IPv4-Bereiche verteilt, kein Problem.

WAS ICH MÖCHTE

Ich möchte eine Möglichkeit zum Erstellen eines Benachrichtigungs- / Ereignisprotokolleintrags oder eines ähnlichen Eintrags, wenn ein Gerät eine DHCP-Adresslease erhält und das Gerät KEIN domänenverbundener Computer in Active Directory ist. Es spielt für mich keine Rolle, ob es sich um benutzerdefinierte PowerShell usw. handelt.

Fazit = Ich möchte wissen, ob sich Geräte im Netzwerk befinden, die keine Domänen sind, ohne derzeit 802.1X zu verwenden. Ich weiß, dass dies nicht für statische IP-Geräte gilt. Ich habe eine Überwachungssoftware, die das Netzwerk durchsucht und Geräte findet, aber im Detail ist sie nicht ganz so detailliert.

FORSCHUNG ERFOLGT / OPTIONEN ERWARTET

Ich sehe keine solchen Möglichkeiten mit der eingebauten Protokollierung.

Ja, ich kenne 802.1X und bin in der Lage, es langfristig an diesem Standort zu implementieren, aber wir sind noch einige Zeit von einem solchen Projekt entfernt. Auch wenn dies Probleme mit der Netzwerkauthentifizierung lösen würde, ist dies für mich außerhalb hilfreich von 802.1X Zielen.

Ich habe mich nach einigen Drehbucheinträgen usw. umgesehen, die sich als nützlich erweisen könnten, aber die Dinge, die ich finde, veranlassen mich zu der Annahme, dass mein Google-Fu mir im Moment nicht hilft.

Ich glaube, die folgende Logik ist richtig ( vorausgesetzt, es gibt keine existierende Lösung ):

1. Gerät empfängt DHCP-Adresse
2. Ereignisprotokolleintrag wird aufgezeichnet (Ereignis-ID 10 im DHCP-Überwachungsprotokoll sollte funktionieren (da eine neue Lease das ist, woran ich am meisten interessiert bin, und nicht die Verlängerung): http://technet.microsoft.com/en-us/library /dd759178.aspx )
3. Zu diesem Zeitpunkt müsste wahrscheinlich eine Art Skript für die verbleibenden "SCHRITTE" übernehmen.
4. Fragen Sie in diesem DHCP-Protokoll nach diesen Ereignis-IDs 10 ab (ich würde gerne Push verwenden, aber ich vermute, Pull ist die einzige Möglichkeit hier).
5. Analysieren Sie die Abfrage nach dem Namen des Geräts, dem die neue Lease zugewiesen wurde
6. Fragen Sie AD nach dem Namen des Geräts ab
7. WENN nicht in AD gefunden, senden Sie eine Benachrichtigungs-E-Mail

Wenn jemand Ideen hat, wie man das richtig macht, würde ich es wirklich schätzen. Ich suche kein "gimme the codez", würde aber gerne wissen, ob es Alternativen zu der obigen Liste gibt oder ob ich nicht klar denke und eine andere Methode zum Sammeln dieser Informationen vorhanden ist. Wenn Sie Code-Snippets / PS-Befehle haben, die Sie teilen möchten, um dies zu erreichen, umso besser.

Mit großem Dank an ErikE und die anderen hier bin ich einen Weg gegangen ... Ich werde nicht sagen, dass es der richtige Weg ist, aber das Powershell-Skript, das ich mir ausgedacht habe, macht den Trick.

Der Code ist unten, wenn jemand es will. Führen Sie es einfach manuell aus, indem Sie auf jeden DHCP-Server zeigen, oder planen Sie es (erneut, indem Sie auf jeden DHCP-Server im Skript zeigen).

Was das Skript macht:

1. Ruft Lease-Informationen vom DHCP-Server ab (IPv4-Leases)
2. Gibt die Leases in eine CSV-Datei aus
3. Liest die CSV-Datei zum Abfragen von AD zurück
4. Fragt AD nach dem Computer ab
5. Wenn nicht gefunden, wird eine neue txt-Datei ausgegeben
6. Erstellt eine eindeutige list final txt-Datei aus der in # 5 oben erstellten (da es zu Dupes kommen kann, wenn sich der Client mehrmals oder mit mehr als einem Adapter registriert)
7. Sendet den Inhalt der endgültigen Ausgabedatei per E-Mail an einen Administrator

Was du brauchen wirst:

Das Skript verwendet das AD-Modul ( import-module activedirectory), sodass es am besten auf einem AD DC mit DHCP ausgeführt wird. Wenn dies bei Ihnen nicht der Fall ist, können Sie das AD-Powershell-Modul installieren: http://blogs.msdn.com/b/rkramesh/archive/2012/01/17/how-to-add-active-directory- Modul-in-PowerShell-in-Windows-7.aspx

Außerdem benötigen Sie die AD Powershell-Cmdlets von Quest, die Sie hier finden: http://www.quest.com/powershell/activeroles-server.aspx . Installieren Sie DIESE, BEVOR Sie das Skript ausführen, da sonst ein Fehler auftritt .

Das Skript selbst (bereinigt, Sie müssen einige der Variablen entsprechend Ihren Anforderungen einrichten, z. B. die Namen der Eingabedateien, die Domäne, zu der eine Verbindung hergestellt werden soll, den DHCP-Server, zu dem eine Verbindung hergestellt werden soll, E-Mail-Einstellungen gegen Ende usw.):

# 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)

Hoffe das hilft jemand anderem!

OK, ich bin mir nicht sicher, ob ich hier der Etikette folge, aber ich poste eine zweite Antwort, anstatt meine vorherige zu bearbeiten, da sie einige Informationen enthielt, die für jemanden von Nutzen sein können, auch wenn sich herausstellt, dass sie für diesen Fall irrelevant sind. Wenn mich das zu einem Idioten in diesem Forum macht, können Sie mich gerne über meine fehlerhaften Methoden informieren.

Das Problem ist in mehrere Teile gegliedert, hier sind Vorschläge für diejenigen, die ich am interessantesten finde. Ohne Beispiele aus dem Protokoll ist dies das Beste, was ich tun kann. Es handelt sich also nur um Vorschläge, keine Lösungen.

Verwenden Sie zum Parsen des Protokolls get-contentden -waitParameter. Für meinen Anwendungsfall reicht es aus, einen Fehler in einem Fehlerprotokoll zu finden.

Das hat für meinen eigenen Anwendungsfall funktioniert, vergib die Formatierung:

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: $_" `
        }

Stattdessen $_ -match "ERROR"müssten Sie das Protokoll-ID-Feld und den Computernamen irgendwie trennen. Ich bin mir nicht sicher, wie ich das im where-object -matchMoment am besten angehen soll , aber da es Regex-Unterstützung gibt, denke ich, könnte dies eine Option sein. Sie können auch damit beginnen, die Variable $ _ in einer anderen neuen Variablen zu speichern, um sie später in der Pipeline in verschachtelten foreach-Schleifen usw. nach Belieben abrufen zu können.

Angenommen, Sie können den Computernamen get-adcomputerabrufen. Ich schätze, das Cmdlet ist die einfachste Methode zum Abfragen Ihres AD ( import-module activedirectory), und ich schätze, dass beim Senden von E-Mails ein Fehler aufgetreten ist .

Die Verwendung von import-csvwäre in Ihrem Fall natürlich weitaus eleganter, aber mir ist keine Möglichkeit bekannt, dies zu verfolgen (wenn jemand dies liest und einen Trick in dieser Gasse kennt, teilen Sie ihn bitte mit).

Unter der Annahme, dass Sie sich der Ereignis-ID sicher sind und dass in dieser ID keine anderen Ereignisse als die von Ihnen gewünschten im DHCP-Protokoll protokolliert werden, ist Push in der Tat eine Option.

1) Öffnen Sie den Server-Manager und rufen Sie das DHCP-Protokoll in der Ereignisanzeige auf.

2) Suchen Sie einen repräsentativen Eintrag, an den Sie Ihre Aktion anhängen möchten. Wählen Sie es aus und klicken Sie mit der rechten Maustaste.

3) Wählen Sie "Aufgabe an dieses Ereignis anhängen".

4) Der Assistent zum Erstellen von Aufgaben wird geöffnet. Nehmen Sie ihn von dort weg.

Es gibt tatsächlich eine explizite E-Mail-Option. Wenn Sie jedoch mehr Logik benötigen, können Sie natürlich auch die Option start-a-program verwenden, um powershell.exe zu starten und ein Skript daran anzuhängen. Es gibt eine Menge hervorragender, gut lesbarer Anleitungen, wie der Task-Manager Powershell-Skripte ausführen kann, wenn Sie eine Anleitung benötigen.

Die sofortige Alternative, die ich sehe, besteht darin, Pull zu verwenden, indem das Ereignisprotokoll in festgelegten Intervallen mit PowerShell analysiert wird. "The Microsoft Scripting Guy", auch bekannt als Ed Wilson, hat einige großartige Blog-Beiträge zum Parsen des Ereignisprotokolls mit den Cmdlets geschrieben, die in den verschiedenen Versionen von Powershell verfügbar sind. Daher wäre es mein Vorschlag, sein Blog als Ausgangspunkt heranzuziehen.

Was die tatsächlichen Cmdlets angeht, habe ich momentan nicht die Zeit, meinen Vorrat an nützlichen Snippets herauszuholen, aber ich werde in ein oder zwei Tagen noch einmal nachsehen und möglicherweise einen Beitrag leisten, wenn sich noch niemand mit einigen ausgewählten befasst hat, oder Sie haben die Wahl Habs nicht alleine gelöst :-)

Hiermit wird Ihre gewünschte Lösung zwar nicht angesprochen, Sie können jedoch mithilfe von arpwatch( Link ) benachrichtigt werden, wenn ein neuer (zuvor nicht sichtbarer) Host im Netzwerk angezeigt wird.

Eine Windows-Alternative zu arpwatchscheint koffeinfrei zu sein, aber ich habe sie nie benutzt, kann also nicht gut oder schlecht dafür sprechen.