I.Ahmed[at]Techmitte.de

3️⃣. PS – Get-GeoIP & check if the IP is blocked

Es kann immer mal wieder nützlich sein über die Konsole geblockte IP-Adressen ermitteln zu können. In der Windows Umgebung kann man dies ganz leicht über Powershell und mittels webcrawler oder auch api umsetzen. Dazu habe ich euch, im ersten Schritt, eine simple Funktion gebaut um die blockliste von „blocklist.de“ und die Geodaten von „ip2c.org„

PowerShell
function Get-GeoIP 
{
    [cmdletbinding()]
    param(
    [Parameter(Mandatory=$true)]
    [System.Net.IPAddress]$ip,
    [switch]$block
    #$ip
    )
    try{
        $webclient = New-Object System.Net.webclient
        if($block -eq $true){
            $blockL ="http://api.blocklist.de/api.php?ip=$ip&start=1"
            $blockData = $webclient.downloadstring($blockL)
            $blockData.Replace('<br />'," ")
        }
        else{
            $providerRoot = "http://ip2c.org/"
            $geoData = $webclient.downloadstring($providerRoot+$ip)
            Write-Output $geoData.Split(';')[3]
        }
        #$geoData = Invoke-RestMethod -Method Get -Uri $providerRoot+$ip -TimeoutSec 35 -ErrorAction SilentlyContinue
    }catch{"NA"}
}

🔍 Überblick und Funktionalität

Das Skript Get-GeoIP hat folgende Hauptfunktionen:

  • Geolokalisierung: Ermittelt das Land (und optional detaillierte Standortinformationen) einer angegebenen IP-Adresse über externe Dienste.
  • Blocklistenprüfung: Überprüft, ob die IP-Adresse in bekannten Blocklisten (z. B. von blocklist.de) enthalten ist.
  • Pipeline-Unterstützung: Ermöglicht den gleichzeitigen Abruf von Geolokalisierungsdaten mehrerer IP-Adressen.
  • Fehlerbehandlung: Fängt mögliche Fehler ab und liefert aussagekräftige Fehlermeldungen.

📝 Parameter und Beispiele

Das Skript akzeptiert folgende Parameter:

  • -IP (erforderlich): Die IP-Adresse, die abgefragt werden soll. Der Parameter unterstützt sowohl IPv4- als auch IPv6-Adressen und validiert das Format.
  • -Block (Switch): Wird dieser Parameter gesetzt, prüft das Skript, ob die IP-Adresse in Blocklisten enthalten ist.
  • -Detailed (Switch): Aktiviert den Abruf detaillierter Geolokalisierungsdaten (z. B. Stadt, Region, Koordinaten, Zeitzone und ISP).
PowerShell
# Gibt das Land der IP 8.8.8.8 zurück
Get-GeoIP -IP 8.8.8.8

# Gibt detaillierte Geolokalisierungsdaten für 8.8.8.8 zurück
Get-GeoIP -IP "8.8.8.8" -Detailed

# Prüft, ob 8.8.8.8 in Blocklisten enthalten ist
Get-GeoIP -IP "8.8.8.8" -Block

# Mehrere IPs über die Pipeline verarbeiten
"8.8.8.8", "1.1.1.1" | Get-GeoIP

🔧 Funktionsweise im Detail

Im begin-Block wird eine Verbose-Nachricht ausgegeben, um den Start der GeoIP-Abfrage zu protokollieren. Im process-Block übernimmt das Skript folgende Aufgaben:

  • Es erzwingt die Nutzung von TLS 1.2 für sichere Web-Anfragen.
  • Es erstellt ein WebClient-Objekt mit einem benutzerdefinierten User-Agent-Header.
  • Wird der -Block Parameter gesetzt, fragt das Skript über blocklist.de ab, ob die IP-Adresse als bösartig gemeldet wurde.
  • Ohne -Block wird, abhängig vom -Detailed Switch, entweder über ipapi.co (für detaillierte Informationen) oder über ip2c.org (für schnelle Länderinformationen) abgefragt.
  • Die Rückgabe erfolgt als PSCustomObject mit den ermittelten Feldern, sodass die Ergebnisse leicht weiterverarbeitet oder in Berichten verwendet werden können.

Fehler werden mittels try/catch abgefangen und in der Ausgabe dokumentiert.

