LicenseGenerator 1.0.3

LicenseGenerator

A .NET 8 NuGet library for software licensing workflows: generate formatted serial keys, derive a machine fingerprint from Windows hardware (WMI), and hash license data for validation or storage.

Published as the LicenseGenerator package by BackOffice. The library ships as a compiled assembly only (no source or debug symbols in the published package).

Features

Requirements

• .NET 8.0 or later
• Windows — required only for requestKey() (uses WMI via System.Management)
• Serial key and hashing APIs work on any platform supported by .NET 8

Install

From NuGet.org (after the package is published):

dotnet add package LicenseGenerator

From a local build:

dotnet build -c Release
dotnet add package LicenseGenerator --source ./bin/Release

Quick start

The namespace and the main static class are both named LicenseGenerator. Use a type alias to avoid ambiguity:

using LG = LicenseGenerator.LicenseGenerator;

// Generate a 16-character key as 4 groups of 4: e.g. "A1B2-C3D4-E5F6-7890"
string serial = LG.GetSerialKeyAlphaNumaric(segment: 4, digits: 4);

// Windows only: fingerprint the current machine's CPU
string machineKey = LG.requestKey();

// Hash a license string (e.g. serial + machine key) for storage or comparison
string licenseHash = LG.GetHash($"{serial}-{machineKey}");

API reference

GetSerialKeyAlphaNumaric(int segment, int digits)

Generates an uppercase alphanumeric serial key derived from a new Guid.

• Total length = segment × digits
• Supported total lengths: 16, 18, 20, 24, 28, 32 (enforced via SNKeyLength)
• Format: characters grouped with - separators (groups of 3 or 4 depending on length)

string key = LG.GetSerialKeyAlphaNumaric(4, 4);
// e.g. "F3A9-1B2C-8D4E-7F01"

GetSerialKeyNumaric(SNKeyNumLength keyLength)

Generates a numeric-only serial key of fixed length.

string shortKey  = LG.GetSerialKeyNumaric(SNKeyNumLength.SN4);   // 4 digits
string mediumKey = LG.GetSerialKeyNumaric(SNKeyNumLength.SN8);   // 8 digits
string longKey   = LG.GetSerialKeyNumaric(SNKeyNumLength.SN12);  // 12 digits

requestKey() (Windows only)

Returns a hardware fingerprint for the current machine by querying WMI Win32_Processor. The method tries, in order:

1. UniqueId
2. ProcessorId
3. Name + Manufacturer + MaxClockSpeed (fallback chain)

Use this to bind a license to a specific machine or to include a machine identifier in license validation logic.

#if WINDOWS
string cpuFingerprint = LG.requestKey();
#endif

Note: Mark calling code with [SupportedOSPlatform("windows")] or guard with platform checks. On non-Windows runtimes, calling this method is not supported.

GetHash(string input)

Computes an MD5 hash of the input string (ASCII encoding) and returns an uppercase hexadecimal string with a - inserted after every 4 hex characters.

string hash = LG.GetHash("my-license-data");
// e.g. "A1B2-C3D4-E5F6-7890-ABCD-EF01-2345-6789"

Enums

public enum SNKeyLength   { SN16 = 16, SN18 = 18, SN20 = 20, SN24 = 24, SN28 = 28, SN32 = 32 }
public enum SNKeyNumLength { SN4 = 4, SN8 = 8, SN12 = 12 }

Typical licensing workflow

A common pattern when building activation or license validation:

using LG = LicenseGenerator.LicenseGenerator;

// 1. Issue a serial key to the customer
string serial = LG.GetSerialKeyAlphaNumaric(4, 4);

// 2. On the client machine (Windows), collect hardware fingerprint
string machineId = LG.requestKey();

// 3. Combine and hash for storage or offline validation
string activationPayload = $"{serial}|{machineId}";
string activationCode = LG.GetHash(activationPayload);

// 4. Store serial, machineId, and activationCode in your license database

Your application is responsible for persisting keys, validating hashes, and enforcing license terms. This library provides the generation and fingerprinting primitives only.

Project structure

LicenseGenerator/
├── LicenseGenerator.cs      # Static API (serial keys, WMI fingerprint, hashing)
├── LicenseGenerator.csproj  # NuGet package metadata and dependencies
├── LicenseGenerator.sln     # Solution file
├── azure-pipelines.yml      # CI/CD: build, pack, verify, publish to NuGet.org
└── README.md

Build locally

dotnet restore
dotnet build -c Release
dotnet pack -c Release -o ./artifacts

The Release build produces:

• bin/Release/net8.0/LicenseGenerator.dll
• artifacts/LicenseGenerator.<version>.nupkg

CI/CD (Azure Pipelines)

The pipeline in azure-pipelines.yml runs on ubuntu-latest and:

1. Auto-versions packages as 1.0.<patch> using an Azure DevOps build counter
2. Restores, builds, and packs in Release (no debug symbols in the published package)
3. Verifies the .nupkg contains only the compiled DLL and metadata — no .cs source or .pdb files
4. Pushes to NuGet.org when the build is on main or a v* tag

Triggers: pushes to main and release/*, tags matching v*, and pull requests to main.

Publishing setup

To enable NuGet.org push from the pipeline, add a secret pipeline variable in Azure DevOps:

Create the key at nuget.org → Account → API Keys → Create. Enable Keep this value secret when adding it to the pipeline variables.

Dependencies

• System.Management 8.0.0 — WMI access for hardware fingerprinting on Windows

Platform support summary

<h2>📞 Support</h2>

For issues or questions, please contact us:

• Email: info@waelelazizy.com
• KSA: 0553373500
• Bahrain: 00973 33030730

<br/>

<p align="center"> <strong>Made with ❤️ for the .NET Developers</strong> </p>

<p align="center"> #DotNet   #NuGet   #Licensing   #SerialKey   #CSharp   #BackOffice </p>