@vorionsys/platform-core 0.1.0

package/dist/security/crypto/shamir/types.d.ts

@@ -0,0 +1,281 @@
+/**
+ * Shamir Secret Sharing - Type Definitions
+ *
+ * Provides strong type definitions for verified Shamir Secret Sharing implementation.
+ * All types are designed to enforce mathematical constraints at the type level.
+ *
+ * @module security/crypto/shamir/types
+ */
+/**
+ * A share index in the range [1, 255].
+ * Index 0 is reserved as it represents the secret itself (f(0) = secret).
+ *
+ * Mathematical constraint: x in GF(2^8) \ {0}
+ */
+export type ShareIndex = number & {
+    readonly __brand: 'ShareIndex';
+};
+/**
+ * A field element in GF(2^8), represented as a byte [0, 255].
+ */
+export type GF256Element = number & {
+    readonly __brand: 'GF256Element';
+};
+/**
+ * Verified share with integrity protection.
+ *
+ * @remarks
+ * Each share contains:
+ * - index: The x-coordinate in polynomial evaluation (1-255)
+ * - value: The y-coordinates for each byte of the secret
+ * - checksum: SHA-256 of (index || value) for integrity verification
+ *
+ * The checksum provides:
+ * - Detection of accidental corruption
+ * - Binding between index and value (prevents index substitution attacks)
+ */
+export interface VerifiedShare {
+    /** Share index (x-coordinate), always in range [1, 255] */
+    readonly index: ShareIndex;
+    /** Share value (y-coordinates), one byte per secret byte */
+    readonly value: Uint8Array;
+    /** SHA-256 checksum of (index || value) for integrity verification */
+    readonly checksum: Uint8Array;
+    /** ISO timestamp of share creation */
+    readonly createdAt: string;
+    /** Optional metadata for share management */
+    readonly metadata?: ShareMetadata;
+}
+/**
+ * Optional metadata attached to a share.
+ */
+export interface ShareMetadata {
+    /** Human-readable label for the share */
+    readonly label?: string;
+    /** Custodian identifier */
+    readonly custodianId?: string;
+    /** Key ceremony identifier */
+    readonly ceremonyId?: string;
+    /** Additional custom metadata */
+    readonly custom?: Record<string, unknown>;
+}
+/**
+ * Parameters for Shamir Secret Sharing scheme.
+ *
+ * @remarks
+ * Constraints:
+ * - 1 <= threshold <= totalShares <= 255
+ * - threshold = 1 provides no security (any single share reveals the secret)
+ * - threshold = totalShares requires all shares (no redundancy)
+ *
+ * Security recommendation: threshold >= 2 for any meaningful security
+ */
+export interface ShamirParams {
+    /**
+     * Minimum shares required for reconstruction (k).
+     * Also known as the "threshold" or "quorum".
+     * Must be in range [1, 255].
+     */
+    readonly threshold: number;
+    /**
+     * Total number of shares to generate (n).
+     * Must be in range [threshold, 255].
+     */
+    readonly totalShares: number;
+    /**
+     * Length of the secret in bytes.
+     * Each byte is shared independently using GF(2^8).
+     */
+    readonly secretLength: number;
+}
+/**
+ * Result of share validation.
+ */
+export interface ShareValidationResult {
+    /** Whether the share is valid */
+    readonly valid: boolean;
+    /** Error message if invalid */
+    readonly error?: string;
+    /** Warnings that don't invalidate the share */
+    readonly warnings?: string[];
+}
+/**
+ * Result of secret reconstruction.
+ */
+export interface ReconstructionResult {
+    /** The reconstructed secret */
+    readonly secret: Uint8Array;
+    /** Share indices used in reconstruction */
+    readonly usedShares: ShareIndex[];
+    /** Time taken for reconstruction in milliseconds */
+    readonly reconstructionTimeMs: number;
+    /** Whether constant-time operations were used */
+    readonly constantTime: boolean;
+}
+/**
+ * Split operation result with additional metadata.
+ */
+export interface SplitResult {
+    /** Generated shares */
+    readonly shares: VerifiedShare[];
+    /** Parameters used for splitting */
+    readonly params: ShamirParams;
+    /** Time taken for splitting in milliseconds */
+    readonly splitTimeMs: number;
+    /** Random bytes consumed (for entropy tracking) */
+    readonly randomBytesConsumed: number;
+}
+/**
+ * Configuration for the Shamir implementation.
+ */
+export interface ShamirConfig {
+    /**
+     * Use constant-time operations to prevent timing attacks.
+     * Default: true
+     */
+    readonly constantTime?: boolean;
+    /**
+     * Verify share checksums during reconstruction.
+     * Default: true
+     */
+    readonly verifyChecksums?: boolean;
+    /**
+     * Custom random number generator for testing.
+     * Default: crypto.getRandomValues
+     */
+    readonly rng?: (bytes: Uint8Array) => Uint8Array;
+    /**
+     * Enable detailed logging for debugging.
+     * Default: false
+     * WARNING: May leak sensitive timing information
+     */
+    readonly debug?: boolean;
+}
+/**
+ * GF(2^8) field operations interface.
+ * All operations are over the Galois Field with 256 elements.
+ */
+export interface GF256Operations {
+    /** Addition in GF(2^8) (XOR) */
+    add(a: GF256Element, b: GF256Element): GF256Element;
+    /** Subtraction in GF(2^8) (same as addition due to characteristic 2) */
+    sub(a: GF256Element, b: GF256Element): GF256Element;
+    /** Multiplication in GF(2^8) */
+    mul(a: GF256Element, b: GF256Element): GF256Element;
+    /** Division in GF(2^8) */
+    div(a: GF256Element, b: GF256Element): GF256Element;
+    /** Multiplicative inverse in GF(2^8) */
+    inv(a: GF256Element): GF256Element;
+    /** Exponentiation in GF(2^8) */
+    pow(base: GF256Element, exp: number): GF256Element;
+}
+/**
+ * Polynomial over GF(2^8).
+ */
+export interface GF256Polynomial {
+    /** Coefficients from constant term to highest degree */
+    readonly coefficients: readonly GF256Element[];
+    /** Degree of the polynomial */
+    readonly degree: number;
+    /** Evaluate polynomial at point x */
+    evaluate(x: GF256Element): GF256Element;
+}
+/**
+ * Test vector for verification.
+ */
+export interface TestVector {
+    /** Test vector identifier */
+    readonly id: string;
+    /** Description of the test */
+    readonly description: string;
+    /** Source of the test vector (e.g., "NIST", "academic paper") */
+    readonly source?: string;
+    /** Input secret */
+    readonly secret: Uint8Array;
+    /** Shamir parameters */
+    readonly params: ShamirParams;
+    /** Expected shares (for deterministic testing) */
+    readonly expectedShares?: Array<{
+        index: number;
+        value: Uint8Array;
+    }>;
+    /** Shares to use for reconstruction test */
+    readonly reconstructionShares?: number[];
+}
+/**
+ * Security analysis result.
+ */
+export interface SecurityAnalysisResult {
+    /** Overall security assessment */
+    readonly secure: boolean;
+    /** Individual checks performed */
+    readonly checks: SecurityCheck[];
+    /** Recommendations for improvement */
+    readonly recommendations?: string[];
+    /** Estimated security level in bits */
+    readonly securityBits?: number;
+}
+/**
+ * Individual security check result.
+ */
+export interface SecurityCheck {
+    /** Name of the check */
+    readonly name: string;
+    /** Whether the check passed */
+    readonly passed: boolean;
+    /** Details about the check result */
+    readonly details: string;
+    /** Severity if failed */
+    readonly severity?: 'low' | 'medium' | 'high' | 'critical';
+}
+/**
+ * Entropy analysis result.
+ */
+export interface EntropyAnalysis {
+    /** Shannon entropy in bits per byte */
+    readonly shannonEntropy: number;
+    /** Min-entropy (conservative estimate) */
+    readonly minEntropy: number;
+    /** Whether entropy is sufficient for cryptographic use */
+    readonly sufficient: boolean;
+    /** Byte frequency distribution */
+    readonly byteDistribution: number[];
+}
+/**
+ * Timing analysis result.
+ */
+export interface TimingAnalysis {
+    /** Average execution time in nanoseconds */
+    readonly avgTimeNs: number;
+    /** Standard deviation in nanoseconds */
+    readonly stdDevNs: number;
+    /** Maximum deviation from mean */
+    readonly maxDeviationNs: number;
+    /** Whether timing appears constant */
+    readonly constantTime: boolean;
+    /** Number of samples analyzed */
+    readonly sampleCount: number;
+}
+/**
+ * Type guard for ShareIndex.
+ */
+export declare function isShareIndex(value: number): value is ShareIndex;
+/**
+ * Type guard for GF256Element.
+ */
+export declare function isGF256Element(value: number): value is GF256Element;
+/**
+ * Create a ShareIndex from a number (validates range).
+ * @throws Error if value is not in valid range [1, 255]
+ */
+export declare function createShareIndex(value: number): ShareIndex;
+/**
+ * Create a GF256Element from a number (validates range).
+ * @throws Error if value is not in valid range [0, 255]
+ */
+export declare function createGF256Element(value: number): GF256Element;
+/**
+ * Validate ShamirParams.
+ */
+export declare function validateShamirParams(params: ShamirParams): ShareValidationResult;
+//# sourceMappingURL=types.d.ts.map

