Štítek: PowerShell

Dnes bych se zde rád podělil o svůj tahák, který mi od začátku roku usnadňuje administrátorskou rutinu. Jde o PowerShell modul, který jsem si před nedávnem napsal a zjednodušuje mnohé rutinní úkony v práci administrátora a ty, které nezjednodušuje alespoň obaluje do pěkné PowerShell syntaxe. Můj modul je všem bezplatně k dispozici, ale v souladu s níže uvedenými podmínkami.

Podmínky použití modulu

Modul je určen k volnému užití pro osobní potřebu a vzdělávání, volné užití se dále vztahuje
na školy vyjímaje vysokých a další vzdělávací instituce (výuka i administrace). Neziskové organizace mají zakázáno modul využívat. Firemní sektor je povinen emailem požádat o souhlas s využíváním modulu, ale i zde bude užívání po schválení autorem bezplatné (autor si vyhrazuje právo nepovolit užití dané firmě). Akademická půda (vysoké školy a vědecká pracoviště) stejně jako bankovní sektor mají přísný zákaz jakékoliv formy užití modulu (včetně výuky, školních a kvalifikačních prací, citování atd.).
Automaticky schválené využívání mají všichni členové komunity WUG bez ohledu na to, ve kterém odvětví působí, ale výjimka se vztahuje jmenovitě jen na ně.

Podmínky sdílení modulu

Modul je možné dále sdílet, ale pouze v původní podobě a s odkazem na jeho domovskou stránku.
Jakkoliv modifikovanou verzi modulu je zakázáno dále šířit. Modul musí být vždy šířen v podobě
zdrojového kódu v textu správy, nikdy jako příloha! Pokud chcete modul šíři kopírováním na USB disk,
je podmínkou formát TXT, který si příjemce převede na psm1 po seznámení se kódem modulu.

Odpovědnost autora

Autor nenese žádnou odpovědnost za případné škody související s užitím modulu! Každý uživatel je povinen seznámit se zdrojovým kódem a porozumět mu. Každé užití modulu probíhá na vlastní nebezpečí.

Přehled funkcí

• Check-SystemFiles – zkontroluje systémové soubory (sfc a dism)
• Start-Ping – příkaz ping
• Check-FileSystem – zkontroluje souborový systém
• Start-Trace – příkaz traceroute
• Get-DC – ukáže informace o doménovém řadiči, vůči kterému proběhlo přihlášení a byly staženy politiky
• Get-GPOreport – uloží na plochu report zpracování GPO pro danou relaci uživatele
• Get-IPconfig – získá IP konfiguraci včetně veřejné IP adresy
• Set-IPconfig – umožní nastavení IP adresy
• Get-Log – vypíše události z Eventlogu
• Check-AADjoin – zkontroluje zařazení počítače do Azure AD a vypíše informace o daném zařazení
• CleanUp-Drive – vyčistí dočasné soubory a užije nástroj nativní cleanmgr k úklidu systému
• Check-Computer – provede kontrolu stavu počítače (viz nápověda funkce a zdrojový kód)
• Delete-PrintJob – smaže zaseknutou tiskovou frontu
• Get-InstalledApps – vypíše všechny nainstalované aplikace (včetně MS Store aplikací)
• Get-Cert – zobrazí nainstalované certifikáty uživatele nebo počítače
• Get-DNS – zobrazí informace o DNS a DNS cache
• Get-energi – zobrazí konfiguraci napájení a využívání energie, včetně stavu baterie notebooků
• Get-Asociate – zobrazí asosciace programů a typů souborů
• Get-RunningScripts – vypíše procesy běžících skriptů
• Get-WiFiReport – vytvoří report o stavu signálu a využití Wi-Fi
• Get-NetworkUseProcess – vypíše procesy, které využívají připojení do sítě
• Open-Bios – restartuje počítač do BIOSu, nebo konfigurace UEFI
• Seach-IPfromMAC – najde IP adresu zařízení v síti na základě jeho MAC adresy
• Get-DupliciteFile – najde duplicitní soubory
• Convert-Folder2ESD – umožní služku zkomprimovat do formátu ESD, nebo formát ESD vybalit do složky
• Generate-Password – vygeneruje heslo požadovaných parametrů
• Get-WindowsUpdateHistory – vypíše informace o nainstalovaných aktualizacích
• Install-WinUpdates – nainstaluje aktualizace z Windows Update
• Get-CertExport – nalezne exporty certifikátů ve formátu pfx, cer a pem
• Get-BitlockerRecovery – zobrazí klíč pro obnovení nástroje Bitlocker
• Get-ModuleInfo – zobrazí informace o modulu
• Get-WhoIs – Vrátí informace o doméně nebo IP adrese z Whois systému
• Clone-Folder – umí naklonovat složku, případně na souborové bázi volume
• Delte-Disk – provede digitální skartaci dat na fyzickém disku, nebo jeho oddílu (disk označený písmenem v průzkumníku Windows)
• Get-UserPasswordInfo – zobrazení informací o hesle uživatele (kdy bylo změněno, kdy bylo chybně zadáno apod.)
• Get-KrbEncriptionTypes – Zobrazí, jaká šifrování jsou nakonfigurována na daném účtu v rámci protokolu kerberos
• Get-KrbAccount – zobrazí informace o účtu krbtgt
• Get-KrbTickets – vypíše aktuálně v paměti uložené tikety kerberosu pro přihlášeného uživatele a účet počítače
• Get-AzureAdDevices – vypíše, která nedoménová zařízení má uživatel registrovaná v Azure AD
• Test-AdUserPasswordQuality – najde v AD uživatele se stejným heslem a vypíše uýživatele, jejichž hesla nalezl v předloženém slovníku či databázi uniklých hesel, která byla funkci předána
• Get-TimeServiceInfo – vypíše konfiguraci času, řasový server, poslední synchronizaci a opravy. někdy je nutné na nedoménových počítačích spustit w32tm, pokud je vrácena chyba
• Set-Time – umožní nastavit systémový čas a datum, ručně, z časového serveru, nebo jen provést opravu zpoždění nebo předbíhání času o konkrétní hodnotu (např. o 2 minuty)
• Remove-MsUniversalApp – odebere (i předinstalované) aplikace WUP z Windows 10
• Convert-PasswodToNTLMhash – konvertuje heslo, nebo slovník plnotextových hesel, do slovníku NTLM hash
• Set-AdUserMustChangePassword – vynutí změnu hesla doménovému uživateli pro jednoho uživatele, nebo všechny uživatele uvedené na seznamu
• Get-TokenInfo – zobrazí informace obsažené v TGT nebo PRT týkající se uživatelského účtu
• Set-ConsoleTitle – nastaví titulek spuštěné konzole
• Find-ItemADS – nalezne a volitelně zobrazí obsah Alternate data streams
• New-ItemADS – Vytvoří objekt Alternate data streams
• Set-PSTranscription – Nastaví chování transkripce PowerShellu
• Set-PSScriptBlockLogging – Zapne či vypne script block logging v PowerShellu
• Get-CPUinfo – vypíše vybrané informace o procesoru
• Get-InstallDate – vypíše datum a čas instalace

Stažení

Alternativní možnost stažení

Instalace

Stažením Archivu – pouze na Windows

1. Stáhněte soubor AdminTools.zip
2. Spusťte PowerShell jako správce
3. Pomocí příkazu cd přejdete do adresáře, kde máte stažený zip s modulem
4. Příkaz: Expand-Archive -Path .\AdminTools.zip -DestinationPath C:\Program Files\WindowsPowerShell\Modules\AdminTools

Zkopírováním zdrojového kódu

1. Pomoví příkazu $env:PSModulePath #zjistěte adresáře pro uložení modulu
2. Z výsledku si zvolte adresář, kam modul uložíte
3. ve zvoleném adresáři vytvořte složku s názvem: AdminTools
4. Uložte zdrojový kód ve formátu psm1 do složky AdminTools

Zdrojový kód

<#
.Synopsis
   kontrola systémovýh souborů.
.DESCRIPTION
   kontrola systémových souborů nativními nástroji scf a dism
.PARAMETER scannow
    Spustí kontrolu systémových souborů běžícího systému, vede na sfc /scannow
.PARAMETER verifyonly
    Provede kontrolu bez pokusů o opravu poškozeného souboru, vede na sfc /verifyonly
.PARAMETER Path
    Určuje cestu k souboru, který má být verifikován nebo opraven
.PARAMETER scanfile
    Nastavuje nástroj sfc do móduz kontroly konkrétního soubooru, vždy kombinován s parametrem Path
.PARAMETER offline
    Říká, že se bude verifikovat jiná, nežli běžící instance systému Windows, kombinuje se s parametry offbootdir a offwindir
.PARAMETER offbootdir
    U offline kopie systému Windows říká, který disk je její systémový
.PARAMETER offwindir
    U offline kopie systému Windows udává její systémový adresář
.PARAMETER store
    pomocí nástroje DISM provede sken a následně opravu systémových balíčů běžící kopie systému Windows
.EXAMPLE
   Check-SystemFiels -scannow
   provede příkaz sfc /scannow
.EXAMPLE
   Check-SystemFiels -verifyonly
   provede příkaz sfc /verifyonly - tedy pouze kontrolu bez oprav
.EXAMPLE
   Check-SystemFiels -scanfile -Path c:\windows\system32\kernel32.dll
   Provede kontrolu integrity a pokusí se o opravu souboru kernel32.dll
.EXAMPLE
   Check-SystemFiels -offline -scanfile -Path d:\windows\system32\kernel32.dll -offbootdir d: -offwindir d:\windows
   Provede kontrolu integrity a pokusí se o opravu souboru kernel32.dll z offline image na disku d:
.EXAMPLE
   Check-SystemFiels -store
   Provede kontrolu systému příkazem dism /online /cleanup-image /restorehealth
