// key format: {prefix}_{environment}_{random_bytes}
// Example:    sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6

interface ApiKeyComponents {
  prefix: string;      // 'sk' (secret key) or 'pk' (public key)
  environment: string; // 'live' or 'test'
  secret: string;      // 32 bytes of cryptographically random data (hex)
}

// The "key ID" is the prefix + environment + first 8 chars of secret
// The full key includes the secret portion — only stored hashed
// KeyID: sk_live_a7f3b9c2 (safe to log)
// Full:  sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6 (secret)

// key format: {prefix}_{environment}_{random_bytes}
// Example:    sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6

public record ApiKeyComponents(
    String prefix,      // "sk" (secret key) or "pk" (public key)
    String environment, // "live" or "test"
    String secret       // 32 bytes of cryptographically random data (hex)
) {}

// The "key ID" is the prefix + environment + first 8 chars of secret
// The full key includes the secret portion — only stored hashed
// KeyID: sk_live_a7f3b9c2 (safe to log)
// Full:  sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6 (secret)

# key format: {prefix}_{environment}_{random_bytes}
# Example:    sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6

from dataclasses import dataclass

@dataclass
class ApiKeyComponents:
    prefix: str      # 'sk' (secret key) or 'pk' (public key)
    environment: str # 'live' or 'test'
    secret: str      # 32 bytes of cryptographically random data (hex)

# The "key ID" is the prefix + environment + first 8 chars of secret
# The full key includes the secret portion — only stored hashed
# KeyID: sk_live_a7f3b9c2 (safe to log)
# Full:  sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6 (secret)

// key format: {prefix}_{environment}_{random_bytes}
// Example:    sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6

public record ApiKeyComponents(
    string Prefix,      // "sk" (secret key) or "pk" (public key)
    string Environment, // "live" or "test"
    string Secret       // 32 bytes of cryptographically random data (hex)
);

// The "key ID" is the prefix + environment + first 8 chars of secret
// The full key includes the secret portion — only stored hashed
// KeyID: sk_live_a7f3b9c2 (safe to log)
// Full:  sk_live_a7f3b9c2d1e4f6a8b0c3d5e7f9a1b2c4d6e8f0a2b4c6d8e0f2a4b6c8d0e2f4a6 (secret)

import crypto from 'crypto';
import { db } from './database';
import bcrypt from 'bcrypt';

// ============================================================================
// API Key Generation
// ============================================================================

interface ApiKey {
  id: string;         // Public identifier (stored in plain text)
  fullKey: string;    // Shown to user ONCE at creation — never stored plain
  prefix: string;
  environment: 'live' | 'test';
  serviceId: string;
  permissions: string[];
  createdAt: Date;
  lastUsedAt?: Date;
  expiresAt?: Date;
  revokedAt?: Date;
}

async function generateApiKey(
  serviceId: string,
  environment: 'live' | 'test',
  permissions: string[]
): Promise<{ keyId: string; fullKey: string }> {
  // Generate cryptographically random secret (32 bytes = 64 hex chars)
  const secretBytes = crypto.randomBytes(32);
  const secretHex = secretBytes.toString('hex');

  // Build the key components
  const prefix = 'sk';
  const keyId = `${prefix}_${environment}_${secretHex.slice(0, 8)}`;
  const fullKey = `${prefix}_${environment}_${secretHex}`;

  // Hash the full key for storage (bcrypt — intentionally slow)
  // We store the hash, not the key itself
  const keyHash = await bcrypt.hash(fullKey, 12);

  // Store in database
  await db.apiKeys.insert({
    id: keyId,
    hash: keyHash,
    serviceId,
    environment,
    permissions,
    createdAt: new Date(),
  });

  // Return full key to caller — shown only once
  return { keyId, fullKey };
}

// ============================================================================
// API Key Verification
// ============================================================================

async function verifyApiKey(
  submittedKey: string
): Promise<{ valid: boolean; serviceId?: string; permissions?: string[] }> {
  // Extract the key ID from the submitted key
  // Format: sk_live_a7f3b9c2... — key ID is first 3 parts
  const parts = submittedKey.split('_');
  if (parts.length < 3) {
    return { valid: false };
  }

  const keyId = `${parts[0]}_${parts[1]}_${parts[2].slice(0, 8)}`;

  // Look up the key record
  const keyRecord = await db.apiKeys.findById(keyId);

  if (!keyRecord || keyRecord.revokedAt) {
    return { valid: false };
  }

  if (keyRecord.expiresAt && keyRecord.expiresAt < new Date()) {
    return { valid: false };
  }

  // Constant-time comparison via bcrypt
  const isValid = await bcrypt.compare(submittedKey, keyRecord.hash);

  if (isValid) {
    // Update last used timestamp (async, non-blocking)
    db.apiKeys.update(keyId, { lastUsedAt: new Date() }).catch(console.error);
  }

  return {
    valid: isValid,
    serviceId: isValid ? keyRecord.serviceId : undefined,
    permissions: isValid ? keyRecord.permissions : undefined,
  };
}

import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.stereotype.Service;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.HexFormat;
import java.util.List;
import java.util.Optional;

// ============================================================================
// API Key Generation
// ============================================================================

public record ApiKey(
    String id,
    String prefix,
    String environment,
    String serviceId,
    List<String> permissions,
    Instant createdAt,
    Instant lastUsedAt,
    Instant expiresAt,
    Instant revokedAt
) {}

public record GenerateApiKeyResult(String keyId, String fullKey) {}

public record VerifyApiKeyResult(boolean valid, String serviceId, List<String> permissions) {}

@Service
public class ApiKeyService {
    private final ApiKeyRepository apiKeyRepository;
    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder(12);
    private final SecureRandom secureRandom = new SecureRandom();

    public ApiKeyService(ApiKeyRepository apiKeyRepository) {
        this.apiKeyRepository = apiKeyRepository;
    }

    public GenerateApiKeyResult generateApiKey(
            String serviceId, String environment, List<String> permissions) {
        // Generate cryptographically random secret (32 bytes = 64 hex chars)
        byte[] secretBytes = new byte[32];
        secureRandom.nextBytes(secretBytes);
        String secretHex = HexFormat.of().formatHex(secretBytes);

        // Build the key components
        String prefix = "sk";
        String keyId = prefix + "_" + environment + "_" + secretHex.substring(0, 8);
        String fullKey = prefix + "_" + environment + "_" + secretHex;

        // Hash the full key for storage (bcrypt — intentionally slow)
        String keyHash = passwordEncoder.encode(fullKey);

        // Store in database
        apiKeyRepository.insert(new ApiKeyRecord(
            keyId, keyHash, serviceId, environment, permissions, Instant.now()
        ));

        // Return full key to caller — shown only once
        return new GenerateApiKeyResult(keyId, fullKey);
    }

    // ============================================================================
    // API Key Verification
    // ============================================================================

    public VerifyApiKeyResult verifyApiKey(String submittedKey) {
        // Extract the key ID from the submitted key
        // Format: sk_live_a7f3b9c2... — key ID is first 3 parts
        String[] parts = submittedKey.split("_");
        if (parts.length < 3) {
            return new VerifyApiKeyResult(false, null, null);
        }

        String keyId = parts[0] + "_" + parts[1] + "_" + parts[2].substring(0, 8);

        // Look up the key record
        Optional<ApiKeyRecord> optRecord = apiKeyRepository.findById(keyId);
        if (optRecord.isEmpty() || optRecord.get().revokedAt() != null) {
            return new VerifyApiKeyResult(false, null, null);
        }

        ApiKeyRecord keyRecord = optRecord.get();

        if (keyRecord.expiresAt() != null && keyRecord.expiresAt().isBefore(Instant.now())) {
            return new VerifyApiKeyResult(false, null, null);
        }

        // Constant-time comparison via bcrypt
        boolean isValid = passwordEncoder.matches(submittedKey, keyRecord.hash());

        if (isValid) {
            // Update last used timestamp (async, non-blocking)
            apiKeyRepository.updateLastUsedAsync(keyId, Instant.now());
        }

        return new VerifyApiKeyResult(
            isValid,
            isValid ? keyRecord.serviceId() : null,
            isValid ? keyRecord.permissions() : null
        );
    }
}

import os
import secrets
import bcrypt
from dataclasses import dataclass, field
from datetime import datetime, timezone
from typing import Optional
from asyncio import create_task

# ============================================================================
# API Key Generation
# ============================================================================

@dataclass
class ApiKey:
    id: str
    prefix: str
    environment: str
    service_id: str
    permissions: list[str]
    created_at: datetime
    last_used_at: Optional[datetime] = None
    expires_at: Optional[datetime] = None
    revoked_at: Optional[datetime] = None

@dataclass
class GenerateApiKeyResult:
    key_id: str
    full_key: str

@dataclass
class VerifyApiKeyResult:
    valid: bool
    service_id: Optional[str] = None
    permissions: Optional[list[str]] = None

async def generate_api_key(
    service_id: str,
    environment: str,
    permissions: list[str]
) -> GenerateApiKeyResult:
    # Generate cryptographically random secret (32 bytes = 64 hex chars)
    secret_hex = secrets.token_hex(32)

    # Build the key components
    prefix = "sk"
    key_id = f"{prefix}_{environment}_{secret_hex[:8]}"
    full_key = f"{prefix}_{environment}_{secret_hex}"

    # Hash the full key for storage (bcrypt — intentionally slow)
    # We store the hash, not the key itself
    key_hash = bcrypt.hashpw(full_key.encode(), bcrypt.gensalt(rounds=12)).decode()

    # Store in database
    await db.api_keys.insert({
        "id": key_id,
        "hash": key_hash,
        "service_id": service_id,
        "environment": environment,
        "permissions": permissions,
        "created_at": datetime.now(timezone.utc),
    })

    # Return full key to caller — shown only once
    return GenerateApiKeyResult(key_id=key_id, full_key=full_key)

# ============================================================================
# API Key Verification
# ============================================================================

async def verify_api_key(submitted_key: str) -> VerifyApiKeyResult:
    # Extract the key ID from the submitted key
    # Format: sk_live_a7f3b9c2... — key ID is first 3 parts
    parts = submitted_key.split("_")
    if len(parts) < 3:
        return VerifyApiKeyResult(valid=False)

    key_id = f"{parts[0]}_{parts[1]}_{parts[2][:8]}"

    # Look up the key record
    key_record = await db.api_keys.find_by_id(key_id)

    if not key_record or key_record.get("revoked_at"):
        return VerifyApiKeyResult(valid=False)

    if key_record.get("expires_at") and key_record["expires_at"] < datetime.now(timezone.utc):
        return VerifyApiKeyResult(valid=False)

    # Constant-time comparison via bcrypt
    is_valid = bcrypt.checkpw(submitted_key.encode(), key_record["hash"].encode())

    if is_valid:
        # Update last used timestamp (async, non-blocking)
        create_task(db.api_keys.update(key_id, {"last_used_at": datetime.now(timezone.utc)}))

    return VerifyApiKeyResult(
        valid=is_valid,
        service_id=key_record["service_id"] if is_valid else None,
        permissions=key_record["permissions"] if is_valid else None,
    )

using System.Security.Cryptography;
using Microsoft.AspNetCore.Cryptography.KeyDerivation;

// ============================================================================
// API Key Generation
// ============================================================================

public record ApiKey(
    string Id,
    string Prefix,
    string Environment,
    string ServiceId,
    List<string> Permissions,
    DateTime CreatedAt,
    DateTime? LastUsedAt,
    DateTime? ExpiresAt,
    DateTime? RevokedAt
);

public record GenerateApiKeyResult(string KeyId, string FullKey);
public record VerifyApiKeyResult(bool Valid, string? ServiceId, List<string>? Permissions);

public class ApiKeyService
{
    private readonly IApiKeyRepository _repository;

    public ApiKeyService(IApiKeyRepository repository)
    {
        _repository = repository;
    }

