Menaxhimi i sigurisë së Active Directory (AD) mund të jetë sfidues, veçanërisht kur identifikoni llogaritë që ndajnë fjalëkalime ose përdorni praktika të dobëta të autentifikimit. , një mjet i fuqishëm, i lehtë PowerShell që zbulon shpejt përdorimin e fjalëkalimit të përbashkët dhe përmirëson qëndrimin e sigurisë të organizatës suaj. LazyAdminFinder Çfarë është LazyAdminFinder? LazyAdminFinder është një skrip PowerShell duke përdorur modulin DSInternals për: 
 
 
 
 Zbuloni dhe raportoni hashes të ndarë të fjalëkalimit NTLM. Arkivoni dhe krahasoni të dhënat e hash historike për të identifikuar përdorimin e përsëritur të fjalëkalimit. Të sigurojë raporte të plota që identifikojnë sjelljet e llogarive të rrezikuara. I projektuar posaçërisht për administratorët e Active Directory, LazyAdminFinder ofron njohuri të shpejta dhe të veprueshme për sigurinë e fjalëkalimeve. Pse të përdorni 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: Si funksionon LazyAdminFinder? Fetch dhe filtruar llogaritë e përdoruesve Skenari mbledh llogaritë e përdoruesve AD, duke filtruar llogaritë e çaktivizuara, makinat dhe shërbimet për t'u fokusuar vetëm në përdoruesit aktivë. Ekstraktimi dhe arkivimi i NTLM Hash LazyAdminFinder extracts NTLM hashes from accounts and securely archives their SHA-256 hashes for historical comparison. Rishikimi i fjalëkalimit Duke krahasuar ekzekutimin aktual me arkivat e mëparshme, mjeti zbulon përdorimin e përsëritur të fjalëkalimit, duke shënuar llogaritë me rreziqe të mundshme të sigurisë. 
 
 
 Admins or privileged users synchronizing passwords between standard and administrative accounts. Përdoruesit, veçanërisht administratorët, vazhdimisht rivendosin fjalëkalimet e tyre në vlerat e përdorura më parë. Password të përbashkët Skenari identifikon dhe grupon llogaritë që ndajnë hashes identike NTLM, e cila mund të tregojë ose ndarjen e qëllimshme të fjalëkalimit ose përdoruesit e shumëfishtë që zgjedhin të njëjtën fjalëkalim në mënyrë të pavarur – shpesh për shkak të zakoneve të dobëta të fjalëkalimit. për shembull, nëse disa përdorues zgjedhin një fjalëkalim të përbashkët si "Summer2025!", LazyAdminFinder do t'i grupojë këto llogari së bashku, duke ju lejuar të identifikoni shpejt të dy fjalëkalimet e mundshme të përbashkëta dhe të mendoni paralelisht në krijimin e fjalëkalimeve. Frekuenca e rekomanduar e përdorimit Konsideroni drejtimin e LazyAdminFinder rregullisht bazuar në politikën e rivendosjes së fjalëkalimit të organizatës suaj. Për shembull, nëse politika juaj kërkon një rivendosje të fjalëkalimit çdo 90 ditë, planifikoni skripin për të drejtuar përafërsisht çdo 100 ditë. Kjo kohë siguron që ju të kapni raste ku administratorët ose përdoruesit e privilegjuar mund të rivendosin fjalëkalimet e tyre përsëri në ato të përdorura më parë. Nëse organizata juaj nuk zbaton një politikë të ri-përdorimit të fjalëkalimit, drejtimi i LazyAdminFinder periodikisht bëhet edhe më i rëndësishëm për të identifikuar dhe zvogëluar rreziqet e mundshme të sigurisë. Instalimi i LazyAdminFinder Hapi 1: Përgatitja 
 
 
 Sigurohuni që PowerShell është instaluar në sistemin tuaj. Instaloni modulin e kërkuar: Install-Module DSInternals
 Step 2: Configure the Script Personalizoni këto parametra thelbësorë brenda skripit të dhënë: 
 
 Kontrolli i Domain: $dc = "your-domain-controller.example.com"
 
 
 Emri i kontekstit: $nc = "DC=yourdomain,DC=com"
 
 
 Rruga e raportit të prodhimit: $outputReport = "C:\Path\To\SharedPasswordsReport.csv"
 
 
 Regjistrimi i arkivave: $archiveDir = "C:\Path\To\HashArchives"
 Hapi i tretë: Run the script Ekzekutoni skripin si një Admin Domain: powershell.exe -ExecutionPolicy Bypass -File "C:\Path\To\LazyAdminFinder.ps1"
 Rishikimi i rezultateve 
 
 
 Një raport i detajuar CSV gjenerohet, duke nxjerrë në pah qartë llogaritë që ndajnë fjalëkalime ose zgjedhin fjalëkalime të dobëta në mënyrë të pavarur. Arkivat historike ruhen në mënyrë të sigurtë për krahasime të ardhshme, duke siguruar menaxhimin e fuqishëm të fjalëkalimeve. Përdorimi i rastit për LazyAdminFinder 
 
 
 
 
 Auditimet e sigurisë: Identifikoni dhe korrigjoni rregullisht fjalëkalimet e ndara, të dobëta ose të kompromentuara. Përgjigjja ndaj incidenteve: Zbuloni shpejt llogaritë e kompromentuara pas incidenteve të sigurisë. Kontrollet e përputhshmërisë rutinë: Siguroni përputhshmërinë e vazhdueshme duke ruajtur praktika të forta të sigurisë së llogarisë. Menaxhimi i llogarive të privilegjuara: Për qëllime specifike për administratorët ose përdoruesit e privilegjuar që mund të ri-përdorin ose të sinkronizojnë fjalëkalimet në shumë llogari. Përdorimi i LazyAdminFinder Ndjehuni të lirë për të rregulluar skripin sipas mjedisit dhe nevojave tuaja: 
 
 
 
 Ndrysho logjikën e filtrimit për të përfshirë / përjashtuar lloje të caktuara të llogarisë. Rregulloni rrugët e arkivimit dhe raportimit për preferencat tuaja të ruajtjes. Integrimi i aftësive shtesë të raportimit sipas nevojës. Përfitimet e përdorimit të 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 thjeshton detyrën kritike të auditimit të fjalëkalimeve në Active Directory, duke i dhënë administratorëve fuqi për të ruajtur një mjedis të sigurt, të përputhshëm dhe efikas IT. Zbuloni fjalëkalimet e përbashkëta, korrigjoni rreziqet e sigurisë dhe forconi sigurinë tuaj të reklamave pa përpjekje me 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

Kjo audio është prodhuar në gjuhën origjinale të tregimit!

Shume gjate; Te lexosh

Download free Tech Leaders Productivity Report!

LazyAdminFinder: Zbuloni me lehtësi fjalëkalimet e përbashkëta dhe përmirësoni sigurinë e Active Directory

About Author

KOMENTE

VARUR TAGS

KY ARTIKU U PARAQIT NË

Related Stories

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps