@vorionsys/platform-core 0.1.0

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

@@ -0,0 +1,155 @@
+/**
+ * Verified Shamir Secret Sharing
+ *
+ * A formally verified implementation of Shamir's Secret Sharing scheme
+ * with comprehensive testing, mathematical proofs, and security analysis.
+ *
+ * This module provides:
+ * - GF(2^8) arithmetic with proven correctness
+ * - Polynomial evaluation with overflow protection
+ * - Lagrange interpolation with numerical stability
+ * - Constant-time operations to prevent timing attacks
+ * - Input validation with mathematical bounds checking
+ *
+ * Security Properties:
+ * - Information-theoretic security: k-1 shares reveal nothing
+ * - Perfect secrecy: each share is uniformly random
+ * - Constant-time: resistant to timing side-channel attacks
+ *
+ * @example
+ * ```typescript
+ * import { split, reconstruct } from './security/crypto/shamir';
+ *
+ * // Split a secret into 5 shares with threshold 3
+ * const secret = new TextEncoder().encode('my-secret-key');
+ * const { shares } = split(secret, {
+ *   threshold: 3,
+ *   totalShares: 5,
+ *   secretLength: secret.length,
+ * });
+ *
+ * // Reconstruct with any 3 shares
+ * const { secret: recovered } = reconstruct(shares.slice(0, 3), 3);
+ * ```
+ *
+ * @module security/crypto/shamir
+ */
+// ============================================================================
+// Core Types
+// ============================================================================
+export { 
+// Type guards and factories
+isShareIndex, isGF256Element, createShareIndex, createGF256Element, validateShamirParams, } from './types';
+// ============================================================================
+// Core Implementation
+// ============================================================================
+export { 
+// Field operations
+GF256, EXP_TABLE, LOG_TABLE, IRREDUCIBLE_POLY, 
+// Polynomial operations
+createPolynomial, generateRandomPolynomial, 
+// Lagrange interpolation
+lagrangeBasisAtZero, lagrangeInterpolateAtZero, 
+// Main operations
+split, reconstruct, 
+// Validation
+validateShare, verifyShareCompatibility, 
+// Constant-time utilities
+constantTimeSelect, constantTimeEqual, } from './verified-shamir';
+// ============================================================================
+// Mathematical Proofs
+// ============================================================================
+export { verifyFieldAxioms, verifyLagrangeInterpolation, verifyPerfectSecrecy, verifyReconstructionCompleteness, verifyGeneratorProperties, runAllProofs, } from './proofs';
+// ============================================================================
+// Test Vectors
+// ============================================================================
+export { 
+// Test vector collections
+NIST_STYLE_VECTORS, EDGE_CASE_VECTORS, ACADEMIC_VECTORS, GF256_OPERATION_VECTORS, POLYNOMIAL_VECTORS, LAGRANGE_VECTORS, ALL_TEST_VECTORS, 
+// Verification functions
+verifyGF256Vector, verifyPolynomialVector, runAllTestVectors, generateDeterministicShares, } from './test-vectors';
+// ============================================================================
+// Property-Based Testing
+// ============================================================================
+export { 
+// Individual property tests
+testReconstructionCompleteness, testInformationTheoreticSecurity, testShareOrderIndependence, testReconstructionIdempotency, testShareSubsetEquivalence, testLagrangeBasisPartition, 
+// Test suite runners
+runAllPropertyTests, runQuickPropertyTests, } from './property-tests';
+// ============================================================================
+// Security Analysis
+// ============================================================================
+export { 
+// Entropy analysis
+calculateShannonEntropy, calculateMinEntropy, analyzeShareEntropy, 
+// Statistical tests
+chiSquareTest, runsTest, serialTest, 
+// Timing analysis
+analyzeTimings, testGF256TimingResistance, testReconstructionTimingResistance, 
+// Memory safety
+analyzeMemorySafety, 
+// Comprehensive analysis
+runSecurityAnalysis, runQuickSecurityCheck, } from './security-analysis';
+// ============================================================================
+// Interoperability
+// ============================================================================
+export { toVaultFormat, fromVaultFormat, verifyVaultCompatibility, toSecretsJsFormat, fromSecretsJsFormat, verifySecretsJsCompatibility, 
+// Cross-implementation testing
+generateInteropTestVectors, runInteroperabilityTests, getCompatibilityReport, IMPLEMENTATION_DIFFERENCES, } from './comparison';
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Run all verification and testing suites.
+ *
+ * @returns Comprehensive verification results
+ */
+export async function runFullVerification() {
+    // Import dynamically to avoid circular dependencies
+    const { runAllProofs } = await import('./proofs.js');
+    const { runAllTestVectors } = await import('./test-vectors.js');
+    const { runQuickPropertyTests } = await import('./property-tests.js');
+    const { runSecurityAnalysis } = await import('./security-analysis.js');
+    const { runInteroperabilityTests } = await import('./comparison.js');
+    const proofs = runAllProofs();
+    const testVectors = runAllTestVectors();
+    const propertyTests = runQuickPropertyTests();
+    const securityAnalysis = runSecurityAnalysis();
+    const interoperability = runInteroperabilityTests();
+    return {
+        proofs: {
+            allPassed: proofs.allPassed,
+            proofs: proofs.proofs,
+        },
+        testVectors: {
+            passed: testVectors.passed,
+            summary: testVectors.summary,
+        },
+        propertyTests: {
+            allPassed: propertyTests.allPassed,
+            totalIterations: propertyTests.totalIterations,
+        },
+        securityAnalysis: {
+            secure: securityAnalysis.secure,
+            checks: securityAnalysis.checks,
+        },
+        interoperability: {
+            allCompatible: interoperability.allCompatible,
+        },
+    };
+}
+/**
+ * Quick verification check for CI/CD pipelines.
+ *
+ * @returns Whether all quick checks pass
+ */
+export function runQuickVerification() {
+    const { runAllProofs } = require('./proofs');
+    const { runQuickPropertyTests } = require('./property-tests');
+    const { runQuickSecurityCheck } = require('./security-analysis');
+    const proofs = runAllProofs();
+    const propertyTests = runQuickPropertyTests();
+    const security = runQuickSecurityCheck();
+    return proofs.allPassed && propertyTests.allPassed && security.passed;
+}
+//# sourceMappingURL=index.js.map

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

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

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