    public async Task<GenerateApiKeyResult> GenerateApiKeyAsync(
        string serviceId, string environment, List<string> permissions)
    {
        // Generate cryptographically random secret (32 bytes = 64 hex chars)
        var secretBytes = RandomNumberGenerator.GetBytes(32);
        var secretHex = Convert.ToHexString(secretBytes).ToLower();

        // Build the key components
        const string prefix = "sk";
        var keyId = $"{prefix}_{environment}_{secretHex[..8]}";
        var fullKey = $"{prefix}_{environment}_{secretHex}";

        // Hash the full key for storage (BCrypt — intentionally slow)
        var keyHash = BCrypt.Net.BCrypt.HashPassword(fullKey, workFactor: 12);

        // Store in database
        await _repository.InsertAsync(new ApiKeyRecord(
            keyId, keyHash, serviceId, environment, permissions, DateTime.UtcNow
        ));

        // Return full key to caller — shown only once
        return new GenerateApiKeyResult(keyId, fullKey);
    }

    // ============================================================================
    // API Key Verification
    // ============================================================================

    public async Task<VerifyApiKeyResult> VerifyApiKeyAsync(string submittedKey)
    {
        // Extract the key ID from the submitted key
        // Format: sk_live_a7f3b9c2... — key ID is first 3 parts
        var parts = submittedKey.Split('_');
        if (parts.Length < 3)
            return new VerifyApiKeyResult(false, null, null);

        var keyId = $"{parts[0]}_{parts[1]}_{parts[2][..8]}";

        // Look up the key record
        var keyRecord = await _repository.FindByIdAsync(keyId);
        if (keyRecord == null || keyRecord.RevokedAt.HasValue)
            return new VerifyApiKeyResult(false, null, null);

        if (keyRecord.ExpiresAt.HasValue && keyRecord.ExpiresAt.Value < DateTime.UtcNow)
            return new VerifyApiKeyResult(false, null, null);

        // Constant-time comparison via BCrypt
        var isValid = BCrypt.Net.BCrypt.Verify(submittedKey, keyRecord.Hash);

        if (isValid)
        {
            // Update last used timestamp (fire-and-forget)
            _ = _repository.UpdateLastUsedAsync(keyId, DateTime.UtcNow);
        }

        return new VerifyApiKeyResult(
            isValid,
            isValid ? keyRecord.ServiceId : null,
            isValid ? keyRecord.Permissions : null
        );
    }
}

import crypto from 'crypto';

// ============================================================================
// Canonical Request Builder
// ============================================================================

interface SigningInput {
  method: string;
  path: string;
  query: Record<string, string>;
  headers: Record<string, string>;
  body: string | Buffer;
  timestamp: string; // ISO 8601
  nonce: string;
}

function buildCanonicalRequest(input: SigningInput): string {
  // 1. Canonical method (uppercase)
  const canonicalMethod = input.method.toUpperCase();

  // 2. Canonical path (URL-encode, preserve slashes)
  const canonicalPath = encodeURIComponent(input.path)
    .replace(/%2F/gi, '/');

  // 3. Canonical query string (sorted by key, URL-encoded)
  const canonicalQuery = Object.keys(input.query)
    .sort()
    .map(k => `${encodeURIComponent(k)}=${encodeURIComponent(input.query[k])}`)
    .join('&');

  // 4. Canonical headers (lowercase keys, trimmed values, sorted)
  const headersToSign = ['content-type', 'host', 'x-timestamp', 'x-nonce'];
  const canonicalHeaders = headersToSign
    .filter(h => input.headers[h] !== undefined)
    .sort()
    .map(h => `${h}:${input.headers[h].trim()}`)
    .join('\n');

  const signedHeadersList = headersToSign
    .filter(h => input.headers[h] !== undefined)
    .sort()
    .join(';');

  // 5. Body hash (SHA-256 of request body)
  const bodyHash = crypto
    .createHash('sha256')
    .update(typeof input.body === 'string' ? input.body : input.body)
    .digest('hex');

  // Combine into canonical string
  return [
    canonicalMethod,
    canonicalPath,
    canonicalQuery,
    canonicalHeaders,
    '',
    signedHeadersList,
    bodyHash,
  ].join('\n');
}

// ============================================================================
// HMAC-SHA256 Signature
// ============================================================================

function signRequest(
  canonicalRequest: string,
  secretKey: string,
  timestamp: string,
  keyId: string
): string {
  // String to sign: algorithm + timestamp + hash of canonical request
  const canonicalHash = crypto
    .createHash('sha256')
    .update(canonicalRequest)
    .digest('hex');

  const stringToSign = [
    'HMAC-SHA256',
    timestamp,
    canonicalHash,
  ].join('\n');

  // Derive signing key: HMAC(HMAC("MyService" + date, secretKey), keyId)
  const date = timestamp.slice(0, 10).replace(/-/g, '');
  const dateKey = crypto
    .createHmac('sha256', `MyService${date}`)
    .update(secretKey)
    .digest();

  const signingKey = crypto
    .createHmac('sha256', dateKey)
    .update(keyId)
    .digest();

  // Final HMAC signature
  return crypto
    .createHmac('sha256', signingKey)
    .update(stringToSign)
    .digest('hex');
}

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.net.URLEncoder;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.util.*;
import java.util.stream.Collectors;

// ============================================================================
// Canonical Request Builder
// ============================================================================

public record SigningInput(
    String method,
    String path,
    Map<String, String> query,
    Map<String, String> headers,
    byte[] body,
    String timestamp, // ISO 8601
    String nonce
) {}

public class HmacSigner {