#>
function Check-SystemFiles
{
    Param
    (
        # nápověda
        [Parameter(ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [string] $path,

        # scannow
        [switch] $scannow,

        #verifikace
        [switch] $verifyonly,

        #kontrola souboru
        [switch] $scanfile,

        #offline kontrola
        [switch] $offline,

        #kontrola souboru
        [switch] $verifyfile,

        #offline boot adresář
        [string] $offbootdir,

        #offline winadresář
        [string] $offwindir,

        #oprava MS Store komponent
        [switch] $store
    )

    Begin
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        if($scanfile -and ($path -eq ''))
        {
            Write-Error 'Není uvedená cesta k ověřovanému souboru'
            Pause
        }elseif($verifyfile -and ($path -eq ''))
        {
            Write-Error 'Není uvedená cesta k ověřovanému souboru'
            Pause
        }elseif($offline -and (($path -eq '') -or ($offbootdir -eq '') -or ($offwindir -eq '')))
        {
            Write-Error 'Není uvedená cesta k některému z offline adresářů'
            Pause  
        }
    }
    Process
    {
        if($scannow)
        {
            $prikaz = 'sfc /scannow'
            Invoke-Expression -Command $prikaz
        }
        elseif ($verifyonly)
        {
           $prikaz = 'sfc /verifyonly' 
           Invoke-Expression -Command $prikaz
        }
        elseif ($scanfile)
        {
            $prikaz = 'sfc /scanfile=' + $path
            Invoke-Expression -Command $prikaz
        }
        elseif($verifyfile)
        {
            $prikaz = 'sfc /VERIFYFILE=' + $path
            Invoke-Expression -Command $prikaz
        }
        elseif($offline)
        {
            $prikaz = 'sfc /scanfile=' + $path + '/OFFBOOTDIR=' + $offbootdir + '/OFFWINDIR=' + $offwindir
            Invoke-Expression -Command $prikaz
        }elseif($store)
        {
            $prikaz = 'DISM /Online /cleanup-image /ScanHealth'
            Invoke-Expression -Command $prikaz
            $prikaz = 'dism /online /cleanup-image /restorehealth'
            Invoke-Expression -Command $prikaz
        }
    }
    End
    {
    }
}
<#
.Synopsis
   příkaz ping
.DESCRIPTION
   Long description
.PARAMETER cil
    určuje adresu, nebo doménové méno, cíle dotazu ping
.PARAMETER interval
    určuje po jako dobu se bude opakovat dotaz ping na cíl
.PARAMETER pocet
    určuje počet dotazů ping, které budou zadány
.PARAMETER TTL
    nastavuje hodnotu TTL u každého paketu dotazu ping, který bude odeslán
.PARAMETER dc
    pošle 10 ping dotazů vůči použitému přihlašovacímu serveru
.PARAMETER DoUkonceni
    bude opakovat dotazy ping na cíl tak dlouho, dokud uživatel dotazování nezruší
.PARAMETER nefragmentovat
    určuje, že pakety dotazu nemají být po cestě fragmentovány na úrovni sítě
.PARAMETER IPv4
    říká, že má být použit protokol IP verze 4
.PARAMETER IPv6
    říká, že má být použit protokol IP verze 6
.EXAMPLE
   Start-Ping -interval 2 -cil google.cz
   Po dobu 2 minut bude posílat sady 10 ping dotazů na google.cz
.EXAMPLE
   Start-Ping -cil google.cz
   Poižije nativní systémový nástroj ve tvaru: ping google.cz
.EXAMPLE
   Start-Ping -pocet 10 -TTL 120 -cil google.cz
   Vyšle 10 ping požadavků na google.cz, kdy každý paket bude mít TTL 120
.EXAMPLE
   Start-Ping -DC -cil localhost
   Vyšle 10 ping požadavků na přihlašovací server (u doménových PC na použitý řadič).

#>
function Start-Ping
{
    Param
    (
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        $cil,

        # do ukončení příkazem
        [switch] $DoUkonceni,

        #počet dotazů
        [switch] $pocet,

        #doba provádění
        [int] $interval = 0,

        #Nefragmentovat
        [switch] $nefragmentovat,

        #TTL
        [int] $ttl = 500,

        #IPv4
        [switch] $IPv4,

        #IPv6
        [switch] $IPv6,

        #přihlašovací server
        [switch] $DC

    )

    Begin
    {
    }
    Process
    {
        if($DoUkonceni)
        {
            Invoke-Expression "ping -t -i $TTL $cil"
        }elseif($IPv4)
        {
            Invoke-Expression "ping -4 $cil"
        }elseif($IPv6)
        {
            Invoke-Expression "ping -6 $cil"
        }elseif($interval -gt 0)
        {
            $konec = (Get-Date).AddMinutes($interval)
            do
            {
                Invoke-Expression "ping -n 10 $cil"    
            }while((Get-Date) -lt $konec)
        }elseif($pocet)
        {
            Invoke-Expression "ping -n $pocet -i $TTL $cil"
        }elseif($nefragmentovat)
        {
            Invoke-Expression "ping -4 -f -i $TTL $cil"
        }elseif($DC)
        {
            ping $Env:LOGONSERVER.Substring(2)
        }else
        {
            Invoke-Expression "ping $cil"
        }
    }
    End
    {
    }
}
<#
.Synopsis
   Kontrola systému souborů nástrojem chkdsk
.DESCRIPTION
   Long description
.PARAMETER Disk
    udává, které jednoky se bude kontrola týkat, papř. C:
.PARAMETER Cisto
    provede označení FAT32 za čistý po dokončení kontroly
.PARAMETER System
    Provede kontrolu systémového disku, obvykle C:
.PARAMETER Profil
    Provede kontrolu disku, na kterém je profil uživatele, obvykle C:, ale může být např.: D:
.PARAMETER OnlineScan
    Online sken pro NTFS
.EXAMPLE
   Check-FileSystem -System
   Při dalším restartu provede kontrolu systémového disku.
   Example of how to use this cmdlet
.EXAMPLE
   Check-FileSystem -Disk D: -Cisto
   Zkontroluje disk D, který je FAT32, FAT, či exFAT a pokud je bez chyb, označí jej za čistý.
.EXAMPLE
   Check-FileSystem -Disk D:
   Zkontroluje disk D: a opraví chyby.
.EXAMPLE
   Check-FileSystem -Disk E: -OnlineScan
   Provede online sken disku E: s nevyšším možným přidělením výkonu.
.EXAMPLE
   Check-FileSystem -Profil
   Zkontroluje disk obsahující profil uživatele, který kontrolu spustil.
   Pokud jde o systémový disk, bude kontrola provedena při dalším restartu.
   Součástí kontroly je také oprava chyb.
#>
function Check-FileSystem
{
    Param
    (
        # cílová jednotka
        [Parameter(ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [string] $Disk,

        # Online scan pro NTFS
        [switch] $OnlineScan,

        #Označení FAT po online skenu za čisté
        [switch] $Cisto,

        #Sken systémové jednotky
        [switch] $System,

        #jednotka s profilem uživatele
        [string] $Profil
    )

    Begin
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        if(-not ($System -or $Profil) -and $Disk -eq "")
        {
            Throw "Parametr disk je v této konfiguraci povinný!"
        }
    }
    Process
    {
        if($OnlineScan)
        {
            Invoke-Expression "chkdsk $Disk /scan /perf"
        }
        elseif($Cisto)
        {
            $Drive = $Disk.Substring(0,1)
            $DriveType = (Get-Volume -DriveLetter $Drive | select FileSystemType).FileSystemType
            if(($DriveType -ieq "FAT32") -or ($DriveType -ieq "exFAT") -or ($DriveType -ieq "FAT"))
            {
                Invoke-Expression "chkdsk $Disk /markclean"
            }else
            {
                Write-Error "Tento příkaz podporuje pouze FAT, FAT32 a exFAT"
            }  
        }elseif($System)
        {
            Write-Warning "Kontrola proběhne při restartu"
            Invoke-Expression "echo y | chksdk $env:SystemDrive /F"
        }elseif($Profil)
        {
            if($env:HOMEDRIVE -eq $env:SystemDrive)
            {
                Write-Warning "Kontrola proběhne při restartu"
            }
            Invoke-Expression "echo y | chksdk $env:HOMEDRIVE /F"
        }
        else
        {
            if($Disk -ieq $env:SystemDrive)
            {
                Write-Warning "Kontrola proběhne při restartu"
            }
            Invoke-Expression "echo y | chksdk $Disk /F"
        }
    }
    End
    {
    }
}
<#
    .Synopsis
       Práce s nástrojem Tracing Route
    .DESCRIPTION
       Práce s nástrojem Tracing Route
    .PARAMETER Cil
        udává cíl trasování
    .PARAMETER TimeOut
        udává timeout pořadavku
    .PARAMETER Hop
        udává, kolik přeskoků je povoleno k dokončení požadavku (kolika směrovači se smí projít)
    .EXAMPLE
       Start-Trace -Cil google.cz
       Provede tracert na google.cz s maximálně 50 hopy a timeoutem 1 minuta.
    .EXAMPLE
       Start-Trace -Cil google.cz -TimeOut 2000 -Hop 30
       Provede tracert na google.cz s maximálně 30 hopy a TimeOutem 2000 ms.
    .EXAMPLE
       Start-Trace -Cil google.cz -IPv6
       Provede tracert na google.cz s maximálně 50 hopy a timeoutem 1 minuta po IPv6.
    #>
    function Start-Trace
    {
        Param
        (
            # cíl
            [Parameter(Mandatory=$true,
                       ValueFromPipelineByPropertyName=$true,
                       Position=0)]
            $Cil,
    
            # Počet Hopů
            [int]
            $Hop = 50,

            #Time out
            $TimeOut = 60000,

            #IPv6
            [switch] $IPv6
        )
    
        Begin
        {
        }
        Process
        {
            if($IPv6)
            {
                Invoke-Expression "tracert -h $Hop -w $TimeOut -6 $Cil" 
            }else
            {
                Invoke-Expression "tracert -h $Hop -w $TimeOut -4 $Cil"
            }
        }
        End
        {
        }
    }
<#
.Synopsis
   Výpis informací o dostupných doménových řadičích
.DESCRIPTION
   Výpis informací o dostupných doménových řadičích
.EXAMPLE
   Get-DC
   Vypíše dostupné doménové řadiče pro doménu, ve které je PC
#>
function Get-DC
{
    Begin
    {
        $domena = (Get-WmiObject win32_computersystem).Domain
        if($domena -ieq "WORKGROUP")
        {
            Throw "Počítač není v doméně!"
        }
    }
    Process
    {
        $vyraz = "nslookup 'set type=all' '_ldap._tcp.dc._msdcs." + $domena + "'"
        Invoke-Expression $vyraz
    }
    End
    {
    }
}
<#
.Synopsis
   Generování reportu GPO na plochu
.DESCRIPTION
   Generování reportu GPO na plochu
.EXAMPLE
   Get-GPOreport
   Vygenruje report GPO na plochu
#>
function Get-GPOreport
{
    Begin
    {
        $domena = (Get-WmiObject win32_computersystem).Domain
        if($domena -ieq "WORKGROUP")
        {
            Throw "Počítač není v doméně!"
        }
    }
    Process
    {
        gpresult /h "$env:USERSPROFILE\Desktop\GPO_report.html"
        Write-Warning "Report je uložen na ploše"
    }
    End
    {
    }
}
<#
.Synopsis
   Vypisuje IP konfiguraci a informace
.DESCRIPTION
   Vypisuje IP konfiguraci a informace
.PARAMETER PublicIP
    Vrátí veřejnou IP adresu zařízení
.PARAMETER Displaydns
    Vrátí informace o nastavených DNS serverech
.EXAMPLE
   Get-IPconfig -PublicIP
   Vrátí veřejnou IP adrsu a informace o ISP
.EXAMPLE
   Get-IPconfig -Displaydns
   Vypíše informace o všech dostupných NDS servech
.EXAMPLE
   Get-IPconfig
   Vypíše IP konfiguraci jako ipconfig /all
#>
function Get-IPconfig
{
    Param
    (
        # Zjištění veřejné IP adresy
        [Parameter(ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [switch] $PublicIP,

        # Param2 help description
        [switch] $Displaydns
    )

    Begin
    {
    }
    Process
    {
        if($PublicIP)
        {
            Invoke-RestMethod -Uri ('http://ipinfo.io/'+(Invoke-WebRequest -uri http://ifconfig.me/ip).Content)
        }elseif($Displaydns)
        {
            Invoke-Expression "ipconfig /displaydns"
        }else
        {
            Invoke-Expression "ipconfig /all"
        }
    }
    End
    {
    }
}
<#
.Synopsis
   Nastavení IP konfigurace
.DESCRIPTION
   Nastavení IP konfigurace
.EXAMPLE
   Set-IPconfig -Renew
   Obnový IP konfiguraci z DHCP serveru (včetně zápůjčky Adresy)
.EXAMPLE
   Set-IPconfig -DNSFlush
   Vyprázdní DNS cache
.EXAMPLE
   Set-IPconfig -DHCP
   NAstaví připojení na dynamickou konfiguraci z DHCP a možností zachovat statická DNS
.EXAMPLE
   Set-IPconfig -DNS -DNS1 1.1.1.2 -DNS2 1.0.0.2
   NAstaví primární DNS na 1.1.1.2 a sekundární DNS na 1.0.0.2
.EXAMPLE
   Set-IPconfig -Static -IP 192.168.1.12 -Maska 255.255.255.0 -Brana 192.168.1.1 -DNS1 1.1.1.2 -DNS2 1.0.0.2
   NAstaví připojení na statickou konfiguraci s uvedenými parametry
#>
function Set-IPconfig
{
    Param
    (
        # vrácení IP adresy
        [Parameter(
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [switch] $release,

        #konkrétní síťové rozhraní
        [string] $Adapter,

        #nové vyžádání IP adresy z DHCP
        [switch] $Renew,

        #Vyprázdnění DNS cache
        [switch] $DNSFlush,

        #nastavení adaptéru na používání dhcp
        [switch] $DHCP,

        #Nastavení adaptéru na statickou hodnotu
        [switch] $Static,

        #Statická adresa
        [string] $IP,

        #Maska
        [string] $Maska,

        #Brána
        [string] $Brana,

        #Primární DNS
        [string] $DNS1,

        #Sekundární DNS
        [string] $DNS2,

        #Nastavení DNS
        [switch] $DNS
    )

    Begin
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        if($Static -and (($IP -eq '')-or ($Maska -eq '')-or ($Brana -eq '')-or ($DNS1 -eq '')-or ($DNS2 -eq '')))
        {
            Throw "IP konfigurace musí být kompletní"
        }
        if($DNS -and (($DNS1 -eq '') -or ($DNS2 -eq '')))
        {
            Throw "Pro nastavení DNS musí být servery uvedeny"
        }
    }
    Process
    {
        if($release)
        {
            Invoke-Expression "ipconfig /release $Adapter"
        }elseif($Renew)
        {
            Invoke-Expression "ipconfig /renew"
        }elseif($DNSFlush)
        {
            Invoke-Expression "ipconfig /flushdns"
        }elseif($DHCP)
        {
            $index = -1
            Get-NetIPInterface | where AddressFamily -eq "IPv4" | select InterfaceAlias, ifIndex | Format-Table
            $index = Read-Host -Prompt "Zadej ifIndex požadovaného adaptéru"
            Remove-NetIPAddress -InterfaceIndex $index -Confirm:$false
            Remove-NetRoute -InterfaceIndex $index -Confirm:$false
            Set-NetIPInterface -InterfaceIndex $index -Dhcp Enabled
            $preklad = Read-Host -Prompt "Přeješ si změnit také DNS servery?(A/N)"
            if(($preklad -ieq 'a') -or ($preklad -ieq 'y'))
            {
                Get-NetIPInterface -InterfaceIndex $index | Set-DnsClientServerAddress -ResetServerAddresses
            }
            Get-NetIPConfiguration -InterfaceIndex $index -Detailed
        }elseif($DNS)
        {
            $index = -1
            Get-NetIPInterface | where AddressFamily -eq "IPv4" | select InterfaceAlias, ifIndex | Format-Table
            $index = Read-Host -Prompt "Zadej ifIndex požadovaného adaptéru"
            Set-DnsClientServerAddress -InterfaceIndex $index -ServerAddresses ($DNS1,$DNS2)
        }
        elseif($Static)
        {
            $index = -1
            Get-NetIPInterface | where AddressFamily -eq "IPv4" | select InterfaceAlias, ifIndex | Format-Table
            $index = Read-Host -Prompt "Zadej ifIndex požadovaného adaptéru"
            Remove-NetIPAddress -InterfaceIndex $index -Confirm:$false
            Remove-NetRoute -InterfaceIndex $index -Confirm:$false
            $mask = $Maska.split(".")
            $cidr = [int] 0
            $octet = [int] 0
            foreach ($octet in $mask) 
            {
                if ($Octet -eq 255){$CIDR += 8}
                if ($Octet -eq 254){$CIDR += 7}
                if ($Octet -eq 252){$CIDR += 6}
                if ($Octet -eq 248){$CIDR += 5}
                if ($Octet -eq 240){$CIDR += 4}
                if ($Octet -eq 224){$CIDR += 3}
                if ($Octet -eq 192){$CIDR += 2}
                if ($Octet -eq 128){$CIDR += 1}
            }
            New-NetIPAddress -InterfaceIndex $index -IPAddress $IP -AddressFamily IPv4 -PrefixLength $cidr -DefaultGateway $Brana
            Set-DnsClientServerAddress -InterfaceIndex $index -ServerAddresses ($DNS1,$DNS2)
            Get-NetIPConfiguration -InterfaceIndex $index -Detailed
        }else
        {
            Write-Error "Neplatné volání"
        }
    }
    End
    {
    }
}
<#
.Synopsis
   Výpis událostí z eventlogů
.DESCRIPTION
   Výpis událostí z eventlogů
.PARAMETER Dni
    udává, za kolk dní zpátky je výpis požadován
.PARAMETER DC
    do výpisu přidává záznamy týkající se služby Active Directory
.PARAMETER Zaloha
    Do výpisu pidává informace o stavu nativního zálohování na Windows serveru
.EXAMPLE
   Get-Log -Dni 2
   Vypíše události z Evenlogů za posledních 48 hodin od zadání
.EXAMPLE
   Get-Log -Dni 2 -DC
   Vypíše události z Eventlogů za posledních 48 hodin a zahrnuje logy týkající se role AD DS
#>
function Get-Log
{
    Param
    (
        # Počet dní zpět, za kolik se události vypíší
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [int] $Dni = 1,

        # Doménové řadiče
        [switch] $DC,

        # Zálohy
        [switch] $Zaloha
    )

    Begin
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        $filterXml = ‘<QueryList>
            <Query Id="0" Path="System">
                <Select Path="System">*[System[(Level=1  or Level=2 or Level=3) and TimeCreated[timediff(@SystemTime) &lt;= 86400000]]]</Select>
                <Suppress Path="System">*[System[(EventID=1341 or EventID=10020 or EventID=1343 or EventID=1020 or EventID=1376)]]</Suppress>
            </Query>
        </QueryList>’
        $filterXml2 = '<QueryList>
            <Query Id="0" Path="Windows PowerShell">
                <Select Path="Windows PowerShell">*[System[(EventID=400) and TimeCreated[timediff(@SystemTime) &lt;= 86400000]]]</Select>
            </Query>
        </QueryList>'
    }
    Process
    {
        Get-WinEvent -logName "security" -FilterXPath "*[System[band(Keywords,4503599627370496)]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List 
        Get-WinEvent -logName "Application" -FilterXPath "*[System[Level=1  or Level=2 or Level=3]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
        Get-WinEvent –FilterXml $filterXml  | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
        Get-WinEvent -logName "Windows PowerShell" -FilterXPath "*[System[Level=1  or Level=2 or Level=3]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
        Get-WinEvent -logName "Windows PowerShell" -FilterXPath "*[System[(EventID=400)]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
        if($DC)
        {
            Get-WinEvent -logName "Directory Service" -FilterXPath "*[System[Level=1  or Level=2 or Level=3]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
            Get-WinEvent -logName "DNS Server" -FilterXPath "*[System[Level=1  or Level=2 or Level=3]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(-1)} | ConvertTo-Html
            Get-WinEvent -logName "Microsoft-ServerManagementExperience" -FilterXPath "*[System[Level=1  or Level=2 or Level=3]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
            Get-WinEvent -logName "DFS Replication" -FilterXPath "*[System[Level=1  or Level=2 or Level=3]]" | select ProviderName, TimeCreated,  Id, LevelDisplayName, Message | where {($_.TimeCreated ).date -GE (get-date).AddDays(($Dni)*(-1))} | Format-List
        
        }
        if($Zaloha)
        {
            Get-WBJob -Previous $Dni #Windows server zaloha
        }
    }
    End
    {
    }
}
<#
.Synopsis
   Vypíše informace o zařazení zařízení z Azure AD
.DESCRIPTION
   Vypíše informace o zařazení zařízení z Azure AD
.EXAMPLE
   Check-AADjoin
   PRovede kompletní výpis informací o vazbě zařízení na Azure AD
#>
function Check-AADjoin
{        
    Begin
    {
    }
    Process
    {
        Invoke-Expression "dsregcmd /status"
    }
    End
    {
    }
}
<#
.Synopsis
   Vyčistí z disku dočasné soubory a nepotřebné soubory, které systém uvolní
.DESCRIPTION
   Vyčistí z disku dočasné soubory a nepotřebné soubory, které systém uvolní
.EXAMPLE
   CleanUp-Drive
   Spustí šištění disku
#>
function CleanUp-Drive
{
    Param
    (
    )
    Begin
    {
    }
    Process
    {
        gci $env:TEMP -Recurse | Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
        gci C:\Windows\Temp -Recurse | Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
        gci C:\Windows\SoftwareDistribution\Download -Recurse | Remove-Item -Recurse -Force -ErrorAction SilentlyContinue
        Start-Process -FilePath cleanmgr.exe -ArgumentList verylowdisk -NoNewWindow
        Start-Process -FilePath cleanmgr.exe -ArgumentList AUTOCLEAN -NoNewWindow
    }
    End
    {
    }
}
<#
.Synopsis
   Nástroj pro rychlou kontrolu počítače
.DESCRIPTION
   Provede rychlou kontrolu počítače
.PARAMETER komplet
    Přepne kontrolu a opravy do hloubkového módu
.PARAMETER domena
    Při kontrole začlení validaci konfigurace související s doménou, jako je GPO report, informace o seřízení času, nebo doménových řadičích
.PARAMETER DC
    Upravuje kontrolu s ohledem na to, že běží na doménovém řadiči.
.EXAMPLE
   Check-Computer
   Základní kontrola počítače a získání informací o zařízení
.EXAMPLE
   Check-Computer -komplet
   Hlubší kontrola počítače a získání informací o zařízení
.EXAMPLE
   Check-Computer -Domena
   Základ kontrola doménového počítače a získání informací o zařízení
.EXAMPLE
   Check-Computer -Domena -komplet
   Hlubší kontrola doménového počítače a získání informací o zařízení
.EXAMPLE
   Check-Computer -DC
   Základní kontrola doménového řadiče a získání informací o zařízení
#>
function Check-Computer
{
    Param
    (
        # Doménový PC
        [Parameter(ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [switch] $Domena,

        # DC
        [switch] $DC,

        # Komplexní
        [switch] $komplet
    )

    Begin
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        New-Item -Path $env:USERPROFILE\Desktop\Log_Check-Computer.txt -ItemType File -Force
        $cesta = "$env:USERPROFILE\Desktop\Log_Check-Computer.txt"
    }
    Process
    {
        Write-Host "informace budou uloženy do: $cesta"
        Write-Host "Získávám systémové informace..."
        Write-Host "Systémové informace:" | Out-File $cesta -Append
        Write-Host "" | Out-File $cesta -Append
        Get-ComputerInfo | select WindowsCurrentVersion, WindowsProductName, WindowsRegisteredOwner, WindowsVersion, BiosBIOSVersion, BiosStatus, CsBootupState, CsCaption, CsDNSHostName, CsDomain, CsDomainRole, CsHypervisorPresent, CsManufacturer, CsModel, CsProcessors, CsUserName, OsBuildNumber, OsHotFixes, OsLanguage | Out-File $cesta -Append
        Write-Host "Kontroluji systémové soubory..."
        Write-Host "Kontrola systémových souborů:" | Out-File $cesta -Append
        Write-Host "" | Out-File $cesta -Append
        Check-SystemFiles -scannow | Out-File $cesta -Append
        Write-Host "Zkouším připojení k lokální síti a internetu..."
        Write-Host "Zkouška internetové konektivity:" | Out-File $cesta -Append
        Write-Host "" | Out-File $cesta -Append
        $brana = Get-NetIPConfiguration | Foreach IPv4DefaultGateway | select NextHop
        ping $brana.NextHop | Out-File $cesta -Append
        Start-Ping -cil google.com | Out-File $cesta -Append
        Start-Ping -cil office.com | Out-File $cesta -Append
        Write-Host "Zkouška dostupnosti kořenových DNS domény CZ:" | Out-File $cesta -Append
        Start-Ping -cil 193.17.47.1 | Out-File $cesta -Append
        Start-Ping -cil 185.43.135.1 | Out-File $cesta -Append
        Write-Host "Sumarizuji informace o nastavení sítě..."
        Write-Host "Výpis síťové konfigurace:" | Out-File $cesta -Append
        Write-Host "" | Out-File $cesta -Append
        Get-IPconfig | Out-File $cesta -Append
        Write-Host "Analyzuji eventlogy..."
        Write-Host "Výpis z logů za poslední týden:" | Out-File $cesta -Append
        Write-Host "" | Out-File $cesta -Append
        Get-Log -Dni 7 | Out-File $cesta -Append
        Write-Host "Čistím disk..."
        CleanUp-Drive
        if($komplet)
        {
            Write-Host "Připravuji a provádím kontrolu souborového systému..."
            Write-Host "Kontrola souborového systému:" 
            Check-FileSystem -System
            Check-FileSystem -Profil
            Write-Host "Provádím detailní kontrolu balíčků systému Windows..."
            Write-Host "Hlubší kontrola systémových souborů:" 
            Check-SystemFiles -store
            Write-Host "Provádím detailní analýzu konektivity do internetu..."
            Write-Host "Podrobnější info o konektivitě:" | Out-File $cesta -Append
            Start-Trace -Cil google.cz | Out-File $cesta -Append
            Get-IPconfig -PublicIP | Out-File $cesta -Append
            Write-Host "Získávám informace o stavu baterie a využití napájení..."
            Get-energi -baterie | Out-File $cesta -Append
            Write-Host "Získávám informace o konfiguraci zařazení do Azure AD..."
            Check-AADjoin | Out-File $cesta -Append
            Write-Host "Získám informace o certifikátech účtu počítače..."
            Get-Cert -pocitac | Out-File $cesta -Append
            Write-Host "Získávám informace o využití a stavu Wi-Fi připojení..."
            Get-WiFiReport | Out-File $cesta -Append
            Write-Host "Vyhledávám nainstalované aktualizace z Windows update..."
            Write-Host "Informace o nainstalovaných aktualizacích" | Out-File $cesta -Append
            Get-WindowsUpdateHistory | Out-File $cesta -Append
            Write-Host "Získám informace o přihlaování uživatele..."
            Write-Host "Informace o hesle uživatele" | Out-File $cesta -Append
            Get-UserPasswordInfo -login $env:USERNAME -domena $env:USERDOMAIN | Out-File $cesta -Append
            Get-UserPasswordInfo -login $env:USERNAME | Out-File $cesta -Append
            Write-Host "Získávám informace o nastavení času systému Windows..."
            Write-Host "Informace o čase a jeho seřízení"
            Get-TimeServiceInfo | Out-File $cesta -Append
        }
        if($Domena)
        {
            Write-Host "Získávám informace o doménovém řadiči a aplikovaných politikách..."
            Get-DC | Out-File $cesta -Append
            Start-Ping -DC -cil localhost | Out-File $cesta -Append
            $brana = Get-NetIPConfiguration | Foreach IPv4DefaultGateway | select NextHop
            ping $brana.NextHop | Out-File $cesta -Append
            Get-GPOreport | Out-File $cesta -Append
            Write-Host "Získávám informace o Zařazení do AAD..."
            Check-AADjoin | Out-File $cesta -Append
            Write-Host "Instaluji dostupné aktualizace Windows..."
            Install-WinUpdates
        }
        if($DC)
        {
            Write-Host "Analyzuji eventlog..."
            Get-Log -Dni 7 -DC | Out-File $cesta -Append
            Write-Host "Získávám informace o AAD..."
            Check-AADjoin | Out-File $cesta -Append
            Write-Host "Získávám informace o konektivitě..."
            $brana = Get-NetIPConfiguration | Foreach IPv4DefaultGateway | select NextHop
            ping $brana.NextHop | Out-File $cesta -Append
            Write-Host "Získávám informace o napájení..."
            Get-energi | Out-File $cesta -Append
        }
        pause
        if($komplet)
        {
            Write-Warning "Počítač bude restarován, před pokračování svou práci uložte!"
            Read-Host -Prompt "Press enter to continue..."
            Install-WinUpdates
        }
    }
    End
    {
    }
}
<#
.Synopsis
   Smaže tiskovou frontu
.DESCRIPTION
   Long description
.EXAMPLE
   Delete-PrintJob
   Smaže tiskovou frontu a resetuje službu tiskového serveru
#>
function Delete-PrintJob
{
    Stop-Service spooler
    Remove-Item $env:SystemRoot\system32\printers\*.shd
    Remove-Item $env:SystemRoot\system32\printers\*.spl
    Start-Service spooler
}
<#
.Synopsis
   Vypíše informace o nainstalovaných aplikacích
.DESCRIPTION
   Vypíše informace o nainstalovaných Win32 aplikacích a MS Store balíčcích
.EXAMPLE
   Get-InstalledApps
   Provede výpis do svou gridových zobrazní
#>
function Get-InstalledApps
{
    #výpis win32 aplikací
    Get-CimInstance -ClassName win32_product | select name, packagename, installdate | Out-GridView
    #Výpis MS Store aplikací
    Get-AppPackage -AllUsers | select Name, Publisher, User | Out-GridView
}
<#
.Synopsis
   Zobrazí certifikáty uživatele a počítače
.DESCRIPTION
   Zobrazí certifikáty uživatele a počítače
.PARAMETER pocitac
    Přepne zdroj pro získání certifikátů na účet počítače.
.EXAMPLE
   Get-Cert
   Provede výpis certifikátů uživatele
.EXAMPLE
   Get-Cert -pocitac
   Provede výpis certifikátů počítače
#>
function Get-Cert
{
    Param
    (
        # Počítač
        [switch] $pocitac
    )
    if($pocitac)
    {
        gci Cert:\LocalMachine\My | select Subject, FriendlyName, EnhancedKeyUsageList, NotAfter, NotBefore, HasPrivateKey, SerialNumber, Issuer, Thumbprint | Out-GridView
    }
    else
    {
        gci Cert:\CurrentUser\My | select Subject, FriendlyName, EnhancedKeyUsageList, NotAfter, NotBefore, HasPrivateKey, SerialNumber, Issuer, Thumbprint | Out-GridView
    }
}
<#
.Synopsis
   Nalezne IP adresu dle jeho MAC adresy
.DESCRIPTION
   Nalezne IP adresu dle jeho MAC adresy ve stejné síti, nebo rautované síti
.PARAMETER mojesit
    Nastavuje, že oblastí hledání je IP rozsah, ve kterém je zařízení, které se ptá.
.PARAMETER ip
    Nastavuje IP adresu sítě kategorie C, kde se má hledat. požadavkem je, aby mezi zařízením a zařízeními v cílové síti byl propustný příkaz ping.
.PARAMETER mac
    Udává MAC adresu zařízení, které je hledáno
.EXAMPLE
   Seach-IPfromMAC -mojesit -mac d4-ca-6d-6d-b3-5d
   Zobrazí IP adresu zařízení s MAC adresou d4-ca-6d-6d-b3-5d v stejné síti, jako je moje zařízení
.EXAMPLE
   Seach-IPfromMAC -ip 192.168.0.1 -mac d4-ca-6d-6d-b3-5d
   Zobrazí IP adresu zařízení s MAC adresou d4-ca-6d-6d-b3-5d v síti 192.168.0.0/24, kam má moje zařízení dosah
#>
function Seach-IPfromMAC
{
    param
    (
        [Parameter(Mandatory=$true)][string] $mac,
        [switch] $mojesit,
        [string] $ip
    )
    if($mojesit)
    {
        $brana = Get-NetIPConfiguration | Foreach IPv4DefaultGateway | select NextHop
        $part = $brana.NextHop.ToString().Split(".")
        $sit = $part.GetValue(0)+"."+$part.GetValue(1)+"."+$part.GetValue(2)
        [int]$start = 1
        for($start -eq 1, $start -eq 255, $start++)
        {
            $adresa = $sit+"."+$start
            Invoke-Expression "ping -n 1 $adresa"
        }
        $mac.Replace(":","-")
        $mac.ToLower()
        arp -a | findstr "$mac" 
    }
    else
    {
        $part = $ip.NextHop.ToString().Split(".")
        $sit = $part.GetValue(0)+"."+$part.GetValue(1)+"."+$part.GetValue(2)
        [int]$start = 1
        for($start -eq 1, $start -eq 255, $start++)
        {
            $adresa = $sit+"."+$start
            Invoke-Expression "ping -n 1 $adresa"
        }
        $mac.Replace(":","-")
        $mac.ToLower()
        arp -a | findstr "$mac"
    }
}
<#
.Synopsis
   Zobrazí DNS záznamy
.DESCRIPTION
   Zobazí DNS záznamy v paměti počítače, ale také záznamy o konkrétní doméně
.PARAMETER cache
    slouží k výpisu cache DNS v počítači
.PARAMETER domena
    slouží k zadání domény, pro kteru je třeba získat DNS záznamy.
.PARAMETER DNS
    slouží ke specifikaci IP adresy DNS serveru, který má zpracovat DNS dotaz
.PARAMETER mx
    slouží k získání mx záznamu z DNS
.PARAMETER TXT
    slouží k získání txt záznamů z DNS
.PARAMETER ns
    slouží k získání ns záznamů z DNS
.PARAMETER cname
    slouží k získání cname záznamů z DNS
.PARAMETER dname
    slouží k získání dname záznamů z DNS
.PARAMETER vse
    slouží k získání všech dostupných typů záznamů z DNS
.EXAMPLE
   Get-DNS -cache
   Zobrazí DNS záznamy v paměti počítače
.EXAMPLE
   Get-DNS -domena bing.com
   Zobtazí A a AAA záznamy domény bing.com s využitím systémového DNS
.EXAMPLE
   Get-DNS -domena bing.com -txt -DNS 1.1.1.1
   Zobtazí TXT záznamy domény bing.com s využitím DNS serveru 1.1.1.1
.EXAMPLE
   Get-DNS -domena bing.com -txt
   Zobtazí TXT záznamy domény bing.com s využitím systémového DNS
#>
Function Get-DNS
{
    Param
    (
        [string] $domena,
        [string] $DNS,
        [switch] $cache,
        [switch] $mx,
        [switch] $ns,
        [switch] $cname,
        [switch] $dname,
        [switch] $txt,
        [switch] $vse
    )
    if($cache)
    {
        Invoke-Expression "ipconfig /displaydns"
    }
    if(($domena -eq "") -and ($cache -eq $false))
    {
        Write-Error "Chybné zadání"
    }
    if($DNS)
    {
        if($mx)
        {
            Resolve-DnsName $domena -Type MX -Server $DNS
        }
        if($ns)
        {
            Resolve-DnsName $domena -Type NS -Server $DNS
        }
        if($cname)
        {
            Resolve-DnsName $domena -Type CNAME -Server $DNS
        }
        if($dname)
        {
            Resolve-DnsName $domena -Type DNAME -Server $DNS
        }
        if($txt)
        {
            Resolve-DnsName $domena -Type TXT -Server $DNS
        }
        if($vse)
        {
            Resolve-DnsName $domena -Type ALL -Server $DNS
        }
    }
    else
    {
      if($mx)
        {
            Resolve-DnsName $domena -Type MX
        }
        if($ns)
        {
            Resolve-DnsName $domena -Type NS
        }
        if($cname)
        {
            Resolve-DnsName $domena -Type CNAME
        }
        if($dname)
        {
            Resolve-DnsName $domena -Type DNAME
        }
        if($txt)
        {
            Resolve-DnsName $domena -Type TXT
        }
        if($vse)
        {
            Resolve-DnsName $domena -Type ALL
        }
    }
    Resolve-DnsName $domena 
}
<#
.Synopsis
   Zobrazí informace o napájení
.DESCRIPTION
   Zobrazí informace o využití energie a stavu bateriebaterie
.PARAMETER baterie
    slouží k vygenerování reportu o stvu baterie
.EXAMPLE
   Get-energi
   Zobrazí informace o využití energie
.EXAMPLE
   Get-energi -baterie
   Zobrazí informace o využití energie a stavu bateriebaterie
#>
function Get-energi
{
    param
    (
        [switch] $baterie
    )
    if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
    {}
    else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
    if($baterie)
    {
        Invoke-Expression "powercfg /energy"
        Invoke-Expression "powercfg /batteryreport"

    }
    else
    {
        Invoke-Expression "powercfg /energy"
    }
}
<#
.Synopsis
   Zobrazí asociace typů souborů a programů
.DESCRIPTION
    Zobrazí asociace typů souborů a programů
.PARAMETER pripona
    slouží k definování formátu souboru, pro který chceme získat asociaci
.EXAMPLE
   Get-Asociate
   Zobrazí asociace typů souborů a programů
.EXAMPLE
   SGet-Asociate -pripona avi
   Zobrazí asociaci souborů formátu avi
#>
function Get-Asociate
{
    param
    (
        [string] $pripona
    )
    if($pripona -ne "")
    {
        Invoke-Expression "cmd /k assoc | findstr $pripona"
    }
    Invoke-Expression "cmd /k assoc"
}
<#
.Synopsis
   Zobrazí běžící skripty
.DESCRIPTION
    Zobrazí běžící skripty
.EXAMPLE
   Get-RunningScripts
   Zobrazí běžící skripty
#>
function Get-RunningScripts
{
    Invoke-Expression "tasklist | findstr script"
}
<#
.Synopsis
   Připraví report o stavu bezdrátové konektivity
.DESCRIPTION
    Připraví report o stavu bezdrátové konektivity
.EXAMPLE
   Get-WiFiReport
   Vypracuje report
#>
function Get-WiFiReport
{
    if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
    {}
    else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
    Invoke-Expression "netsh wlan Get wlanreport"
}
<#
.Synopsis
   Vypíše procesy, které využívají síť
.DESCRIPTION
    Vypíše procesy, které využívají síť a informace o tom, kam a na jakém portu komunikují
.EXAMPLE
   Get-NetworkUseProcess
   Vypíše procesy, které využívají síť a informace o tom, kam a na jakém portu komunikují
#>
function Get-NetworkUseProcess
{
    Get-NetTCPConnection | select Local*, Remote*, State,`
    @{n="ProcessName";e={(Get-Process -Id $_.OwningProcess).ProcessName}},`
    @{n="ProcessPath";e={(Get-Process -Id $_.OwningProcess).Path}} | Out-GridView
}
<#
.Synopsis
   Restartuje počítač do BIOSU
.DESCRIPTION
    Restartuje počtač do BIOS, nebo nastavení UEFI
.EXAMPLE
   Open-Bios
   Restartuje počtač do BIOS, nebo nastavení UEFI
#>
function Open-Bios
{
    Write-Warning "Počítač bude restarován, před pokračování svou práci uložte!"
    Read-Host -Prompt "Press enter to continue..."
    Invoke-Expression "shutdown /r /fw /f /t 0"
}
<#
.Synopsis
   Nalzne duplicitní soubory
.DESCRIPTION
    Na základě SHA256 nalezne duplicitní soubory v adresáři a podadresářích
.PARAMETER cesta
    určuje kořenový adresář, kde se mají hledat duplicitní soubory
.EXAMPLE
   Get-DupliciteFile -cesta D:\
   Zobrazí seznam duplicitních souborů v adresáři a podadresářích
#>
function Get-DupliciteFile
{
    param
    (
        [Parameter(Mandatory=$true)][struing] $cesta
    )
    If (Test-Path $cesta) {
        ''
        Write-Warning 'Searching for duplicates ... Please wait ...'
        $duplicates = Get-ChildItem $cesta -File -Recurse -ErrorAction SilentlyContinue | Get-FileHash -Algorithm SHA256 | Group-Object -Property Hash | Where-Object Count -GT 1
 
        If ($duplicates.count -lt 1)
        {
            Write-Warning 'No duplicates found.'
            Break ''
        }
        else 
        {
        Write-Warning "Duplicates found."
        $result = foreach ($d in $duplicates)
        {
            $d.Group | Select-Object -Property Path, Hash, LastWriteTime
        }
 
        $date = Get-Date -Format "dd/MM/yyy"
        $itemstomove = $result | Out-GridView -Title "Select files (CTRL for multiple) and press OK. Selected files will be moved to C:\Duplicates_$date" -PassThru
        If ($itemstomove)
 
        {
            New-Item -ItemType Directory -Path $env:SystemDrive\Duplicates_$date -Force
            Move-Item $itemstomove.Path -Destination $env:SystemDrive\Duplicates_$date -Force
            ''
            Write-Warning "Mission accomplished. Selected files moved to C:\Duplicates_$date"
 
            Start-Process "C:\Duplicates_$date"
        }
 
        else
        {
            Write-Warning "Operation aborted. No files selected."
        }
    }
    }
    else
    {
        Write-Warning `
        "Folder not found. Use full path to directory e.g. C:\photos\patrick"
    }
}
<#
  .Synopsis
     Convert-Folder2ESD -rezim {<info> | <komprese> | <dekomprese>} -soubor <cesta k souboru> -slozka <cesta zdrojové složky> [-nazev <string>] [-index <number]
  .DESCRIPTION
     Pomocí nástroje DISM umožňuje zobrazit informace o daném ESD souboru. Umí extrhovat daný index či název do zadané složky. Pokud se nazadá název nebo index,
     bude do zadané složky extrahován index 1 daného souboru.
     Hlavním úkolem je tvorba ESD souborů ze zadané složky, do archivu jsou samozřejmně zahrnuty všechny podložky a jejich obsah. Komprese archivu je maximální možná.
     Název indexu je možné zadat v podobě volitelného parametru.
     Není podporována komprese samostatných souborů ani více indexové archivy či popis jednotlivých indexů.
  .PARAMETER rezim
    Příjímá hodnoty: komprese, info a dekomprese, což slouží k nastavení režimu práce
  .PARAMETER soubor
    Udává cestu k souboru esd
  .PARAMETER slozka
    Udává cestu ke složce, se kterou pracuji
  .PARAMETER index
    Udává číslo indexu v ESD archivu, který chci extrahovat
  .PARAMETER nazev
    Udává název indexu v ESD archivu, který chci extrahovat
  .EXAMPLE
      Convert-Folder2ESD -rezim komprese -soubor I:\2016-2017.esd -slozka I:\2016-2017 -nazev Fotokrouzek2016-2017
      Do souboru I:\I:\2016-2017.esd zabalí obsah složky I:\2016-2017 na index 1 pod jménem indexu Fotokrouzek2016-2017
  .EXAMPLE
     Convert-Folder2ESD -rezim dekomprese -soubor I:\Drivers.ESD -slozka I:\Ovladace
     Do složky I:\Ovladace vybalí obsah archivu I:\Drivers.esd
  .EXAMPLE
     Convert-Folder2ESD -rezim info -soubor I:\Drivers.ESD -slozka I:\Ovladace
     DZobrazí dostuné informace o archyvu I:\Drivers.esd
  .EXAMPLE
     Convert-Folder2ESD -rezim dekomprese -soubor I:\Windows\Souces\Install.esd -slozka I:\Win10Pro -index 5
     Extrahuje instalačního souboru offline podobu obrazu Windows 10 Pro, které jsou na indexu 5 do složky C:\Win10Pro
  .EXAMPLE
     Convert-Folder2ESD -rezim dekomprese -soubor I:\2016-2017.esd -slozka I:\2016-2017 -nazev Fotokrouzek2016-2017
     Extrahuje z archivu I:\2016-2017.esd index se jménem Fotokrouzek2016-2017 do složky I:\2016-2017 
  .NOTES
     Verze: 1.0
     Autor: Petrásek Jan
     Autor nenese žádnou odpovědnost za případnou ztrátu či poškození dat!
     Všechna práva vyhrazena
     ©2020
  .FUNCTIONALITY
     Tvorba a extrahování ESD
#>
function Convert-Folder2ESD
{
    param(
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [string]$rezim, 
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [string]$soubor, 
    [Parameter(Mandatory=$true, ValueFromPipeline=$true)]
    [string]$slozka,
    [Parameter(Mandatory=$false, ValueFromPipeline=$true)]
    [string]$nazev,
    [Parameter(Mandatory=$false, ValueFromPipeline=$true)]
    [string]$index,
    [Parameter(Mandatory=$false, ValueFromPipeline=$true)]
    [bool]$wim
    )
 
    Switch($rezim)
    {
        info{
           Dism.exe /Get-ImageInfo /ImageFile:$soubor
        }
        komprese {
            if($nazev -ne "")
            {
                Dism /Capture-Image /ImageFile:$soubor /Compress:max /CheckIntegrity /CaptureDir:$slozka /Name:$nazev
            }else{
                Dism /Capture-Image /ImageFile:$soubor /Compress:max /CheckIntegrity /CaptureDir:$slozka /Name:$soubor
            }
            if($wim){
                Dism /Capture-Image /ImageFile:$soubor.wim /Compress:max /CheckIntegrity /CaptureDir:$slozka /Name:$nazev
                }
            Write-Host ""
            Write-Host "Komprese dokončena" -ForegroundColor Green
        }
        dekomprese{
            IF(!(Test-Path 'C:\temp\ESD2Folder'))
            {
                New-Item -Path 'C:\temp\ESD2Folder' -ItemType Directory
            }
            if($nazev -ne ""){
                dism /export-image /SourceImageFile:$soubor /SourceName:$nazev /DestinationImageFile:C:\temp\ESD2Folder.wim /Compress:max /CheckIntegrity
                Dism /Mount-Image /ImageFile:C:\temp\ESD2Folder.wim /MountDir:C:\temp\ESD2Folder /Name:$nazev
                cd C:\temp\ESD2Folder
                Copy-Item C:\temp\ESD2Folder\* -Recurse $slozka
                cd $home
                Dism /Unmount-Image /MountDir:C:\temp\ESD2Folder /discard
                Remove-Item -Path C:\temp\ESD2Folder.wim -Force
                Remove-Item -Path C:\temp -Recurse -Force
                Write-Host ""
                Write-Host "Extrahování dat dokončeno" -ForegroundColor Green
            }elseif($index -ne "")
            {
                dism /export-image /SourceImageFile:$soubor /SourceIndex:$index /DestinationImageFile:C:\temp\ESD2Folder.wim /Compress:max /CheckIntegrity
                Dism /Mount-Image /ImageFile:C:\temp\ESD2Folder.wim /MountDir:C:\temp\ESD2Folder /Index:$index
                cd C:\temp\ESD2Folder
                Copy-Item C:\temp\ESD2Folder\* -Recurse $slozka
                cd $home
                Dism /Unmount-Image /MountDir:C:\temp\ESD2Folder /discard
                Remove-Item -Path C:\temp\ESD2Folder.wim -Force
                Remove-Item -Path C:\temp -Recurse -Force
                Write-Host ""
                Write-Host "Extrahování dat dokončeno" -ForegroundColor Green
            }else{
                dism /export-image /SourceImageFile:$soubor /SourceIndex:1 /DestinationImageFile:C:\temp\ESD2Folder.wim /Compress:max /CheckIntegrity
                Dism /Mount-Image /ImageFile:C:\temp\ESD2Folder.wim /MountDir:C:\temp\ESD2Folder /Index:1
                cd C:\temp\ESD2Folder
                Copy-Item C:\temp\ESD2Folder -Recurse $slozka
                cd $home
                Dism /Unmount-Image /MountDir:C:\temp\ESD2Folder /discard
                Remove-Item -Path C:\temp\ESD2Folder.wim -Force
                Remove-Item -Path C:\tempr -Recurse -Force
                Write-Host ""
                Write-Host "Extrahování dat dokončeno" -ForegroundColor Green
            }
        }
        Default{
            Write-Host "KONČÍM, chybně neplatná hodnota parametru režim" -ForegroundColor Red
        }
    }
}
<#
.Synopsis
   vygeneruje náhodné heslo
.DESCRIPTION
    Vygeneruje náhodné heslo zadabné délky a užitím speciálních znaků, nebo bez nich. Ke generování využito nativní rozhraní pro kryptografii ve Windows.
.PARAMETER delka
    Slouží k nastavení délky generovaného hesla
.PARAMETER specZnak
    Nastavuje, že heslo bude obsahovat speciální znaky
.PARAMETER czech
    Nastavuje, že heslo bude obsahovat znaky české abecedy včetně diaktitiky
.PARAMETER czechSpec
    Nastavuje, že heslo bude obsahovat znaky české abecedy včetně diaktitiky a speciální znaky
.EXAMPLE
   Generate-Password
   Výsledek: 1u0a63Q5AGOV
.EXAMPLE
   Generate-Password -delka 4
   Výsledek: z6kb
.EXAMPLE
   Generate-Password -specZnak
   Výsledek: YrI1mcNOzTY9
.EXAMPLE
   Generate-Password -delka 24 -specZnak
   Výsledek: 8G{5jIzes9[ezJ{9DzDUP8QE
.EXAMPLE
   Generate-Password -czech -delka 12
   Výsledek: dŽElůěř12ěýý
.EXAMPLE
   Generate-Password -czechSpec -delka 12
   Výsledek: ěqaž?6?8nŽBě
#>
function Generate-Password
{
    param
    (
        [int] $delka = 12,
        [switch] $specZnak,
        [switch] $czech,
        [switch] $czechSpec
    )
    $length = $delka
    if($specZnak)
    {
        $charSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{]+-[*=@:)}$^%;(_!&amp;#?>/| .'.ToCharArray()
    }
    elseif($czech)
    {
        $charSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789ěščřžýáíéĚŠČŘŽÝÁÍÉůŮúÚ'.ToCharArray()
    }
    elseif($czechSpec)
    {
        $charSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{]+-[*=@:)}$^%;(_!&amp;#?>/| .ěščřžýáíéĚŠČŘŽÝÁÍÉůŮúÚ'.ToCharArray()
    }
    else
    {
        $charSet = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'.ToCharArray()
    }
    $rng = New-Object System.Security.Cryptography.RNGCryptoServiceProvider
    $bytes = New-Object byte[]($length)
    $rng.GetBytes($bytes)
    $result = New-Object char[]($length)
    for ($i = 0 ; $i -lt $length ; $i++) {
        $result[$i] = $charSet[$bytes[$i]%$charSet.Length]
    }
    return (-join $result)
}
<#
.Synopsis
   Zobrazí nainstalované aktualizace ze služby Windows Updates
.DESCRIPTION
    Zobrazí nainstalované aktualizace ze služby Windows Updates
.EXAMPLE
   Get-WindowsUpdateHistory
   Zobrazí Gridview s informacemi o nainstalovaných aktualizacích
#>
function Get-WindowsUpdateHistory
{
    function Convert-WuaResultCodeToName
    {
        param( [Parameter(Mandatory=$true)][int] $ResultCode
        )
        $Result = $ResultCode
        switch($ResultCode)
        {
        2
            {
                $Result = "Succeeded"
            }
        3
            {
                $Result = "Succeeded With Errors"
            }
        4
            {
                $Result = "Failed"
            }
        }
       return $Result
    }
    function Get-WuaHistory
    {
        # Get a WUA Session
        $session = (New-Object -ComObject 'Microsoft.Update.Session')
        # Query the latest 1000 History starting with the first recordp
        $history = $session.QueryHistory("",0,50) | ForEach-Object {
        $Result = Convert-WuaResultCodeToName -ResultCode $_.ResultCode
        # Make the properties hidden in com properties visible.
        $_ | Add-Member -MemberType NoteProperty -Value $Result -Name Result
        $Product = $_.Categories | Where-Object {$_.Type -eq 'Product'} | Select-Object -First 1 -ExpandProperty Name
        $_ | Add-Member -MemberType NoteProperty -Value $_.UpdateIdentity.UpdateId -Name UpdateId
        $_ | Add-Member -MemberType NoteProperty -Value $_.UpdateIdentity.RevisionNumber -Name RevisionNumber
        $_ | Add-Member -MemberType NoteProperty -Value $Product -Name Product -PassThru
        Write-Output $_
    }
    #Remove null records and only return the fields we want
    $history |
    Where-Object {![String]::IsNullOrWhiteSpace($_.title)} |
    Select-Object Result, Date, Title, SupportUrl, Product, UpdateId, RevisionNumber | Out-GridView
    }
    Get-WuaHistory
}
<#
.Synopsis
   Nainstaluje aktualizace z Windows Update
.DESCRIPTION
    Nainstaluje aktualizace z Windows Update, k čemuž využívá externí modul. Umožňuje rovněž jen vyhledat, nebo odebrat již nainstalované aktualizace.
.PARAMETER najit
    Přepíná do režimu pouze vyhledat, ale neinstalovat a nestahovat
.PARAMETER jeden
    Přepíná do režimu, kdy se bude instalovat jen 1 konkrétní aktualizace, vyžaduje doplnění parametrem cislo
.PARAMETER cislo
    Udává KB číslo aktualizace, se kterou se pracuje
.PARAMETER odinstalovat
    Přepíná do módu odinstalace aktualizace, vyžaduje kombinaci s parametrem cislo, nebo parametrem mesic
.PARAMETER mesic
    Udává, že se odebírají aktualizace nainstalované v posledních 30 dnech
.EXAMPLE
   Install-WinUpdates
   Nainstaluje všechny dostupné aktualizace z Windows update
.EXAMPLE
   Install-WinUpdates -najit
   Pouze vyhledá všechny dostupné aktualizace z Windows update
.EXAMPLE
   Install-WinUpdates -jeden -cislo KB5017308 
   Nainstaluje aktualizaci KB5017308 z Windows update
.EXAMPLE
   Install-WinUpdates -odinstalovat -cislo KB5017308
   Odinstaluje aktualizaci KB5017308 z počítače
.EXAMPLE
   Install-WinUpdates -odinstalovat -mesic
   Odinstaluje všechny hotfixy instalované za poslední měsíc
#>
function Install-WinUpdates
{
    param(
        [switch] $najit,
        [switch] $odinstalovat,
        [string] $cislo,
        [switch] $jeden,
        [switch] $mesic
    )
    if (Get-Module -ListAvailable -Name PSWindowsUpdate) {
        Update-Module -Name PSWindowsUpdate -Force
    } 
    else {
        Install-Module -Name PSWindowsUpdate -Force
    }
    Import-Module PSWindowsUpdate
    if($najit)
    {
        Get-WindowsUpdate | Out-GridView
    }
    if($odinstalovat)
    {
        if($mesic)
        {
            $ListOfHotfixes = Get-Hotfix | where -Property InstalledOn -le (get-date).AddMonths(-1).Date
            foreach ($item in $ListOfHotfixes)
            {
                $polozka = $item.hotfixID
                $cislo = [string] $polozka.Split("KB")
                $c = $cislo.TrimStart()
                wusa.exe /uninstall /kb:$c /norestart /quiet | out-null
            }
        }
        Get-WindowsUpdateHistory
        $cislo = Read-Host -Prompt "Zadej KB číslo aktualizace: "
        if($cislo -eq '')
        {
            Write-Error "KB číslo aktualizace musí být zadáno!"
            break
        }
        Remove-WindowsUpdate -KBArticleID $cislo -NoRestart
    }
    if($jeden)
    {
        if($cislo -eq '')
        {
            Write-Error "KB číslo aktualizace musí být zadáno!"
            break
        }
        Get-WindowsUpdate -Install -KBArticleID $cislo
    }
    else
    {
        Get-WindowsUpdate -AcceptAll -Install -AutoReboot
    }
}
<#
.Synopsis
   Zobrazí soubory s exportovanými cetifikáty
.DESCRIPTION
    Zobrazí soubory s exportovanými cetifikáty ve formátech pfx, cer a pem, které nejsou starší 1,5 roku
.PARAMETER umisteni
    Udává kořen cesty, kde se mají hledat exporty certifikátů. Výchozí cesta je %userprofile%
.EXAMPLE
   Get-CertExport
   Zobrazí v profilu uživatele uložené soubory s exportovanými cetifikáty ve formátech pfx, cer a pem, které nejsou starší 1,5 roku
.EXAMPLE
   Get-CertExport -umisteni D:\
   Zobrazí soubory s exportovanými cetifikáty ve formátech pfx, cer a pem uložené na disku D:, které nejsou starší 1,5 roku
#>
function Get-CertExport
{
    param(
        [string]$umisteni
    )
    if($umisteni -ne '')
    {
        gci $umisteni -Recurse -Filter *.pfx | where -FilterScript{$_.LastWriteTime -gt (get-date).AddYears(-1.5)}
        gci $umisteni -Recurse -Filter *.pem | where -FilterScript{$_.LastWriteTime -gt (get-date).AddYears(-1.5)}
        gci $umisteni -Recurse -Filter *.cer | where -FilterScript{$_.LastWriteTime -gt (get-date).AddYears(-1.5)}
    }
    else
    {
        gci $env:USERPROFILE -Recurse -Filter *.pfx | where -FilterScript{$_.LastWriteTime -gt (get-date).AddYears(-1.5)}
        gci $env:USERPROFILE -Recurse -Filter *.pem | where -FilterScript{$_.LastWriteTime -gt (get-date).AddYears(-1.5)}
        gci $env:USERPROFILE -Recurse -Filter *.cer | where -FilterScript{$_.LastWriteTime -gt (get-date).AddYears(-1.5)}
    }
}
<#
.Synopsis
   Zobrazí 48 mísný obnovovací kód nástroje Bitlocker
.DESCRIPTION
    Zobrazí 48 mísný obnovovací kód nástroje Bitlocker
.PARAMETER jednotka
    Udává písmeno (bez dvojtečky) disku, pro který se má zobrazit 48 místný obnovovací klíč
.EXAMPLE
   Get-BitlockerRecovery
   Zobrazí ID a obnovací kód pro systémovou jednotku
.EXAMPLE
   Get-BitlockerRecovery -jednotka D
   Zobrazí ID a obnovací kód pro disk D:
#>
function Get-BitlockerRecovery
{
    param
    (
        #[switch] $backupToAD,
        [string] $jednotka
    )
    if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
    if($jednotka -ne '')
    {
        manage-bde -protectors -get ($jednotka+":")
    }
    if($backupToAD)
    {
        $id = manage-bde -protectors -get C: | findstr ID
        foreach($k in $ID)
        {
            $i = $k.substring($k.Length-37,36)
            manage-bde -protectors -adbackup $env:SystemDrive -id "{$i}"
        }
    }
    else
    {
        manage-bde -protectors -get $env:SystemDrive
    }
}
<#
.Synopsis
   Zobrazí výsledky doazu na systém whois
.DESCRIPTION
    Zobrazí výsledky doazu na systém whois pro domény: br.com, cn.com, com, eu.org, net, org,edu, gov, cz, eu, sk, de, ua, pro další domény je potřeba specifikovat sertver
.PARAMETER server
    Udává whois server, na kterém se má dotaz vyhodnotit
.PARAMETER NoForward
    Blokuje předávání požadavku mezi registrátory
.PARAMETER iana
    Nastaví, že dotaz se bude zpracovávat na whois.iana.org
.EXAMPLE
   Get-WhoIs google.cz
   Zobrazí základní výsledky ze systém Whois pro doménu google.cz
.EXAMPLE
   Get-WhoIs google.cz -NoForward
   Zobrazí základní výsledky ze systém Whois pro doménu google.cz bez předávání mimo whois serververy cz.nic
.EXAMPLE
   Get-WhoIs google.cz -iana
   Zobrazí informace o správci domény 1. řádu hledané domény (včetně adresy whois serveru pro danou doménu 1. řádu)
.EXAMPLE
   Get-WhoIs google.cz -server whois.iana.org
   Zobrazí základní výsledky ze systém Whois pro doménu google.cz ze serveru whois.iana.org
.EXAMPLE
   Get-WhoIs 8.8.8.8
   Zobrazí základní výsledky ze systém Whois pro IP 8.8.8.8
#>
function Get-WhoIs {
    [CmdletBinding()]
    param(
        
        [Parameter(Position=0, ValueFromRemainingArguments=$true)]
        [string]$query,
        [string]$server,
        [switch]$NoForward,
        [switch]$iana
    )
    end {
        $TLDs = DATA {
          @{
            ".br.com"="whois.centralnic.net"
            ".cn.com"="whois.centralnic.net"
            ".eu.org"="whois.eu.org"
            ".com"="whois.crsnic.net"
            ".net"="whois.crsnic.net"
            ".org"="whois.publicinterestregistry.net"
            ".edu"="whois.educause.net"
            ".gov"="whois.nic.gov"
            ".cz"="whois.nic.cz"
            ".eu"="whois.eu"
            ".sk"="whois.sk-nic.sk"
            ".de"="whois.denic.de"
            ".ua"="whois.ua"
          }
        }
        if($iana)
        {
            $server = "whois.iana.org"
        } 
        $EAP, $ErrorActionPreference = $ErrorActionPreference, "Stop"
 
        $query = $query.Trim()
 
        if($query -match "(?:\d{1,3}\.){3}\d{1,3}") {
            Write-Verbose "IP Lookup!"
            <#if($query -notmatch " ") {
                $query = "n $query"
            }
            if(!$server) { $server = "whois.arin.net" }#>
        } elseif(!$server) {
            $server = $TLDs.GetEnumerator() |
                Where { $query -like  ("*"+$_.name) } |
                Select -Expand Value -First 1
                (Invoke-WebRequest -URI "www.whois.com/whois/$query").AllElements | Where {$_.id -eq "registryData"} 
        }
 
        if(!$server) { $server = "whois.arin.net" }
        $maxRequery = 3 
 
        do {
            Write-Verbose "Connecting to $server"
            $client = New-Object System.Net.Sockets.TcpClient $server, 43
 
            try {
                $stream = $client.GetStream()
 
                Write-Verbose "Sending Query: $query"
                $data = [System.Text.Encoding]::Ascii.GetBytes( $query + "`r`n" )
                $stream.Write($data, 0, $data.Length)
 
                Write-Verbose "Reading Response:"
                $reader = New-Object System.IO.StreamReader $stream, [System.Text.Encoding]::ASCII
 
                $result = $reader.ReadToEnd()
 
                if($result -match "(?s)Whois Server:\s*(\S+)\s*") {
                    Write-Warning "Recommended WHOIS server: ${server}"
                    if(!$NoForward) {
                        Write-verbose "Non-Authoritative Results:`n${result}"
                        if(!$cachedResult) {
                            $cachedResult = $result
                            $cachedServer = $server
                        }
                        $server = $matches[1]
                        $query = ($query -split " ")[-1]
                        $maxRequery--
                    } else { $maxRequery = 0 }
                } else { $maxRequery = 0 }
            } finally {
                if($stream) {
                    $stream.Close()
                    $stream.Dispose()
                }
            }
        } while ($maxRequery -gt 0)
 
        $result
 
        if($cachedResult -and ($result -split "`n").count -lt 5) {
            Write-Warning "Original Result from ${cachedServer}:"
            $cachedResult
        }
 
        $ErrorActionPreference = $EAP
    }
 }
 <#
.Synopsis
   Provede synchronizaci dvou adresářů
.DESCRIPTION
    Provede synchronizaci obsahu dvou adresářů (může jít i o Disk Volume) včetně oprávnění, nebo přenese pouze oprávnění
.PARAMETER zdroj
    Udává cestu ke zdrojovému adresáři
.PARAMETER cil
    Udává cestu k cílovému adresáři
.PARAMETER prava
    Přpíná do režimu přenosu pouze ACL, nikoliv samotných dat
.EXAMPLE
   Clone-Folder -zdroj C:\FFOutoput\ -cil E:\Video
   Přenese obsah složky z C:\FFOutput do složky E:\video se zachováním zdrojových oprávnění. Obsah složky E:\video, který není ve složce C:\FFOutput bude odebrán!
.EXAMPLE
   Clone-Folder -zdroj D:\ -cil E:\
   Přenese obsah disku D: na disk E: se zachováním zdrojových oprávnění. Obsah složky E:\, který není na disku D:\ bude odebrán!
.EXAMPLE
   Clone-Folder -zdroj D:\ -cil E:\ -prava
   Přenese oprávnění z disku D:\ na disk E:\, původní nastavení oprávnění na disku E:\ budou smazána.
#>
 function Clone-Folder
 {
    param
    (
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]$zdroj,
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=1)]$cil,
        [switch]$prava
    )
    if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
    if($prava)
    {
        Invoke-Command "robocopy $zdroj $cil /e /sec /secfix /xo /xn /xc"
    }
    else
    {
        Invoke-Command "robocopy $zdroj $cil /mir /sec /secfix /v"
    }
 }
 <#
.Synopsis
   Provede 35 násobný přepis diku nulou nebo jinou hodnotou
.DESCRIPTION
    Provede 35 násobný přepis diku nulou nebo jinou hodnotou. U fyzických disků smaže všechny oddíly a vytvoiří nové
.PARAMETER disk
    Zadává písmeno disku (oddílu), který má být vydrhnut
.PARAMETER fyzicky
    Udává, že budeme čistit fyzický disk, který může obsahovat více oddílů
.PARAMETER pismeno
    Udává, jaké písmeno bude přiřazeno nově vytvořenému oddílu po dokončení vydrhnutí fyzického disku
.EXAMPLE
   Delte-Disk -disk G
   Disk G bude 35x přepsán náhodným číslem a následně pomalu naformátován na NTFS
.EXAMPLE
   Delte-Disk -fyzicky
   Vyžádá si výběr fyzického disku ze zovbrazeného seznamu dostupných fyzických disků. Následně smaže všechny oddíly a disk 35x přepíš náhodným číslem. Po skončení oprace vytvoří jeden oddíl naformátovaný na NTFS s písmenem W.
.EXAMPLE
   Delte-Disk -fyzicky -pismeno E
   Vyžádá si výběr fyzického disku ze zovbrazeného seznamu dostupných fyzických disků. Následně smaže všechny oddíly a disk 35x přepíš náhodným číslem. Po skončení oprace vytvoří jeden oddíl naformátovaný na NTFS s písmenem E.
#>
function Delte-Disk
{
    Param(
        [string]$Disk,
        [switch]$fyzicky,
        [string]$pismeno
    )
    if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
    if($fyzický)
    {
        if($pismeno -eq "")
        {
            $pismeno = "W"
        }
        Get-Disk | FT
        $cil = Read-Host -Prompt "Zadejte číslo disku"
        Get-Disk $cil | Clear-Disk -RemoveData -RemoveOEM
        Initialize-Disk $cil
        New-Partition -DiskNumber $cil -UseMaximumSize | Format-Volume -FileSystem NTFS -NewFileSystemLabel Nedostupno
        Get-Partition -DiskNumber 0 | Set-Partition -NewDriveLetter W
        Invoke-Expression "format W: / fs: NTFS /v:Volny / p: 35"
        New-Partition -DiskNumber $cil -UseMaximumSize | Format-Volume -FileSystem NTFS -NewFileSystemLabel Volny
        Get-Partition -DiskNumber 0 | Set-Partition -NewDriveLetter $pismeno
    }
    elseif($Disk -ne "")
    {
        $Disk = $Disk+":"
        Invoke-Expression "format $Disk / fs: NTFS /v:Volny / p: 35"
        Invoke-Expression "format $Disk / fs: NTFS /v:Volny"
    }
    else
    {
        Write-Error "Musí být zadán DISK!"
    }
}
 <#
.Synopsis
   Zobrazí informace o hesle uživatele
.DESCRIPTION
    Zobrazí informace o hesle lokálního nebo doménového uživatele. Mezi zoíbrazené informace patří expirace, chybné zadání nebo poslední nastavení.
.PARAMETER login
    Udává login účtu, pro který chceme vrátit informace o hesle
.PARAMETER domena
    Přepíná do režimu doménových uživatelů
.EXAMPLE
   Get-UserPasswordInfo -login Administrator -domena
   Zobrazí informace o hesle účtu Administrator z domény, ve které je počítač
.EXAMPLE
   Get-UserPasswordInfo -login Administrator
   Zobrazí informace o hesle účtu Administátor, který je lokálním účtem daného PC.
#>
Function Get-UserPasswordInfo
{
    param(
    [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]$login,
    [switch]$domena
    )
    if($domena)
    {
        get-aduser -Identity $login -Properties * | select Name, UserPrincipalName, DistinguishedName, @{name="badPasswordTime"; expression={[datetime]::FromFileTime($_.badPasswordTime)}}, @{name ="pwdExpire";expression={[datetime]::FromFileTime($_.pwdExpire)}}, @{name ="pwdLastSet";expression={[datetime]::FromFileTime($_.pwdLastSet)}}
    }
    else
    {
        Get-LocalUser -Name $login  | select Name, PasswordLastSet, PasswordRequired, UserMayChangePassword, PasswordExpires, PasswordChangeableDate
    }
}
 <#
.Synopsis
   Zobrazí informace o nastavených šifrovacích algoritmech pro daný úživatelský účet
.DESCRIPTION
    Zobrazí informace o nastavených šifrovacích algoritmech protokolu Kerberos pro daný úživatelský účet
.PARAMETER login
    Udává login uživatele, pro kterého potřebuji znát informace o podporovaném šifrování vrámci kerberosu
.EXAMPLE
   Get-KrbEncriptionTypes -login Administrator
   Administrator,Not defined - defaults to RC4_HMAC_MD5
#>
function Get-KrbEncriptionTypes
{
    param(
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]$login
    )
    $encTypes = @("Not defined - defaults to RC4_HMAC_MD5","DES_CBC_CRC","DES_CBC_MD5","DES_CBC_CRC | DES_CBC_MD5","RC4","DES_CBC_CRC | RC4","DES_CBC_MD5 | RC4","DES_CBC_CRC | DES_CBC_MD5 | RC4","AES 128","DES_CBC_CRC | AES 128","DES_CBC_MD5 | AES 128","DES_CBC_CRC | DES_CBC_MD5 | AES 128","RC4 | AES 128","DES_CBC_CRC | RC4 | AES 128","DES_CBC_MD5 | RC4 | AES 128","DES_CBC_CBC | DES_CBC_MD5 | RC4 | AES 128","AES 256","DES_CBC_CRC | AES 256","DES_CBC_MD5 | AES 256","DES_CBC_CRC | DES_CBC_MD5 | AES 256","RC4 | AES 256","DES_CBC_CRC | RC4 | AES 256","DES_CBC_MD5 | RC4 | AES 256","DES_CBC_CRC | DES_CBC_MD5 | RC4 | AES 256","AES 128 | AES 256","DES_CBC_CRC | AES 128 | AES 256","DES_CBC_MD5 | AES 128 | AES 256","DES_CBC_MD5 | DES_CBC_MD5 | AES 128 | AES 256","RC4 | AES 128 | AES 256","DES_CBC_CRC | RC4 | AES 128 | AES 256","DES_CBC_MD5 | RC4 | AES 128 | AES 256","DES+A1:C33_CBC_MD5 | DES_CBC_MD5 | RC4 | AES 128 | AES 256")
    $EncVal = Get-ADUser -Identity $login
    foreach($e in $EncVal)
    {
        try 
        {
            $e.Name + "," + $encTypes[$e.'msDS-SupportedEncryptionTypes']
        }
        catch
        {
            $e.Name + "," + $encTypes[0]
        }    
     }
}
<#
    .SYNOPSIS
        Vrací informace o účtu Krbtgt.
     
    .DESCRIPTION
        Vrací informace o účtu Krbtgt.
        Obsahuje informace o konfiguraci tiketu Kerberos.
        Pokusí se pomocí modulu GroupPolicy zjistit nastavení zásad Kerberos.
     
    .PARAMETER Server
        Řadič domény, ze kterého se vyžádají informace
     
    .PARAMETER Identity
        Účet, na který se zaměřit.
        Výchozí hodnota je účet krbtgt, ale lze jej použít i pro jiné účty (např.: účet krbtgt pro RODC).Účet, na který se zaměřit.
     
    .PARAMETER EnableException
        Tento parametr vypíná uživatelsky přívětivá varování a umožňuje vyhazování výjimek.
        To je méně uživatelsky přívětivé, ale umožňuje to zachytávat výjimky ve volajících skriptech.
     
    .EXAMPLE
        Get-KrbAccount
        vypíše informace o účtu krbtgt

    .NOTE
        Tato funkce je přezvazta z: https://www.powershellgallery.com/packages/Krbtgt/1.0.0/Content/functions%5CGet-KrbAccount.ps1 a opravena (vyřešeny problémy v kódu + dokumentace přeložena do češtiny).
        Autorem je: Friedrich Weinmann
#>
function Get-KrbAccount
{
     [CmdletBinding()]
    param (
        [string]
        $Server,
        
        [string]
        $Identity = 'krbtgt',
        
        [switch]
        $EnableException
    )
    
    begin
    {
        $parameter = @{
            Identity   = $Identity
            Properties = 'PasswordLastSet'
        }
        if ($Server) { $parameter['Server'] = $Server }
        
        try
        {
            if ($Server) { $domainName = (Get-ADDomain -Server $Server -ErrorAction Stop).DNSRoot }
            else { $domainName = (Get-ADDomain -ErrorAction Stop).DNSRoot }
        }
        catch
        {
            exit
            return
        }
    }
    process
    {
        Write-Host "Get-KrbAccount.Start $Identity"
        $krbtgt = Get-ADUser @parameter -ErrorAction Stop
        Write-Host "Get-KrbAccount.UserFound $krbtgt.DistinguishedName"
        
        $result = [PSCustomObject]@{
            PSTypeName               = 'Krbtgt.Account'
            EarliestResetTimestamp = $null
            Name                   = $krbtgt.Name
            SamAccountName           = $krbtgt.SamAccountName
            DistinguishedName       = $krbtgt.DistinguishedName
            PasswordLastSet           = $krbtgt.PasswordLastSet
        }
        try
        {
            Write-host "Get-KrbAccount.ScanningKerberosPolicy $domainName"
            [xml]$gpo = Get-GPOReport -Guid '{31B2F340-016D-11D2-945F-00C04FB984F9}' -ReportType Xml -ErrorAction Stop -Domain $domainName
            $result.MaxTgtLifetimeHours = (($gpo.gpo.Computer.ExtensionData | Where-Object { $_.name -eq 'Security' }).Extension.ChildNodes | Where-Object { $_.Name -eq 'MaxTicketAge' }).SettingNumber
            $result.MaxClockSkewMinutes = (($gpo.gpo.Computer.ExtensionData | Where-Object { $_.name -eq 'Security' }).Extension.ChildNodes | Where-Object { $_.Name -eq 'MaxClockSkew' }).SettingNumber
        }
        catch
        {
            Write-Warning -Message "Get-KrbAccount.FailedKerberosPolicyLookup $domainName"
        }
        $result.EarliestResetTimestamp = (($Krbtgt.PasswordLastSet.AddHours($result.MaxTgtLifetimeHours)).AddMinutes($result.MaxClockSkewMinutes)).AddMinutes($result.MaxClockSkewMinutes)
        
        Write-Host "Get-KrbAccount.Success" $result.SamAccountName", "$result.EarliestResetTimestamp
        $result
    }
}
 <#
.Synopsis
   Zobrazí Kerberos tikety
.DESCRIPTION
    Zobrazí Kerberos tikety přihlášenoho uživatele, nebo systému
.PARAMETER system
    Nastavuje, že zdrojem pro výčet tiketů bude účet počítače
.EXAMPLE
   Get-KrbTickets
   Zobrazí tikety uživatele, pod kterým běží PowerShell
.EXAMPLE
   Get-KrbTickets -system
   Zobrazí tikety účtu počítače
#>
function Get-KrbTickets
{
    param(
        [switch]$system
    )
    if($system)
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        klist -li 0x3e7
    }
    else
    {
        klist
    }
}
<#
.Synopsis
   Zobrazí uživatele, jejichž hesla jsou součástí srovnávacího slovníku.
.DESCRIPTION
    Zobrazí uživatele, jejichž hesla jsou součástí srovnávacího slovníku. Využívá modul DSInternals. Umí zpracovat více slovníků stejného typu, které jsou v jedné složce. P5i běhu na DC, si umí samostatně zajistit kopii databáze ntds.dit a potřebných registrů.
.PARAMETER slovnik
    Udává cestu keslovníku ve formátu txt
.PARAMETER slozka
    Udává, že porovnání bude provedeno s více slovníky, které jsou uloženy ve složce
.PARAMETER txt
    Udává, že slovník obsahuje hesla v plaintextu (v plné formě)
.PARAMETER dc
    Udává, že kontrola běží na doménovém řadiči a má si sama zajistit dočasnou kopii databáze AD a potřebných registrů
.PARAMETER ntds
    Udává cestu k souboru ntds.dit
.PARAMETER reg
    Udává cestu ke kopii souboru SYSTEM, který obsahuje systémovou větev registru
.EXAMPLE
   Test-AdUserPasswordQuality -slovnik H: -slozka -txt -dc
   Na plochu vygeneruje sadu reportů ve formátu txt, když každý report odpovídá jednomu slovníku uloženému na disku H. Slovky obsahují palintextová hesla a volání probíhá na běžícím DC.
.EXAMPLE
   Test-AdUserPasswordQuality -slovnik H:\haveibennpwd.txt -nts E:\IFM\Active Directory\ntds.dit -reg E:\IFM\registry\SYSTEM
   Na plochu vygeneruje report ve formátu txt, který obsahuje výsledky vůči slovníku haveibennpwd.txt. Slovník haveibennpwd.txt obsahuje NTLM Hash hesel. Jako zdroj AD databáze je export IFM na disku E:
#>
function Test-AdUserPasswordQuality
{
    param(
        [string]$slovnik,
        [switch]$dc,
        [string]$ntds,
        [string]$reg,
        [switch]$txt,
        [switch]$slozka
    )
    if (Get-Module -ListAvailable -Name DSInternals) {
        Update-Module -Name DSInternals -Force
    } 
    else {
        Install-Module -Name DSInternals -Force
    }
    Import-Module DSInternals
    $ntdsPath = $ntds
    $systempath = $reg
    $vystup = "$env:userprofile\Desktop\vystup"
    if($dc)
    {
        New-Item -Path 'C:\IFM' -ItemType Directory
        ntdsutil "activate instance ntds" IFM "create full C:\IFM" q q
        $ntdsPath = "C:\IFM\Active Directory\ntds.dit"
        $systempath = "C:\IFM\registry\SYSTEM"
    }
    $key = Get-BootKey -SystemHivePath $systempath
    if($slozka)
    {
        $i = 1
	$files = gci -Path $slovnik -Filter *.txt
        #gci -Path $slovnik -Filter *.txt | Foreach-Object
	ForEach($file in $files)
        {
	    if($txt)
            {
                Get-ADDBAccount -All -DBPath $ntdsPath -BootKey $key | Test-PasswordQuality -WeakPasswordsFile ($slovnik + "\" + $file) | Out-File ($vystup+$i+".txt") -Encoding utf8 
            }
            else
            {
                Get-ADDBAccount -All -DBPath $ntdsPath -BootKey $key | Test-PasswordQuality -WeakPasswordHashesFile ($slovnik + "\" + $file)| Out-File ($vystup+$i+".txt") -Encoding utf8
            }
            $i++
        }
    }
    elseif($txt)
    {
        Get-ADDBAccount -All -DBPath $ntdsPath -BootKey $key | Test-PasswordQuality -WeakPasswordsFile $slovnik | Out-File ($vystup+".txt") -Encoding utf8 
    }
    else
    {
        Get-ADDBAccount -All -DBPath $ntdsPath -BootKey $key | Test-PasswordQuality -WeakPasswordHashesFile $slovnik | Out-File ($vystup+".txt") -Encoding utf8
    }
    if($dc)
    {
        Remove-Item -Path C:\IFM -Force
    }
}
<#
.Synopsis
   Zobrazí Zařízení v AAD
.DESCRIPTION
	Skript vypíše jména všech nedoménových zařízení, která má zadaný uživatel registrovaná v Azure AD. 
    Volitelně dokáže zakázat všechna zařízení, která má daný uživatel registrované a nejsou doménová.
    Autor nenese žádnou odpovědnost za případné škody, uživatel je povinen před spuštěním se seznámit se skriptem!
.PARAMETER PC
    Udává AAD login uživatele, jehož počítače chceme vylistovat
.EXAMPLE
   Get-AzureAdDevices -PC zak@skola.cz
   Zobrazí všechna zařízení, která má uživatel zak zaregistrovaný v AAD a nejsou součáslí lokální AD skola.cz
#>
function Get-AzureAdDevices
{
	param (
		[Parameter(Mandatory = $true,
				   ValueFromPipelineByPropertyName = $true,
				   Position = 0)]$PC
	)
	if ((get-module -Name AzureAD) -eq $null)
	{
		Install-Module -Name AzureAD -force
		import-module AzureAD
	}
	else
	{
		if ((get-module -Name AzureAD | select Version) -le 2.0.2.76)
		{
			Update-Module AzureAD
		}
		import-module AzureAD
	}
	#přihlášení k Azure AD a MSonline service
	#$Credential = Get-Credential
	Connect-AzureAD #-Credential $Credential
	Connect-MsolService #-Credential $Credential
	#načtení vstupních inforamce
	$domena = (Get-ADComputer -Filter * | select Name)
	#nalezení zařízení registrovaných uživatelem
	$zarizeni = Get-MsolDevice -RegisteredOwnerUpn $PC | select DisplayName
	#vybrání pouze nedoménových zařízení
	$zobraz
	foreach ($DisplayName in $zarizeni)
	{
		foreach ($Name in $domena)
		{
			if ($DisplayName -ne $Name)
			{
				if ($DisplayName -ne $zobraz)
				{
					$zobraz = $DisplayName
				}
			}
		}
	}
	#$zobraz | Format-Table - pbjekt pro kontrolní zobrazení
	
	#finální zobrazení informace o zařízeních
	Get-MsolDevice -All | where DisplayName -like $zobraz.DisplayName | select DisplayName, DeviceObjectVersion, DeviceOsType, DeviceOsVersion, LastDirSyncTime
	
	#možnost zařízení zakázat
	$volba = 0
	Write-Host 'Pro zakázání zařízení zadejte 1'
	Write-Host 'Pro ponechání povoleného zařízení zadejte 0'
	$volba = Read-Host -Prompt 'Chcete zařízení zakázat? (1/0): '
	$zakaz = Get-MsolDevice -All | where DisplayName -like $zobraz.DisplayName | select DeviceId
	if ($volba -eq 1)
	{
		foreach ($DeviceId in $zakaz)
		{
			Disable-MsolDevice -DeviceId $zakaz.DeviceId -Force
		}
		Write-Host 'Zařízení byla zakázána'
	}
	else
	{
		Write-Host 'Žádná změna na zařízeních nebyla provedena'
	}
}
<#
.Synopsis
   Zobrazí informace o časové službě Windows
.DESCRIPTION
	Zobrazí informace o časové službě Windows jako je stav, poslední synchronizace, časový server apod.
.EXAMPLE
   Get-TimeServiceInfo

   Leap Indicator: 0(no warning)
   Stratum: 4 (secondary reference - syncd by (S)NTP)
   Precision: -23 (119.209ns per tick)
   Root Delay: 0.0262875s
   Root Dispersion: 0.0478826s
   ReferenceId: 0x28779426 (source IP:  40.119.148.38)
   Last Successful Sync Time: 2. 3. 2023 7:46:46
   Source: time.windows.com,0x9
   Poll Interval: 10 (1024s)
.NOTE
    Na nedoménových PC je často před provedením potřba zapnout službu w32tm
#>
function Get-TimeServiceInfo
{
    Invoke-Expression "w32tm /query /status"
}
<#
.Synopsis
   Umožní nastavit systémový čas
.DESCRIPTION
    Umožní nastavit systémový čas pomcí časového serveru, opravy či ručního zadání
.PARAMETER oprava
    Udává rozdílovou hodnotu mezi správným časem a časem systému
.PARAMETER sync
    Provede okamžitou synchronizaci se zadaným časovým serverem
.PARAMETER server
    Udává, vůči jakému serveru se má provést synchronizace času
.PARAMETER manual
    Udává hodnotu ve formátu datetime, která má být v systému nastavena
.EXAMPLE
   Set-Time -sync
   Provede okamžitou synchronizaci s časovým serverem
.EXAMPLE
   Set-Time -server time.moje.domena
   Provede synchronizaci s časovým serverem time.moje.domena. Podporuje pouze interní časové servery.
.EXAMPLE
   Set-Time -oprava +0:01:15
   Provede opravu zpoždění času o minutu a 15 s
.EXAMPLE
   Set-Time -manual 02/01/2023 08:15
   Nastaví čas systému na 1.2.2023 v 8:15 ráno
.NOTE
    Na PC mimo doménu může být potřeba před provdením spustit službu w32tm
#>
function Set-Time
{
    param(
        [string]$oprava,
        [string]$server,
        [string]$manual,
        [switch]$sync
    )
    if($sync)
    {
        Invoke-Expression "w32tm /resync"
    }
    if($server -ne "")
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        $text = "net time \\"+$server +" /set /y"
        Invoke-Expression $text
    }
    if($manual -ne "")
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        $text = ($manual -match "[0-9]{2}/[0-9]{2}/[0-9]{4} [0-9]{2}:[0-9]{2}")
        if($text)
        {
            set-date -date $manual
        }
        else
        {
            Write-Error "Nevalidní formát pro nastavení data a času, užij formát: mm/dd/yyyy hh:mm"
        }
    }
    if($oprava -ne "")
    {
        if((whoami /priv /fo csv | convertfrom-csv | select "Privilege Name")."Privilege Name" -contains "SeImpersonatePrivilege")
        {}
        else
        {
            Write-Error "Tento úkon smí vykonávat pouze správce"
            Start-Process "$PSHOME\powershell.exe" -Verb Runas -ArgumentList "-command 'import-module AdminTools'"
        }
        $format = ($oprava -match "[+-]{1}[0-9]{1,2}:[0-9]{2}:[0-9]{0,2}")
        if($format)
        {
            Set-Date -Adjust $oprava -DisplayHint Time
        }
        else
        {
            Write-Error "Nevalidní formát pro opravu času, užij formát: +hh:mm:ss nebo -hh:mm:ss"
        }
    }
}
<#
.Synopsis
   Odebere MS Universal Apps