@@ -0,0 +1,259 @@
+/**
+ * Mathematical Proofs for Shamir Secret Sharing
+ *
+ * This module contains formal mathematical proofs documenting the correctness
+ * and security properties of the Shamir Secret Sharing implementation.
+ *
+ * Proofs are expressed as:
+ * - Structured documentation with precise mathematical statements
+ * - Executable verification code where possible
+ * - References to academic literature
+ *
+ * @module security/crypto/shamir/proofs
+ */
+/**
+ * THEOREM 1: GF(2^8) Field Axioms
+ *
+ * GF(2^8) with irreducible polynomial p(x) = x^8 + x^4 + x^3 + x + 1 (0x11B)
+ * forms a field with 256 elements.
+ *
+ * PROOF OUTLINE:
+ *
+ * 1. CLOSURE under addition and multiplication:
+ *    - Addition (XOR) of two bytes produces a byte: (a XOR b) in [0, 255]
+ *    - Multiplication with reduction mod p(x) produces an element in [0, 255]
+ *
+ * 2. ASSOCIATIVITY:
+ *    - Addition: (a XOR b) XOR c = a XOR (b XOR c) (property of XOR)
+ *    - Multiplication: Follows from polynomial arithmetic properties
+ *
+ * 3. COMMUTATIVITY:
+ *    - Addition: a XOR b = b XOR a
+ *    - Multiplication: a * b = b * a (polynomial multiplication is commutative)
+ *
+ * 4. IDENTITY elements:
+ *    - Additive identity: 0 (a XOR 0 = a)
+ *    - Multiplicative identity: 1 (a * 1 = a)
+ *
+ * 5. INVERSE elements:
+ *    - Additive inverse: a + a = 0 (every element is its own inverse in char 2)
+ *    - Multiplicative inverse: For a != 0, exists b such that a * b = 1
+ *      (guaranteed since GF(2^8) is a field)
+ *
+ * 6. DISTRIBUTIVITY:
+ *    - a * (b + c) = (a * b) + (a * c)
+ *    - Follows from polynomial arithmetic over GF(2)
+ *
+ * IRREDUCIBILITY of p(x) = x^8 + x^4 + x^3 + x + 1:
+ * - p(x) has no roots in GF(2): p(0) = 1, p(1) = 1 + 1 + 1 + 1 + 1 = 1 (mod 2)
+ * - p(x) is not divisible by any irreducible polynomial of degree 2, 3, or 4
+ * - This is verified by exhaustive check (standard result, see FIPS 197)
+ *
+ * Reference: FIPS 197 (AES specification), Section 4.1
+ */
+export declare function verifyFieldAxioms(): {
+    passed: boolean;
+    details: {
+        closure: boolean;
+        associativity: boolean;
+        commutativity: boolean;
+        identity: boolean;
+        inverse: boolean;
+        distributivity: boolean;
+    };
+};
+/**
+ * THEOREM 2: Lagrange Interpolation Uniqueness and Correctness
+ *
+ * STATEMENT:
+ * Given n distinct points (x_1, y_1), ..., (x_n, y_n) in a field F,
+ * there exists a unique polynomial p(x) of degree at most n-1 such that
+ * p(x_i) = y_i for all i.
+ *
+ * PROOF:
+ *
+ * EXISTENCE:
+ * Define the Lagrange basis polynomials:
+ *   L_i(x) = Product_{j != i} (x - x_j) / (x_i - x_j)
+ *
+ * Properties of L_i:
+ *   - L_i(x_i) = 1 (all terms in the product equal 1)
+ *   - L_i(x_j) = 0 for j != i (numerator contains factor (x - x_j) = 0)
+ *   - degree(L_i) = n - 1
+ *
+ * The interpolating polynomial is:
+ *   p(x) = Sum_{i=1}^{n} y_i * L_i(x)
+ *
+ * Verification:
+ *   p(x_k) = Sum_{i=1}^{n} y_i * L_i(x_k)
+ *          = y_k * L_k(x_k) + Sum_{i != k} y_i * L_i(x_k)
+ *          = y_k * 1 + Sum_{i != k} y_i * 0
+ *          = y_k
+ *
+ * UNIQUENESS:
+ * Suppose p(x) and q(x) both interpolate the points, both with degree <= n-1.
+ * Then r(x) = p(x) - q(x) has:
+ *   - degree <= n-1
+ *   - r(x_i) = 0 for all i (n roots)
+ *
+ * A non-zero polynomial of degree d has at most d roots.
+ * Since r has n roots but degree <= n-1, we must have r = 0.
+ * Therefore p = q.
+ *
+ * APPLICATION TO SHAMIR:
+ * For Shamir's scheme with threshold k:
+ *   - Secret is f(0) where f is a polynomial of degree k-1
+ *   - Given k shares (x_i, f(x_i)), Lagrange interpolation recovers f uniquely
+ *   - Then f(0) = secret
+ *
+ * Reference: "How to Share a Secret" by Adi Shamir, CACM 1979
+ */
+export declare function verifyLagrangeInterpolation(): {
+    passed: boolean;
+    testResults: Array<{
+        description: string;
+        passed: boolean;
+        expected?: number;
+        actual?: number;
+    }>;
+};
+/**
+ * THEOREM 3: Information-Theoretic Security
+ *
+ * STATEMENT:
+ * In a (k, n) Shamir secret sharing scheme, any subset of k-1 or fewer shares
+ * provides zero information about the secret. This is information-theoretic
+ * security, not computational security.
+ *
+ * PROOF:
+ *
+ * Let S be the secret and let (x_1, y_1), ..., (x_{k-1}, y_{k-1}) be k-1 shares.
+ *
+ * We must show: For any possible secret value s in the field,
+ *   P(S = s | shares) = P(S = s)
+ *
+ * Analysis:
+ * 1. The polynomial f(x) has degree k-1, with k coefficients: f(x) = a_0 + a_1*x + ... + a_{k-1}*x^{k-1}
+ * 2. The secret is a_0 = f(0)
+ * 3. Given k-1 points, we have k-1 linear equations in k unknowns
+ * 4. This system is underdetermined
+ *
+ * For any value of a_0 = s:
+ * - The remaining k-1 unknowns (a_1, ..., a_{k-1}) form a system of k-1 equations
+ * - This system has a unique solution (Lagrange interpolation through k-1 points with
+ *   the constraint that f(0) = s)
+ *
+ * Therefore:
+ * - Every possible secret s is equally consistent with the k-1 shares
+ * - The k-1 shares provide zero bits of information about s
+ * - This is perfect secrecy in the information-theoretic sense
+ *
+ * COROLLARY:
+ * The mutual information I(S; Y_1, ..., Y_{k-1}) = 0
+ * where Y_i are the share values.
+ *
+ * Reference: "How to Share a Secret" by Adi Shamir, CACM 1979
+ * Reference: Cover & Thomas, "Elements of Information Theory"
+ */
+export declare function verifyPerfectSecrecy(): {
+    passed: boolean;
+    description: string;
+    analysis: {
+        testedSecrets: number;
+        testedShareCombinations: number;
+        allSecretsConsistent: boolean;
+    };
+};
+/**
+ * THEOREM 4: Reconstruction Completeness
+ *
+ * STATEMENT:
+ * Any k shares from a (k, n) Shamir secret sharing scheme can reconstruct
+ * the original secret.
+ *
+ * PROOF:
+ *
+ * Setup:
+ * - Original polynomial f(x) has degree k-1
+ * - f(0) = secret
+ * - Shares are (x_i, f(x_i)) for i = 1, ..., n
+ *
+ * Given any k shares (x_{i_1}, y_{i_1}), ..., (x_{i_k}, y_{i_k}):
+ *
+ * 1. By Theorem 2 (Lagrange Interpolation), there exists a unique polynomial
+ *    p(x) of degree at most k-1 that passes through these k points.
+ *
+ * 2. Since f(x) also passes through these points and has degree k-1,
+ *    by uniqueness we have p(x) = f(x).
+ *
+ * 3. Therefore p(0) = f(0) = secret.
+ *
+ * The reconstruction is deterministic and always succeeds given k valid shares.
+ *
+ * COROLLARY:
+ * The choice of which k shares to use does not affect the result.
+ * All C(n, k) combinations of k shares reconstruct the same secret.
+ *
+ * Reference: "How to Share a Secret" by Adi Shamir, CACM 1979
+ */
+export declare function verifyReconstructionCompleteness(): {
+    passed: boolean;
+    testResults: Array<{
+        threshold: number;
+        totalShares: number;
+        secret: number;
+        combinationsTested: number;
+        allSucceeded: boolean;
+    }>;
+};
+/**
+ * THEOREM 5: Generator Properties of g = 0x03
+ *
+ * STATEMENT:
+ * The element g = 3 is a generator of the multiplicative group GF(2^8)*.
+ * This means g has order 255, and every non-zero element of GF(2^8) can be
+ * written as g^i for some i in {0, 1, ..., 254}.
+ *
+ * PROOF:
+ *
+ * The multiplicative group GF(2^8)* has 255 elements (all non-zero elements).
+ * By Lagrange's theorem, the order of any element divides 255.
+ *
+ * 255 = 3 * 5 * 17
+ *
+ * An element g generates the group iff g^(255/p) != 1 for each prime divisor p.
+ *
+ * For g = 3:
+ * - 3^(255/3) = 3^85 != 1 (verified by computation)
+ * - 3^(255/5) = 3^51 != 1 (verified by computation)
+ * - 3^(255/17) = 3^15 != 1 (verified by computation)
+ *
+ * Therefore ord(g) = 255 and g generates GF(2^8)*.
+ *
+ * COROLLARY:
+ * The EXP_TABLE contains all 255 non-zero elements of GF(2^8) exactly once.
+ * The LOG_TABLE provides a bijection from GF(2^8)* to Z_255.
+ */
+export declare function verifyGeneratorProperties(): {
+    passed: boolean;
+    details: {
+        generatorValue: number;
+        computedOrder: number;
+        expectedOrder: number;
+        allElementsGenerated: boolean;
+        expTableCorrect: boolean;
+        logTableCorrect: boolean;
+    };
+};
+/**
+ * Run all proofs and return comprehensive verification results.
+ */
+export declare function runAllProofs(): {
+    allPassed: boolean;
+    proofs: Array<{
+        name: string;
+        passed: boolean;
+        details: unknown;
+    }>;
+};
+//# sourceMappingURL=proofs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proofs.d.ts","sourceRoot":"","sources":["../../../../src/security/crypto/shamir/proofs.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAsBH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,iBAAiB,IAAI;IACnC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE;QACP,OAAO,EAAE,OAAO,CAAC;QACjB,aAAa,EAAE,OAAO,CAAC;QACvB,aAAa,EAAE,OAAO,CAAC;QACvB,QAAQ,EAAE,OAAO,CAAC;QAClB,OAAO,EAAE,OAAO,CAAC;QACjB,cAAc,EAAE,OAAO,CAAC;KACzB,CAAC;CACH,CAwGA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,wBAAgB,2BAA2B,IAAI;IAC7C,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,KAAK,CAAC;QACjB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,OAAO,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;CACJ,CAyEA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAgB,oBAAoB,IAAI;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE;QACR,aAAa,EAAE,MAAM,CAAC;QACtB,uBAAuB,EAAE,MAAM,CAAC;QAChC,oBAAoB,EAAE,OAAO,CAAC;KAC/B,CAAC;CACH,CA4EA;AAMD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,gCAAgC,IAAI;IAClD,MAAM,EAAE,OAAO,CAAC;IAChB,WAAW,EAAE,KAAK,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,WAAW,EAAE,MAAM,CAAC;QACpB,MAAM,EAAE,MAAM,CAAC;QACf,kBAAkB,EAAE,MAAM,CAAC;QAC3B,YAAY,EAAE,OAAO,CAAC;KACvB,CAAC,CAAC;CACJ,CAoDA;AA8CD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,yBAAyB,IAAI;IAC3C,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE;QACP,cAAc,EAAE,MAAM,CAAC;QACvB,aAAa,EAAE,MAAM,CAAC;QACtB,aAAa,EAAE,MAAM,CAAC;QACtB,oBAAoB,EAAE,OAAO,CAAC;QAC9B,eAAe,EAAE,OAAO,CAAC;QACzB,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;CACH,CAgEA;AAMD;;GAEG;AACH,wBAAgB,YAAY,IAAI;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,OAAO,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;KAClB,CAAC,CAAC;CACJ,CA+CA"}