Powerview.py

Übersicht

PowerView.py ist eine Alternative zu dem großartigen ursprünglichen PowerView.ps1 Skript. Die meisten der in PowerView verwendeten Module sind hier verfügbar ( einige der Flags wurden geändert ). Das Hauptziel ist es, eine interaktive Sitzung zu erreichen, ohne sich wiederholt bei ldap authentifizieren zu müssen.

Installation

https://github.com/aniqfakhrul/powerview.py/wiki/Installation-Guide

Grundlegende Verwendung

[!NOTE] Beachten Sie, dass einige der Kerberos-Funktionen noch nicht ganz einwandfrei funktionieren, aber das Skript wird trotzdem den Großteil der Arbeit erledigen. Detaillierte Verwendung finden Sie im Abschnitt Wiki.

Verbindung initialisieren``` powerview range.net/lowpriv:[email protected] [-k] [--use-ldap | --use-ldaps | --use-gc | --use-gc-ldaps | --use-adws]

* Persistente Verbindung aufrechterhalten
> [!TIP]
> Die Verbindungspersistenz ist standardmäßig deaktiviert. LDAP-Sitzungen laufen nach Inaktivität ab. Verwenden Sie `--keepalive-interval`, um regelmäßige Abfragen zu senden, die den Sitzungszustand aufrechterhalten.

* Weboberfläche starten```
powerview range.net/lowpriv:[email protected] --web [--web-host 0.0.0.0] [--web-port 3000] [--web-auth user:password1234]

Verbindung mit bestimmter Authentifizierung initialisieren. Beachten Sie, dass --use-sign-and-seal und --use-channel-binding nur verfügbar sind, wenn Sie die Bibliothek ldap3 direkt von diesem Branch installieren.``` powerview range.net/lowpriv:[email protected] [--use-channel-binding | --use-sign-and-seal | --use-simple-auth]

* Init mit schannel. Das `--pfx`-Flag akzeptiert eine pfx-formatierte Zertifikatsdatei.
> [!NOTE]  
> powerview versucht beim ersten Versuch, das Zertifikat ohne Passwort zu laden. Schlägt dies fehl, fordert es zur Eingabe eines Passworts auf. Ein Passwortparameter ist daher nicht erforderlich.```
powerview 10.10.10.10 --pfx administrator.pfx

intro

Bestimmten Benutzer abfragen``` Get-DomainUser Administrator Get-DomainUser -Identity Administrator

* Suchattribute angeben```
Get-DomainUser -Properties samaccountname,description

Ergebnisse filtern``` Get-DomainUser -Where 'samaccountname [contains][in][eq] admins'

* Ergebnisse zählen```
Get-DomainUser -Count

Ergebnis in Datei ausgeben``` Get-DomainUser -OutFile ~/domain_user.txt

* Formatieren Sie die Ausgabe in einer Tabelle.```
Get-DomainUser -Properties samaccountname,memberof -TableView
Get-DomainUser -Properties samaccountname,memberof -TableView [csv,md,html,latex]

Modul festlegen``` Set-DomainObject -Identity "adminuser" -Set 'servicePrincipalname=http/web.ws.local' Set-DomainObject -Identity "adminuser" -Append 'servicePrincipalname=http/web.ws.local' Set-DomainObject -Identity "adminuser" -Clear 'servicePrincipalname'

Reading from local file

Set-DomainObject -Identity "adminuser" -Set 'servicePrincipalname=@/path/to/local/file' Set-DomainObject -Identity "adminuser" -Append 'servicePrincipalname=@/path/to/local/file'

* Relay-Modus```
powerview 10.10.10.10 --relay [--relay-host] [--relay-port] [--use-ldap | --use-ldaps]

relay

[!NOTE]
Diese Demonstration zeigt, dass erzwungene Authentifizierung mithilfe von printerbug.py durchgeführt wurde. Sie können andere Methoden verwenden, die HTTP-Authentifizierung erzwingen.

Obfuscation

PowerView verwendet ldapx-py, um LDAP-Abfragen und zugehörige Parameter zu verschleiern, wobei beobachtbare Muster variiert werden, während die Abfrageabsicht erhalten bleibt.

Über CLI aktivieren (Standardkette)``` powerview range.net/lowpriv:[email protected] --obfuscate

* Über die CLI aktivieren (benutzerdefinierte Chain-Codes)```
powerview range.net/lowpriv:[email protected] --obfuscate CZXANDR

Aktivieren über das Web

[!TIP] Schalten Sie Obfuscate in den Einstellungen um. Dies gilt für nachfolgende Abfragen der aktiven Sitzung.

Was verschleiert wird

Filter: transformiert Attributnamen, Operatoren und Werte vor dem Senden
DN: verändert den distinguishedName der Suchbasis
Attribute: verändert die angeforderte Attributliste

Standard-Ketten (bei Verwendung von --obfuscate ohne Wert)

Ziel	Kette	Techniken
Filter	`CZNDR`	Case, Zeros, aNR, De Morgan, Reorder
BaseDN

Führen Sie ldapx codes --all aus, um alle verfügbaren Verschleierungscodes anzuzeigen.

[!NOTE] Die Ergebnisse sind in den meisten Fällen funktional äquivalent, aber Approximations-/Wildcard-Erweiterungen können die Treffer ausweiten. Einige Codes (G, O, S) sind möglicherweise nicht mit ldap3 kompatibel - mit Vorsicht verwenden.

[!WARNING] Übermäßige Verschleierung kann von strengen Servern oder zwischengeschalteten Tools abgelehnt werden. Nur bei Bedarf verwenden.

ldapx-py: Bibliothek zur Verschleierung von LDAP-Abfragen — https://github.com/j0hnZ3RA/ldapx-py
ldapx: Flexibler LDAP-Proxy als Referenz — https://github.com/Macmod/ldapx
Forschung: MaLDAPtive: Verschleierung und Entschleierung (DEF CON 32 Vortrag) — https://www.youtube.com/watch?v=mKRS5Iyy7Qo
Autoren: Sabajete Elezaj — https://x.com/sabi_elezi, Daniel Bohannon — https://x.com/danielhbohannon

