Tutorial: HAIP Compliance

using SdJwt.Net.HAIP;
using SdJwt.Net.HAIP.Models;

var validator = new HaipValidator(SecurityLevel.Level2);

// Generate compliant key
var keyGenerator = new HaipKeyGenerator(SecurityLevel.Level2);
var issuerKey = keyGenerator.GenerateKey();  // P-256 for Level 2

// Validate existing key
var existingKey = LoadKey();
if (!validator.IsKeyCompliant(existingKey))
{
    throw new SecurityException("Key does not meet HAIP Level 2 requirements");
}

// Check algorithm compliance
var algorithm = SecurityAlgorithms.EcdsaSha256;

if (!validator.IsAlgorithmCompliant(algorithm))
{
    throw new SecurityException($"Algorithm {algorithm} not allowed at Level 2");
}

var haipIssuer = new HaipSdJwtIssuer(
    signingKey: issuerKey,
    securityLevel: SecurityLevel.Level2
);

var payload = new Dictionary<string, object>
{
    ["iss"] = "https://gov.example.com",
    ["sub"] = "citizen-123",
    ["given_name"] = "Alice",
    ["family_name"] = "Smith",
    ["national_id"] = "123-45-6789"
};

var options = new SdIssuanceOptions
{
    DisclosureStructure = new
    {
        given_name = true,
        family_name = true,
        national_id = true
    }
};

// Issuance validates algorithm compliance automatically
var credential = haipIssuer.Issue(payload, options, holderPublicKey);

var haipVerifier = new HaipSdVerifier(
    keyResolver: ResolveIssuerKey,
    securityLevel: SecurityLevel.Level2
);

var result = await haipVerifier.VerifyAsync(
    presentation,
    sdJwtParams,
    kbJwtParams
);

// Verifier automatically rejects non-compliant algorithms

// Allowed signing algorithms
var level1Algorithms = new[]
{
    SecurityAlgorithms.EcdsaSha256,   // ES256
    SecurityAlgorithms.EcdsaSha384,   // ES384
    SecurityAlgorithms.EcdsaSha512,   // ES512
    SecurityAlgorithms.RsaSha256,     // RS256
    SecurityAlgorithms.RsaSha384,     // RS384
    SecurityAlgorithms.RsaSha512      // RS512
};

// RSA not allowed
var level2Algorithms = new[]
{
    SecurityAlgorithms.EcdsaSha256,   // ES256 (P-256)
    SecurityAlgorithms.EcdsaSha384,   // ES384 (P-384)
    SecurityAlgorithms.EcdsaSha512    // ES512 (P-521)
};

// Minimum curve: P-256

// Minimum ES384
var level3Algorithms = new[]
{
    SecurityAlgorithms.EcdsaSha384,   // ES384 (P-384)
    SecurityAlgorithms.EcdsaSha512    // ES512 (P-521)
};

// Minimum curve: P-384
// Additional: strict timestamp validation

// NEVER allowed at any level
var blockedAlgorithms = new[]
{
    "none",           // No signature
    "HS256",          // Symmetric (not for credentials)
    "RS256" /* at Level 2+ */
};

// NEVER allowed hash algorithms
var blockedHashes = new[]
{
    "MD5",            // Cryptographically broken
    "SHA1"            // Deprecated, collision attacks
};

// Level 3 requires:
var level3Options = new HaipValidationOptions
{
    MaxClockSkew = TimeSpan.FromMinutes(1),     // Tighter tolerance
    RequireIat = true,                           // Must have issued-at
    MaxCredentialAge = TimeSpan.FromHours(24),   // Freshness requirement
    RequireExp = true                            // Must have expiration
};

var report = validator.GenerateComplianceReport(credential);

Console.WriteLine($"HAIP Level: {report.Level}");
Console.WriteLine($"Signing Algorithm: {report.Algorithm} - {report.AlgorithmCompliant}");
Console.WriteLine($"Key Curve: {report.KeyCurve} - {report.KeyCompliant}");
Console.WriteLine($"Timestamps: {report.TimestampCompliant}");
Console.WriteLine($"Overall: {(report.IsCompliant ? "PASS" : "FAIL")}");

// 1. Generate new Level 2 compliant keys
var newIssuerKey = keyGenerator.GenerateKey(SecurityLevel.Level2);

// 2. Publish new keys (keep old for transition)
var jwks = new JsonWebKeySet
{
    Keys = { oldKey, newIssuerKey }
};

// 3. Issue new credentials with Level 2 algorithm
var newCredentials = haipIssuer.Issue(payload, options);

// 4. After transition period, remove old keys

cd samples/SdJwt.Net.Samples
dotnet run -- 3.2