Category: Microsoft Windows

$computername='testwindows'
$adminUsername='intranet\testadmin'
$adminPassword='PASSWORD'
$workgroup='Archive'

function unjoinComputerFromDomain{
    param(
        $computername,
        $adminUsername,
        $adminPassword,
        $workgroup='Archive'
        )
  $adminCred=New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $adminUsername,$(ConvertTo-SecureString $adminPassword -AsPlainText -Force)
  $psSession=try{
    $psOptions=New-PSSessionOption -OpenTimeout 300 -CancelTimeout 300
    new-pssession -computername $computername -Credential $adminCred -SessionOption $psOptions
    write-host "Connected to $computername..."
  }catch{
    write-warning $_
    $false
  }
  if($psSession.State -eq 'Opened'){
    try{
        $result=invoke-command -session $psSession -scriptblock{
            param ($adminUsername,$adminPassword,$workgroup)
            if ((gwmi win32_computersystem).partofdomain -eq $true) {
                $userdomain=$env:USERDNSDOMAIN
                $encryptedPassword=$(ConvertTo-SecureString $adminPassword -AsPlainText -Force)
                Set-LocalUser -name Administrator -Password $encryptedPassword
                write-host "The local 'Administrator' account password has been reset to be the same as the password of user $adminUsername"
                $adminCred=New-Object -TypeName System.Management.Automation.PSCredential -ArgumentList $adminUsername,$encryptedPassword
                try{
                    Remove-Computer -UnjoinDomaincredential $adminCred -PassThru -Verbose -Restart -WorkgroupName $workgroup -Force
                    write-host "$env:computername has been removed from $userdomain"
                    return $true
                }catch{
                    write-warning $_
                    return $false
                }
            }else{
                write-host "$env:computer is NOT joined to any domain. No actions taken."
                return $true
            }      
        } -Args $adminUsername,$adminPassword,$workgroup -EA Stop
        $nullRemove-PSSession -ID $psSession.ID
        return $result
    }catch{
        write-warning $_
        $null=Remove-PSSession $psSession
        return $false
    }    
  }else{
    write-host "Unable to connect to $computername..."
    return $false
  }
}

unjoinComputerFromDomain $computername $adminUsername $adminPassword

[TESTSERVER]: PS C:\Users\administrator> Get-LocalGroupMember 'Remote Desktop Users'

Get-LocalGroupMember : Failed to compare two elements in the array.
    + CategoryInfo          : NotSpecified: (:) [Get-LocalGroupMember], InvalidOperationException
    + FullyQualifiedErrorId : An unspecified error occurred.,Microsoft.PowerShell.Commands.GetLocalGroupMemberCommand

[TESTSERVER]: PS C:\Users\administrator> Add-LocalGroupMember -group 'Remote Desktop Users' -member intranet\testuser
Add-LocalGroupMember : Principal intranet\testuser was not found.
    + CategoryInfo          : ObjectNotFound: (portal\nbsingh:String) [Add-LocalGroupMember], PrincipalNotFoundExcepti
   on
    + FullyQualifiedErrorId : PrincipalNotFound,Microsoft.PowerShell.Commands.AddLocalGroupMemberCommand

$servers = "localhost"
$groupName = 'Remote Desktop Users'

function getGroupMembers{
  param(
    $servers='localhost',
    $groupName='Administrators'
  )
  $members=@()
  foreach ($server in $servers){
      $group = [ADSI]"WinNT://$Server/$groupName"
      $groupMembers = @($group.Invoke('Members') | ForEach-Object {([ADSI]$_).path})
      $members+=$groupMembers
  }
  return $members
}

getGroupMembers $servers $groupName

# This is an ancient script that would work with PowerShell versions 2 to 5, but it won't work with version 6

  function checkRpc($server){
    #  WORKFLOW QUERIES THE PASSED ARRAY OF PORTS TO DETERMINE STATUS
    workflow Check-Port {
    param ([string[]]$RPCServer,[array]$arrRPCPorts)
    $comp = hostname

    ForEach -parallel ($RPCPort in $arrRPCPorts){
    $bolResult = InlineScript{Test-NetConnection -ComputerName $Using:RPCServer -port $Using:RPCPort -InformationLevel Quiet}
    If ($bolResult){
    Write-Output "$RPCPort on $RPCServer is reachable"
    }Else{
    Write-Output "$RPCPort on $RPCServer is unreachable"
    }
    }
    }
    #  INITIAL RPC PORT
    $strRPCPort = "135"
    #  MODIFY PATH TO THE PORTQRY BINARY IF NECESSARY
    $strPortQryPath = "C:\Sysinternals"
    #  TEST THE PATH TO SEE IF THE BINARY EXISTS
    If (get-command portqry.exe){
    $strPortQryCmd = "PortQry.exe -e $strRPCPort -n $Server"
    }Else{
    Write-Output "Could not locate Portqry.exe"
    Exit
    }
    #  CREATE AN EMPTY ARRAY TO HOLD THE PORTS RETURNED FROM THE RPC PORTMAPPER
    $arrPorts = @()
    #  RUN THE PORTQRY COMMAND TO GET THE EPHEMERAL PORTS
    $arrQuryResult = Invoke-Expression $strPortQryCmd
    # CREATE AN ARRAY OF THE PORTS
    ForEach ($strResult in $arrQuryResult)
    {
    If ($strResult.Contains("ip_tcp"))
    {
    $arrSplt = $strResult.Split("[")
    $strPort = $arrSplt[1]
    $strPort = $strPort.Replace("]","")
    $arrPorts += $strPort
    }
    }
    #  DE-DUPLICATE THE PORTS
    $arrPorts = $arrPorts | Sort-Object |Select-Object -Unique
    #  EXECUTE THE WORKFLOW TO CHECK THE PORTS
    Check-Port -RPCServer $Server -arrRPCPorts $arrPorts
  }

checkRpc remotecomputername

# Create SMB Share
$sharePath='C:\testshare'
$accessList="$env:USERDOMAIN\Domain Admins","NT AUTHORITY\Authenticated Users"
$shareName=split-path $sharePath -leaf
mkdir $sharePath
New-SmbShare -Name $shareName -Path $sharePath -FullAccess $accessList

# Check SMB Acccesses
[SMBSERVER]: PS C:\Users\kimconnect\Documents> Get-SmbShareAccess $shareName
Name          ScopeName AccountName                      AccessControlType AccessRight
----          --------- -----------                      ----------------- -----------
testshare *         KIMCONNECT\Domain Admins         Allow             Full
testshare *         NT AUTHORITY\Authenticated Users Allow             Full

# Add Share Permissions
$grantPrinciple="$env:USERDOMAIN\Domain Admins"
Grant-SmbShareAccess -Name $shareName -AccountName $grantPrinciple -AccessRight Full -Force

# Remove Share Permissions
$removePrinciple="NT AUTHORITY\Authenticated Users"
Revoke-SmbShareAccess -Name $shareName -AccountName $removePrinciple -Force

# Clone NTFS Access Control List (ACL)
# Warning: only do this to a new clone-to directory as misuse can cause permission problems
$cloneAclFrom='C:\originalshare'
$cloneAclTo=$sharePath
get-acl $cloneAclFrom|set-acl $cloneAclTo

# Check NTFS Permissions:
[SMBSERVER]: PS C:\Users\kimconnect\Documents> (get-acl c:\testshare).AccessToString
Everyone Allow  ReadAndExecute, Synchronize
CREATOR OWNER Allow  FullControl
NT AUTHORITY\SYSTEM Allow  FullControl
BUILTIN\Administrators Allow  FullControl
KIMCONNECt\TestAdmin Allow  FullControl

# editWindowsSecurity.ps1
# Version 0.0.1
# Notes:
# - This has NOT been thoroughly tested. Microsoft Windows version variances may render this script ineffective
# - need to add a routine to translate SID into principle name as part of the matching sequence
#
# WARNING: Do Not Use Mis-use This as It Can Brick Your Windows!
# No implied or express warranties shall be assumed. Caveat Emptor!


