← Back to projects
Windows Desktop Application Open Source

File Hash Generator & Validator

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.

A practical Windows tool for file integrity verification.

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.

Language C# 14
Framework .NET 10
UI WPF
Architecture MVVM

File verification is simple. The workflow still needs to be reliable.

01

Large file processing

Hashing large files should not require loading the complete file into memory. The application processes file data incrementally through the KZ.FileHash engine.

02

Integrity verification

Users need a straightforward way to compare a calculated file hash against a checksum published by the software or file provider.

03

Responsive desktop processing

Hashing large files can take time. Asynchronous processing, progress reporting, and cancellation keep the application workflow responsive and controllable.

04

Correct algorithm selection

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.

Focused functionality. Built around a real verification workflow.

01

Generate Hashes

Calculate cryptographic hashes for selected files using the supported hashing algorithms.

02

Verify Checksums

Compare a calculated file hash against an expected publisher checksum to verify file integrity.

03

Algorithm Suggestions

Expected hash lengths are validated before processing, allowing the application to detect potential algorithm mismatches and suggest compatible algorithms.

04

Drag & Drop

Files can be selected directly through the interface or provided using the application's drag-and-drop workflow.

05

Progress & Cancellation

Long-running operations expose real-time progress through IProgress<double> and support cancellation through CancellationToken.

06

Offline Processing

File hashing and verification are performed locally, keeping the files and calculated values on the user's machine.

Separate the interface from the hashing engine.

MVVM application structure

The application follows a lightweight MVVM structure, separating the WPF interface from the application's state and command handling.

Dedicated hashing service

File hashing is exposed through a dedicated FileHashService rather than being embedded directly into the view layer. The service integrates the KZ.FileHash engine.

Core application components

The project contains dedicated models, services, view models, commands, and converters, keeping the desktop application structure lightweight and explicit.

Local asynchronous processing

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.

project-structure.txt
FileHashGeneratorAndValidator/
│
├── Core/
│   ├── Bindable.cs
│   └── RelayCommand.cs
│
├── Models/
│   └── HashOperationResult.cs
│
├── Services/
│   └── FileHashService.cs
│
├── ViewModels/
│   └── MainWindowViewModel.cs
│
├── Converters/
│   └── InverseBooleanConverter.cs
│
├── MainWindow.xaml
└── App.xaml

From file selection to verified integrity.

01

Select the file

Choose a file through the desktop interface or drag and drop it into the application.

02

Choose the algorithm

Select the hashing algorithm required for the integrity check or hash generation workflow.

03

Process the file

The application processes the file incrementally through the KZ.FileHash engine while reporting progress.

04

Compare the result

When validating a file, the calculated hash is compared against the expected checksum using a case-insensitive comparison.

Designed for large files without loading them into RAM.

Incremental processing

The application does not load complete files into system memory before hashing. File data is processed incrementally through buffered streaming.

Low and predictable memory usage

KZ.FileHash processes data in buffered chunks and uses pooled memory internally, keeping allocations low relative to the size of the file being processed.

Large-file testing

The project successful processing of files larger than 3 GB without memory spikes or UI freezing.

processing-model.txt
File
 │
 ▼
Buffered Stream
 │
 ▼
KZ.FileHash Engine
 │
 ├── Incremental Hashing
 ├── ArrayPool<byte>
 ├── Async Processing
 └── Progress / Cancellation
 │
 ▼
Calculated Hash
 │
 ▼
Generate / Verify

Multiple hashing standards for compatibility and verification.

MD5
MD5
SHA-1
SHA-1
SHA-2
SHA-256 SHA-384 SHA-512
SHA-3
SHA3-256 SHA3-384 SHA3-512

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.

Built with modern .NET desktop tooling.

Language
C# 14
Runtime
.NET 10
UI
WPF WPF-UI Fluent Design
Architecture
MVVM
Processing
Async/Await CancellationToken IProgress<double>
Core Engine
KZ.FileHash ArrayPool<byte> IncrementalHash

What this project actually demonstrates.

01

Separate UI from processing

File hashing is kept outside the presentation layer, allowing the WPF interface to coordinate the workflow without owning the hashing implementation.

02

Reuse specialized components

The application builds on KZ.FileHash instead of duplicating the underlying hashing engine inside the desktop application.

03

Design for large inputs

File-processing workflows should account for inputs that are several gigabytes rather than assuming that files are small.

04

Make long operations controllable

Progress reporting and cancellation give users and the application control over operations that may take significant time.

Have a backend problem worth solving?

I work on backend systems, APIs, SQL Server, ERP software, and performance-focused engineering problems.

Let’s talk