package/dist/security/crypto/shamir/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/security/crypto/shamir/types.ts"],"names":[],"mappings":"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"}

package/dist/security/crypto/shamir/types.js

@@ -0,0 +1,82 @@
+/**
+ * Shamir Secret Sharing - Type Definitions
+ *
+ * Provides strong type definitions for verified Shamir Secret Sharing implementation.
+ * All types are designed to enforce mathematical constraints at the type level.
+ *
+ * @module security/crypto/shamir/types
+ */
+/**
+ * Type guard for ShareIndex.
+ */
+export function isShareIndex(value) {
+    return Number.isInteger(value) && value >= 1 && value <= 255;
+}
+/**
+ * Type guard for GF256Element.
+ */
+export function isGF256Element(value) {
+    return Number.isInteger(value) && value >= 0 && value <= 255;
+}
+/**
+ * Create a ShareIndex from a number (validates range).
+ * @throws Error if value is not in valid range [1, 255]
+ */
+export function createShareIndex(value) {
+    if (!isShareIndex(value)) {
+        throw new RangeError(`Share index must be in range [1, 255], got ${value}`);
+    }
+    return value;
+}
+/**
+ * Create a GF256Element from a number (validates range).
+ * @throws Error if value is not in valid range [0, 255]
+ */
+export function createGF256Element(value) {
+    if (!isGF256Element(value)) {
+        throw new RangeError(`GF(2^8) element must be in range [0, 255], got ${value}`);
+    }
+    return value;
+}
+/**
+ * Validate ShamirParams.
+ */
+export function validateShamirParams(params) {
+    const warnings = [];
+    if (!Number.isInteger(params.threshold)) {
+        return { valid: false, error: 'Threshold must be an integer' };
+    }
+    if (!Number.isInteger(params.totalShares)) {
+        return { valid: false, error: 'Total shares must be an integer' };
+    }
+    if (!Number.isInteger(params.secretLength)) {
+        return { valid: false, error: 'Secret length must be an integer' };
+    }
+    if (params.threshold < 1) {
+        return { valid: false, error: 'Threshold must be at least 1' };
+    }
+    if (params.threshold > 255) {
+        return { valid: false, error: 'Threshold cannot exceed 255' };
+    }
+    if (params.totalShares < params.threshold) {
+        return { valid: false, error: 'Total shares must be >= threshold' };
+    }
+    if (params.totalShares > 255) {
+        return { valid: false, error: 'Total shares cannot exceed 255' };
+    }
+    if (params.secretLength < 1) {
+        return { valid: false, error: 'Secret length must be at least 1 byte' };
+    }
+    // Warnings for potentially insecure configurations
+    if (params.threshold === 1) {
+        warnings.push('Threshold of 1 provides no security - any single share reveals the secret');
+    }
+    if (params.threshold === params.totalShares) {
+        warnings.push('Threshold equals total shares - no redundancy, all shares required');
+    }
+    if (params.threshold < 3 && params.totalShares > 3) {
+        warnings.push('Low threshold relative to total shares may indicate weak security requirements');
+    }
+    return { valid: true, warnings: warnings.length > 0 ? warnings : undefined };
+}
+//# sourceMappingURL=types.js.map