    public static String buildCanonicalRequest(SigningInput input) throws Exception {
        // 1. Canonical method (uppercase)
        String canonicalMethod = input.method().toUpperCase();

        // 2. Canonical path (URL-encode, preserve slashes)
        String canonicalPath = Arrays.stream(input.path().split("/"))
            .map(seg -> URLEncoder.encode(seg, StandardCharsets.UTF_8))
            .collect(Collectors.joining("/"));

        // 3. Canonical query string (sorted by key, URL-encoded)
        String canonicalQuery = input.query().entrySet().stream()
            .sorted(Map.Entry.comparingByKey())
            .map(e -> URLEncoder.encode(e.getKey(), StandardCharsets.UTF_8) + "="
                    + URLEncoder.encode(e.getValue(), StandardCharsets.UTF_8))
            .collect(Collectors.joining("&"));

        // 4. Canonical headers (lowercase keys, trimmed values, sorted)
        List<String> headersToSign = List.of("content-type", "host", "x-timestamp", "x-nonce");
        String canonicalHeaders = headersToSign.stream()
            .filter(h -> input.headers().containsKey(h))
            .sorted()
            .map(h -> h + ":" + input.headers().get(h).trim())
            .collect(Collectors.joining("\n"));

        String signedHeadersList = headersToSign.stream()
            .filter(h -> input.headers().containsKey(h))
            .sorted()
            .collect(Collectors.joining(";"));

        // 5. Body hash (SHA-256 of request body)
        MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
        byte[] bodyHashBytes = sha256.digest(input.body());
        String bodyHash = HexFormat.of().formatHex(bodyHashBytes);

        // Combine into canonical string
        return String.join("\n",
            canonicalMethod, canonicalPath, canonicalQuery,
            canonicalHeaders, "", signedHeadersList, bodyHash
        );
    }

    // ============================================================================
    // HMAC-SHA256 Signature
    // ============================================================================

    public static String signRequest(
            String canonicalRequest, String secretKey,
            String timestamp, String keyId) throws Exception {
        // String to sign: algorithm + timestamp + hash of canonical request
        MessageDigest sha256 = MessageDigest.getInstance("SHA-256");
        String canonicalHash = HexFormat.of()
            .formatHex(sha256.digest(canonicalRequest.getBytes(StandardCharsets.UTF_8)));

        String stringToSign = String.join("\n", "HMAC-SHA256", timestamp, canonicalHash);

        // Derive signing key: HMAC(HMAC("MyService" + date, secretKey), keyId)
        String date = timestamp.substring(0, 10).replace("-", "");
        byte[] dateKey = hmacSha256(secretKey.getBytes(StandardCharsets.UTF_8),
            ("MyService" + date).getBytes(StandardCharsets.UTF_8));
        byte[] signingKey = hmacSha256(keyId.getBytes(StandardCharsets.UTF_8), dateKey);

        // Final HMAC signature
        byte[] sigBytes = hmacSha256(
            stringToSign.getBytes(StandardCharsets.UTF_8), signingKey);
        return HexFormat.of().formatHex(sigBytes);
    }

    private static byte[] hmacSha256(byte[] data, byte[] key) throws Exception {
        Mac mac = Mac.getInstance("HmacSHA256");
        mac.init(new SecretKeySpec(key, "HmacSHA256"));
        return mac.doFinal(data);
    }
}

import hashlib
import hmac
import urllib.parse
from dataclasses import dataclass

# ============================================================================
# Canonical Request Builder
# ============================================================================

@dataclass
class SigningInput:
    method: str
    path: str
    query: dict[str, str]
    headers: dict[str, str]
    body: bytes | str
    timestamp: str  # ISO 8601
    nonce: str

def build_canonical_request(input: SigningInput) -> str:
    # 1. Canonical method (uppercase)
    canonical_method = input.method.upper()

    # 2. Canonical path (URL-encode, preserve slashes)
    canonical_path = "/".join(
        urllib.parse.quote(seg, safe="") for seg in input.path.split("/")
    )

    # 3. Canonical query string (sorted by key, URL-encoded)
    canonical_query = "&".join(
        f"{urllib.parse.quote(k, safe='')}={urllib.parse.quote(v, safe='')}"
        for k, v in sorted(input.query.items())
    )

    # 4. Canonical headers (lowercase keys, trimmed values, sorted)
    headers_to_sign = ["content-type", "host", "x-timestamp", "x-nonce"]
    present = sorted(h for h in headers_to_sign if h in input.headers)
    canonical_headers = "\n".join(f"{h}:{input.headers[h].strip()}" for h in present)
    signed_headers_list = ";".join(present)

    # 5. Body hash (SHA-256 of request body)
    body_bytes = input.body.encode() if isinstance(input.body, str) else input.body
    body_hash = hashlib.sha256(body_bytes).hexdigest()

    # Combine into canonical string
    return "\n".join([
        canonical_method,
        canonical_path,
        canonical_query,
        canonical_headers,
        "",
        signed_headers_list,
        body_hash,
    ])

# ============================================================================
# HMAC-SHA256 Signature
# ============================================================================

def sign_request(
    canonical_request: str,
    secret_key: str,
    timestamp: str,
    key_id: str,
) -> str:
    # String to sign: algorithm + timestamp + hash of canonical request
    canonical_hash = hashlib.sha256(canonical_request.encode()).hexdigest()
    string_to_sign = "\n".join(["HMAC-SHA256", timestamp, canonical_hash])

    # Derive signing key: HMAC(HMAC("MyService" + date, secretKey), keyId)
    date = timestamp[:10].replace("-", "")
    date_key = hmac.new(
        secret_key.encode(), f"MyService{date}".encode(), hashlib.sha256
    ).digest()
    signing_key = hmac.new(date_key, key_id.encode(), hashlib.sha256).digest()

    # Final HMAC signature
    return hmac.new(signing_key, string_to_sign.encode(), hashlib.sha256).hexdigest()

using System.Security.Cryptography;
using System.Text;
using System.Web;

// ============================================================================
// Canonical Request Builder
// ============================================================================

public record SigningInput(
    string Method,
    string Path,
    Dictionary<string, string> Query,
    Dictionary<string, string> Headers,
    byte[] Body,
    string Timestamp, // ISO 8601
    string Nonce
);

