La gestión de la seguridad de Active Directory (AD) puede ser desafiante, especialmente cuando se identifican cuentas que comparten contraseñas o cuando se utilizan prácticas de autenticación débiles. , una herramienta PowerShell potente y ligera que revela rápidamente el uso compartido de contraseñas y mejora la postura de seguridad de AD de su organización. LazyAdminFinder ¿Qué es LazyAdminFinder? LazyAdminFinder es un script PowerShell que aprovecha el módulo DSInternals para: 
 
 
 
 Detectar y reportar hashes de contraseña NTLM compartidos. Archivar y comparar datos de hash históricos para identificar el reuso de contraseñas. Proporcionar informes completos que identifiquen comportamientos de cuentas de riesgo. Diseñado específicamente para administradores de Active Directory, LazyAdminFinder proporciona una visión rápida y actuable de la seguridad de contraseñas. ¿Por qué usar LazyAdminFinder? 
 
 
 
 
 
  Identify weak or compromised passwords. Security Improvement: 
 
  Maintain AD integrity for audit and compliance purposes. Compliance: 
 
  Quickly audit accounts without manually reviewing data. Efficiency: ¿Cómo funciona LazyAdminFinder? Fetch y filtro de cuentas de usuario El script recopila las cuentas de usuario de AD, filtrando las cuentas de deshabilitado, de máquina y de servicio para centrarse sólo en los usuarios activos. Extracción y archivo de hash de NTLM LazyAdminFinder extrae hashes NTLM de las cuentas y archiva de forma segura sus hashes SHA-256 para la comparación histórica. Recuperación de contraseña Al comparar la ejecución actual con archivos anteriores, la herramienta detecta el reuso de contraseñas, marcando cuentas con posibles riesgos de seguridad. 
 
 
 Sincroniza las contraseñas entre las cuentas administrativas y estándar. Los usuarios, especialmente los administradores, repetidamente resetan sus contraseñas a valores previamente utilizados. Grupos de contraseña compartidos El script identifica y agrupa las cuentas que comparten hashes NTLM idénticos, lo que puede indicar que se comparten intencionalmente las contraseñas o que varios usuarios eligen la misma contraseña de forma independiente, a menudo debido a hábitos de contraseña débiles.Por ejemplo, si varios usuarios eligen una contraseña común como "Summer2025!", LazyAdminFinder agrupará estas cuentas juntas, lo que le permitirá detectar rápidamente tanto las posibles contraseñas compartidas como el pensamiento paralelo arriscado en la creación de contraseñas. Frecuencia de uso recomendada Considere ejecutar LazyAdminFinder regularmente basándose en la política de restauración de contraseñas de su organización. Por ejemplo, si su política requiere una restauración de contraseñas cada 90 días, planifique el script para que se ejecute aproximadamente cada 100 días. Este calendario asegura que capture instancias en las que los administradores o usuarios privilegiados podrían restablecer sus contraseñas a las usadas anteriormente. Si su organización no aplica una política de reutilización de contraseñas, ejecutar LazyAdminFinder periódicamente se vuelve aún más crucial para identificar y mitigar posibles riesgos de seguridad. Instalación de LazyAdminFinder Paso 1: Preparación 
 
 
 Asegúrese de que PowerShell esté instalado en su sistema. Instalación del módulo requerido: Install-Module DSInternals
 Paso 2: Configurar el script Personalizar estos parámetros esenciales dentro del guión proporcionado: 
 
 Controlador de dominio: $dc = "your-domain-controller.example.com"
 
 
 Nombre del contexto: $nc = "DC=yourdomain,DC=com"
 
 
 Paseo del informe de salida: $outputReport = "C:\Path\To\SharedPasswordsReport.csv"
 
 
 Archivo de Directorios: $archiveDir = "C:\Path\To\HashArchives"
 Paso 3: Executa el guión Ejecutar el script como administrador de dominio: powershell.exe -ExecutionPolicy Bypass -File "C:\Path\To\LazyAdminFinder.ps1"
 Revisión de los resultados 
 
 
 Se genera un informe CSV detallado, destacando claramente las cuentas que comparten contraseñas o eligen independientemente contraseñas débiles. Los archivos históricos se almacenan de forma segura para futuras comparaciones, lo que garantiza una gestión robusta de contraseñas. Casos de uso para LazyAdminFinder 
 
 
 
 
 Auditorías de seguridad: Identificar y corregir regularmente contraseñas compartidas, débiles o comprometidas. Respuesta a incidentes: detecta rápidamente cuentas comprometidas tras incidentes de seguridad. Verificaciones de cumplimiento de rutina: Asegure el cumplimiento continuo manteniendo prácticas de seguridad de cuentas sólidas. Gestión de cuentas privilegiadas: Se dirige específicamente a administradores o usuarios privilegiados que pueden reutilizar o sincronizar contraseñas en varias cuentas. Configuración de LazyAdminFinder Siéntate libre de ajustar el guión de acuerdo a tu entorno y necesidades: 
 
 
 
 Modificar la lógica de filtro para incluir/excluir tipos de cuenta específicos. Ajuste los caminos de archivo y informe para sus preferencias de almacenamiento. Incorporar capacidades adicionales de información según sea necesario. Beneficios del uso de LazyAdminFinder 
 
 
 
 
 
  Automates complex AD security checks. Rapid Security Assessments: 
 
  Clearly identifies potential security risks within AD. Enhanced Visibility: 
 
  Enables administrators to swiftly address vulnerabilities before exploitation. Proactive Defense: LazyAdminFinder simplifica la tarea crítica de auditoría de contraseñas en Active Directory, permitiendo a los administradores mantener un entorno de TI seguro, compatible y eficiente. Descubra contraseñas compartidas, remedie los riesgos de seguridad y fortalezca su seguridad de AD sin esfuerzo con LazyAdminFinder. #Another        /\_[]_/\