package/dist/security/crypto/shamir/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/security/crypto/shamir/types.ts"],"names":[],"mappings":"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"}

package/dist/security/crypto/shamir/verified-shamir.d.ts

@@ -0,0 +1,170 @@
+/**
+ * Verified Shamir Secret Sharing Implementation
+ *
+ * A formally verified implementation of Shamir's Secret Sharing scheme
+ * using GF(2^8) arithmetic with proven correctness properties.
+ *
+ * Security Properties:
+ * - Information-theoretic security: k-1 shares reveal nothing about the secret
+ * - Perfect secrecy: Each share is uniformly random and independent
+ * - Constant-time operations: Resistant to timing attacks
+ *
+ * Mathematical Foundation:
+ * - Field: GF(2^8) with irreducible polynomial x^8 + x^4 + x^3 + x + 1 (0x11B)
+ * - This is the same field used in AES (Rijndael)
+ * - All arithmetic is performed modulo the irreducible polynomial
+ *
+ * @module security/crypto/shamir/verified-shamir
+ */
+import { VerifiedShare, ShamirParams, ShamirConfig, ShareIndex, GF256Element, GF256Operations, GF256Polynomial, SplitResult, ReconstructionResult, ShareValidationResult } from './types';
+/**
+ * Irreducible polynomial for GF(2^8): x^8 + x^4 + x^3 + x + 1
+ * Binary representation: 100011011 = 0x11B
+ *
+ * This polynomial is irreducible over GF(2), meaning it cannot be factored
+ * into polynomials of lower degree with coefficients in GF(2).
+ *
+ * Proof of irreducibility:
+ * - Degree 8 polynomial over GF(2)
+ * - No roots in GF(2): f(0) = 1, f(1) = 1
+ * - Not divisible by any degree 2, 3, or 4 irreducible polynomial
+ * - This is verified by the AES specification (FIPS 197)
+ */
+declare const IRREDUCIBLE_POLY = 283;
+/**
+ * Pre-computed lookup tables for GF(2^8) operations.
+ * Using lookup tables ensures constant-time operations.
+ */
+declare const EXP_TABLE: GF256Element[];
+declare const LOG_TABLE: GF256Element[];
+/**
+ * GF(2^8) field operations with proven correctness.
+ *
+ * All operations are implemented using lookup tables for constant-time
+ * execution, preventing timing side-channel attacks.
+ */
+export declare const GF256: GF256Operations;
+/**
+ * Create a polynomial over GF(2^8) with given coefficients.
+ *
+ * The polynomial is represented as:
+ * f(x) = coefficients[0] + coefficients[1]*x + coefficients[2]*x^2 + ...
+ */
+export declare function createPolynomial(coefficients: GF256Element[]): GF256Polynomial;
+/**
+ * Generate a random polynomial of specified degree with given constant term.
+ *
+ * The polynomial f(x) is constructed such that f(0) = secret.
+ * All other coefficients are uniformly random from GF(2^8).
+ *
+ * @param secret - The constant term (f(0) = secret)
+ * @param degree - Degree of the polynomial (threshold - 1)
+ * @param rng - Random number generator function
+ */
+export declare function generateRandomPolynomial(secret: GF256Element, degree: number, rng: (bytes: Uint8Array) => Uint8Array): GF256Polynomial;
+/**
+ * Compute Lagrange basis polynomial value at x=0.
+ *
+ * The Lagrange basis polynomial L_i(x) is defined as:
+ * L_i(x) = Product_{j != i} (x - x_j) / (x_i - x_j)
+ *
+ * At x = 0:
+ * L_i(0) = Product_{j != i} (-x_j) / (x_i - x_j)
+ *        = Product_{j != i} x_j / (x_j - x_i)  [in GF(2^8), -x = x]
+ *
+ * Correctness proof:
+ * - L_i(x_i) = 1 (all terms in product are 1)
+ * - L_i(x_j) = 0 for j != i (numerator contains (x - x_j) = 0)
+ * - This is the unique polynomial of degree <= n-1 with these properties
+ *
+ * @param indices - All x-coordinates of the interpolation points
+ * @param i - Index of the basis polynomial to compute
+ * @returns L_i(0) in GF(2^8)
+ */
+export declare function lagrangeBasisAtZero(indices: ShareIndex[], i: number): GF256Element;
+/**
+ * Reconstruct secret using Lagrange interpolation at x = 0.
+ *
+ * Given points (x_1, y_1), ..., (x_k, y_k), the interpolating polynomial is:
+ * f(x) = Sum_{i=1}^{k} y_i * L_i(x)
+ *
+ * The secret is f(0) = Sum_{i=1}^{k} y_i * L_i(0)
+ *
+ * Correctness proof:
+ * - Lagrange interpolation uniquely determines a polynomial of degree <= k-1
+ * - For Shamir's scheme, the original polynomial has degree = threshold - 1
+ * - With k = threshold shares, we recover the exact polynomial
+ * - f(0) = secret by construction
+ *
+ * @param shares - Array of (index, value) pairs for a single byte position
+ * @returns The reconstructed byte
+ */
+export declare function lagrangeInterpolateAtZero(shares: Array<{
+    index: ShareIndex;
+    value: GF256Element;
+}>): GF256Element;
+/**
+ * Split a secret into shares using Shamir's Secret Sharing.
+ *
+ * Algorithm:
+ * 1. For each byte of the secret:
+ *    a. Generate random polynomial f(x) of degree (threshold - 1) with f(0) = secret_byte
+ *    b. Evaluate f(x) at x = 1, 2, ..., totalShares
+ * 2. Combine evaluations into shares
+ * 3. Add integrity checksums
+ *
+ * Security properties:
+ * - Any k shares can reconstruct the secret (completeness)
+ * - k-1 shares reveal no information about the secret (perfect secrecy)
+ *
+ * @param secret - The secret to split
+ * @param params - Shamir parameters (threshold, totalShares)
+ * @param config - Optional configuration
+ * @returns Split result with shares and metadata
+ */
+export declare function split(secret: Uint8Array, params: ShamirParams, config?: ShamirConfig): SplitResult;
+/**
+ * Reconstruct secret from shares using Lagrange interpolation.
+ *
+ * Algorithm:
+ * 1. Verify we have enough shares (>= threshold)
+ * 2. Optionally verify share checksums
+ * 3. For each byte position:
+ *    a. Collect (index, value) pairs from shares
+ *    b. Apply Lagrange interpolation at x = 0
+ * 4. Combine reconstructed bytes
+ *
+ * Correctness:
+ * - With k >= threshold shares, Lagrange interpolation uniquely determines
+ *   the original polynomial of degree (threshold - 1)
+ * - The secret is f(0), which is recovered correctly
+ *
+ * @param shares - Shares to use for reconstruction
+ * @param threshold - Minimum shares needed (must match original split)
+ * @param config - Optional configuration
+ * @returns Reconstruction result with secret and metadata
+ */
+export declare function reconstruct(shares: VerifiedShare[], threshold: number, config?: ShamirConfig): ReconstructionResult;
+/**
+ * Validate a single share.
+ */
+export declare function validateShare(share: VerifiedShare): ShareValidationResult;
+/**
+ * Verify that shares are compatible for reconstruction.
+ * Checks that all shares have matching lengths and unique indices.
+ */
+export declare function verifyShareCompatibility(shares: VerifiedShare[]): ShareValidationResult;
+/**
+ * Constant-time select operation.
+ * Returns a if condition is true, b otherwise.
+ * Executes in constant time regardless of condition.
+ */
+export declare function constantTimeSelect(condition: boolean, a: GF256Element, b: GF256Element): GF256Element;
+/**
+ * Constant-time comparison of two byte arrays.
+ * Returns true if equal, false otherwise.
+ * Executes in constant time regardless of content.
+ */
+export declare function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean;
+export { EXP_TABLE, LOG_TABLE, IRREDUCIBLE_POLY };
+//# sourceMappingURL=verified-shamir.d.ts.map