PowerShell
function Get-GeoIP 
{
    [cmdletbinding()]
    param(
    [Parameter(Mandatory=$true)]
    [System.Net.IPAddress]$ip,
    [switch]$block
    #$ip
    )
    try{
        $webclient = New-Object System.Net.webclient
        if($block -eq $true){
            $blockL ="http://api.blocklist.de/api.php?ip=$ip&start=1"
            $blockData = $webclient.downloadstring($blockL)
            $blockData.Replace('<br />'," ")
        }
        else{
            $providerRoot = "http://ip2c.org/"
            $geoData = $webclient.downloadstring($providerRoot+$ip)
            Write-Output $geoData.Split(';')[3]
        }
        #$geoData = Invoke-RestMethod -Method Get -Uri $providerRoot+$ip -TimeoutSec 35 -ErrorAction SilentlyContinue
    }catch{"NA"}
}

Wenn man den ersten noch etwas aufhübscht durch Comment-Based-Help und erweiterte Funktionalität mit detaillierten Informationen und besserer Fehlerbehandlung durch hinzufügen von Verbose, sowie die Pipeline-Unterstützung.

PowerShell
<#
.SYNOPSIS
 Ermittelt Geolokalisierungsdaten für eine IP-Adresse oder prüft, ob diese in Blocklisten enthalten ist.

.DESCRIPTION
 Diese Funktion ruft Geolokalisierungsdaten für eine angegebene IP-Adresse ab 
 oder prüft, ob die IP-Adresse in bekannten Blocklisten enthalten ist.
 Es werden externe Dienste verwendet, um die Daten zu ermitteln (ip2c.org, ipapi.co und blocklist.de).
 Die Funktion kann sowohl einfache Länderinformationen als auch detaillierte Standortdaten liefern.

.PARAMETER IP
 Die IP-Adresse, die geolokalisiert oder auf Blocklisten überprüft werden soll.
 Dieser Parameter ist obligatorisch.

.PARAMETER Block
 Gibt an, ob die IP-Adresse in Blocklisten überprüft werden soll.
 Wenn dieser Parameter gesetzt ist, wird der Dienst blocklist.de abgefragt.
 Standardwert: $false

.PARAMETER Detailed
 Gibt an, ob detaillierte Geolokalisierungsinformationen abgerufen werden sollen.
 Wenn dieser Parameter gesetzt ist, werden Stadt, Region, Koordinaten usw. zurückgegeben.
 Standardwert: $false

.EXAMPLE
 Get-GeoIP -IP "8.8.8.8"
 Gibt das Land zurück, in dem die IP-Adresse 8.8.8.8 registriert ist.

.EXAMPLE
 Get-GeoIP -IP "8.8.8.8" -Detailed
 Gibt detaillierte Geolokalisierungsdaten (Land, Stadt, Region, Koordinaten) für die IP-Adresse 8.8.8.8 zurück.

.EXAMPLE
 Get-GeoIP -IP "8.8.8.8" -Block
 Prüft, ob die IP-Adresse 8.8.8.8 in bekannten Blocklisten enthalten ist.

.EXAMPLE
 "8.8.8.8", "1.1.1.1" | Get-GeoIP
 Verarbeitet mehrere IP-Adressen über die Pipeline und gibt deren Geolokalisierungsdaten zurück.

.NOTES
 Dateiname:      Get-GeoIP.ps1
 Autor:          Ismahil Ahmed
 Erstelldatum:   13.03.2023
 Version:        2.1
 
 Änderungsprotokoll:
 1.0 - Ursprüngliche Version
 2.0 - Erweiterte Funktionalität mit detaillierten Informationen, besserer Fehlerbehandlung und Pipeline-Unterstützung
 2.1 - Timeout-Einstellung entfernt, da nicht in allen PowerShell-Versionen verfügbar
#>

