powershell 算法

1.AES

#加密
$key="aes256keyaes256keyaes256keyaes25";
$test="1111111111111111111111111111111111111111111111111"
$aes_obj = New-Object "System.Security.Cryptography.AesManaged";
$aes_obj.Mode = [System.Security.Cryptography.CipherMode]::ECB;
$aes_obj.BlockSize = 128;
$aes_obj.KeySize = 256;
$aes_obj.Key = [System.Text.Encoding]::UTF8.GetBytes($key);
$aes_obj.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;
$in_text=[System.Text.Encoding]::UTF8.GetBytes($test);
$data = New-Object System.IO.MemoryStream(,$aes_obj.CreateEncryptor().TransformFinalBlock($in_text,0,$in_text.Length));
$ret=[System.Convert]::ToBase64String($data.ToArray());
Write-Host $ret;
$aes_obj.Dispose();

#輸出 Si6rEIOwyVivcfsUG5Gz00ouqxCDsMlYr3H7FBuRs9NKLqsQg7DJWK9x+xQbkbPTDGEetru8uf6iFaWXvuyWEQ==

#解密

$key="aes256keyaes256keyaes256keyaes25";
$ret="Si6rEIOwyVivcfsUG5Gz00ouqxCDsMlYr3H7FBuRs9NKLqsQg7DJWK9x+xQbkbPTDGEetru8uf6iFaWXvuyWEQ=="
$aes_obj1 = New-Object "System.Security.Cryptography.AesManaged";
$aes_obj1.Mode = [System.Security.Cryptography.CipherMode]::ECB;
$aes_obj1.BlockSize = 128;
$aes_obj1.KeySize = 256;
$aes_obj1.Key = [System.Text.Encoding]::UTF8.GetBytes($key);
$aes_obj1.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;


$out= [System.Convert]::FromBase64String($ret)
$io_obj = New-Object System.IO.MemoryStream
$en_data = New-Object System.IO.MemoryStream(,$aes_obj1.CreateDecryptor().TransformFinalBlock($out,0,$out.Length));
$en_data.CopyTo($io_obj)
$en_data.Close();
$en = [System.Text.Encoding]::UTF8.GetString($io_obj.ToArray());
$aes_obj1.Dispose();

Write-Host $en

#輸出 1111111111111111111111111111111111111111111111111

powershell5.0

class encrypt
{
    static [string]aes_encrypt($key,$text)
    {
        $aes_obj = New-Object "System.Security.Cryptography.AesManaged";
        $aes_obj.Mode = [System.Security.Cryptography.CipherMode]::ECB;
        $aes_obj.BlockSize = 128;
        $aes_obj.KeySize = 256;
        $aes_obj.Key = [System.Text.Encoding]::UTF8.GetBytes($key);
        $aes_obj.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;
        $in_text=[System.Text.Encoding]::UTF8.GetBytes($text);
        $data = New-Object System.IO.MemoryStream(,$aes_obj.CreateEncryptor().TransformFinalBlock($in_text,0,$in_text.Length));
        $ret=[System.Convert]::ToBase64String($data.ToArray());
        #Write-Host $ret;
        $aes_obj.Dispose();
        return $ret;
    }

    static  [string]aes_decrypt($key,$text)
    {
        $aes_obj1 = New-Object "System.Security.Cryptography.AesManaged";
        $aes_obj1.Mode = [System.Security.Cryptography.CipherMode]::ECB;
        $aes_obj1.BlockSize = 128;
        $aes_obj1.KeySize = 256;
        $aes_obj1.Key = [System.Text.Encoding]::UTF8.GetBytes($key);
        $aes_obj1.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;


        $out= [System.Convert]::FromBase64String($text)
        $io_obj = New-Object System.IO.MemoryStream
        $en_data = New-Object System.IO.MemoryStream(,$aes_obj1.CreateDecryptor().TransformFinalBlock($out,0,$out.Length));
        $en_data.CopyTo($io_obj)
        $en_data.Close();
        $en = [System.Text.Encoding]::UTF8.GetString($io_obj.ToArray());
        $aes_obj1.Dispose();
        $io_obj.close();
        return $en;
    }

    static [string]aes_encrypt_CBC($key,$text)
    {
        $aes_obj = New-Object "System.Security.Cryptography.AesManaged";
        $aes_obj.Mode = [System.Security.Cryptography.CipherMode]::CBC;
        $aes_obj.BlockSize = 128;
        $aes_obj.KeySize = 256;
        $iv="1234567890123456";
        $aes_obj.iv = [System.Text.Encoding]::UTF8.GetBytes($iv);
        $aes_obj.Key = [System.Text.Encoding]::UTF8.GetBytes($key);
        $aes_obj.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;
        $in_text=[System.Text.Encoding]::UTF8.GetBytes($text);
        $data = New-Object System.IO.MemoryStream(,$aes_obj.CreateEncryptor().TransformFinalBlock($in_text,0,$in_text.Length));
        $ret=[System.Convert]::ToBase64String($data.ToArray());
        #Write-Host $ret;
        $aes_obj.Dispose();
        return $ret;
    }

    static  [string]aes_decrypt_cbc($key,$text)
    {
        $aes_obj1 = New-Object "System.Security.Cryptography.AesManaged";
        $aes_obj1.Mode = [System.Security.Cryptography.CipherMode]::CBC;
        $aes_obj1.BlockSize = 128;
        $aes_obj1.KeySize = 256;
        $iv="1234567890123456";
        $aes_obj1.iv = [System.Text.Encoding]::UTF8.GetBytes($iv);
        $aes_obj1.Key = [System.Text.Encoding]::UTF8.GetBytes($key);
        $aes_obj1.Padding = [System.Security.Cryptography.PaddingMode]::PKCS7;


        $out= [System.Convert]::FromBase64String($text)
        $io_obj = New-Object System.IO.MemoryStream
        $en_data = New-Object System.IO.MemoryStream(,$aes_obj1.CreateDecryptor().TransformFinalBlock($out,0,$out.Length));
        $en_data.CopyTo($io_obj)
        $en_data.Close();
        $en = [System.Text.Encoding]::UTF8.GetString($io_obj.ToArray());
        $aes_obj1.Dispose();
        $io_obj.close();
        return $en;
    }
}
$key="aes256keyaes256keyaes256keyaes25";
$test="1111111111111111111111111111111111111111111111111";

$test1=[encrypt]::aes_encrypt($key,$test);
write-host $test1

$test2=[encrypt]::aes_decrypt($key,$test1);
write-host $test2


$test3=[encrypt]::aes_encrypt_cbc($key,$test);
write-host $test3

$test4=[encrypt]::aes_decrypt_cbc($key,$test3);
write-host $test4

2.md5/sha1/sha256

$input="1111111111111111111111111111111111111111111"
$algorithm = 'sha256'#[sha|md5|sha256|sha512]
$hasher = [System.Security.Cryptography.HashAlgorithm]::create($algorithm)
$in_text=[System.Text.Encoding]::UTF8.GetBytes($input);
$hash = $hasher.ComputeHash($in_text)
#[system.bitconverter]::tostring($hash)
$hash=[system.bitconverter]::tostring($hash).ToLower().replace('-','')
write-host $algorithm,$hash

https://gist.github.com/kennwhite/ea5c371ed784bf68ab3f

# Simple powershell (built-in to Win7/8) utility script
#  to compute sha256 (or md5, sha1 or sha512) of a file
#
# Usage:
# C:\> powershell
# PS .\hash filename.ext [sha|md5|sha256|sha512]
#
# May require: Control Panel/System/Admin/Windows Power Shell Modules, then: set-executionpolicy remotesigned
#
# Based on James Manning's and Mike Wilbur's get-hashes and get-sha256 MSDN scripts
#
param(
    [string] $file = $(throw "A filename is required. Usage: .\hash filename.ext [sha|md5|sha256|sha512]"),
    [string] $algorithm = 'sha256'
)
$fileStream = [system.io.file]::openread((resolve-path $file))
$hasher = [System.Security.Cryptography.HashAlgorithm]::create($algorithm)
$hash = $hasher.ComputeHash($fileStream)
$fileStream.close()
$fileStream.dispose()
[system.bitconverter]::tostring($hash).ToLower().replace('-','')+" '"+$file+"' "+$algorithm+"`r`n"

3.rc4

https://www.remkoweijnen.nl/blog/2013/04/05/rc4-encryption-in-powershell/

function BinToHex {
	param(
    [Parameter(
        Position=0, 
        Mandatory=$true, 
        ValueFromPipeline=$true)
	]
	[Byte[]]$Bin)
	# assume pipeline input if we don't have an array (surely there must be a better way)
	if ($bin.Length -eq 1) {$bin = @($input)}
	$return = -join ($Bin |  foreach { "{0:X2}" -f $_ })
	Write-Output $return
}

function HexToBin {
	param(
    [Parameter(
        Position=0, 
        Mandatory=$true, 
        ValueFromPipeline=$true)
	]	
	[string]$s)
	$return = @()
	
	for ($i = 0; $i -lt $s.Length ; $i += 2)
	{
		$return += [Byte]::Parse($s.Substring($i, 2), [System.Globalization.NumberStyles]::HexNumber)
	}
	
	Write-Output $return
}