package/dist/security/crypto/shamir/verified-shamir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verified-shamir.d.ts","sourceRoot":"","sources":["../../../../src/security/crypto/shamir/verified-shamir.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EACL,aAAa,EACb,YAAY,EACZ,YAAY,EACZ,UAAU,EACV,YAAY,EACZ,eAAe,EACf,eAAe,EACf,WAAW,EACX,oBAAoB,EACpB,qBAAqB,EAItB,MAAM,SAAS,CAAC;AAMjB;;;;;;;;;;;;GAYG;AACH,QAAA,MAAM,gBAAgB,MAAQ,CAAC;AAE/B;;;GAGG;AACH,QAAA,MAAM,SAAS,EAAE,YAAY,EAAmB,CAAC;AACjD,QAAA,MAAM,SAAS,EAAE,YAAY,EAAmB,CAAC;AA2CjD;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,eA0InB,CAAC;AAMF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,EAAE,GAAG,eAAe,CAsC9E;AAED;;;;;;;;;GASG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,UAAU,GACrC,eAAe,CA8BjB;AAMD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,UAAU,EAAE,EAAE,CAAC,EAAE,MAAM,GAAG,YAAY,CAuBlF;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,KAAK,EAAE,YAAY,CAAA;CAAE,CAAC,GACxD,YAAY,CAed;AAqCD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,KAAK,CACnB,MAAM,EAAE,UAAU,EAClB,MAAM,EAAE,YAAY,EACpB,MAAM,GAAE,YAAiB,GACxB,WAAW,CAmEb;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,WAAW,CACzB,MAAM,EAAE,aAAa,EAAE,EACvB,SAAS,EAAE,MAAM,EACjB,MAAM,GAAE,YAAiB,GACxB,oBAAoB,CAyDtB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,qBAAqB,CAoCzE;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,aAAa,EAAE,GAAG,qBAAqB,CA0BvF;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,OAAO,EAClB,CAAC,EAAE,YAAY,EACf,CAAC,EAAE,YAAY,GACd,YAAY,CAId;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,GAAG,OAAO,CAWvE;AAMD,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,gBAAgB,EAAE,CAAC"}