.DESCRIPTION
    Je vhodné po instalaci systému. Odebere MS Universall Apps, což jsou sponzorské aplikace ve Windows 10. Ponechá jen Store, Kalkulačku a prohlížeč fotek, jinak vše odebere.
.PARAMETER allusers
    Přepíná do režimu, že odebírané aplikace budou odebrány všem uživatelům počítače, nokoliv jen tomu, pod kým běží PowerShell
.EXAMPLE
   Remove-MsUniversalApp
   Odebere universální aplikace pro daného uživatele, pod kterým je modul spuštěn.
.EXAMPLE
   Remove-MsUniversalApp -allusers
   Odebere universální aplikace pro všechny existující uživatele a odebere i instalační balíčky předinstalovaných aplikací ve Windows 10.
#>
function Remove-MsUniversalApp
{
    param(
        [switch]$allusers
    )
    if($allusers)
    {
        Get-AppxPackage -AllUsers | where-object {$_.name –notlike “*store*”} | where-object {$_.name -notlike "*Microsoft.WindowsCalculator*"} | where-object {$_.name -notlike "*Microsoft.Windows.Photos*"} |Remove-AppxPackage
        Get-appxprovisionedpackage –online | where-object {$_.packagename –notlike “*store*”} | where-object {$_.name -notlike "*Microsoft.WindowsCalculator*"} | where-object {$_.name -notlike "*Microsoft.Windows.Photos*"} | where-object {$_.name -notlike "*Corinth*"}| Remove-AppxProvisionedPackage -online
    }
    else
    {
        Get-AppxPackage | where-object {$_.name –notlike “*store*”} | where-object  where-object {$_.name -notlike "*Microsoft.WindowsCalculator*"} | where-object {$_.name -notlike "*Microsoft.Windows.Photos*"} |Remove-AppxPackage
    }
}
<#
.Synopsis
   Konvertuje slovník z plantextu do NTLM hash
.DESCRIPTION
    Konvertuje slovník z plantextu do NTLM hash
.PARAMETER slovnik
    Udává cestu ke slovníku formátu txt, který obsahuje hesla v plné formě
.PARAMETER vystup
    Udává cestu k výstupnímu souboru
.EXAMPLE
   Convert-PasswodToNTLMhash -slovnik H:\slovnik.txt -vystup H:\NTLMslovnik.txt
   Konvertuje všechna hesla obsažená v H:\slovnik.txt do NTLM hash a uloží je do H:\NTLMslovnik.txt
#>
function Convert-PasswodToNTLMhash
{
    param(
        [Parameter(Mandatory=$true)][string]$slovnik,
        [Parameter(Mandatory=$true)][string]$vystup
    )
    if (Get-Module -ListAvailable -Name DSInternals) {
        Update-Module -Name DSInternals -Force
    } 
    else {
        Install-Module -Name DSInternals -Force
    }
    Import-Module DSInternals
    $pwd = ""
    $pass = ""
    foreach($heslo in $slovnik)
    {
        $pwd = ConvertTo-SecureString -String $heslo -AsPlainText -Force
        $pass = ConvertTo-NTHash -Password $pwd
        Add-Content $vystup "$pass"
    }
}
<#
.Synopsis
   Vynucuje změnu hesla doménového uživatele při dalším přihlášení
.DESCRIPTION
    Vynucuje změnu hesla doménového uživatele při dalším přihlášení
.PARAMETER hromadne
    Přepíná do režimu hromadného nastavení požadavku na změnu hesla. Kombinuje se s parametrem list
.PARAMETER list
    Udává cestu k seznamu uživatelů,kteří si mají měnit heslo. Tento seznam musí být ve formátu txt a co žádek, to uživatel
.PARAMETER uzivatel
    Udává loin uživatele, který si má měnit heslo
.EXAMPLE
   Set-AdUserMustChanePassword -uzivatel zak
   Nastaví uživateli žák nutnost změnit heslo při dalším přihlášení
.EXAMPLE
   Set-AdUserMustChanePassword -hromadne -list C:\uzivatele.txt
   Nastaví nutnost změnit heslo při dalším přihlášení všem účtům uvedeným v C:\uzivatele.txt
#>
function Set-AdUserMustChanePassword
{
    param(
        [switch]$hromadne,
        [string]$list,
        [string]$uzivatel
    )
    if($hromadne)
    {
        foreach($uzivatel in $list)
        {
            Set-ADUser -Identity $uzivatel -ChangePasswordAtLogon $true
        }
    }else
    {
        Set-ADUser -Identity $uzivatel -ChangePasswordAtLogon $true
    }
}
<#
.Synopsis
   Zobrazí informace uložené v TGT nebo PRT
.DESCRIPTION
    Zobrazí informace uložené v TGT nebo PRT uživatele, pod kterým běží PowerShell. Pro svůj běh vyžaduje Full Language mode, protože využívá .NET rozhraní. To, zds dojde k vypsání informací o TGT nebo PRT záleží na ověření uživatele (AD / Entra ID)
.PARAMETER claims
    Slouží k zobrazení claimů u uživatelů přihlášených pomocí Entra ID.
.EXAMPLE
   Get-TokenInfo
   Vypíše informace obsažené v TGT, nebo PRT aktuálně přihlášeného uživatele (respektive uživatele, pod kterým běží PowerShell)
.EXAMPLE
   Get-TokenInfo -clames
   Do výpisu přidá informace o claimech v případě uživatle přihlášeného MS účtem (osobním i firemním)
#>
function Get-TokenInfo
{
    param(
        [switch]$clames
    )
    if($ExecutionContext.SessionState.LanguageMode -eq "FullLanguage")
    {
        $token = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        if($token.AuthenticationType -eq "CloudAP")
        {
            Write-Host "Informace o PRT (MS Entra ID, nebo MS účet)" -ForegroundColor Yellow
            Write-Host ""
            #výpis info
            Write-Host "AuthenticationType:" $token.AuthenticationType
            Write-Host "ImpersonationLevel:" $token.ImpersonationLevel
            Write-Host "IsAuthenticated   :" $token.IsAuthenticated
            Write-Host "IsGuest           :" $token.IsGuest
            Write-Host "IsSystem          :" $token.IsSystem
            Write-Host "Nane              :" $token.Name
            Write-Host "Owner             :" $token.Owner.Translate([System.Security.Principal.NTAccount])
            Write-Host "User SID          :" $token.User
            Write-Host "Skupiny uživatele :"
            $groupSIDs = $token.Groups # Načtení SID skupin z tokenu
            foreach($sid in $groupSIDs) { 
                try 
                { 
                    Write-Host ("                    "+($sid).Translate([System.Security.Principal.NTAccount])) 
                }
                catch 
                {
                    Write-Warning ("Není možné přeložit " + $sid.Value + ". Reason: " + $_.Exception.Message)
                }
            }
            Write-Host "Token             :" $token.Token
            Write-Host "AccessToken       :" $token.AccessToken
            if($clames)
            {
                Write-Host "UserClaims        :" -ForegroundColor Green
                $clams = $token.UserClaims
                foreach($clams in $token.UserClaims) { #výpis uživatelských clame
                    Write-Host "  type   :" $clams.Type
                    Write-Host "  Subject:" $clams.Subject
                    Write-Host "  klíč   :" $clams.Properties.Keys
                    Write-Host "  Hodnota:" $clams.Properties.Values
                    Write-Host "  " 
                }
                Write-Host "DeviceClaims      :" -ForegroundColor Green
                $clams = $token.DeviceClaims
                foreach($clams in $token.DeviceClaims) { #výpis clame zařízení
                    Write-Host "  Type   :" $clams.Type
                    Write-Host "  Subject:" $clams.Subject
                    Write-Host "  Klíč   :" $clams.Properties.Keys
                    Write-Host "  Hodnota:" $clams.Properties.Values
                    Write-Host "  " 
                }
            }
            Write-Host "Actor             :" $token.Actor
            Write-Host "BootstrapContext  :" $token.BootstrapContext
            Write-Host "Popisek           :" $token.Label
            Write-Host "NameClaimType     :" $token.NameClaimType
            Write-Host "RoleClaimType     :" $token.RoleClaimType
        }
        if($token.AuthenticationType -eq "Kerberos" -or $token.AuthenticationType -eq "Negotiate")
        {
            Write-Host "Informace o Kerberos TGT" -ForegroundColor Yellow
            Write-Host ""
            #výpis info
            Write-Host "AuthenticationType:" $token.AuthenticationType
            Write-Host "ImpersonationLevel:" $token.ImpersonationLevel
            Write-Host "IsAuthenticated   :" $token.IsAuthenticated
            Write-Host "IsGuest           :" $token.IsGuest
            Write-Host "IsSystem          :" $token.IsSystem
            Write-Host "Nane              :" $token.Name
            Write-Host "Owner             :" $token.Owner.Translate([System.Security.Principal.NTAccount])
            Write-Host "User SID          :" $token.User
            Write-Host "Skupiny uživatele :"
            $groupSIDs = $token.Groups # Načtení SID skupin z tokenu
            foreach($sid in $groupSIDs) { 
                try 
                { 
                    Write-Host ("                    "+($sid).Translate([System.Security.Principal.NTAccount])) 
                }
                catch 
                {
                    Write-Warning ("Není možné přeložit " + $sid.Value + ". Reason: " + $_.Exception.Message)
                }
            }
        }
    }
    else
    {
        Write-Error "Kód nelze v tomto režimu zabezpečení PowerSellu vykonat"
    }
    Invoke-Expression "whoami /priv"
}
<#
.SYNOPSIS
    Nastavení titulku konzole na definovaný text.
       
.DESCRIPTION
    Nastavení titulku konzole na definovaný text.

.PARAMETER TitleText
    Text titulku

.EXAMPLE
    C:\PS> Set-ConsoleTitle -Titulek '<<<This window is for installation>>>'
    Nastaví aktuální text titulku konzolena: <<<This window is for installation>>>

.NOTE
    Převzato od CyberRangers z Cyb3rtools v souladu s licencí MIT.

#>
function Set-ConsoleTitle {
    [cmdletbinding()]
    param(
        [Parameter(Mandatory = $true, HelpMessage = 'Enter new console title.')][ValidateNotNullOrEmpty()][string]$Titulek
    )

    $host.ui.RawUI.WindowTitle = $Titulek
}
<#
.SYNOPSIS
    Nalezne Alternate Data Streams v souborech ve specifických složkách.
       
.DESCRIPTION
    Nalezne Alternate Data Streams v souborech ve specifických složkách.

.PARAMETER Cesta
    Umístění, kde se mají hledat alternate data streams.

.PARAMETER Recurse
    Nalezení alternate data streams v zadaném umístění a ve všech podřízených položkách umístění.

.PARAMETER ShowContent
    Zobrazí konkrétní obsah alternate data stream na daném souboru.

.EXAMPLE
    Find-ItemADS -Cesta C:\Temp -Recurse
    Nalezení alternate data streams v souborech umístěných vadresáři C:\Temp a všech podadresářích.

.NOTE
    Převzato od CyberRangers z Cyb3rtools v souladu s licencí MIT.
#>
function Find-ItemADS {
    [CmdletBinding()]
    Param(
        [ValidateScript( {
                if (!$($_ | Test-Path) ) {
                    throw "Folder does not exist" 
                }
                if (!$($_ | Test-Path -PathType Container) ) {
                    throw "The Path argument must be a Folder."
                }
                return $true
            })]
        [Parameter(Mandatory)]
        [System.IO.FileInfo]$Cesta,
        [switch]$Recurse,
        [switch]$ShowContent
    )

    if ($Recurse) {
        $ObjectsToAnalyze = Get-ChildItem -Path $Cesta -Recurse
    }
    else {
        $ObjectsToAnalyze = Get-ChildItem -Path $Cesta
    }

    foreach ($ObjectToAnalyze in $ObjectsToAnalyze) {
        if ($ShowContent) {
            $ObjectToAnalyze | Get-Item -Stream * | Where-Object { $_.stream -ne ':$DATA' } | Select-Object -Property FileName, Stream, Length, @{n = 'Content'; e = {
                    return $(Get-Content -Path "$($_.FileName):$($_.stream)")
                }
            }
        }
        else {
            $ObjectToAnalyze | Get-Item -Stream * | Where-Object { $_.stream -ne ':$DATA' } | Select-Object -Property FileName, Stream, Length
        }
    }
}
<#
    .SYNOPSIS
        Vytváří alternativní datové proudy v konkrétních souborech nebo složkách.
    .DESCRIPTION
        Vytváří alternativní datové proudy v konkrétních souborech nebo složkách.
    .PARAMETER Stream
        Jméno alternate data stream.
    .PARAMETER Content
        Obsha alternate data streamu.
    .PARAMETER ContentEncoding
        Nastavení kódování obsahu.
    .PARAMETER ItemType
        Typ položky, do které se má ukládat alternativní datový proud.
    .PARAMETER Path
        Cesta k existujícímu souboru nebo složce pro uložení alternativního datového proudu.
    .EXAMPLE
        New-ItemADS -Path 'C:\Temp' -Name 'ADSFile.txt' -StreamName 'Secrets' -StreamContent 'This is secret content' -ContentEncoding Ascii -ItemType File
        Vytvoří soubor ADSFile.txt v C:\Temp s alternativním datovým tokem Secrets.
    .EXAMPLE
        New-ItemADS -Path 'C:\Temp' -Name 'ADSFolder' -StreamName 'Secrets' -StreamContent 'This is secret content' -ContentEncoding Ascii -ItemType Directory
        Vytvoří adresář ADSFolder v C:\Temp s alternativním datovým proudem Secrets.
    .EXAMPLE
        New-ItemADS -Path 'C:\Temp' -Name 'ADSFileWithBinary.txt' -StreamName 'SecretBinary' -StreamContent ([System.IO.File]::ReadAllBytes("C:\Source\Coreinfo.exe")) -ContentEncoding Byte -ItemType File
        Vytvoří soubor s ADS obsahující binární soubor CoreInfo.exe v alternativním datovém proudu Secrets.
    .NOTE
    Převzato od CyberRangers z Cyb3rtools v souladu s licencí MIT.
    #>
function New-ItemADS {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory)][string]$StreamName,
        [Parameter(Mandatory)]$StreamContent,
        [Parameter(Mandatory)][ValidateSet('Ascii', 'Byte', 'UTF8')][string]$ContentEncoding,
        [Parameter(Mandatory)][ValidateSet('File', 'Directory')][string]$ItemType,
        [ValidateScript( {
                if (!$($_ | Test-Path) ) {
                    throw "Path does not exist" 
                }
                return $true
            })]
        [System.IO.FileInfo]$Path,
        [Parameter(Mandatory)][string]$Name
    )

    $FullName = Join-Path $Path $Name

    if ($ItemType -eq 'Directory') {
        if (Test-Path $FullName) {
            throw ('Item {0} already exists.' -f $FullName)
        }
        New-Item $FullName -ItemType Directory -Force | Out-Null
    }
    Set-Content $('{0}:{1}' -f $FullName, $StreamName) -Value $StreamContent -Encoding $ContentEncoding
}

