Qubic.Crypto 1.0.0

Qubic.Crypto

A pure C#/.NET implementation of cryptographic primitives for the Qubic protocol. Zero external dependencies - runs on any .NET 8.0 platform.

Features

• K12 (KangarooTwelve) - Fast hash function based on Keccak-p[1600,12]
• FourQ - High-performance elliptic curve over Fp2
• SchnorrQ - Digital signatures using FourQ and K12
• ECDH - Elliptic Curve Diffie-Hellman key exchange
• Identity - Qubic identity (60-char base-26) encoding/decoding with checksum

Installation

No external NuGet packages required. Just reference the project:

dotnet add reference path/to/Qubic.Crypto.csproj

Quick Start

using Qubic.Crypto;

var crypt = new QubicCrypt();

// From a 55-character lowercase seed (a-z)
var seed = "abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzabc";

// Get keys
var publicKey = crypt.GetPublicKey(seed);
var privateKey = crypt.GetPrivateKey(seed);

// Get Qubic identity (60-char string like "ABCD...WXYZ")
var identity = crypt.GetIdentityFromPublicKey(publicKey);

// Sign a message (returns message + 64-byte signature)
var message = new byte[] { 0x01, 0x02, 0x03 };
var signedMessage = crypt.Sign(seed, message);

// Verify signature
bool isValid = crypt.Verify(publicKey, signedMessage);

// ECDH shared key
var sharedKey = crypt.GetSharedKey(seed, otherPublicKey);

// K12 hashing
var hash = crypt.KangarooTwelve(data, outputLength: 32);

API Reference

IQubicCrypt Interface

Low-Level SchnorrQ API

using Qubic.Crypto;

// From 55-char seed to 32-byte subSeed
var subSeed = SchnorrQ.GetSubSeedFromSeed(seed);

// Generate keys from subSeed
var privateKey = SchnorrQ.GeneratePrivateKey(subSeed);
var publicKey = SchnorrQ.GeneratePublicKey(subSeed);

// Sign a 32-byte digest
var signature = SchnorrQ.Sign(subSeed, publicKey, digest);

// Verify
bool valid = SchnorrQ.Verify(publicKey, digest, signature);

// Sign full message (hashes internally)
var sig = SchnorrQ.SignMessage(subSeed, publicKey, message);
bool valid = SchnorrQ.VerifyMessage(publicKey, message, sig);

Direct K12 Hashing

using Qubic.Crypto;

var hash = K12.Hash(data, outputLength: 32);
var hash64 = K12.Hash(data, outputLength: 64);

Project Structure

Qubic.Crypto/
├── K12.cs              # KangarooTwelve hash implementation
├── SchnorrQ.cs         # SchnorrQ signature scheme
├── IQubicCrypt.cs      # Interface definition
├── QubicCrypt.cs       # Full implementation
└── FourQ/
    ├── Fp.cs           # Prime field (p = 2^127 - 1)
    ├── Fp2.cs          # Quadratic extension field
    ├── Point.cs        # Curve point operations
    ├── Codec.cs        # Point encoding/decoding
    └── ScalarField.cs  # Scalar arithmetic (mod N)

Technical Details

K12 (KangarooTwelve)

• Keccak-p[1600,12] permutation (12 rounds)
• Rate: 168 bytes, Capacity: 256 bits
• Domain separator: 0x07
• Compatible with noble/hashes implementation

FourQ Curve

• Twisted Edwards curve over Fp2 where p = 2^127 - 1 (Mersenne prime)
• Curve equation: -x² + y² = 1 + d·x²·y²
• ~128-bit security level
• Curve order N = 0x29CBC14E5E0A72F05397829CBC14E5DFBD004DFE0F79992FB2540EC7768CE7

Qubic Identity Format

• 60 characters using A-Z (base-26)
• First 56 chars: encoded public key (4 chunks × 14 chars)
• Last 4 chars: K12 checksum (18 bits encoded)

Security Warning

This is a pure managed C# implementation optimized for portability, not for side-channel resistance. Do not use signing operations in environments where timing attacks are a concern.

Building & Testing

dotnet build
dotnet test

All 74 tests pass, including:

• Real Qubic network signature verification
• Identity round-trip conversion
• ECDH shared key derivation

Platform Support

Runs on any platform supporting .NET 8.0:

• Windows (x64, ARM64)
• Linux (x64, ARM64)
• macOS (x64, ARM64)

No native dependencies or platform-specific code.

References

• FourQlib - Microsoft's FourQ library
• KangarooTwelve - Official K12 specification