Verfügbare Module (bisher?)```cs

PV > Add-ADComputer Get-ADObject Get-EventLogChannel Login-As Set-ADObject Add-ADUser Get-CA Get-EventLogPublisher Logoff-Session Set-ADObjectDN Add-CATemplate Get-CATemplate Get-ExchangeDatabase Reboot-Computer Set-CATemplate Add-CATemplateAcl Get-DMSA Get-ExchangeMailbox Remove-ADComputer Set-DomainCATemplate Add-DMSA Get-Domain Get-ExchangeServer Remove-ADObject Set-DomainComputerPassword Add-DomainCATemplate Get-DomainCA Get-GMSA Remove-ADUser Set-DomainDNSRecord Add-DomainCATemplateAcl Get-DomainCATemplate Get-GPOLocalGroup Remove-CATemplate Set-DomainObject Add-DomainComputer Get-DomainComputer Get-GPOSettings Remove-DMSA Set-DomainObjectDN Add-DomainDMSA Get-DomainController Get-LocalUser Remove-DomainCATemplate Set-DomainObjectOwner Add-DomainDNSRecord Get-DomainDMSA Get-NamedPipes Remove-DomainComputer Set-DomainRBCD Add-DomainGMSA Get-DomainDNSRecord Get-NetComputerInfo Remove-DomainDMSA Set-DomainUserPassword Add-DomainGPO Get-DomainDNSZone Get-NetLoggedOn Remove-DomainDNSRecord Set-NetService Add-DomainGroup Get-DomainForeignGroupMember Get-NetProcess Remove-DomainGMSA Set-ObjectOwner Add-DomainGroupMember Get-DomainForeignUser Get-NetService Remove-DomainGroupMember Set-RBCD Add-DomainObjectAcl Get-DomainGMSA Get-NetSession Remove-DomainObject Set-ShadowCred Add-DomainOU Get-DomainGPO Get-NetShare Remove-DomainObjectAcl Set-ShadowCredential Add-DomainUser Get-DomainGPOLocalGroup Get-NetTerminalSession Remove-DomainOU Shutdown-Computer Add-GMSA Get-DomainGPOSettings Get-ObjectAcl Remove-DomainUser Start-NetService Add-GPLink Get-DomainGroup Get-ObjectOwner Remove-GMSA Stop-Computer Add-GPO Get-DomainGroupMember Get-RBCD Remove-GPLink Stop-NetProcess Add-GroupMember Get-DomainObject Get-RegLoggedOn Remove-GroupMember Stop-NetService Add-NetService Get-DomainObjectAcl Get-SCCM Remove-NetService Unlock-ADAccount Add-ObjectAcl Get-DomainObjectOwner Get-ShadowCred Remove-NetSession clear Add-OU Get-DomainOU Get-ShadowCredential Remove-NetTerminalSession exit Clear-Cache Get-DomainRBCD Get-TrustKey Remove-ObjectAcl get_pool_stats ConvertFrom-SID Get-DomainSCCM Get-WDS Remove-OU history ConvertFrom-UACValue Get-DomainTrust Invoke-ASREPRoast Remove-ShadowCred taskkill Disable-DomainDNSRecord Get-DomainTrustKey Invoke-DFSCoerce Remove-ShadowCredential tasklist Get-DomainTrustMapping Find-ForeignGroup Get-DomainUser Invoke-Kerberoast Restart-Computer Find-ForeignUser Get-DomainWDS Invoke-MessageBox Restore-ADObject Find-LocalAdminAccess Get-EventLog Invoke-PrinterBug Restore-DomainObject

### Domain/LDAP-Funktionen

| Module | Alias | Description |
| ------ | ----- | ---- |
|Get-DomainUser||Alle Benutzer oder bestimmte Benutzerobjekte in AD abfragen|
|Get-DomainComputer||Alle Computer oder bestimmte Computerobjekte in AD abfragen|
|Get-DomainGroup||Alle Gruppen oder bestimmte Gruppenobjekte in AD abfragen|
|Get-DomainGroupMember||Mitglieder einer bestimmten Domänengruppe abfragen|
|Get-DomainOU||Alle OUs oder bestimmte OU-Objekte in AD abfragen|
|Get-Domain||Domäneninformationen abfragen|
|Get-DomainController||Verfügbare Domänencontroller abfragen|
|Get-DomainDNSRecord||Verfügbare Datensätze abfragen. Wenn -ZoneName nicht angegeben wird, werden alle DNS-Zonen rekursiv durchsucht|
|Get-DomainDNSZone||Verfügbare DNS-Zonen in der Domäne abfragen|
|Get-DomainObject|Get-ADObject|Alle oder angegebene Domänenobjekte in AD abfragen|
|Get-DomainObjectAcl|Get-ObjectAcl|ACLs für das angegebene AD-Objekt abfragen|
|Get-DomainSCCM|Get-SCCM|SCCM abfragen|
|Get-DomainRBCD|Get-RBCD|Findet Konten, die für ressourcenbasierte eingeschränkte Delegierung (RBCD) konfiguriert sind|
|Get-DomainObjectOwner|Get-ObjectOwner|Besitzer des AD-Objekts abfragen|
|Get-DomainGMSA|Get-GMSA|Gruppenverwaltete Dienstkonten (gMSA) abfragen und deren Passwort-Blobs abrufen|
|Get-DomainDMSA|Get-GDSA|Delegierte verwaltete Dienstkonten (dMSA) abfragen|
|Remove-DomainGMSA|Remove-GMSA|Ein vorhandenes gruppenverwaltetes Dienstkonto (gMSA) aus der Domäne löschen|
|Remove-DomainDMSA|Remove-DMSA|Ein vorhandenes delegiertes verwaltetes Dienstkonto (dMSA) aus der Domäne löschen|
|Remove-DomainDNSRecord||Domänen-DNS-Eintrag entfernen|
|Remove-DomainComputer|Remove-ADComputer|Domänencomputer entfernen|
|Remove-DomainGroupMember|Remove-GroupMember|Mitglied einer bestimmten Domänengruppe entfernen|
|Remove-DomainOU|Remove-OU|OUs oder bestimmte OU-Objekte in AD entfernen|
|Remove-DomainObjectAcl|Remove-ObjectAcl|ACLs für das angegebene AD-Objekt entfernen|
|Remove-DomainObject|Remove-ADObject|Angegebenes Domänenobjekt entfernen|
|Remove-DomainUser|Remove-ADUser|Angegebenen Domänenbenutzer in AD entfernen|
|Set-DomainDNSRecord||Domänen-DNS-Eintrag festlegen|
|Set-DomainUserPassword||Passwort für angegebenen Domänenbenutzer festlegen|
|Set-DomainComputerPassword||Passwort für angegebenen Domänencomputer festlegen|
|Set-DomainObject|Set-ADObject|Für angegebene Domänenobjekte in AD festlegen|
|Set-DomainObjectDN|Set-ADObjectDN|Ändert das distinguishedName-Attribut des Objekts sowie die OU|
|Set-DomainObjectOwner|Set-ObjectOwner|Besitzer des AD-Objekts festlegen|
|Set-ShadowCredential|Set-ShadowCred|msDS-KeyCredentialLink (Shadow Credentials) für ein Domänenobjekt verwalten|
|Get-ShadowCredential|Get-ShadowCred|Shadow Credentials (msDS-KeyCredentialLink) für ein Domänenobjekt oder alle Objekte auflisten|
|Remove-ShadowCredential|Remove-ShadowCred|Shadow Credentials per DeviceId entfernen oder alle von einem Domänenobjekt löschen|
|Add-DomainDNSRecord||Domänen-DNS-Eintrag hinzufügen|
|Disable-DomainDNSRecord||DNS-Eintrag deaktivieren, indem auf eine ungültige Adresse verwiesen wird|
|Add-DomainGMSA|Add-GMSA|Ein neues gruppenverwaltetes Dienstkonto (gMSA) in der Domäne erstellen|
|Add-DomainDMSA|Add-GMSA|Ein neues delegiertes verwaltetes Dienstkonto (dMSA) in der Domäne erstellen|
|Add-DomainUser|Add-ADUser|Neuen Domänenbenutzer in AD hinzufügen|
|Add-DomainComputer|Add-ADComputer|Neuen Domänencomputer in AD hinzufügen|
|Add-DomainGroupMember|Add-GroupMember|Neues Mitglied zur angegebenen Domänengruppe in AD hinzufügen|
|Add-DomainOU|Add-OU|Neues OU-Objekt in AD hinzufügen|
|Add-DomainGPO|Add-GPO|Neues GPO-Objekt in AD hinzufügen|
|Add-DomainObjectAcl|Add-ObjectAcl|Unterstützte Rechte sind bisher All, DCsync, RBCD, ShadowCred, WriteMembers|
|Clear-Cache||Cache leeren|

### GPO-Funktionen

| Module | Alias | Description |
| ------ | ----- | ---- |
|Get-DomainGPO||Domänen-Gruppenrichtlinienobjekte abfragen|
|Get-DomainGPOLocalGroup|Get-GPOLocalGroup|Alle GPOs in einer Domäne abfragen, die lokale Gruppenmitgliedschaften über `Restricted Groups` oder `Group Policy preferences` ändern|
|Add-GPLink||Neuen GPO-Link zu einer OU erstellen|
|Remove-GPLink||GPO-Link von einer OU entfernen|

### Computer-Enumeration-Funktionen

| Module | Alias | Description |
| ------ | ----- | ---- |
|Get-NetSession||[MS-SRVS] Sitzungsinformationen für den lokalen oder einen entfernten Computer abfragen|
|Get-NetShare||Offene Freigaben auf dem lokalen oder einem entfernten Computer abfragen|
|Get-NetLoggedOn||[MS-WKST] Angemeldete Benutzer auf dem lokalen oder einem entfernten Computer abfragen|
|Get-EventLog||[MS-EVEN6] Windows-Ereignisprotokolle von einem entfernten Computer per RPC abfragen|
|Get-EventLogChannel||[MS-EVEN6] Ereignisprotokollkanäle auf einem entfernten Computer mit Erkennung von Sicherheitsprodukten auflisten|
|Get-EventLogPublisher||[MS-EVEN6] Ereignisprotokoll-Herausgeber auf einem entfernten Computer mit Erkennung von Sicherheitsprodukten auflisten|
|Get-NetService||[MS-SCMR] Ausgeführte Dienste auf dem lokalen oder einem entfernten Computer abfragen|
|Stop-NetService||[MS-SCMR] Einen bestimmten Dienst auf dem lokalen oder einem entfernten Computer beenden|
|Get-NetProcess|tasklist|[MS-TSTS] Ausgeführte Prozesse auf dem lokalen oder einem entfernten Computer abfragen|
|Stop-NetProcess|taskkill|[MS-TSTS] Einen bestimmten Prozess auf dem lokalen oder einem entfernten Computer beenden|
|Get-NetTerminalSession||[MS-TSTS] Aktive Terminalsitzungen auf dem lokalen oder einem entfernten Computer abfragen|
|Remove-NetTerminalSession||[MS-TSTS] Eine bestimmte Terminalsitzung auf dem lokalen oder einem entfernten Computer beenden|
|Stop-Computer|Shutdown-Computer|[MS-TSTS] Einen entfernten Computer herunterfahren|
|Restart-Computer|Reboot-Computer|[MS-TSTS] Einen entfernten Computer neu starten|

### ADCS-Funktionen

| Module | Alias | Description |
| ------ | ----- | ---- |
|Get-DomainCATemplate|Get-CATemplate|Verfügbare CA-Vorlagen abfragen. Unterstützt Filterung nach verwundbaren Vorlagen|
|Get-DomainCA|Get-CA|Zertifizierungsstelle (CA) abfragen|
|Remove-DomainCATemplate|Remove-CATemplate|Angegebene Domänen-CA-Vorlage entfernen|
|Set-DomainCATemplate|Set-CATemplate|Attribute des Domänenobjekts einer CA-Vorlage ändern|
|Add-DomainCATemplate|Add-CATemplate|Neue Domänen-CA-Vorlage hinzufügen|
|Add-DomainCATemplateAcl|Add-CATemplateAcl|ACL zu einer Zertifikatsvorlage hinzufügen. Unterstützte Rechte sind bisher All, Enroll, Write|

### Exchange-Funktionen

| Module | Alias | Description |
| ------ | ----- | ----------- |
|Get-ExchangeServer|Get-Exchange|Liste der verfügbaren Exchange-Server in der Domäne abrufen|

### Domänenvertrauens-Funktionen

| Module | Alias | Description |
| ------ | ----- | ---- |
|Get-DomainTrust||Alle Domänenvertrauensstellungen abfragen|
|Get-DomainTrustMapping||Rekursiv alle von der aktuellen Domäne aus erreichbaren Vertrauensstellungen abbilden. Springt zu jedem Vertrauenspartner und fasst die Ergebnisse mit den Spalten `SourceName` / `TargetName` zusammen (entspricht `Get-DomainTrustMapping` aus PowerView.ps1). Mit `-NoRecurse` die Einschränkung auf die Startdomäne vornehmen.|
|Get-DomainForeignUser|Find-ForeignUser|Benutzer abfragen, die in einer Gruppe außerhalb der Domäne des Benutzers sind|
|Get-DomainForeignGroupMember|Find-ForeignGroup|Gruppen mit Benutzern außerhalb der Domäne der Gruppe abfragen und nach fremden Mitgliedern suchen|

### Sonstige Funktionen

| Module | Alias | Description |
| ------ | ----- | ---- |
|ConvertFrom-SID||Eine angegebene Sicherheitskennung (SID) in Benutzer-/Gruppennamen umwandeln|
|ConvertFrom-UACValue||Wandelt einen UAC-Integerwert in eine lesbare Form um|
|Get-NamedPipes||Named Pipes für einen bestimmten Computer auflisten|
|Invoke-DFSCoerce||Erzwingt die Authentifizierung von Computerkonten über MS-DFSNM NetrDfsRemoveStdRoot()|
|Invoke-Kerberoast||Fordert ein Kerberos-Ticket für einen angegebenen Dienstprinzipalnamen (SPN) an|
|Invoke-PrinterBug||Löst die Funktion MS-RPRN RpcRemoteFindFirstPrinterChangeNotificationEx aus, um einen Server zu zwingen, sich bei einem bestimmten Computer zu authentifizieren|
|Unlock-ADAccount||Domänenkonten durch Ändern des lockoutTime-Attributs entsperren|
|Find-LocalAdminAccess||Findet Computer in der lokalen Domäne, auf denen der aktuelle Benutzer lokale Administratorrechte besitzt|

### Protokollierung

Wir überspringen niemals die Protokollierung, um die durchgeführten Aktionen nachzuverfolgen. Standardmäßig erstellt PowerView einen `.powerview`-Ordner im Home-Verzeichnis des aktuellen Benutzers _(~)_. Jede Protokolldatei wird basierend auf dem aktuellen Datum erzeugt.
Beispielpfad: `/root/.powerview/logs/bionic.local/2024-02-13.log`

### Schwachstellenerkennung

PowerView.py enthält ein integriertes Schwachstellenerkennungssystem, das automatisch häufige Active-Directory-Sicherheitsprobleme identifiziert. Beim Abfragen von Objekten werden Schwachstellen in der Ausgabe angezeigt:```
vulnerabilities: [VULN-026] Domain with high machine account quota (allows users to add computer accounts) (MEDIUM)
                 [VULN-029] Domain with weak minimum password length policy (less than 8 characters) (HIGH)