function Get-GeoIP {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory = $true, 
                   ValueFromPipeline = $true, 
                   ValueFromPipelineByPropertyName = $true,
                   HelpMessage = "IP-Adresse, die geolokalisiert werden soll")]
        [ValidateScript({
            $_ -match "^(\d{1,3}\.){3}\d{1,3}$" -or 
            $_ -match "^([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$"
        })]
        [System.Net.IPAddress]$IP,

        [Parameter(HelpMessage = "Prüft, ob die IP in einer Blockliste aufgeführt ist")]
        [switch]$Block,

        [Parameter(HelpMessage = "Zeigt detaillierte Standortinformationen an")]
        [switch]$Detailed
    )

    begin {
        # Protokolliert den Start der Funktion
        Write-Verbose "Starte GeoIP-Abfrage"
    }

    process {
        try {
            # Verwenden von TLS 1.2 für mehr Sicherheit
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
            
            # Erstellen eines WebClient-Objekts
            $webClient = New-Object System.Net.WebClient
            $webClient.Headers.Add("User-Agent", "PowerShell/Get-GeoIP")
            
            if ($Block) {
                Write-Verbose "Prüfe Blocklisten-Status für IP: $IP"
                $blockListUrl = "https://api.blocklist.de/api.php?ip=$IP&start=1"
                
                $blockData = $webClient.DownloadString($blockListUrl)
                
                if ($blockData -eq "no attacks" -or $blockData -match "attacks: 0<br />reports: 0<br />") {
                    [PSCustomObject]@{
                        IP = $IP
                        Status = "Nicht blockiert"
                        Details = "Keine Angriffe von dieser IP gemeldet"
                    }
                }
                else {
                    [PSCustomObject]@{
                        IP = $IP
                        Status = "Blockiert"
                        Details = $blockData.Replace('<br />', ', ')
                    }
                }
            }
            else {
                Write-Verbose "Geolokalisiere IP: $IP"
                
                if ($Detailed) {
                    # Verwende ipapi.co für detaillierte Informationen
                    $geoDetailUrl = "https://ipapi.co/$IP/json/"
                    $geoDetailData = $webClient.DownloadString($geoDetailUrl)
                    $geoDetailJson = $geoDetailData | ConvertFrom-Json
                    
                    [PSCustomObject]@{
                        IP = $IP
                        Land = $geoDetailJson.country_name
                        LandCode = $geoDetailJson.country_code
                        Region = $geoDetailJson.region
                        Stadt = $geoDetailJson.city
                        Postleitzahl = $geoDetailJson.postal
                        Zeitzone = $geoDetailJson.timezone
                        Latitude = $geoDetailJson.latitude
                        Longitude = $geoDetailJson.longitude
                        ISP = $geoDetailJson.org
                    }
                }
                else {
                    # Verwende ip2c.org für einfache Länderinformationen (schneller)
                    $providerRoot = "http://ip2c.org/"
                    $geoData = $webClient.DownloadString($providerRoot + $IP)
                    $geoDataParts = $geoData.Split(';')
                    
                    if ($geoDataParts[0] -eq "1") {
                        [PSCustomObject]@{
                            IP = $IP
                            LandCode = $geoDataParts[1]
                            Land = $geoDataParts[3]
                        }
                    }
                    else {
                        Write-Warning "Für IP $IP wurden keine Geolokalisierungsdaten gefunden"
                        [PSCustomObject]@{
                            IP = $IP
                            LandCode = "NA"
                            Land = "Nicht verfügbar"
                        }
                    }
                }
            }
        }
        catch {
            Write-Error "Fehler bei der GeoIP-Abfrage für $IP : $($_.Exception.Message)"
            [PSCustomObject]@{
                IP = $IP
                LandCode = "ERROR"
                Land = "Fehler bei der Abfrage: $($_.Exception.Message)"
            }
        }
        finally {
            if ($webClient) {
                $webClient.Dispose()
            }
        }
    }

    end {
        Write-Verbose "GeoIP-Abfrage abgeschlossen"
    }
}

📚 Fazit

Das PowerShell-Skript Get-GeoIP demonstriert, wie externe Webdienste in Skripten integriert werden können, um Geolokalisierungsdaten zu ermitteln und gleichzeitig Sicherheitsaspekte durch Blocklistenabfragen zu berücksichtigen. Dank der Unterstützung von Pipeline-Eingaben und einer robusten Fehlerbehandlung ist es ein leistungsstarkes Werkzeug für Administratoren, die Netzwerkinformationen automatisiert auswerten möchten.

Hast du Fragen oder eigene Erweiterungen zu diesem Skript? Dann teile deine Erfahrungen und Anregungen gern in den Kommentaren!

Ähnliche Beiträge

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert

Im Trend

🚀 Installation Fail2ban und ssh absichern – Schritt für Schritt
OwnCloud vs. Nextcloud – Welche Cloud-Lösung ist die beste?
🚀 Installation Nextcloud 27 unter Ubuntu 22.04 – Schritt für Schritt
🚀 Installation von Ubuntu 24.04 und Hardening – Schritt für Schritt