public static class HmacSigner
{
    public static string BuildCanonicalRequest(SigningInput input)
    {
        // 1. Canonical method (uppercase)
        var canonicalMethod = input.Method.ToUpper();

        // 2. Canonical path (URL-encode, preserve slashes)
        var canonicalPath = string.Join("/",
            input.Path.Split('/').Select(seg => Uri.EscapeDataString(seg)));

        // 3. Canonical query string (sorted by key, URL-encoded)
        var canonicalQuery = string.Join("&",
            input.Query
                .OrderBy(kv => kv.Key)
                .Select(kv => $"{Uri.EscapeDataString(kv.Key)}={Uri.EscapeDataString(kv.Value)}"));

        // 4. Canonical headers (lowercase keys, trimmed values, sorted)
        var headersToSign = new[] { "content-type", "host", "x-timestamp", "x-nonce" };
        var present = headersToSign
            .Where(h => input.Headers.ContainsKey(h))
            .OrderBy(h => h)
            .ToList();

        var canonicalHeaders = string.Join("\n",
            present.Select(h => $"{h}:{input.Headers[h].Trim()}"));
        var signedHeadersList = string.Join(";", present);

        // 5. Body hash (SHA-256 of request body)
        var bodyHash = Convert.ToHexString(SHA256.HashData(input.Body)).ToLower();

        // Combine into canonical string
        return string.Join("\n",
            canonicalMethod, canonicalPath, canonicalQuery,
            canonicalHeaders, "", signedHeadersList, bodyHash);
    }

    // ============================================================================
    // HMAC-SHA256 Signature
    // ============================================================================

    public static string SignRequest(
        string canonicalRequest, string secretKey,
        string timestamp, string keyId)
    {
        // String to sign: algorithm + timestamp + hash of canonical request
        var canonicalHash = Convert.ToHexString(
            SHA256.HashData(Encoding.UTF8.GetBytes(canonicalRequest))).ToLower();

        var stringToSign = string.Join("\n", "HMAC-SHA256", timestamp, canonicalHash);

        // Derive signing key: HMAC(HMAC("MyService" + date, secretKey), keyId)
        var date = timestamp[..10].Replace("-", "");
        var dateKey = HmacSha256(
            Encoding.UTF8.GetBytes(secretKey),
            Encoding.UTF8.GetBytes($"MyService{date}"));
        var signingKey = HmacSha256(dateKey, Encoding.UTF8.GetBytes(keyId));

        // Final HMAC signature
        var sig = HmacSha256(signingKey, Encoding.UTF8.GetBytes(stringToSign));
        return Convert.ToHexString(sig).ToLower();
    }

    private static byte[] HmacSha256(byte[] key, byte[] data)
    {
        using var mac = new HMACSHA256(key);
        return mac.ComputeHash(data);
    }
}

import https from 'https';
import { URL } from 'url';
import crypto from 'crypto';

// ============================================================================
// HMAC Request Client
// ============================================================================

interface HmacClientConfig {
  keyId: string;
  secretKey: string;
  baseUrl: string;
  serviceName: string;
}

class HmacHttpClient {
  private config: HmacClientConfig;

  constructor(config: HmacClientConfig) {
    this.config = config;
  }

  private buildSignedHeaders(
    method: string,
    url: URL,
    body: string
  ): Record<string, string> {
    const timestamp = new Date().toISOString();
    const nonce = crypto.randomBytes(16).toString('hex');

    const query: Record<string, string> = {};
    url.searchParams.forEach((v, k) => { query[k] = v; });

    const headers: Record<string, string> = {
      'content-type': 'application/json',
      'host': url.host,
      'x-timestamp': timestamp,
      'x-nonce': nonce,
      'x-key-id': this.config.keyId,
    };

    const canonical = buildCanonicalRequest({
      method,
      path: url.pathname,
      query,
      headers,
      body,
      timestamp,
      nonce,
    });

    const signature = signRequest(
      canonical,
      this.config.secretKey,
      timestamp,
      this.config.keyId
    );

    headers['x-signature'] = signature;
    headers['x-signed-headers'] = 'content-type;host;x-timestamp;x-nonce';

    return headers;
  }

  async post<T>(path: string, body: unknown): Promise<T> {
    const url = new URL(path, this.config.baseUrl);
    const payload = JSON.stringify(body);
    const headers = this.buildSignedHeaders('POST', url, payload);

    headers['content-length'] = Buffer.byteLength(payload).toString();

    return new Promise((resolve, reject) => {
      const req = https.request(
        {
          hostname: url.hostname,
          port: url.port || 443,
          path: url.pathname + url.search,
          method: 'POST',
          headers,
          timeout: 5000,
        },
        (res) => {
          let data = '';
          res.on('data', (chunk) => { data += chunk; });
          res.on('end', () => {
            if (res.statusCode && res.statusCode >= 400) {
              reject(new Error(`HTTP ${res.statusCode}: ${data}`));
            } else {
              resolve(JSON.parse(data) as T);
            }
          });
        }
      );

      req.on('error', reject);
      req.on('timeout', () => { req.destroy(); reject(new Error('Timeout')); });
      req.write(payload);
      req.end();
    });
  }
}

// Usage
const client = new HmacHttpClient({
  keyId: 'sk_live_a7f3b9c2',
  secretKey: process.env.SERVICE_API_SECRET!,
  baseUrl: 'https://payment-service.internal',
  serviceName: 'order-service',
});

import org.springframework.http.*;
import org.springframework.stereotype.Component;
import org.springframework.web.client.RestClient;
import java.net.URI;
import java.security.SecureRandom;
import java.time.Instant;
import java.util.HexFormat;
import java.util.Map;
import java.util.TreeMap;

// ============================================================================
// HMAC Request Client
// ============================================================================

public record HmacClientConfig(
    String keyId,
    String secretKey,
    String baseUrl,
    String serviceName
) {}

@Component
public class HmacHttpClient {
    private final HmacClientConfig config;
    private final RestClient restClient;
    private final SecureRandom secureRandom = new SecureRandom();

    public HmacHttpClient(HmacClientConfig config) {
        this.config = config;
        this.restClient = RestClient.builder()
            .baseUrl(config.baseUrl())
            .build();
    }

    private HttpHeaders buildSignedHeaders(
            String method, URI uri, String body) throws Exception {
        String timestamp = Instant.now().toString();
        byte[] nonceBytes = new byte[16];
        secureRandom.nextBytes(nonceBytes);
        String nonce = HexFormat.of().formatHex(nonceBytes);

        Map<String, String> query = new TreeMap<>();
        uri.getQuery() != null
            ? Arrays.stream(uri.getQuery().split("&"))
                .forEach(p -> { var kv = p.split("=", 2); query.put(kv[0], kv[1]); })
            : null;

        Map<String, String> headers = new TreeMap<>();
        headers.put("content-type", "application/json");
        headers.put("host", uri.getHost());
        headers.put("x-timestamp", timestamp);
        headers.put("x-nonce", nonce);

        var signingInput = new SigningInput(
            method, uri.getPath(), query, headers,
            body.getBytes(), timestamp, nonce
        );

        String canonical = HmacSigner.buildCanonicalRequest(signingInput);
        String signature = HmacSigner.signRequest(
            canonical, config.secretKey(), timestamp, config.keyId());

        HttpHeaders httpHeaders = new HttpHeaders();
        headers.forEach(httpHeaders::set);
        httpHeaders.set("x-key-id", config.keyId());
        httpHeaders.set("x-signature", signature);
        httpHeaders.set("x-signed-headers", "content-type;host;x-timestamp;x-nonce");
        return httpHeaders;
    }

    public <T> T post(String path, Object body, Class<T> responseType) throws Exception {
        URI uri = URI.create(config.baseUrl() + path);
        String payload = new ObjectMapper().writeValueAsString(body);
        HttpHeaders headers = buildSignedHeaders("POST", uri, payload);

        return restClient.post()
            .uri(uri)
            .headers(h -> h.addAll(headers))
            .body(payload)
            .retrieve()
            .body(responseType);
    }
}

// Usage
HmacHttpClient client = new HmacHttpClient(new HmacClientConfig(
    "sk_live_a7f3b9c2",
    System.getenv("SERVICE_API_SECRET"),
    "https://payment-service.internal",
    "order-service"
));

import aiohttp
import secrets
import json
from datetime import datetime, timezone
from urllib.parse import urlparse, parse_qs

# ============================================================================
# HMAC Request Client
# ============================================================================

from dataclasses import dataclass

@dataclass
class HmacClientConfig:
    key_id: str
    secret_key: str
    base_url: str
    service_name: str

class HmacHttpClient:
    def __init__(self, config: HmacClientConfig):
        self.config = config

    def _build_signed_headers(
        self, method: str, url: str, body: str
    ) -> dict[str, str]:
        parsed = urlparse(url)
        timestamp = datetime.now(timezone.utc).isoformat()
        nonce = secrets.token_hex(16)

        query: dict[str, str] = {}
        if parsed.query:
            for k, v in parse_qs(parsed.query).items():
                query[k] = v[0]

        headers = {
            "content-type": "application/json",
            "host": parsed.netloc,
            "x-timestamp": timestamp,
            "x-nonce": nonce,
            "x-key-id": self.config.key_id,
        }

        signing_input = SigningInput(
            method=method,
            path=parsed.path,
            query=query,
            headers=headers,
            body=body.encode(),
            timestamp=timestamp,
            nonce=nonce,
        )

        canonical = build_canonical_request(signing_input)
        signature = sign_request(
            canonical, self.config.secret_key, timestamp, self.config.key_id
        )

        headers["x-signature"] = signature
        headers["x-signed-headers"] = "content-type;host;x-timestamp;x-nonce"
        return headers

    async def post(self, path: str, body: object) -> dict:
        url = self.config.base_url.rstrip("/") + path
        payload = json.dumps(body)
        headers = self._build_signed_headers("POST", url, payload)
        headers["content-length"] = str(len(payload.encode()))

        async with aiohttp.ClientSession() as session:
            async with session.post(
                url, data=payload, headers=headers, timeout=aiohttp.ClientTimeout(total=5)
            ) as resp:
                resp.raise_for_status()
                return await resp.json()

# Usage
client = HmacHttpClient(HmacClientConfig(
    key_id="sk_live_a7f3b9c2",
    secret_key=os.environ["SERVICE_API_SECRET"],
    base_url="https://payment-service.internal",
    service_name="order-service",
))

using System.Net.Http.Json;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

// ============================================================================
// HMAC Request Client
// ============================================================================

public record HmacClientConfig(
    string KeyId,
    string SecretKey,
    string BaseUrl,
    string ServiceName
);

public class HmacHttpClient
{
    private readonly HmacClientConfig _config;
    private readonly HttpClient _httpClient;

    public HmacHttpClient(HmacClientConfig config, HttpClient httpClient)
    {
        _config = config;
        _httpClient = httpClient;
        _httpClient.BaseAddress = new Uri(config.BaseUrl);
    }

    private Dictionary<string, string> BuildSignedHeaders(
        string method, Uri uri, string body)
    {
        var timestamp = DateTime.UtcNow.ToString("o");
        var nonce = Convert.ToHexString(RandomNumberGenerator.GetBytes(16)).ToLower();

        var query = new Dictionary<string, string>();
        if (!string.IsNullOrEmpty(uri.Query))
        {
            foreach (var part in uri.Query.TrimStart('?').Split('&'))
            {
                var kv = part.Split('=', 2);
                if (kv.Length == 2) query[kv[0]] = kv[1];
            }
        }

        var headers = new Dictionary<string, string>
        {
            ["content-type"] = "application/json",
            ["host"] = uri.Host,
            ["x-timestamp"] = timestamp,
            ["x-nonce"] = nonce,
            ["x-key-id"] = _config.KeyId,
        };

        var signingInput = new SigningInput(
            method, uri.AbsolutePath, query, headers,
            Encoding.UTF8.GetBytes(body), timestamp, nonce);

        var canonical = HmacSigner.BuildCanonicalRequest(signingInput);
        var signature = HmacSigner.SignRequest(
            canonical, _config.SecretKey, timestamp, _config.KeyId);

        headers["x-signature"] = signature;
        headers["x-signed-headers"] = "content-type;host;x-timestamp;x-nonce";
        return headers;
    }

    public async Task<T?> PostAsync<T>(string path, object body)
    {
        var uri = new Uri(_config.BaseUrl.TrimEnd('/') + path);
        var payload = JsonSerializer.Serialize(body);
        var signedHeaders = BuildSignedHeaders("POST", uri, payload);

        var request = new HttpRequestMessage(HttpMethod.Post, uri)
        {
            Content = new StringContent(payload, Encoding.UTF8, "application/json")
        };
        foreach (var (key, value) in signedHeaders)
            request.Headers.TryAddWithoutValidation(key, value);

        var response = await _httpClient.SendAsync(request);
        response.EnsureSuccessStatusCode();
        return await response.Content.ReadFromJsonAsync<T>();
    }
}

// Usage
var client = new HmacHttpClient(
    new HmacClientConfig(
        KeyId: "sk_live_a7f3b9c2",
        SecretKey: Environment.GetEnvironmentVariable("SERVICE_API_SECRET")!,
        BaseUrl: "https://payment-service.internal",
        ServiceName: "order-service"
    ),
    new HttpClient()
);

import express from 'express';

// ============================================================================
// HMAC Verification Middleware
// ============================================================================

const TIMESTAMP_TOLERANCE_SECONDS = 300; // 5 minutes

async function hmacAuthMiddleware(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
): Promise<void> {
  try {
    // 1. Extract signature headers
    const keyId = req.headers['x-key-id'] as string;
    const signature = req.headers['x-signature'] as string;
    const timestamp = req.headers['x-timestamp'] as string;
    const nonce = req.headers['x-nonce'] as string;

    if (!keyId || !signature || !timestamp || !nonce) {
      res.status(401).json({ error: 'Missing authentication headers' });
      return;
    }

    // 2. Verify timestamp to prevent replay attacks
    const requestTime = new Date(timestamp).getTime();
    const now = Date.now();

    if (isNaN(requestTime)) {
      res.status(401).json({ error: 'Invalid timestamp format' });
      return;
    }

    const diffSeconds = Math.abs(now - requestTime) / 1000;
    if (diffSeconds > TIMESTAMP_TOLERANCE_SECONDS) {
      res.status(401).json({
        error: 'Request timestamp too old or too far in future',
        tolerance: `±${TIMESTAMP_TOLERANCE_SECONDS}s`,
      });
      return;
    }

    // 3. Check nonce to prevent replay within the tolerance window
    const nonceKey = `hmac:nonce:${nonce}`;
    const nonceExists = await redis.get(nonceKey);
    if (nonceExists) {
      res.status(401).json({ error: 'Duplicate nonce — possible replay attack' });
      return;
    }

    // Store nonce with TTL slightly longer than replay window
    await redis.setEx(nonceKey, TIMESTAMP_TOLERANCE_SECONDS * 2, '1');

    // 4. Look up the secret key
    const keyRecord = await db.apiKeys.findById(keyId);
    if (!keyRecord || keyRecord.revokedAt) {
      res.status(401).json({ error: 'Invalid key ID' });
      return;
    }

    // 5. Reconstruct the canonical request from the incoming request
    const query: Record<string, string> = {};
    for (const [k, v] of Object.entries(req.query)) {
      if (typeof v === 'string') query[k] = v;
    }

    const canonical = buildCanonicalRequest({
      method: req.method,
      path: req.path,
      query,
      headers: {
        'content-type': req.headers['content-type'] || '',
        'host': req.headers['host'] || '',
        'x-timestamp': timestamp,
        'x-nonce': nonce,
      },
      body: (req as any).rawBody || '',
      timestamp,
      nonce,
    });

    // 6. Recompute signature
    const expectedSignature = signRequest(
      canonical,
      keyRecord.secretKey,
      timestamp,
      keyId
    );

    // 7. Constant-time comparison to prevent timing attacks
    const sigBuffer = Buffer.from(signature, 'hex');
    const expectedBuffer = Buffer.from(expectedSignature, 'hex');

    if (
      sigBuffer.length !== expectedBuffer.length ||
      !crypto.timingSafeEqual(sigBuffer, expectedBuffer)
    ) {
      console.warn('HMAC: Signature mismatch', { keyId, path: req.path });
      res.status(401).json({ error: 'Invalid signature' });
      return;
    }

    // 8. Attach service identity
    (req as any).serviceId = keyRecord.serviceId;
    (req as any).servicePermissions = keyRecord.permissions;

    next();
  } catch (error) {
    console.error('HMAC middleware error', error);
    res.status(500).json({ error: 'Authentication error' });
  }
}

// ============================================================================
// Raw Body Capture (needed for body hash verification)
// ============================================================================

function captureRawBody(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
): void {
  let data = '';
  req.on('data', (chunk) => { data += chunk; });
  req.on('end', () => {
    (req as any).rawBody = data;
    next();
  });
}

// Apply raw body capture BEFORE json parser
app.use(captureRawBody);
app.use(express.json({ verify: (req: any, res, buf) => { req.rawBody = buf; } }));

import jakarta.servlet.*;
import jakarta.servlet.http.*;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.time.Instant;
import java.time.Duration;
import java.util.Map;
import java.util.TreeMap;

// ============================================================================
// HMAC Verification Filter
// ============================================================================

@Component
public class HmacAuthFilter extends OncePerRequestFilter {
    private static final int TIMESTAMP_TOLERANCE_SECONDS = 300;

    private final ApiKeyRepository apiKeyRepository;
    private final StringRedisTemplate redisTemplate;

    public HmacAuthFilter(ApiKeyRepository repo, StringRedisTemplate redis) {
        this.apiKeyRepository = repo;
        this.redisTemplate = redis;
    }

