Obtener los usuarios privilegiados que no se encuentran en el grupo de usuarios protegidos
# Obtener miembros de grupos privilegiados
$PrivilegedGroups = @("Domain Admins", "Enterprise Admins", "Schema Admins", "Administrators")
$PrivilegedUsers = foreach ($Group in $PrivilegedGroups) {
Get-ADGroupMember -Identity $Group -Recursive | Where-Object { $_.objectClass -eq 'user' }
}
# Obtener usuarios del grupo Protected Users
$ProtectedUsers = Get-ADGroupMember -Identity "Protected Users" -Recursive | Where-Object { $_.objectClass -eq 'user' }
# Preparar resultados
$Results = foreach ($User in $PrivilegedUsers) {
$adUser = Get-ADUser -Identity $User.SamAccountName -Properties adminCount
$isProtected = $ProtectedUsers.SamAccountName -contains $User.SamAccountName
$isVulnerable = if (-not $isProtected -or $adUser.adminCount -ne 1) { $true } else { $false }
[PSCustomObject]@{
Name = $User.Name
SamAccountName = $User.SamAccountName
DistinguishedName = $User.DistinguishedName
InProtectedUsers = $isProtected
AdminCount = $adUser.adminCount
IsVulnerable = $isVulnerable
}
}
# Incluir la fecha en el nombre del archivo
$Date = Get-Date -Format "yyyyMMdd"
$FileName = ".\Privileged_Users_Status_$Date.csv"
# Exportar resultados a CSV
$Results | Export-Csv -Path $FileName -NoTypeInformation
Write-Output "Reporte exportado a $FileName"
Obtiene los usuarios miembros de grupos privilegiados.
Compara contra los miembros del grupo Protected Users.
Consulta el atributo adminCount de cada usuario.
Agrega columnas:
Si pertenece o no a Protected Users.
El valor de adminCount.
Si es considerado vulnerable (por no estar en Protected Users o por no tener adminCount = 1).
Incluye la fecha en el nombre del CSV para trazabilidad.
Grupos
Obtener todos los grupos del dominio
Herramienta
Comando
PowerView
Net
ADSI
Obtener propiedades de un grupo
Herramienta
Comando
AD Module
Net
Obtener miembros de un grupo
Herramienta
Comando
AD Module
Obtener grupos a los que pertenece un grupo
Herramienta
Comando
AD Module
Obtener todos los miembros de todos los grupos de forma recursiva
# Obtener todos los grupos del dominio
$allGroups = Get-ADGroup -Filter *
# Crear lista para guardar resultados
$groupMembers = @()
# Iterar sobre cada grupo
foreach ($group in $allGroups) {
try {
$members = Get-ADGroupMember -Identity $group.SamAccountName -Recursive -ErrorAction Stop
foreach ($member in $members) {
$groupMembers += [PSCustomObject]@{
GroupName = $group.Name
GroupSamAccount = $group.SamAccountName
MemberName = $member.Name
MemberSamAccount = $member.SamAccountName
MemberObjectClass = $member.ObjectClass
DistinguishedName = $member.DistinguishedName
}
}
} catch {
Write-Warning "Error al enumerar miembros del grupo $($group.SamAccountName): $_"
}
}
# Mostrar en formato tabla en consola
$groupMembers | Format-Table -AutoSize
# Exportar a CSV
$groupMembers | Export-Csv -NoTypeInformation -Encoding UTF8 -Path ".\domain_group_members_recursive.csv"
Obtener todos los miembros de todos los grupos (lista txt) de forma recursiva
Input: Lista de grupos en un fichero txt (ej: group_list.txt)
Server Management
IT Support
Ejecución del script:
# Definir la ruta del archivo de entrada con la lista de grupos
$inputFile = ".\group_list.txt"
$outputFile = ".\groups_members.csv"
# Verificar que el archivo de entrada existe
if (-not (Test-Path $inputFile)) {
Write-Error "El archivo de entrada $inputFile no existe."
exit
}
# Leer los nombres de los grupos desde el archivo de texto
$groupNames = Get-Content $inputFile
# Crear un array para almacenar los resultados
$groupMembers = @()
# Configurar el encabezado del CSV con el formato requerido "GroupName;Member"
"GroupName;Member" | Out-File -FilePath $outputFile -Encoding UTF8
# Iterar sobre cada grupo en la lista
foreach ($groupName in $groupNames) {
# Eliminar espacios en blanco al inicio y final
$groupName = $groupName.Trim()
# Saltar líneas vacías
if ([string]::IsNullOrEmpty($groupName)) {
continue
}
try {
Write-Host "Procesando grupo: $groupName"
# Obtener los miembros del grupo recursivamente
$members = Get-ADGroupMember -Identity $groupName -Recursive -ErrorAction Stop
if ($members.Count -eq 0) {
# Si el grupo no tiene miembros, añadir una entrada indicándolo
"$groupName;Sin miembros" | Out-File -FilePath $outputFile -Encoding UTF8 -Append
} else {
# Procesar cada miembro del grupo
foreach ($member in $members) {
# Escribir directamente al archivo CSV con el formato "GroupName;Member"
"$groupName;$($member.Name)" | Out-File -FilePath $outputFile -Encoding UTF8 -Append
}
}
} catch {
$errorMessage = $_.Exception.Message
Write-Warning "Error al enumerar miembros del grupo $groupName`: $errorMessage"
# Registrar los grupos con error en el CSV
"$groupName;Error: $errorMessage" | Out-File -FilePath $outputFile -Encoding UTF8 -Append
}
}
Write-Host "Proceso completado. Resultados guardados en $outputFile"
Output: Fichero CSV con la lista de grupos y miembros.
Obtener los miembros recursivos del grupo "Domain Admins"
$domainAdmins = Get-DomainGroupMember -Identity "Domain Admins" -Recurse
# Mostrar los resultados en formato tabla
$domainAdmins | Select-Object Name, SamAccountName, ObjectClass, DistinguishedName | Format-Table -AutoSize
# Exportar todos los atributos disponibles a un fichero CSV
$domainAdmins | Select-Object * | Export-Csv -Path ".\domain_admins_members.csv" -NoTypeInformation -Encoding UTF8
Obtener todos los grupos con "admin" y sus miembros (si los hay)
# Enumerar grupos con "admin" en el nombre
$adminGroups = Get-DomainGroup -LDAPFilter "(name=*admin*)"
# Crear una lista para todos los resultados
$allAdminGroupMembers = @()
foreach ($group in $adminGroups) {
try {
# Intentar obtener los miembros del grupo
$members = Get-DomainGroupMember -Identity $group.DistinguishedName -Recurse -ErrorAction Stop
if ($members.Count -eq 0) {
# Grupo sin miembros
$entry = [PSCustomObject]@{
GroupName = $group.Name
Name = ''
SamAccountName = ''
ObjectClass = ''
DistinguishedName = ''
}
$allAdminGroupMembers += $entry
} else {
# Agregar cada miembro al array
foreach ($member in $members) {
$member | Add-Member -NotePropertyName GroupName -NotePropertyValue $group.Name -Force
$allAdminGroupMembers += $member
}
}
} catch {
# Si el grupo no permite consultar miembros, registrar igual el grupo vacío
Write-Warning "❌ Error en grupo '$($group.Name)': $_"
$entry = [PSCustomObject]@{
GroupName = $group.Name
Name = 'ERROR'
SamAccountName = ''
ObjectClass = ''
DistinguishedName = ''
}
$allAdminGroupMembers += $entry
}
}
# Mostrar en tabla los resultados clave
$allAdminGroupMembers |
Select-Object GroupName, Name, SamAccountName, ObjectClass, DistinguishedName |
Format-Table -AutoSize
# Exportar todo a CSV
$allAdminGroupMembers |
Select-Object * |
Export-Csv -Path ".\admin_groups_members_full.csv" -NoTypeInformation -Encoding UTF8
Equipos / Servidores
Obtener equipos/servidores
Herramienta
Comando
PowerView
ADSI
Unidades organizativas
Obtener unidades organizativas
Herramienta
Comando
PowerView
Obtener todos los equipos asociados a una unidad organizativa
Herramienta
Comando
PowerView
Obtener GPLink asociada a una unidad organizativa
Herramienta
Comando
PowerView
El siguiente comando une los dos anteriores en uno:
Política de contraseñas
Herramienta
Comando
Net
ACL (Listas de control de acceso)
Obtener las ACLs
GUI con Out-GridView:
Invoke-ACLScanner -ResolveGUIDs | Out-GridView
PowerShell:
Herramienta
Comando
PowerView
Obtener los ACLs de un objeto, por ejemplo, "Administrator"
# Obtener los ACLs del objeto 'Administrator'
$acls = Get-DomainObjectAcl -SamAccountName Administrator -ResolveGUIDs
# Resolver el SID de cada ACL manualmente si no está ya resuelto
foreach ($acl in $acls) {
if (-not $acl.IdentityReference) {
try {
$sidObj = New-Object System.Security.Principal.SecurityIdentifier($acl.SecurityIdentifier)
$acl | Add-Member -NotePropertyName "IdentityReference" -NotePropertyValue $sidObj.Translate([System.Security.Principal.NTAccount]) -Force
} catch {
$acl | Add-Member -NotePropertyName "IdentityReference" -NotePropertyValue $acl.SecurityIdentifier -Force
}
}
}
# Mostrar campos clave
$acls | Select-Object IdentityReference, ActiveDirectoryRights, ObjectAceType, InheritanceFlags, AceType, IsInherited |
Format-Table -AutoSize
# Exportar todos los campos a CSV
$acls | Select-Object * | Export-Csv -Path ".\administrator_objectacls_full.csv" -NoTypeInformation -Encoding UTF8
Write-Host "`nExportación completada: administrator_objectacls_full.csv" -ForegroundColor Green
Obtener los ACLs de SYSVOL
# Ruta SYSVOL adaptada a tu dominio actual
$sysvolPath = "\\dc.xtormincorp.local\SYSVOL"
# Obtener ACL del recurso compartido
$acl = Get-PathAcl -Path $sysvolPath
# Mostrar campos clave en tabla
$acl | Select-Object IdentityReference, FileSystemRights, AccessControlType, IsInherited, InheritanceFlags, PropagationFlags |
Format-Table -AutoSize
# Exportar todos los datos a CSV
$acl | Select-Object * | Export-Csv -Path ".\sysvol_acl_full.csv" -NoTypeInformation -Encoding UTF8
Write-Host "`nExportación completada: sysvol_acl_full.csv" -ForegroundColor Green
Lo mismo, pero recursivo:
# Ruta SYSVOL adaptada a tu dominio
$rootPath = "\\dc.xtormincorp.local\SYSVOL"
# Array para almacenar todos los ACLs
$allACLs = @()
# Obtener recursivamente todos los archivos y carpetas
$items = Get-ChildItem -Path $rootPath -Recurse -Force -ErrorAction SilentlyContinue
# Añadir también la raíz
$items += Get-Item -Path $rootPath
foreach ($item in $items) {
try {
$acl = Get-PathAcl -Path $item.FullName
foreach ($entry in $acl) {
$entry | Add-Member -NotePropertyName Path -NotePropertyValue $item.FullName -Force
$allACLs += $entry
}
} catch {
Write-Warning "❌ Error al obtener ACL de: $($item.FullName)"
}
}
# Mostrar en tabla campos clave
$allACLs |
Select-Object Path, IdentityReference, FileSystemRights, AccessControlType, IsInherited |
Format-Table -AutoSize
# Exportar todos los campos a CSV
$allACLs | Select-Object * | Export-Csv -Path ".\sysvol_recursive_acls.csv" -NoTypeInformation -Encoding UTF8
Write-Host "`nExportación completada: sysvol_recursive_acls.csv" -ForegroundColor Green
Obtener ACLs que podrían ser interesantes
Herramienta
Comando
PowerView
GPO
Se enumera información sobre las políticas de grupo e información de la configuración del usuario. Como los grupos de seguridad a los que pertenece, versión del sistema operativo, nombre de dominio, etc.
Herramienta
Comando
PowerView
CMD
Objetos AD
Obtener todos los objetos que hayan cambiado tras una determinada fecha
Herramienta
Comando
AD Module
Enumerar cuentas que cuenten con un badPwdCount > 0
Esto es útil para enumerar las cuentas que ya cuenten con intentos de contraseñas fallidas. ¿Y por qué es interesante este dato? Porque antes de hacer un ataque de password spraying, se pueden omitir estas cuentas de la prueba para evitar bloquearlas:
Herramienta
Comando
AD Module
Sesiones activas
Enumerar todas las sesiones usando el fichero CSV de equipos listado en el script anterior:
# Cargar equipos desde el CSV exportado anteriormente
$computers = Import-Csv -Path ".\domain_computers.csv"
# Array para almacenar resultados
$userSessions = @()
foreach ($computer in $computers) {
$hostname = $computer.dnshostname
if (-not $hostname) {
Write-Warning ("El equipo {0} no tiene un DNS hostname definido, se omite." -f $computer.name)
continue
}
Write-Host "`nObteniendo sesiones de: $hostname" -ForegroundColor Cyan
$result = [PSCustomObject]@{
Hostname = $hostname
NetLoggedOnUsers = $null
LocallyLoggedUsers = $null
LastLoggedUser = $null
}
try {
$netLogged = Get-NetLoggedon -ComputerName $hostname
if ($netLogged) {
$result.NetLoggedOnUsers = ($netLogged | Select-Object -ExpandProperty UserName) -join ', '
}
} catch {
$msg = $_.Exception.Message
Write-Warning ("Error en Get-NetLoggedon para {0}: {1}" -f $hostname, $msg)
}
try {
$localLogged = Get-LoggedonLocal -ComputerName $hostname
if ($localLogged) {
$result.LocallyLoggedUsers = ($localLogged | Select-Object -ExpandProperty UserName) -join ', '
}
} catch {
$msg = $_.Exception.Message
Write-Warning ("Error en Get-LoggedonLocal para {0}: {1}" -f $hostname, $msg)
}
try {
$lastLogged = Get-LastLoggedOn -ComputerName $hostname
if ($lastLogged) {
$result.LastLoggedUser = $lastLogged.UserName
}
} catch {
$msg = $_.Exception.Message
Write-Warning ("Error en Get-LastLoggedOn para {0}: {1}" -f $hostname, $msg)
}
$userSessions += $result
}
# Mostrar en tabla
$userSessions | Format-Table -AutoSize
# Exportar a CSV
$userSessions | Export-Csv -Path ".\user_sessions_all.csv" -NoTypeInformation -Encoding UTF8
Write-Host "`nSesiones exportadas a 'user_sessions_all.csv'" -ForegroundColor Green
Enumerar las sesiones de todas las máquinas remotas
Es una herramienta en PowerShell desarrollada por NetSPI que permite descubrir y analizar potenciales vulnerabilidades en carpetas compartidas vía SMB en entornos Active Directory.
Su objetivo es facilitar la identificación de permisos excesivos, shares de alto riesgo y potenciales vectores de ataque a través de un análisis automatizado con generación de informes en HTML y CSV.
Import-Module .\PowerHuntShares.psm1
# Reduce SSL operating level to support connection to GitHub
[System.Net.ServicePointManager]::ServerCertificateValidationCallback ={$true}
[Net.ServicePointManager]::SecurityProtocol=[Net.SecurityProtocolType]::Tls12
# Download and load PowerHuntShares.psm1 into memory
IEX(New-Object System.Net.WebClient).DownloadString("https://raw.githubusercontent.com/NetSPI/PowerHuntShares/main/PowerHuntShares.psm1")
Se puede contar con una lista de hosts objetivo ya predefinida o que sea necesario enumerar.
Por ejemplo, se pueden enumerar los equipos en AD con el siguiente comando de PowerView y crear un txt con la lista para usarla posteriormente como lista de hosts objetivo en adelante:
