Introduction

PowerShell 2.0 does not include the newer convenience cmdlets for file hashing, so calculating a SHA-1 digest means using the underlying .NET cryptography classes directly. That is straightforward once you decide whether you are hashing a string, a byte array, or a file stream.

Hash a String With .NET Crypto Classes

In PowerShell 2.0, a common pattern is:

1. convert the string to bytes
2. create a SHA-1 provider
3. compute the hash
4. format the bytes as hexadecimal

1$string = "hello world"
2$bytes = [System.Text.Encoding]::UTF8.GetBytes($string)
3$sha1 = New-Object System.Security.Cryptography.SHA1Managed
4$hashBytes = $sha1.ComputeHash($bytes)
5$hash = [System.BitConverter]::ToString($hashBytes) -replace '-', ''
6$hash.ToLower()

This returns the familiar hexadecimal SHA-1 digest.

If you need repeatable interoperability, pay attention to the text encoding. UTF-8 and UTF-16 do not produce the same byte sequence, so they do not produce the same hash.

Hash a File in PowerShell 2.0

For files, hash the stream contents instead of loading the file as plain text. That avoids encoding confusion and works for binary files too.

1$path = "C:\temp\example.zip"
2$stream = [System.IO.File]::OpenRead($path)
3$sha1 = New-Object System.Security.Cryptography.SHA1CryptoServiceProvider
4
5try {
6    $hashBytes = $sha1.ComputeHash($stream)
7    $hash = [System.BitConverter]::ToString($hashBytes) -replace '-', ''
8    $hash.ToLower()
9}
10finally {
11    $stream.Close()
12    $sha1.Dispose()
13}

This is the PowerShell 2.0 equivalent of what later versions do with built-in hashing cmdlets.

Wrap the Logic in a Reusable Function

If you need this more than once, put it in a helper function.

1function Get-Sha1FileHash {
2    param(
3        [Parameter(Mandatory=$true)]
4        [string]$Path
5    )
6
7    $stream = [System.IO.File]::OpenRead($Path)
8    $sha1 = New-Object System.Security.Cryptography.SHA1Managed
9
10    try {
11        $hashBytes = $sha1.ComputeHash($stream)
12        return ([System.BitConverter]::ToString($hashBytes) -replace '-', '').ToLower()
13    }
14    finally {
15        $stream.Close()
16        $sha1.Dispose()
17    }
18}
19
20Get-Sha1FileHash -Path "C:\temp\example.zip"

That keeps the resource cleanup and formatting details in one place.

Know Why SHA-1 Is Usually a Legacy Requirement

SHA-1 is still useful for compatibility with old systems, file manifests, and some legacy workflows, but it is not recommended for new security-sensitive designs. Collision attacks against SHA-1 are practical enough that modern systems usually prefer SHA-256 or stronger hashes.

So if you are implementing new verification logic rather than matching an old protocol, use a stronger algorithm. In PowerShell 2.0, the coding pattern is the same. Only the algorithm class changes.

$sha256 = New-Object System.Security.Cryptography.SHA256Managed

That is often the better choice when you control both ends of the system.

String Hashing Versus File Hashing

People often mix these up. Hashing a string means hashing the bytes produced by a particular encoding. Hashing a file means hashing the raw bytes stored on disk.

Those are not interchangeable operations, even if the file contains visible text. If the requirement is to verify file integrity, hash the file stream. If the requirement is to sign or compare a text payload, hash the explicitly encoded string bytes.

Common Pitfalls

• Hashing a string with the wrong encoding produces a different digest even when the visible text looks identical.
• Reading a binary file as text before hashing corrupts the input for hashing purposes. Use a file stream for file hashes.
• Forgetting to close the file stream can leave the file locked in the PowerShell session.
• Using SHA-1 for new security-sensitive work is a design mistake when stronger algorithms are available.
• Comparing hashes with mixed casing or embedded dashes can cause false mismatches. Normalize the hex format before comparing.

Summary

• In PowerShell 2.0, calculate SHA-1 hashes through the .NET cryptography classes.
• Hash strings by converting them to bytes with a known encoding.
• Hash files by passing a file stream into ComputeHash.
• Wrap the pattern in a helper function if you need to reuse it.
• Use SHA-1 only when compatibility requires it; prefer stronger hashes for new systems.