Benutzerdefinierte Regeln

Sie können benutzerdefinierte Schwachstellenerkennungsregeln definieren, indem Sie die Datei vulns.json im PowerView-Speicherverzeichnis (~/.powerview/vulns.json) ändern.

Jede Schwachstellenregel hat die folgende Struktur:```json "rule_name": { "description": "Human-readable description of the vulnerability", "rules": [ { "attribute": "attributeName", "condition": "condition_type", "value": "value_to_check" }, { "attribute": "anotherAttribute", "condition": "another_condition", "value": "another_value" } ], "exclusions": [ { "attribute": "attributeName", "condition": "condition_type", "value": "value_to_exclude" } ], "severity": "low|medium|high|critical", "id": "VULN-XXX", "rule_operator": "AND|OR", "exclusion_operator": "AND|OR", "details": "Optional detailed explanation of the vulnerability and remediation steps" }

**Regelkomponenten:**

- **rules**: Liste der Bedingungen, die erfüllt sein müssen, damit die Schwachstelle erkannt wird
- **exclusions**: Liste der Bedingungen, die, wenn sie erfüllt sind, ein Objekt von der Erkennung ausschließen, selbst wenn es den Regeln entspricht
- **rule_operator**: Wie mehrere Regeln kombiniert werden (Standard: "OR")
  - "AND": Alle Regeln müssen übereinstimmen
  - "OR": Jede Regel kann übereinstimmen
- **exclusion_operator**: Wie mehrere Ausschlüsse kombiniert werden (Standard: "OR")
  - "OR": Jeder Ausschluss kann zutreffen, um das Objekt auszuschließen
  - "AND": Alle Ausschlüsse müssen zutreffen, um das Objekt auszuschließen
- **negate**: Optionaler boolescher Wert (True/False), der zu jeder Regel hinzugefügt werden kann, um ihr Ergebnis umzukehren

**Unterstützte Bedingungen:**

| Bedingung | Beschreibung |
| --------- | ----------- |
| `exists` | Attribut existiert |
| `not_exists` | Attribut existiert nicht |
| `equals` | Exakte Übereinstimmung (Groß-/Kleinschreibung wird ignoriert) |
| `not_equals` | Keine exakte Übereinstimmung |
| `contains` | Teilstring-Übereinstimmung (Groß-/Kleinschreibung wird ignoriert) |
| `not_contains` | Keine Teilstring-Übereinstimmung |
| `startswith` | Beginnt mit Zeichenfolge (Groß-/Kleinschreibung wird ignoriert) |
| `endswith` | Endet mit Zeichenfolge (Groß-/Kleinschreibung wird ignoriert) |
| `older_than` | Datum ist älter als die angegebene Anzahl von Tagen |
| `newer_than` | Datum ist neuer als die angegebene Anzahl von Tagen |
| `greater_than` | Numerischer Wert ist größer als angegeben |
| `less_than` | Numerischer Wert ist kleiner als angegeben |
| `greater_than_or_equal` | Numerischer Wert ist größer als oder gleich dem angegebenen Wert |
| `less_than_or_equal` | Numerischer Wert ist kleiner als oder gleich dem angegebenen Wert |
| `has_flag` | Bit-Flag ist in einem numerischen Wert gesetzt |
| `missing_flag` | Bit-Flag ist in einem numerischen Wert nicht gesetzt |
| `any_flag_set` | Eines der angegebenen Flags ist gesetzt |
| `all_flags_set` | Alle angegebenen Flags sind gesetzt |

**Mehrere Werte:**

Sie können mehrere Werte für eine Bedingung angeben, indem Sie:
1. Durch Pipe getrennte Zeichenfolge: `"value": "value1|value2|value3"`
2. Listenformat: `"value": ["value1", "value2", "value3"]`

**Beispielregel:**```json
"weak_password_policy": {
    "description": "Domain with weak minimum password length policy (less than 8 characters)",
    "rules": [
        {
            "attribute": "objectClass",
            "condition": "contains",
            "value": "domainDNS"
        },
        {
            "attribute": "minPwdLength",
            "condition": "less_than",
            "value": 8
        }
    ],
    "exclusions": [],
    "severity": "high",
    "id": "VULN-029",
    "rule_operator": "AND"
}

MCP

[!note] Dies ist nicht im Basis-Projekt installiert enthalten. Sie können pip3 install .[mcp] oder pip3 install powerview[mcp] ausführen, um die MCP-Funktionalitäten einzubinden.

Dies aktiviert den Model Context Protocol-Server und ermöglicht es KI-Agenten, über eine standardisierte Schnittstelle per Streamable-HTTP-Transport mit der PowerView-Funktionalität zu interagieren. Weitere Details finden Sie in der MCP-Dokumentation.

MCP-Server starten```bash powerview domain.local/lowpriv:[email protected] --mcp [--mcp-host 0.0.0.0] [--mcp-port 8888] [--mcp-path powerview]

Der MCP-Server stellt den Großteil der Funktionalität von PowerView über eine standardisierte Tool-Schnittstelle bereit. Dazu gehört die Möglichkeit:
- Active Directory-Objekte (Benutzer, Computer, Gruppen, OUs) abzufragen und aufzulisten
- Informationen über Domänenvertrauensstellungen, GPOs und Gruppenmitgliedschaften abzurufen
- Nach Sicherheitslücken und Fehlkonfigurationen zu suchen
- ...

#### Claude Desktop
Claude Desktop unterstützt noch keinen HTTP-basierten Transport [Github](https://github.com/orgs/modelcontextprotocol/discussions/16). Möglicherweise möchten Sie [mcp-proxy](https://github.com/sparfenyuk/mcp-proxy) verwenden.

* `mcp-proxy` installieren```bash
# Option 1: With uv (recommended)
uv tool install mcp-proxy

# Option 2: With pipx (alternative)
pipx install mcp-proxy

Ändern Sie `%APPDATA%\Claude\claude_desktop_config.json````json { "mcpServers": { "Powerview": { "command": "mcp-proxy", "args": ["http://10.10.10.10:5000/powerview"] } } }

#### Cursor
Sie können dies in den Cursor-Einstellungen unter der Schaltfläche für MCP-Optionen ändern.

>[!tip]
>Aktivieren Sie den YOLO-Modus, um den autonomen Modus zu aktivieren, damit Sie nicht jedes Mal auf „Run Tool“ klicken müssen. Weitere Informationen finden Sie [hier](https://docs.cursor.com/chat/agent#yolo-mode)```json
{
  "mcpServers": {
    "Powerview": {
      "url": "http://127.0.0.1:5000/powerview"
    }
  }
}

[!warning] Bei der Verwendung von MCP mit öffentlichen KI-Modellen (wie Claude, GPT usw.) können Ihre Active-Directory-Daten an diese Dienste übertragen und gemäß deren Datenverarbeitungsrichtlinien protokolliert werden. Seien Sie sich der Offenlegung vertraulicher Informationen bewusst, wenn Sie diese Tools verwenden. Wir übernehmen keine Verantwortung für Datenlecks oder Sicherheitsauswirkungen, die durch die Verbindung von PowerView mit KI-Diensten Dritter entstehen. Selbst gehostet FTW!