#    fine      |] _||_ [|
#       ___     \/ || \/
#      /___\       ||
#     (|0 0|)      ||
#   __/{\U/}\_ ___/vvv
#  / \  {~}   / _|_P|
#  | /\  ~   /_/   []
#  |_| (____)        
#  \_]/______\  Barberion  
#     _\_||_/_     Production      
#    (_,_||_,_)
#
Import-Module DSInternals

# === Parameters ===
$dc           = "your-domain-controller.example.com"
$nc           = "DC=yourdomain,DC=com"
$outputReport = "C:\Path\To\SharedPasswordsReport.csv"
$archiveDir   = "C:\Path\To\HashArchives"

# Ensure archive directory exists
if (-not (Test-Path $archiveDir)) {
    New-Item -ItemType Directory -Path $archiveDir | Out-Null
}

$timestamp = (Get-Date).ToString("yyyyMMdd_HHmmss")

# === 1. Fetch & filter AD user accounts ===
Write-Host "[+] Fetching AD user accounts (skipping machines, service & disabled)..."
$filteredAccounts = Get-ADReplAccount -All -Server $dc -NamingContext $nc |
    Where-Object { $_.NTHash -and $_.SamAccountName } |
    Where-Object { $_.SamAccountName -notmatch '\$$' } |
    Where-Object { $_.SamAccountName -notmatch '^(?i)(svc|service)' } |
    Where-Object {
        if ($_.PSObject.Properties.Match('IsDisabled').Count -gt 0) {
            -not $_.IsDisabled
        }
        else {
            # bit 2 = disabled
            ( ($_.UserAccountControl -band 2) -eq 0 )
        }
    }

if (-not $filteredAccounts) {
    Write-Host "[-] No matching user accounts found. Exiting."
    exit
}

# === 2. Convert NTLM byte array to hex string ===
$filteredAccounts | ForEach-Object {
    $hex = [BitConverter]::ToString($_.NTHash) -replace '-', ''
    $_ | Add-Member -MemberType NoteProperty -Name NTLMHashString -Value $hex -Force
}

