Generate Hashes
Calculate cryptographic hashes for selected files using the supported hashing algorithms.
A Windows desktop application for generating and validating cryptographic file hashes, built with C# and .NET 10 using WPF, MVVM, asynchronous processing, and the KZ.FileHash hashing engine.
File Hash Generator & Validator is a Windows desktop application for generating cryptographic hashes and verifying files against expected publisher checksums.
Starting from version 1.0.0.1, the application uses KZ.FileHash as its underlying hashing engine, keeping the hashing implementation separate from the desktop application's presentation layer.
The application is designed for a simple integrity workflow: select a file, calculate its hash, or compare the calculated value against an expected checksum.
All processing happens locally on the user's machine, with no requirement to upload files or checksums to an external service.
Hashing large files should not require loading the complete file into memory. The application processes file data incrementally through the KZ.FileHash engine.
Users need a straightforward way to compare a calculated file hash against a checksum published by the software or file provider.
Hashing large files can take time. Asynchronous processing, progress reporting, and cancellation keep the application workflow responsive and controllable.
Expected hashes have algorithm-specific lengths. The application validates the supplied hash length and can suggest matching algorithms when the selected algorithm does not match the expected value.
Calculate cryptographic hashes for selected files using the supported hashing algorithms.
Compare a calculated file hash against an expected publisher checksum to verify file integrity.
Expected hash lengths are validated before processing, allowing the application to detect potential algorithm mismatches and suggest compatible algorithms.
Files can be selected directly through the interface or provided using the application's drag-and-drop workflow.
Long-running operations expose real-time progress through IProgress<double> and support cancellation through CancellationToken.
File hashing and verification are performed locally, keeping the files and calculated values on the user's machine.
The application follows a lightweight MVVM structure, separating the WPF interface from the application's state and command handling.
File hashing is exposed through a dedicated FileHashService rather than being embedded directly into the view layer. The service integrates the KZ.FileHash engine.
The project contains dedicated models, services, view models, commands, and converters, keeping the desktop application structure lightweight and explicit.
File operations are performed asynchronously with cancellation and progress reporting, allowing the application to handle large files without tying the UI directly to synchronous processing.
FileHashGeneratorAndValidator/
│
├── Core/
│ ├── Bindable.cs
│ └── RelayCommand.cs
│
├── Models/
│ └── HashOperationResult.cs
│
├── Services/
│ └── FileHashService.cs
│
├── ViewModels/
│ └── MainWindowViewModel.cs
│
├── Converters/
│ └── InverseBooleanConverter.cs
│
├── MainWindow.xaml
└── App.xaml
Choose a file through the desktop interface or drag and drop it into the application.
Select the hashing algorithm required for the integrity check or hash generation workflow.
The application processes the file incrementally through the KZ.FileHash engine while reporting progress.
When validating a file, the calculated hash is compared against the expected checksum using a case-insensitive comparison.
The application does not load complete files into system memory before hashing. File data is processed incrementally through buffered streaming.
KZ.FileHash processes data in buffered chunks and uses pooled memory internally, keeping allocations low relative to the size of the file being processed.
The project successful processing of files larger than 3 GB without memory spikes or UI freezing.
File
│
▼
Buffered Stream
│
▼
KZ.FileHash Engine
│
├── Incremental Hashing
├── ArrayPool<byte>
├── Async Processing
└── Progress / Cancellation
│
▼
Calculated Hash
│
▼
Generate / Verify
The application supports MD5, SHA-1, SHA-256, SHA-384, SHA-512, SHA3-256, SHA3-384, and SHA3-512.
Hash verification confirms that the calculated hash matches the expected checksum. A matching value does not, by itself, prove that the file or checksum came from a trusted source.
File hashing is kept outside the presentation layer, allowing the WPF interface to coordinate the workflow without owning the hashing implementation.
The application builds on KZ.FileHash instead of duplicating the underlying hashing engine inside the desktop application.
File-processing workflows should account for inputs that are several gigabytes rather than assuming that files are small.
Progress reporting and cancellation give users and the application control over operations that may take significant time.
Read the implementation, architecture, project structure, and development history on GitHub.
I work on backend systems, APIs, SQL Server, ERP software, and performance-focused engineering problems.
Let’s talk