Plugins

PowerView unterstützt ein dekoratorbasiertes Plugin-System, mit dem Sie neue Befehle hinzufügen und Hooks vor/nach bestehenden Befehlen einfügen können.

So funktioniert es```

                     ┌────────────────────────────────┐
                     │         Plugin Loader          │
                     │  Scans directories on startup  │
                     └──────────────┬─────────────────┘
                                    │
                    ┌───────────────┴───────────────┐
                    ▼                               ▼
        ┌───────────────────┐           ┌───────────────────┐
        │ builtin/ plugins  │           │  ~/.powerview/    │
        │                   │           │  plugins/         │
        │  dehashed.py      │           │                   │
        │  highlight.py     │           │  my_plugin.py     │
        │  recon.py         │           │  ...              │
        └───────────────────┘           └───────────────────┘
                    │                               │
                    └───────────────┬───────────────┘
                                    ▼
                        ┌──────────────────────┐
                        │   Sanity Validation  │
                        │  Check signatures &  │
                        │  required decorators │
                        └──────────┬───────────┘
                                    ▼
                        ┌──────────────────────┐
                        │   Plugin Registry    │
                        │                      │
                        │  commands: {}        │
                        │  before_hooks: {}    │
                        │  after_hooks: {}     │
                        └──────────┬───────────┘
                                    │
                                    ▼
            ┌─────────────────────────────────────────────────┐
            │              Command Execution Flow             │
            │                                                 │
            │  User Input: "Get-DomainUser -Identity admin"   │
            │                       │                         │
            │                       ▼                         │
            │          ┌────────────────────────┐             │
            │          │   @before hooks        │             │
            │          │   (modify args)        │             │
            │          └───────────┬────────────┘             │
            │                      │                          │
            │                      ▼                          │
            │          ┌────────────────────────┐             │
            │          │   Core command OR      │             │
            │          │   @command plugin      │             │
            │          └───────────┬────────────┘             │
            │                      │                          │
            │                      ▼                          │
            │          ┌────────────────────────┐             │
            │          │   @after hooks         │             │
            │          │   (modify results)     │             │
            │          └───────────┬────────────┘             │
            │                      │                          │
            │                      ▼                          │
            │               Format & Display                  │
            └─────────────────────────────────────────────────┘

Plugins are single `.py` files discovered automatically from two paths:

| Pfad | Zweck |
|------|---------|
| `powerview/plugins/builtin/` | Wird mit dem Paket ausgeliefert |
| `~/.powerview/plugins/` | Benutzerverwaltete Plugins |

#### Integrierte Plugins

| Plugin | Befehle | Hooks | Beschreibung |
|--------|----------|-------|-------------|
| Recon | `Invoke-DomainRecon` | — | Zusammenfassung der Domänen-Aufklärung per Einzelbefehl |
| Highlight | — | `after:Get-DomainUser` | Hebt Passwörter hervor, die in Benutzerbeschreibungen gefunden wurden |

#### Plugin-Verwaltung```
Get-Plugin                          # List all plugins with status
Enable-Plugin -Name <plugin_name>   # Enable a disabled plugin
Disable-Plugin -Name <plugin_name>  # Disable a plugin at runtime