# === 3. Archive SHA-256 of each NTLM hash ===
Write-Host "[+] Archiving SHA-256 of each NTLM hash..."
$sha256 = [System.Security.Cryptography.SHA256]::Create()
$currentArchive = $filteredAccounts | ForEach-Object {
    $shaBytes = $sha256.ComputeHash($_.NTHash)
    $shaHex   = [BitConverter]::ToString($shaBytes) -replace '-', ''
    [PSCustomObject]@{
        SamAccountName = $_.SamAccountName
        HashSha256     = $shaHex
    }
}
$sha256.Dispose()

$archiveFile = Join-Path $archiveDir "UserHashArchive_$timestamp.csv"
$currentArchive | Export-Csv -Path $archiveFile -NoTypeInformation

# === 4. Compare to previous archive ===
$allArchives = Get-ChildItem -Path $archiveDir -Filter "UserHashArchive_*.csv" |
               Sort-Object LastWriteTime -Descending

if ($allArchives.Count -gt 1) {
    $previousFile = $allArchives[1].FullName
    Write-Host "[+] Comparing this run to previous archive: $previousFile"
    $prevData = Import-Csv $previousFile

    $reused = Compare-Object `
        -ReferenceObject $prevData `
        -DifferenceObject $currentArchive `
        -Property SamAccountName, HashSha256 `
        -IncludeEqual |
      Where-Object { $_.SideIndicator -eq '==' } |
      Select-Object SamAccountName, HashSha256

    if ($reused) {
        $reuseReport = Join-Path $archiveDir "PasswordReuse_$timestamp.csv"
        Write-Host "[!] $($reused.Count) accounts reused their old hash; exporting to $reuseReport"
        $reused | Export-Csv -Path $reuseReport -NoTypeInformation
    }
    else {
        Write-Host "[+] No password‑reuse detected this run."
    }
}
else {
    Write-Host "[+] Only one archive present; skipping reuse comparison."
}

# === 5. Shared‑password grouping & report ===
Write-Host "[+] Grouping accounts by shared NTLM hash..."
$sharedGroups = $filteredAccounts |
    Group-Object -Property NTLMHashString |
    Where-Object { $_.Count -gt 1 }

if (-not $sharedGroups) {
    Write-Host "[-] No shared hashes found."
    exit
}

$reportResults = @()
Write-Host "[+] Generating shared‑password report:"
foreach ($g in $sharedGroups) {
    $h     = $g.Name
    $users = $g.Group | ForEach-Object { $_.SamAccountName }
    $reportResults += [PSCustomObject]@{
        SharedHash = $h
        UserCount  = $users.Count
        Users      = $users -join ', '
    }

    Write-Host '----------------------------------------------'
    Write-Host "Shared Hash: $h"
    Write-Host "User Count : $($users.Count)"
    Write-Host "Users      : $($users -join ', ')"
    Write-Host '----------------------------------------------`n'
}

Write-Host "[+] Saving shared‑password report to $outputReport"
$reportResults | Export-Csv -Path $outputReport -NoTypeInformation

Write-Host "[Summary] Shared groups: $($reportResults.Count); Total archives: $($allArchives.Count)"


The code in this story is for educational purposes. The readers are solely responsible for whatever they build with it.

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Read My Stories

Este audio es producido en el idioma original de la historia!

Demasiado Largo; Para Leer

Download free Tech Leaders Productivity Report!

LazyAdminFinder: Descubre fácilmente contraseñas compartidas y mejora la seguridad de Active Directory

About Author

COMENTARIOS

ETIQUETAS

ESTE ARTÍCULO FUE PRESENTADO EN

Related Stories

Telegram: el puente de Crypto Island hacia el continente

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

La fuga rápida del sistema Claude Sonnet 3.5: un análisis forense

Una breve introducción a la teoría del cerebro de Boltzmann

Telegram: el puente de Crypto Island hacia el continente

¿Quieres ganar un concurso de redacción de HackerNoon? Esto es lo que recomiendan los ganadores del concurso #crypto-api

La fuga rápida del sistema Claude Sonnet 3.5: un análisis forense

Una breve introducción a la teoría del cerebro de Boltzmann

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps