new ps script, process directory with filter

sri.ps1

@@ -1,48 +1,96 @@
 param (
-    # Specifies a path to one or more locations.
+    # List of files to hash
-    [Parameter(Mandatory=$true,
+    [Parameter(HelpMessage="Comma-separated list of files to hash.")]
-               HelpMessage="Path to resource for which to generate integrity hash.")]
+    [Alias("file", "list")]
-    [Alias("path", "resource")]
+    [ValidateNotNullOrEmpty()]
+    [string[]]
+    $files,
+
+    # Directory of files to hash
+    [Parameter(HelpMessage="Hash all files within this directory.")]
     [ValidateNotNullOrEmpty()]
     [string]
-    $filename,
+    $directory,
 
-    [Parameter(HelpMessage="Desired hash algorithm.")]
+    # File filter
+    [Parameter(HelpMessage="Only hash files of this type, relevant only when processing a directory.")]
+    [Alias("only")]
+    [ValidateNotNullOrEmpty()]
+    [string]
+    $filter = '*',
+
+    # Hash algorithm to use
+    [Parameter(HelpMessage="Hash algorithm to use (SHA256, SHA384, SHA512).")]
     [Alias("algorithm")]
     [ValidateSet('sha256', 'sha384', 'sha512')]
     [string]
     $hashAlgo = 'sha384'
 )
 
+function displayError($returnCode, $eMsg){
+    Write-Host "`nERROR: $eMsg" -ForegroundColor Red
+    Write-Host "Exiting.`n" -ForegroundColor Red
+    exit $returnCode
+}
+
 function hashSHA($type){
     switch($type){
         'sha256' { return [System.Security.Cryptography.SHA256]::Create() }
         'sha384' { return [System.Security.Cryptography.SHA384]::Create() }
         'sha512' { return [System.Security.Cryptography.SHA512]::Create() }
         default{
-            Write-Host "`rUnknown hash algorithm.`r"
+            displayError 2 'Unknown hash algorithm.'
-            exit 2
         }
     }
 }
 
-$fileContents = Get-Content $filename -Raw
+function doHash($file, $hash){
-$hashAlgo = $hashAlgo.ToLower()
+    $fileContents = Get-Content $file -Raw
-$hashValue = hashSHA $hashAlgo
-
     try {
-    $hashBytes = $hashValue.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($fileContents))
+        $hashBytes = $hash.ComputeHash([System.Text.Encoding]::UTF8.GetBytes($fileContents))
-    $hashBase64 = [System.Convert]::ToBase64String($hashBytes)
+        return [System.Convert]::ToBase64String($hashBytes)
-    Write-Host "`r$hashAlgo-$hashBase64`r"
     }
     catch {
-    Write-Host "There was a problem generating a hash value."
+        return 1
-    exit 1
     }
-finally {
-    $hashValue.Dispose()
 }
 
+
+# instantiate hash provider
+$hashAlgo = $hashAlgo.ToLower()
+$hash = hashSHA $hashAlgo
+
+# process directory, if specified
+if ($directory){
+    # continue only if directory exists, otherwise exit with error
+    if (Test-Path -Path $directory){
+        Write-Host "`nProcessing directory: $directory" -ForegroundColor Cyan
+        Get-ChildItem -Path $directory -Filter $filter | ForEach-Object({
+            $hashValue = doHash $directory\$_ $hash
+            if ($hashValue -ne 1){
+                Write-Host "$_ --> $hashAlgo-$hashValue" -ForegroundColor Green
+            }
+            else {
+                Write-Host "$_ --> unable to hash file" -ForegroundColor Red
+            }
+        })
+    }
+    else {
+        displayError 1 "Directory '$directory' does not exist."
+    }
+}
+
+# process file list, if specified
+if ($files) {
+    Write-Host
+    foreach ($file in $files) {
+        Write-Host "Processing $file"
+    }
+    Write-Host
+}
+
+# clean up and exit
+$hash.Dispose()
 exit 0
 
 #EOF