function editWindowsSecurity{
  param(
    $principle="Remote Desktop Users",
    $privilege="SeRemoteInteractiveLogonRight",
    $operation='add' # or 'remove'
  )

  $originalSecurity='C:\originalSecurity.inf'
  $newSecurity='C:\newSecurity.inf'
  $originalDb='c:\windows\security\database\secedit.sdb'
  $securityDb='C:\originalSecurity.sdb'
  $log='C:\security.log'

  try{
    $null=get-process mmc -ea Ignore|stop-process
    cp $originalDb $securityDb -ea Stop
  }catch{
    write-warning $_
    return $false
  }
  #secedit /export /db $securityDb /mergedpolicy /cfg $originalSecurity /log $log /quiet

  $null=secedit /export /areas USER_RIGHTS /cfg $originalSecurity
  $null="[Unicode]`r`nUnicode=yes`r`n`r`n[Version]`r`nsignature=`"`$CHICAGO`$`"`r`nrevision=1`r`n`r`n[Privilege Rights]"|Out-File $newSecurity -Force -WhatIf:$false 
  $originalRights=Get-Content $originalSecurity
  $applyChanges=$false

  if($operation -eq 'add'){
    write-host "Adding $principle to $privilege..."
    foreach($line in $originalRights){ 
        if($line -like "$privilege`*"){
            write-host "Before: $line"
            $line=$line+",$principle"
            write-host "After: $line"
            $line|Out-File $newSecurity -Append -WhatIf:$false
            $applyChanges=$true
        }
    }
  }elseif($operation -eq 'remove'){
    write-host "Removing $principle from $privilege..."
    $security=$originalRights|?{$_ -match "^$privilege"}
    if($security){
      $list=[regex]::match($security,'=\s(.*)').captures.groups[1].value
      $newList=($list -split ','|?{$_ -notmatch "$principle"}) -join ','
      $line="$privilege = $newList"
      if($line -ne $security){
        write-host "Before: $security`r`nAfter:$line"
        $line|Out-File $newSecurity -Append -WhatIf:$false
        $applyChanges=$true
      }else{
        write-host "No changes."
      }
    }
  }else{
    write-warning "Please specify operation type as either ADD or REMOVE"
  }

  if($applyChanges){
    try{
      $output=SECEDIT /configure /db $securityDb /cfg $newSecurity /log $log
      write-host $output
    }catch{
      write-warning $_
      return $false
    }    
  }  
  #Remove-Item $originalSecurity -Force -WhatIf:$false
  #Remove-Item $newSecurity -Force -WhatIf:$false
}

$folder1='C:\Temp'
$folder2='C:\Temp2'
$username=$null
$password=$null

function compareFileCounts{
  param($folder1,$folder2,$mountAsUser,$mountAsPassword)
  function mountPathAsDrive($path,$driveLetter,$mountAsUser,$mountAsPassword){

    function convertPathToUnc($path,$computername=$env:computername,$credentials=$null){
      $pathIsUnc=$path -match '^\\\\'
      $pathIsReachable=if($credentials){test-path $path -credentials $credentials}else{test-path $path}
      if($pathIsUnc -and $pathIsReachable){
          return $path
      }elseif(!$pathIsUnc){
          $convertedPath=.{
                      $x=$path -replace "^([a-zA-Z])\:","\\$computername\`$1`$";
                      if($x -match '\\$'){return $x.Substring(0,$x.length-1)}else{return $x}
                      }
          $validUnc=if($convertedPath){test-path $convertedPath -ErrorAction SilentlyContinue}else{$false}
          if($validUnc){
              write-host "$path has been converted to $convertedPath, and it is reachable"
              return $convertedPath
          }else{
              write-warning "$path has been converted to $convertedPath, but it is NOT unreachable"
              return $null
          }            
      }else{
          write-warning "Path is invalid"
          return $null
      }
    }

    $pathIsUnc=$path -match '^\\\\'
    $credentials = if($mountAsUser -and $mountAsPassword){
          $password = "$mountAsPassword" | ConvertTo-SecureString -AsPlainText -Force
          New-Object System.Management.Automation.PSCredential ("$mountAsUser", $password )
      }else{
          $null
      }
    $driveLetter=if($driveLetter){
      $driveLetter
    }else{
      $unavailableDriveLetters=(Get-Volume).DriveLetter|sort
      $availableDriveLetters=.{(65..90|%{[char]$_})|?{$_ -notin $unavailableDriveLetters}}
      [char]($availableDriveLetters[0])
    }

    if($pathIsUnc){
      if($credentials){
          $null=net use "$driveLetter`:" "$path" /user:$mountAsUser "'$mountAsPassword'"
      }else{
          $null=net use "$driveLetter`:" "$path"
      }      
    }else{
        $pathAsUnc=convertPathToUnc $path
        if($credentials){
          $null=net use "$driveLetter`:" "$pathAsUnc" /user:$mountAsUser "'$mountAsPassword'"
        }else{
          $null=net use "$driveLetter`:" "$pathAsUnc"
        }
    }

    $reachable=if($credentials){test-path "$driveLetter`:\" -credentials $credentials}else{test-path "$driveLetter`:\"}
    return $(if($reachable){"$driveLetter`:\"}else{$false})
  }

  $unavailableDriveLetters=(Get-Volume).DriveLetter|sort
  $availableDriveLetters=.{(65..90|%{[char]$_})|?{$_ -notin $unavailableDriveLetters}}
  $firstDriveLetter=[char]($availableDriveLetters[0])
  $secondDriveLetter=[char]($availableDriveLetters[1])

  $path1=mountPathAsDrive $folder1 $firstDriveLetter $mountAsUser $mountAsPassword
  $path2=mountPathAsDrive $folder2 $secondDriveLetter $mountAsUser $mountAsPassword

  if($path1 -and $path2){
    $timer1=[System.Diagnostics.Stopwatch]::StartNew()
    $filesInFolder1 = Invoke-Expression -Command:"cmd.exe /C dir '$path1' /S /B /W /A:-D" -EA Ignore
    $filesCount1=$filesInFolder1.Count
    $elapsed1=[math]::round($timer1.Elapsed.TotalMinutes,2)
    $timer1.Stop()
    write-host "$folder1 (mounted as $path1) file count: $filesCount1 ($elapsed1 minutes)"
    $timer2=[System.Diagnostics.Stopwatch]::StartNew()
    $filesInFolder2 = Invoke-Expression -Command:"cmd.exe /C dir '$path2' /S /B /W /A:-D" -EA Ignore
    $filesCount2=$filesInFolder2.Count
    $elapsed2=[math]::round($timer2.Elapsed.TotalMinutes,2)
    $timer2.Stop()
    write-host "$folder2 (mounted as $path2) file count: $filesCount2 ($elapsed2 minutes)"
  }elseif(!$path1 -and !$path2){
    write-warning "Both $path1 and $path2 are NOT accessible."
  }elseif(!$path1){
    write-warning "$path1 is NOT accessible."
  }elseif(!$path2){
    write-warning "$path2 is NOT accessible."
  }
  $null=net use "$($path1[0]):" /delete
  $null=net use "$($path2[0]):" /delete
  write-host "Total duration: $($elapsed1+$elapsed2) minutes"
  return $($filesCount1 -eq $filesCount2)
}

compareFileCounts $folder1 $folder2 $username $password

# old version

$folder1='\\FILESERVER1\TEST'
$folder2='\\BACKUP1\TEST'

function compareFileCounts($folder1,$folder2){
    $filesInFolder1 = Invoke-Expression -Command:"cmd.exe /C dir '$folder1' /S /B /W /A:-D" -EA Ignore
    $fileCount1=$filesInFolder1.Count
    write-host "$folder1 file count: $fileCount1"
    $filesInFolder2 = Invoke-Expression -Command:"cmd.exe /C dir '$folder2' /S /B /W /A:-D" -EA Ignore
    $fileCount2=$filesInFolder2.Count
    write-host "$folder2 file count: $fileCount2"
    return $($fileCount1 -eq $fileCount2)    
}

compareFileCounts $folder1 $folder2