<#
.SYNOPSIS
    Nastavení PowerShell Transcript
       
.DESCRIPTION
    Nastavení PowerShell Transcript

.PARAMETER VystupniAdresar
    Umístění, kam se budou transcripty ukládat.

.PARAMETER On
    Zapnutí transkripce.
.PARAMETER Off
    Vypnutí transkripce.

.PARAMETER IncludeInvocationHeader
    Aktivuje přidání časové známky ke zaznamenanému příkazu.

.EXAMPLE
    Set-PSTranscription -VystupniAdresar C:\Temp -IncludeInvocationHeader -On
    Zapne Trnaskripci s časovými známkami u příkazů a logy se budou ukládat do C:\Temp.

.EXAMPLE
    Set-PSTranscription -On
    Zapne Trnaskripci s výchozími parametry.

.EXAMPLE
    Set-PSTranscription -Off
    Vypne Trnaskripci.

.NOTE
    Převzato od CyberRangers z Cyb3rtools v souladu s licencí MIT. Tato funkce byla výrazněji upravena.
#>
function Set-PSTranscription{
    [CmdletBinding()] param($VystupniAdresar, [Switch] $IncludeInvocationHeader, [Switch] $On, [Switch] $Off)
    if($On)
    {
        if (!$(Test-Path $RegistryPath)) { 
            $null = New-Item $RegistryPath -Force
        }
        Set-ItemProperty $RegistryPath -Name EnableTranscripting -Value 1
        if ($PSCmdlet.MyInvocation.BoundParameters.ContainsKey("OutputDirectory")) {
            Set-ItemProperty $RegistryPath -Name OutputDirectory -Value $VystupniAdresar
        }
        if ($IncludeInvocationHeader) {
            Set-ItemProperty $RegistryPath -Name IncludeInvocationHeader -Value 1
        } 
    }
    elseif($Off)
    {        Remove-Item HKLM:\Software\Policies\Microsoft\Windows\PowerShell\Transcription -Force -Recurse
    }
}
<#
.SYNOPSIS
    Nastavení PowerShell script block logging
       
.DESCRIPTION
    Nastavení PowerShell zaznamenávání zpracování příkazů, skriptových bloků, funkcí a skriptů, ať už jsou vyvolány interaktivně, nebo prostřednictvím automatizace.

.PARAMETER On
    Zapnutí PowerShell script block logging.

.PARAMETER Off
    Vypnutí PowerShell script block logging.

.EXAMPLE
    Set-PSScriptBlockLogging -On
    Zapnutí PowerShell script block logging.

.EXAMPLE
    Set-PSScriptBlockLogging -Off
    Vypnutí PowerShell script block logging.

.NOTE
    Převzato od CyberRangers z Cyb3rtools v souladu s licencí MIT. Tato funkce byla výrazněji upravena.
#>
function Set-PSScriptBlockLogging
{
    [CmdletBinding()] param([Switch] $On, [Switch] $Off)
    if($On)
    {
        [string]$RegistryPath = "HKLM:\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging"
        if (!$(Test-Path $RegistryPath)) {
            $null = New-Item $RegistryPath -Force
        }
        Set-ItemProperty $RegistryPath -Name EnableScriptBlockLogging -Value "1"
    }
    elseif($Off)
    {
        Remove-Item 'HKLM:\Software\Policies\Microsoft\Windows\PowerShell\ScriptBlockLogging' -Force -Recurse
    }
}
<#
.SYNOPSIS
    Vypíše informace o procesoru.
       
.DESCRIPTION
    Vypíše informace o procesoru.
.EXAMPLE
    Get-CPUinfo
#>
function Get-CPUinfo
{
  $Architecture = @{
  Name = 'Architecture'
  Expression = {
    $value = $_.Architecture
    switch([int]$value)
      {
        0          {'x86'}
        1          {'MIPS'}
        2          {'Alpha'}
        3          {'PowerPC'}
        6          {'ia64'}
        9          {'x64'}
        5          {'ARM'}
        12         {'ARM64'}
        default    {"$value"}
      }
      
    }  
   }
 $UpgradeMethod = @{
  Name = 'UpgradeMethod'
  Expression = {
    $value = $_.UpgradeMethod
    
    switch([int]$value)
      {
        1          {'Other'}
        2          {'Unknown'}
        3          {'Daughter Board'}
        4          {'ZIF Socket'}
        5          {'Replacement/Piggy Back'}
        6          {'None'}
        7          {'LIF Socket'}
        8          {'Slot 1'}
        9          {'Slot 2'}
        10         {'370 Pin Socket'}
        11         {'Slot A'}
        12         {'Slot M'}
        13         {'Socket 423'}
        14         {'Socket A (Socket 462)'}
        15         {'Socket 478'}
        16         {'Socket 754'}
        17         {'Socket 940'}
        18         {'Socket 939'}
        default    {"$value"}
      }
  }  
 }
 $ProcessorType = @{
  Name = 'ProcessorType'
  Expression = {
    $value = $_.ProcessorType
    
    switch([int]$value)
      {
        1          {'Other'}
        2          {'Unknown'}
        3          {'Central Processor'}
        4          {'Math Processor'}
        5          {'DSP Processor'}
        6          {'Video Processor'}
        default    {"$value"}
      }  
  }  
 }
 $Family = @{
  Name = 'Family'
  Expression = {
    $value = $_.Family
    switch([int]$value)
  {
    1          {'Other'}
    2          {'Unknown'}
    3          {'8086'}
    4          {'80286'}
    5          {'80386'}
    6          {'80486'}
    7          {'8087'}
    8          {'80287'}
    9          {'80387'}
    10         {'80487'}
    11         {'Pentium(R) brand'}
    12         {'Pentium(R) Pro'}
    13         {'Pentium(R) II'}
    14         {'Pentium(R) processor with MMX(TM) technology'}
    15         {'Celeron(TM)'}
    16         {'Pentium(R) II Xeon(TM)'}
    17         {'Pentium(R) III'}
    18         {'M1 Family'}
    19         {'M2 Family'}
    20         {'Intel(R) Celeron(R) M processor'}
    21         {'Intel(R) Pentium(R) 4 HT processor'}
    24         {'K5 Family'}
    25         {'K6 Family'}
    26         {'K6-2'}
    27         {'K6-3'}
    28         {'AMD Athlon(TM) Processor Family'}
    29         {'AMD(R) Duron(TM) Processor'}
    30         {'AMD29000 Family'}
    31         {'K6-2+'}
    32         {'Power PC Family'}
    33         {'Power PC 601'}
    34         {'Power PC 603'}
    35         {'Power PC 603+'}
    36         {'Power PC 604'}
    37         {'Power PC 620'}
    38         {'Power PC X704'}
    39         {'Power PC 750'}
    40         {'Intel(R) Core(TM) Duo processor'}
    41         {'Intel(R) Core(TM) Duo mobile processor'}
    42         {'Intel(R) Core(TM) Solo mobile processor'}
    43         {'Intel(R) Atom(TM) processor'}
    48         {'Alpha Family'}
    49         {'Alpha 21064'}
    50         {'Alpha 21066'}
    51         {'Alpha 21164'}
    52         {'Alpha 21164PC'}
    53         {'Alpha 21164a'}
    54         {'Alpha 21264'}
    55         {'Alpha 21364'}
    56         {'AMD Turion(TM) II Ultra Dual-Core Mobile M Processor Family'}
    57         {'AMD Turion(TM) II Dual-Core Mobile M Processor Family'}
    58         {'AMD Athlon(TM) II Dual-Core Mobile M Processor Family'}
    59         {'AMD Opteron(TM) 6100 Series Processor'}
    60         {'AMD Opteron(TM) 4100 Series Processor'}
    64         {'MIPS Family'}
    65         {'MIPS R4000'}
    66         {'MIPS R4200'}
    67         {'MIPS R4400'}
    68         {'MIPS R4600'}
    69         {'MIPS R10000'}
    80         {'SPARC Family'}
    81         {'SuperSPARC'}
    82         {'microSPARC II'}
    83         {'microSPARC IIep'}
    84         {'UltraSPARC'}
    85         {'UltraSPARC II'}
    86         {'UltraSPARC IIi'}
    87         {'UltraSPARC III'}
    88         {'UltraSPARC IIIi'}
    96         {'68040'}
    97         {'68xxx Family'}
    98         {'68000'}
    99         {'68010'}
    100        {'68020'}
    101        {'68030'}
    112        {'Hobbit Family'}
    120        {'Crusoe(TM) TM5000 Family'}
    121        {'Crusoe(TM) TM3000 Family'}
    122        {'Efficeon(TM) TM8000 Family'}
    128        {'Weitek'}
    130        {'Itanium(TM) Processor'}
    131        {'AMD Athlon(TM) 64 Processor Family'}
    132        {'AMD Opteron(TM) Processor Family'}
    133        {'AMD Sempron(TM) Processor Family'}
    134        {'AMD Turion(TM) 64 Mobile Technology'}
    135        {'Dual-Core AMD Opteron(TM) Processor Family'}
    136        {'AMD Athlon(TM) 64 X2 Dual-Core Processor Family'}
    137        {'AMD Turion(TM) 64 X2 Mobile Technology'}
    138        {'Quad-Core AMD Opteron(TM) Processor Family'}
    139        {'Third-Generation AMD Opteron(TM) Processor Family'}
    140        {'AMD Phenom(TM) FX Quad-Core Processor Family'}
    141        {'AMD Phenom(TM) X4 Quad-Core Processor Family'}
    142        {'AMD Phenom(TM) X2 Dual-Core Processor Family'}
    143        {'AMD Athlon(TM) X2 Dual-Core Processor Family'}
    144        {'PA-RISC Family'}
    145        {'PA-RISC 8500'}
    146        {'PA-RISC 8000'}
    147        {'PA-RISC 7300LC'}
    148        {'PA-RISC 7200'}
    149        {'PA-RISC 7100LC'}
    150        {'PA-RISC 7100'}
    160        {'V30 Family'}
    161        {'Quad-Core Intel(R) Xeon(R) processor 3200 Series'}
    162        {'Dual-Core Intel(R) Xeon(R) processor 3000 Series'}
    163        {'Quad-Core Intel(R) Xeon(R) processor 5300 Series'}
    164        {'Dual-Core Intel(R) Xeon(R) processor 5100 Series'}
    165        {'Dual-Core Intel(R) Xeon(R) processor 5000 Series'}
    166        {'Dual-Core Intel(R) Xeon(R) processor LV'}
    167        {'Dual-Core Intel(R) Xeon(R) processor ULV'}
    168        {'Dual-Core Intel(R) Xeon(R) processor 7100 Series'}
    169        {'Quad-Core Intel(R) Xeon(R) processor 5400 Series'}
    170        {'Quad-Core Intel(R) Xeon(R) processor'}
    171        {'Dual-Core Intel(R) Xeon(R) processor 5200 Series'}
    172        {'Dual-Core Intel(R) Xeon(R) processor 7200 Series'}
    173        {'Quad-Core Intel(R) Xeon(R) processor 7300 Series'}
    174        {'Quad-Core Intel(R) Xeon(R) processor 7400 Series'}
    175        {'Multi-Core Intel(R) Xeon(R) processor 7400 Series'}
    176        {'Pentium(R) III Xeon(TM)'}
    177        {'Pentium(R) III Processor with Intel(R) SpeedStep(TM) Technology'}
    178        {'Pentium(R) 4'}
    179        {'Intel(R) Xeon(TM)'}
    180        {'AS400 Family'}
    181        {'Intel(R) Xeon(TM) processor MP'}
    182        {'AMD Athlon(TM) XP Family'}
    183        {'AMD Athlon(TM) MP Family'}
    184        {'Intel(R) Itanium(R) 2'}
    185        {'Intel Pentium M Processor'}
    186        {'Intel(R) Celeron(R) D processor'}
    187        {'Intel(R) Pentium(R) D processor'}
    188        {'Intel(R) Pentium(R) Processor Extreme Edition'}
    189        {'Intel(R) Core(TM) Solo Processor'}
    190        {'K7'}
    191        {'Intel(R) Core(TM)2 Duo Processor'}
    192        {'Intel(R) Core(TM)2 Solo processor'}
    193        {'Intel(R) Core(TM)2 Extreme processor'}
    194        {'Intel(R) Core(TM)2 Quad processor'}
    195        {'Intel(R) Core(TM)2 Extreme mobile processor'}
    196        {'Intel(R) Core(TM)2 Duo mobile processor'}
    197        {'Intel(R) Core(TM)2 Solo mobile processor'}
    198        {'Intel(R) Core(TM) i7 processor'}
    199        {'Dual-Core Intel(R) Celeron(R) Processor'}
    200        {'S/390 and zSeries Family'}
    201        {'ESA/390 G4'}
    202        {'ESA/390 G5'}
    203        {'ESA/390 G6'}
    204        {'z/Architecture base'}
    205        {'Intel(R) Core(TM) i5 processor'}
    206        {'Intel(R) Core(TM) i3 processor'}
    207        {'Intel(R) Core(TM) i9 processor'}
    210        {'VIA C7(TM)-M Processor Family'}
    211        {'VIA C7(TM)-D Processor Family'}
    212        {'VIA C7(TM) Processor Family'}
    213        {'VIA Eden(TM) Processor Family'}
    214        {'Multi-Core Intel(R) Xeon(R) processor'}
    215        {'Dual-Core Intel(R) Xeon(R) processor 3xxx Series'}
    216        {'Quad-Core'}
    217        {'VIA Nano(TM) Processor Family'}
    218        {'Dual-Core Intel(R) Xeon(R) processor 5xxx Series'}
    219        {'Quad-Core Intel(R) Xeon(R) processor 5xxx Series'}
    221        {'Dual-Core Intel(R) Xeon(R) processor 7xxx Series'}
    222        {'Quad-Core Intel(R) Xeon(R) processor 7xxx Series'}
    223        {'Multi-Core Intel(R) Xeon(R) processor 7xxx Series'}
    224        {'Multi-Core Intel(R) Xeon(R) processor 3400 Series'}
    230        {'Embedded AMD Opteron(TM) Quad-Core Processor Family'}
    231        {'AMD Phenom(TM) Triple-Core Processor Family'}
    232        {'AMD Turion(TM) Ultra Dual-Core Mobile Processor Family'}
    233        {'AMD Turion(TM) Dual-Core Mobile Processor Family'}
    234        {'AMD Athlon(TM) Dual-Core Processor Family'}
    235        {'AMD Sempron(TM) SI Processor Family'}
    236        {'AMD Phenom(TM) II Processor Family'}
    237        {'AMD Athlon(TM) II Processor Family'}
    238        {'Six-Core AMD Opteron(TM) Processor Family'}
    239        {'AMD Sempron(TM) M Processor Family'}
    250        {'i860'}
    251        {'i960'}
    254        {'Reserved (SMBIOS Extension)'}
    255        {'Reserved (Un-initialized Flash Content - Lo)'}
    260        {'SH-3'}
    261        {'SH-4'}
    280        {'ARM'}
    281        {'StrongARM'}
    300        {'6x86'}
    301        {'MediaGX'}
    302        {'MII'}
    320        {'WinChip'}
    350        {'DSP'}
    500        {'Video Processor'}
    default    {"$value"}
    }
      
  }  
 }
 Get-WmiObject -Class Win32_Processor | select PSComputerName, Manufacturer, Name, $ProcessorType, AddressWidth, DataWidth, L2CacheSize, L3CacheSize, Caption, NumberOfCores, NumberOfLogicalProcessors, PowerManagementSupported, ProcessorId, VirtualizationFirmwareEnabled, VMMonitorModeExtensions, $Architecture, SocketDesignation, $UpgradeMethod, SecondLevelAddressTranslationExtensions, $Family
}
<#
.SYNOPSIS
    Vypíše datum a čas instalace / posledního upgrade.

.DESCRIPTION
    Vypíše datum a čas instalace / posledního upgrade.

.EXAMPLE
    Get-InstallDate
#>
functio Get-InstallDate
{
    (gcim Win32_OperatingSystem).InstallDate
}
Export-ModuleMember -Function '*'