function rc4 {
	param(
    	[Byte[]]$data,
    	[Byte[]]$key
  	)

	# Make a copy of the input data
	[Byte[]]$buffer = New-Object Byte[] $data.Length
	$data.CopyTo($buffer, 0)
	
	[Byte[]]$s = New-Object Byte[] 256;
    [Byte[]]$k = New-Object Byte[] 256;

    for ($i = 0; $i -lt 256; $i++)
    {
        $s[$i] = [Byte]$i;
        $k[$i] = $key[$i % $key.Length];
    }

    $j = 0;
    for ($i = 0; $i -lt 256; $i++)
    {
        $j = ($j + $s[$i] + $k[$i]) % 256;
        $temp = $s[$i];
        $s[$i] = $s[$j];
        $s[$j] = $temp;
    }

    $i = $j = 0;
    for ($x = 0; $x -lt $buffer.Length; $x++)
    {
        $i = ($i + 1) % 256;
        $j = ($j + $s[$i]) % 256;
        $temp = $s[$i];
        $s[$i] = $s[$j];
        $s[$j] = $temp;
        [int]$t = ($s[$i] + $s[$j]) % 256;
        $buffer[$x] = $buffer[$x] -bxor $s[$t];
    }

	return $buffer
}


#Example:


$enc = [System.Text.Encoding]::ASCII
# The data we're going to encrypt
[Byte[]]$data = $enc.GetBytes("Hello World!")
# The key we're going to use
[Byte[]]$key = $enc.GetBytes("SECRET")

# Encryp the data, a byte array is returned
$EncryptedBytes = rc4 $data $key

# Convert the byte array into a hex string so we eg save it to disk
$EncryptedString = BinToHex $EncryptedBytes

# Now decrypt the data
[Byte[]]$data = HexToBin $EncryptedString
$DecryptedBytes = rc4 $data $key
$DecryptedString = $enc.GetString($DecryptedBytes)

4.des

http://qshino.hatenablog.com/entry/2017/03/14/233735

function get-des($in, $key) {
    $des = New-Object System.Security.Cryptography.DESCryptoServiceProvider
    $des.Padding = [System.Security.Cryptography.PaddingMode]::Zeros

    $des.Key = [System.Text.Encoding]::ASCII.GetBytes($key)
    $des.IV  = [Byte[]](0,0,0,0,0,0,0,0)

    $ib = [System.Text.Encoding]::ASCII.GetBytes($in)
    $params = ($ib, 0, $ib.Length)

    $encrypter = $des.CreateEncryptor()
    $eb = [System.Security.Cryptography.ICryptoTransform].GetMethod("TransformFinalBlock").Invoke($encrypter , $params)
   $encrypter.Dispose()
   $eb
}

function get-undes($in, $key) {
    $des = New-Object System.Security.Cryptography.DESCryptoServiceProvider
    $des.Padding = [System.Security.Cryptography.PaddingMode]::Zeros

    $des.Key = [System.Text.Encoding]::ASCII.GetBytes($key)
    $des.IV  = [Byte[]](0,0,0,0,0,0,0,0)
    $params = ($in, 0, $in.Length)

    $decrypter = $des.CreateDecryptor()
    $db = [System.Security.Cryptography.ICryptoTransform].GetMethod("TransformFinalBlock").Invoke($decrypter , $params)
    $decrypter.Dispose()

    $ds = [System.Text.Encoding]::ASCII.GetString($db)
    $ds
}

$in="password"
$key="keyword1"
$des=get-des($in,$key)
$undes=get-undes($des,$key)
$in
$des
$undes

5.triple des

https://gist.github.com/k-rol/7e132e0fcd782a729ec6fdd8eacb68fa

$TDESKEY = 'fhEzg3Svho6nMYPcyCnEJc4qVRTkGY82'

##ENCODE

$password = "Im a password"
$MS = New-Object System.IO.MemoryStream
$keyb = [Convert]::FromBase64String($TDESKEY)
$TD = New-Object System.Security.Cryptography.TripleDESCryptoServiceProvider
$CS = New-Object System.Security.Cryptography.CryptoStream($MS,$TD.CreateEncryptor($keyb, $TD.IV), [System.Security.Cryptography.CryptoStreamMode]::Write)
$Writer = New-Object System.IO.StreamWriter($CS)
$Writer.Write($password)
$Writer.Flush()
$CS.FlushFinalBlock()
#$MS.Seek(0, [System.IO.SeekOrigin]::Begin) > NULL #not sure of its utility
$EncodedText = [Convert]::ToBase64String($MS.ToArray())
$IVS = [Convert]::ToBase64String($TD.IV)
$EncryptedData = "${IVS}:$EncodedText"
$Writer.Dispose()
$EncryptedData


##DECODE

$Data = $EncryptedData.Split(':')
$TD = New-Object System.Security.Cryptography.TripleDESCryptoServiceProvider
$Key = [Convert]::FromBase64String($TDESKEY)
$IV = [Convert]::FromBase64String($Data[0])
$DataByte = [Convert]::FromBase64String($Data[1])
$MS = New-Object System.IO.MemoryStream(,$DataByte) #array of one item must have a preceding coma
$CS = New-Object System.Security.Cryptography.CryptoStream($MS,$TD.CreateDecryptor($Key,$IV), [System.Security.Cryptography.CryptoStreamMode]::Read)
$Reader = New-Object System.IO.StreamReader($CS)
$Result = $Reader.ReadToEnd()
$Reader.Dispose()
$Result