    @Override
    protected void doFilterInternal(
            HttpServletRequest request, HttpServletResponse response,
            FilterChain chain) throws ServletException, IOException {
        // Cache request body for repeated reading
        CachedBodyHttpServletRequest cachedRequest =
            new CachedBodyHttpServletRequest(request);

        try {
            // 1. Extract signature headers
            String keyId = request.getHeader("x-key-id");
            String signature = request.getHeader("x-signature");
            String timestamp = request.getHeader("x-timestamp");
            String nonce = request.getHeader("x-nonce");

            if (keyId == null || signature == null || timestamp == null || nonce == null) {
                sendError(response, 401, "Missing authentication headers");
                return;
            }

            // 2. Verify timestamp to prevent replay attacks
            Instant requestTime = Instant.parse(timestamp);
            long diffSeconds = Math.abs(
                Instant.now().getEpochSecond() - requestTime.getEpochSecond());
            if (diffSeconds > TIMESTAMP_TOLERANCE_SECONDS) {
                sendError(response, 401, "Request timestamp too old or too far in future");
                return;
            }

            // 3. Check nonce to prevent replay within the tolerance window
            String nonceKey = "hmac:nonce:" + nonce;
            Boolean nonceExists = redisTemplate.hasKey(nonceKey);
            if (Boolean.TRUE.equals(nonceExists)) {
                sendError(response, 401, "Duplicate nonce — possible replay attack");
                return;
            }
            redisTemplate.opsForValue().set(nonceKey, "1",
                Duration.ofSeconds(TIMESTAMP_TOLERANCE_SECONDS * 2L));

            // 4. Look up the secret key
            var keyRecord = apiKeyRepository.findById(keyId).orElse(null);
            if (keyRecord == null || keyRecord.revokedAt() != null) {
                sendError(response, 401, "Invalid key ID");
                return;
            }

            // 5. Reconstruct the canonical request
            byte[] rawBody = cachedRequest.getBody();
            Map<String, String> query = new TreeMap<>();
            request.getParameterMap().forEach((k, v) -> query.put(k, v[0]));

            Map<String, String> headers = new TreeMap<>();
            headers.put("content-type",
                request.getHeader("content-type") != null ? request.getHeader("content-type") : "");
            headers.put("host",
                request.getHeader("host") != null ? request.getHeader("host") : "");
            headers.put("x-timestamp", timestamp);
            headers.put("x-nonce", nonce);

            var signingInput = new SigningInput(
                request.getMethod(), request.getRequestURI(),
                query, headers, rawBody, timestamp, nonce);
            String canonical = HmacSigner.buildCanonicalRequest(signingInput);

            // 6. Recompute signature
            String expectedSignature = HmacSigner.signRequest(
                canonical, keyRecord.secretKey(), timestamp, keyId);

            // 7. Constant-time comparison
            byte[] sigBytes = HexFormat.of().parseHex(signature);
            byte[] expectedBytes = HexFormat.of().parseHex(expectedSignature);
            if (!MessageDigest.isEqual(sigBytes, expectedBytes)) {
                sendError(response, 401, "Invalid signature");
                return;
            }

            // 8. Attach service identity
            cachedRequest.setAttribute("serviceId", keyRecord.serviceId());
            cachedRequest.setAttribute("servicePermissions", keyRecord.permissions());
            chain.doFilter(cachedRequest, response);

        } catch (Exception e) {
            sendError(response, 500, "Authentication error");
        }
    }

    private void sendError(HttpServletResponse resp, int status, String msg)
            throws IOException {
        resp.setStatus(status);
        resp.setContentType("application/json");
        resp.getWriter().write("{\"error\":\"" + msg + "\"}");
    }
}

import hashlib
import hmac as hmac_lib
import json
from datetime import datetime, timezone
from functools import wraps
from fastapi import Request, HTTPException
from fastapi.responses import JSONResponse

# ============================================================================
# HMAC Verification Middleware (FastAPI)
# ============================================================================

TIMESTAMP_TOLERANCE_SECONDS = 300  # 5 minutes

async def hmac_auth_middleware(request: Request, call_next):
    # 1. Extract signature headers
    key_id = request.headers.get("x-key-id")
    signature = request.headers.get("x-signature")
    timestamp = request.headers.get("x-timestamp")
    nonce = request.headers.get("x-nonce")

    if not all([key_id, signature, timestamp, nonce]):
        return JSONResponse({"error": "Missing authentication headers"}, status_code=401)

    # 2. Verify timestamp to prevent replay attacks
    try:
        request_time = datetime.fromisoformat(timestamp)
    except ValueError:
        return JSONResponse({"error": "Invalid timestamp format"}, status_code=401)

    diff_seconds = abs(
        (datetime.now(timezone.utc) - request_time).total_seconds()
    )
    if diff_seconds > TIMESTAMP_TOLERANCE_SECONDS:
        return JSONResponse(
            {"error": "Request timestamp too old or too far in future"}, status_code=401
        )

    # 3. Check nonce to prevent replay
    nonce_key = f"hmac:nonce:{nonce}"
    if await redis.get(nonce_key):
        return JSONResponse(
            {"error": "Duplicate nonce — possible replay attack"}, status_code=401
        )
    await redis.setex(nonce_key, TIMESTAMP_TOLERANCE_SECONDS * 2, "1")

    # 4. Look up the secret key
    key_record = await db.api_keys.find_by_id(key_id)
    if not key_record or key_record.get("revoked_at"):
        return JSONResponse({"error": "Invalid key ID"}, status_code=401)

    # 5. Reconstruct the canonical request
    raw_body = await request.body()
    query = dict(request.query_params)

    signing_input = SigningInput(
        method=request.method,
        path=request.url.path,
        query=query,
        headers={
            "content-type": request.headers.get("content-type", ""),
            "host": request.headers.get("host", ""),
            "x-timestamp": timestamp,
            "x-nonce": nonce,
        },
        body=raw_body,
        timestamp=timestamp,
        nonce=nonce,
    )
    canonical = build_canonical_request(signing_input)

    # 6. Recompute signature
    expected_signature = sign_request(
        canonical, key_record["secret_key"], timestamp, key_id
    )

    # 7. Constant-time comparison
    if not hmac_lib.compare_digest(signature, expected_signature):
        return JSONResponse({"error": "Invalid signature"}, status_code=401)

    # 8. Attach service identity
    request.state.service_id = key_record["service_id"]
    request.state.service_permissions = key_record["permissions"]

    return await call_next(request)

# Register in FastAPI app
# app.middleware("http")(hmac_auth_middleware)