Ein Plugin schreiben

Erstelle eine .py-Datei in ~/.powerview/plugins/. Plugins verwenden drei Dekoratoren: @command, um neue Befehle zu registrieren, @before, um Logik vor einem vorhandenen Befehl auszuführen, und @after, um Logik danach auszuführen.```python

~/.powerview/plugins/custom_enum.py

from powerview.plugins import command, before, after, PowerviewPlugin

plugin = PowerviewPlugin( name="CustomEnum", description="Custom enumeration helpers", author="yourname", version="1.0", )

@command("Get-DomainAdminUser", args=["-Identity", "-Properties", "-SearchBase"], description="Find users with adminCount=1") def get_domainadminuser(pv, args=None, identity=None, properties=None, searchbase=None): results = pv.get_domainuser( identity=identity or "*", properties=properties or ["sAMAccountName", "adminCount", "memberOf", "description"], searchbase=searchbase, ) if results: return [r for r in results if str(r.get("attributes", r).get("adminCount", "")) == "1"] return results

@before("Get-DomainUser", priority=10) def inject_enabled_filter(pv, args): """Automatically filter out disabled accounts.""" if not hasattr(args, 'ldapfilter') or not args.ldapfilter: args.ldapfilter = "(!(userAccountControl:1.2.840.113556.1.4.803:=2))" return args

@after("Get-DomainUser", priority=20) def add_password_age(pv, args, results): """Enrich results with password age.""" from datetime import datetime, timezone if not results: return results for entry in results: attrs = entry.get("attributes", entry) pwdlast = attrs.get("pwdLastSet") if isinstance(pwdlast, datetime): if pwdlast.tzinfo is None: pwdlast = pwdlast.replace(tzinfo=timezone.utc) age = (datetime.now(timezone.utc) - pwdlast).days attrs["PasswordAge"] = f"{age} days" return results

**Decoratoren:**

| Decorator | Signatur | Beschreibung |
|-----------|-----------|--------------|
| `@command(name, args, description)` | `func(pv, args=None, **kwargs)` | Registriert einen neuen Verb-Substantiv-Befehl |
| `@before(command_name, priority)` | `func(pv, args)` | Wird vor einem Befehl ausgeführt. Gibt modifizierte `args` oder `None` zurück |
| `@after(command_name, priority)` | `func(pv, args, results)` | Wird nach einem Befehl ausgeführt. Gibt modifizierte `results` oder `None` zurück |

> [!NOTE]
> `@before` und `@after` akzeptieren einen einzelnen Befehlsnamen oder eine Liste (z. B. `@after(["Get-DomainUser", "Get-DomainComputer"])`). Niedrigere Prioritätswerte werden zuerst ausgeführt.

**Erweiterte Argumentdefinitionen:**

Plugin-Argumente können einfache Zeichenketten (`"-Identity"`) oder Dictionaries für eine feinere Steuerung sein:```python
@command("Get-CustomThing", args=[
    "-Identity",
    {"name": "-Days", "type": int, "default": 90, "help": "Threshold in days"},
    {"name": "-Verbose", "action": "store_true", "help": "Show details"},
])

[!TIP] Alle Plugin-Befehle erhalten automatisch die Flags -OutFile, -TableView und -SortBy.

Beliebteste

powerview.py