One of the first things I discovered with Windows 7 was that they moved access to network adapters. I had some quick way to get to it and now I need to visit a few more screens. Today a coworker was talking about that same issue. He wanted a faster way to get to it. My response was, “I bet we can do that with Powershell”. The most common reason we end up looking at network adapters is to change ip settings to static or to DHCP. The only other things we do can be done with IPConfig. So I set out to write a little powershell that would give a computer a static IP address.

This turned out to be very simple with the Win32_NetworkAdapterConfiguration WMI object. I can use it to manage everything that was done with the GUI. The usual way we set static addresses is by first taking the dhcp address, entering it as static to the computer, then go into the dhcp server and exclude that address.

Set-NetworkStatic.ps1

$NICs = Get-WMIObject Win32_NetworkAdapterConfiguration | where{$_.IPEnabled -eq “TRUE”}
Foreach($NIC in $NICs) {

    $IP =$NIC.IPAddress -match "\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b"

    $Subnet = $NIC.IPSubnet -match "\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b"

    $Gateway = $NIC.DefaultIPGateway
    $DNSServers = $NIC.DNSServerSearchOrder
    $Domain = $NIC.DNSDomain

    $NIC.EnableStatic($IP, $Subnet)
    $NIC.SetGateways($Gateway)
    $NIC.SetDNSServerSearchOrder($DNSServers)
    $NIC.SetDynamicDNSRegistration(“TRUE”)
    $NIC.SetDNSDomain($Domain)
}

And then a second script to set it back to DHCP.

Set-NetworkDHCP.ps1

$NICs = Get-WMIObject Win32_NetworkAdapterConfiguration | where{$_.IPEnabled -eq “TRUE”}
Foreach($NIC in $NICs) {

    $NIC.EnableDHCP()
    $NIC.SetDNSServerSearchOrder()
}

Cypher Mysteries just revealed a old substitution cypher from 1918. Here is a detailed example on how to work the method by hand.  After I read both of those sites I decided to flesh out the code for it in PowerShell.  This turned out to be very easy to put to code.  Review the linked example then take a look at my PowerShell sample.

I used ArrayLists to hold the left and right alphabets. When I thought about the circular nature and shifting of the alphabets, linked lists where the first things to come to mind. I think this sample can easily be translated in to other languages.

# Kevin Marquette
# www.ithinkincode.com
$cipher = ""

for($index=0; $index -ne $message.length;$index++)
{
    # Find the plain text letter and shift it to the front
    while($message[$index] -ne $right[0])
        {
        $right.Add($right[0]); $right.removeat(0); # Shift left
        $left.add($left[0]);    $left.removeat(0); # Shift Left
        }
    $cipher += $left[0];   

    # move from zenith + 1 to nadar (zenith + 13) position
    $left.insert(14,$left[1]);
    $left.removeat(1);

    # rotate right one more letter
    $right.Add($right[0]);   $right.removeat(0);  #Shift left

    # move from zenith + 2 to nadar (zenith + 13) position
    $right.insert(14,$right[2]);
    $right.removeat(2);
}

Write-Host $cipher;

Thats the base implementation of the Chaocipher. Here is my full implementation that also includes decryption.

# Kevin Marquette
# www.ithinkincode.com

function get-chaocipher([string]$message = "WELLDONEISBETTERTHANWELLSAID", [string]$leftalphabet = "HXUCZVAMDSLKPEFJRIGTWOBNYQ", [string]$rightalphabet="PTLNBQDEOYSFAVZKGJRIHWXUMC", [bool]$encrypt=1)
{
Write-Host "Message: $message";
Write-Host "Left: $leftalphabet";
Write-Host "Right: $rightalphabet";
Write-Host "Encrypt: $encrypt";

# Validate Input
if($message -cmatch "^[A-Z]+$")
    {Write-Host "Message is Valid";}
else
    {
    Write-Host "Message is not Valid";
    return;
    }
if($leftalphabet -cmatch "^[A-Z]{26}$")
    {Write-Host "Left is Valid";}
else
    {
    Write-Host "Left is not Valid";
    return;
    }
if($rightalphabet -cmatch "^[A-Z]{26}$")
    {Write-Host "Right is Valid";}
else
    {
    Write-Host "Right is not Valid";
    return;
    }

# I want to use a linked list to manage the rotations
$left = New-Object System.Collections.ArrayList
$right = New-Object System.Collections.ArrayList
$cipher = New-Object System.Collections.ArrayList

# convert left and right to linked lists
for($i=0;$i -le 25; $i++)
    {
        $left.add($leftalphabet[$i]);
        $right.add($rightalphabet[$i]);
    }

$cipher = ""

#for each letter in the message
for($index=0; $index -ne $message.length;$index++)
{
    # Find the plain text letter and shift it to the front
    while(($message[$index] -ne $right[0] -and $encrypt -eq 1) -or ($message[$index] -ne $left[0] -and $encrypt -ne 1) )
        {
        $right.Add($right[0]); $right.removeat(0); # Shift left
        $left.add($left[0]);    $left.removeat(0); # Shift Left
        }
    if($encrypt -eq 1)
        {$cipher += $left[0];}
    else
        {$cipher += $right[0];}

    # move from zenith + 1 to nadar (zenith + 13) position
    $left.insert(14,$left[1]);
    $left.removeat(1);

    # rotate right one more letter
    $right.Add($right[0]);   $right.removeat(0);  #Shift left

    # move from zenith + 2 to nadar (zenith + 13) position
    $right.insert(14,$right[2]);
    $right.removeat(2);
}
Write-Host $cipher;
}

#encrypt
get-chaocipher "WELLDONEISBETTERTHANWELLSAID" "HXUCZVAMDSLKPEFJRIGTWOBNYQ" "PTLNBQDEOYSFAVZKGJRIHWXUMC" 1
#decrypt
get-chaocipher "OAHQHCNYNXTSZJRRHJBYHQKSOUJY" "HXUCZVAMDSLKPEFJRIGTWOBNYQ" "PTLNBQDEOYSFAVZKGJRIHWXUMC" 0

Decryption is as simple as checking from the other list. All the other steps are the same.

I was wanting to see how big my users’ home folders are.  With out quotas in place, I decided to use powershell.  I put together a function that will list the size of a folder that I pass to it. I wrote it in a way that if I pass a collection of folders to it, it will list the sizes of those folders individually.   This way I can spot check individual folders or check every folder in the home folders location.

This works even better for me because I need it to list the sub folder of each folder in the home folder location.  My home folders are placed in department folders.  So I have to add that extra step to every script I use to make sure it processes at the right level.  Allowing my function to work on a collection of folders allows powershell to handle this for me. Here is the syntax in action:

#Single folder
PS> Get-Item . | Get-FolderSize

#Sub folders
PS> Get-ChildItem . | Get-FolderSize

#Sub Sub Folders
PS> Get-ChildItem . | %{Get-ChildItem $_.FullName} | Get-FolderSize

It is required that you pass your directory objects to it.  I may update it to allow you to pass a folder path later. But for my needs, this is exactly how I will use it in my scripts.  Here is the full code for Get-FolderSize:

function Get-FolderSize ($_ = (get-item .))  {
  Process {
    $ErrorActionPreference = "SilentlyContinue"
    $length = (Get-ChildItem $_.fullname -recurse | Measure-Object -property length -sum).sum
    $obj = New-Object PSObject
    $obj | Add-Member NoteProperty Name ($_.Name)
    $obj | Add-Member NoteProperty FullName ($_.FullName)
    $obj | Add-Member NoteProperty Length ($length)
    $obj | Add-Member NoteProperty MB ("{0,13:N2}" -f ($length / 1MB))
    Write-Output $obj
  }
}