@de-otio/trellis 0.4.0

package/dist/lib/crypto/voting/hash-utils.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Hash Utilities for Secure Voting
+ *
+ * Provides hash functions for Secure Voting System using the shared cryptographic library.
+ * These functions are used for:
+ * - Verification codes
+ * - Election record hashing
+ * - Proof challenges (Fiat-Shamir heuristic)
+ *
+ * Note: ElGamal encryption remains separate (homomorphic requirement).
+ * Only hash functions use the shared library.
+ *
+ * @see packages/crypto for shared cryptographic operations
+ * @see doc/02-technical/architecture/cryptography/ for design documentation
+ */
+/**
+ * Hash data for verification codes
+ *
+ * Verification codes are used to allow voters to verify their vote was counted.
+ * Uses SHA-256 from the shared cryptographic library.
+ *
+ * @param data - Data to hash (typically ballot identifier or vote data)
+ * @returns SHA-256 hash as hex string
+ */
+export declare function hashVerificationCode(data: string | object): Promise<string>;
+/**
+ * Hash election record for integrity verification
+ *
+ * Election records contain cryptographic commitments to election parameters.
+ * Uses SHA-256 from the shared cryptographic library.
+ *
+ * @param electionRecord - Election record data to hash
+ * @returns SHA-256 hash as hex string
+ */
+export declare function hashElectionRecord(electionRecord: string | object): Promise<string>;
+/**
+ * Generate proof challenge using Fiat-Shamir heuristic
+ *
+ * The Fiat-Shamir heuristic converts interactive zero-knowledge proofs
+ * to non-interactive proofs by using a hash of the proof transcript as the challenge.
+ *
+ * Uses SHA-256 from the shared cryptographic library.
+ *
+ * @param transcript - Proof transcript (public values, commitments, etc.)
+ * @returns Challenge value (hash of transcript) as hex string
+ */
+export declare function generateFiatShamirChallenge(transcript: string | object): Promise<string>;
+/**
+ * Hash device information for ballot tracking
+ *
+ * Device information is hashed (not stored in plaintext) to enable
+ * ballot tracking while maintaining privacy.
+ *
+ * @param deviceInfo - Device information object
+ * @returns SHA-256 hash as hex string
+ */
+export declare function hashDeviceInfo(deviceInfo: object): Promise<string>;
+//# sourceMappingURL=hash-utils.d.ts.map

package/dist/lib/crypto/voting/hash-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-utils.d.ts","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/hash-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAIH;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CACxC,IAAI,EAAE,MAAM,GAAG,MAAM,GACpB,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CACtC,cAAc,EAAE,MAAM,GAAG,MAAM,GAC9B,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,2BAA2B,CAC/C,UAAU,EAAE,MAAM,GAAG,MAAM,GAC1B,OAAO,CAAC,MAAM,CAAC,CAEjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,cAAc,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAExE"}

package/dist/lib/crypto/voting/hash-utils.js

@@ -0,0 +1,73 @@
+"use strict";
+/**
+ * Hash Utilities for Secure Voting
+ *
+ * Provides hash functions for Secure Voting System using the shared cryptographic library.
+ * These functions are used for:
+ * - Verification codes
+ * - Election record hashing
+ * - Proof challenges (Fiat-Shamir heuristic)
+ *
+ * Note: ElGamal encryption remains separate (homomorphic requirement).
+ * Only hash functions use the shared library.
+ *
+ * @see packages/crypto for shared cryptographic operations
+ * @see doc/02-technical/architecture/cryptography/ for design documentation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashVerificationCode = hashVerificationCode;
+exports.hashElectionRecord = hashElectionRecord;
+exports.generateFiatShamirChallenge = generateFiatShamirChallenge;
+exports.hashDeviceInfo = hashDeviceInfo;
+const index_js_1 = require("../index.js");
+/**
+ * Hash data for verification codes
+ *
+ * Verification codes are used to allow voters to verify their vote was counted.
+ * Uses SHA-256 from the shared cryptographic library.
+ *
+ * @param data - Data to hash (typically ballot identifier or vote data)
+ * @returns SHA-256 hash as hex string
+ */
+async function hashVerificationCode(data) {
+    return await index_js_1.EncryptionService.hash(data);
+}
+/**
+ * Hash election record for integrity verification
+ *
+ * Election records contain cryptographic commitments to election parameters.
+ * Uses SHA-256 from the shared cryptographic library.
+ *
+ * @param electionRecord - Election record data to hash
+ * @returns SHA-256 hash as hex string
+ */
+async function hashElectionRecord(electionRecord) {
+    return await index_js_1.EncryptionService.hash(electionRecord);
+}
+/**
+ * Generate proof challenge using Fiat-Shamir heuristic
+ *
+ * The Fiat-Shamir heuristic converts interactive zero-knowledge proofs
+ * to non-interactive proofs by using a hash of the proof transcript as the challenge.
+ *
+ * Uses SHA-256 from the shared cryptographic library.
+ *
+ * @param transcript - Proof transcript (public values, commitments, etc.)
+ * @returns Challenge value (hash of transcript) as hex string
+ */
+async function generateFiatShamirChallenge(transcript) {
+    return await index_js_1.EncryptionService.hash(transcript);
+}
+/**
+ * Hash device information for ballot tracking
+ *
+ * Device information is hashed (not stored in plaintext) to enable
+ * ballot tracking while maintaining privacy.
+ *
+ * @param deviceInfo - Device information object
+ * @returns SHA-256 hash as hex string
+ */
+async function hashDeviceInfo(deviceInfo) {
+    return await index_js_1.EncryptionService.hash(deviceInfo);
+}
+//# sourceMappingURL=hash-utils.js.map

package/dist/lib/crypto/voting/hash-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash-utils.js","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/hash-utils.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;AAaH,oDAIC;AAWD,gDAIC;AAaD,kEAIC;AAWD,wCAEC;AA5DD,0CAAgD;AAEhD;;;;;;;;GAQG;AACI,KAAK,UAAU,oBAAoB,CACxC,IAAqB;IAErB,OAAO,MAAM,4BAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC5C,CAAC;AAED;;;;;;;;GAQG;AACI,KAAK,UAAU,kBAAkB,CACtC,cAA+B;IAE/B,OAAO,MAAM,4BAAiB,CAAC,IAAI,CAAC,cAAc,CAAC,CAAC;AACtD,CAAC;AAED;;;;;;;;;;GAUG;AACI,KAAK,UAAU,2BAA2B,CAC/C,UAA2B;IAE3B,OAAO,MAAM,4BAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAClD,CAAC;AAED;;;;;;;;GAQG;AACI,KAAK,UAAU,cAAc,CAAC,UAAkB;IACrD,OAAO,MAAM,4BAAiB,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AAClD,CAAC"}

package/dist/lib/crypto/voting/hybrid-encryption.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Hybrid Encryption Scheme
+ *
+ * Supports dual encryption using both classical (ElGamal) and post-quantum schemes.
+ * Provides quantum resistance while maintaining backward compatibility.
+ *
+ * Part of: Cryptographic Design Comparison
+ * Status: Design Document
+ * Last Updated: January 2025
+ *
+ * This is a design document for hybrid encryption support.
+ * Implementation will follow when post-quantum schemes are available.
+ */
+import type { EncryptionScheme, PublicKey, PrivateKey, EncryptedData } from "./encryption-scheme.js";
+/**
+ * Hybrid encrypted data structure
+ * Contains both classical and post-quantum encryptions
+ */
+export interface HybridEncryptedData extends EncryptedData {
+    /**
+     * Classical encryption (ElGamal)
+     */
+    classical: EncryptedData;
+    /**
+     * Post-quantum encryption
+     */
+    postQuantum: EncryptedData;
+}
+/**
+ * Hybrid Encryption Class
+ *
+ * Implements dual encryption using both classical and post-quantum schemes.
+ * This provides:
+ * - Quantum resistance (post-quantum component)
+ * - Backward compatibility (classical component)
+ * - Gradual migration path
+ */
+export declare class HybridEncryption implements EncryptionScheme {
+    private readonly classicalScheme;
+    private readonly postQuantumScheme;
+    constructor();
+    /**
+     * Encrypt data using both classical and post-quantum schemes
+     *
+     * @param message - Message to encrypt
+     * @param publicKey - Hybrid public key (contains both classical and post-quantum keys)
+     * @returns Hybrid encrypted data
+     */
+    encrypt(message: unknown, publicKey: PublicKey): Promise<EncryptedData>;
+    /**
+     * Decrypt data using either classical or post-quantum scheme
+     *
+     * Supports backward compatibility: can decrypt with classical key only
+     * or with post-quantum key only, or with both.
+     *
+     * @param encryptedData - Hybrid encrypted data
+     * @param privateKey - Hybrid private key (contains both classical and post-quantum keys)
+     * @returns Decrypted message
+     */
+    decrypt(encryptedData: EncryptedData, privateKey: PrivateKey): Promise<unknown>;
+    /**
+     * Check if hybrid encryption is quantum-resistant
+     *
+     * @returns true (post-quantum component provides quantum resistance)
+     */
+    isQuantumResistant(): boolean;
+    /**
+     * Get algorithm name
+     *
+     * @returns 'hybrid'
+     */
+    getAlgorithmName(): string;
+    /**
+     * Check if hybrid encryption supports homomorphic operations
+     *
+     * @returns true (if both schemes support homomorphic operations)
+     */
+    isHomomorphic(): boolean;
+    /**
+     * Perform homomorphic addition on hybrid encrypted data
+     *
+     * @param encrypted1 - First hybrid encrypted value
+     * @param encrypted2 - Second hybrid encrypted value
+     * @returns Sum of encrypted values (hybrid encrypted)
+     */
+    homomorphicAdd(encrypted1: EncryptedData, encrypted2: EncryptedData): Promise<EncryptedData>;
+}
+/**
+ * Migration Strategy for Hybrid Encryption
+ *
+ * Phase 1 (Current): Classical Only
+ * - Use ElGamal encryption only
+ * - Monitor NIST PQC standards
+ * - Design hybrid scheme architecture
+ *
+ * Phase 2 (Transition): Hybrid Classical/Post-Quantum
+ * - Implement hybrid encryption
+ * - Encrypt with both schemes
+ * - Decrypt with either (backward compatibility)
+ * - Test in non-critical elections
+ *
+ * Phase 3 (Future): Post-Quantum Only
+ * - Migrate to post-quantum only
+ * - Deprecate classical encryption
+ * - Update all protocols
+ *
+ * See: doc/02-technical/architecture/cryptography/voting-post-quantum-migration.md
+ */
+//# sourceMappingURL=hybrid-encryption.d.ts.map

package/dist/lib/crypto/voting/hybrid-encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybrid-encryption.d.ts","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/hybrid-encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,aAAa,EACd,MAAM,wBAAwB,CAAC;AAIhC;;;GAGG;AACH,MAAM,WAAW,mBAAoB,SAAQ,aAAa;IACxD;;OAEG;IACH,SAAS,EAAE,aAAa,CAAC;IAEzB;;OAEG;IACH,WAAW,EAAE,aAAa,CAAC;CAC5B;AAED;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,YAAW,gBAAgB;IACvD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAoB;IACpD,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAwB;;IAO1D;;;;;;OAMG;IACG,OAAO,CACX,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,aAAa,CAAC;IAazB;;;;;;;;;OASG;IACG,OAAO,CACX,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,OAAO,CAAC;IAanB;;;;OAIG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;;;OAIG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;;;OAIG;IACH,aAAa,IAAI,OAAO;IAOxB;;;;;;OAMG;IACG,cAAc,CAClB,UAAU,EAAE,aAAa,EACzB,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,aAAa,CAAC;CAY1B;AAED;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/lib/crypto/voting/hybrid-encryption.js

@@ -0,0 +1,134 @@
+"use strict";
+/**
+ * Hybrid Encryption Scheme
+ *
+ * Supports dual encryption using both classical (ElGamal) and post-quantum schemes.
+ * Provides quantum resistance while maintaining backward compatibility.
+ *
+ * Part of: Cryptographic Design Comparison
+ * Status: Design Document
+ * Last Updated: January 2025
+ *
+ * This is a design document for hybrid encryption support.
+ * Implementation will follow when post-quantum schemes are available.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HybridEncryption = void 0;
+const elgamal_encryption_js_1 = require("./elgamal-encryption.js");
+const post_quantum_encryption_js_1 = require("./post-quantum-encryption.js");
+/**
+ * Hybrid Encryption Class
+ *
+ * Implements dual encryption using both classical and post-quantum schemes.
+ * This provides:
+ * - Quantum resistance (post-quantum component)
+ * - Backward compatibility (classical component)
+ * - Gradual migration path
+ */
+class HybridEncryption {
+    classicalScheme;
+    postQuantumScheme;
+    constructor() {
+        this.classicalScheme = new elgamal_encryption_js_1.ElGamalEncryption();
+        this.postQuantumScheme = new post_quantum_encryption_js_1.PostQuantumEncryption();
+    }
+    /**
+     * Encrypt data using both classical and post-quantum schemes
+     *
+     * @param message - Message to encrypt
+     * @param publicKey - Hybrid public key (contains both classical and post-quantum keys)
+     * @returns Hybrid encrypted data
+     */
+    async encrypt(message, publicKey) {
+        // TODO: Implement hybrid encryption
+        // This requires:
+        // 1. Extract classical public key from hybrid key
+        // 2. Extract post-quantum public key from hybrid key
+        // 3. Encrypt with both schemes
+        // 4. Return hybrid encrypted data containing both
+        throw new Error("Hybrid encryption not yet implemented. Requires post-quantum scheme to be available.");
+    }
+    /**
+     * Decrypt data using either classical or post-quantum scheme
+     *
+     * Supports backward compatibility: can decrypt with classical key only
+     * or with post-quantum key only, or with both.
+     *
+     * @param encryptedData - Hybrid encrypted data
+     * @param privateKey - Hybrid private key (contains both classical and post-quantum keys)
+     * @returns Decrypted message
+     */
+    async decrypt(encryptedData, privateKey) {
+        // TODO: Implement hybrid decryption
+        // This requires:
+        // 1. Check if encrypted data is hybrid or classical-only
+        // 2. If hybrid, try both decryption methods
+        // 3. If classical-only, use classical decryption (backward compatibility)
+        // 4. Verify decryption results match (if both available)
+        throw new Error("Hybrid decryption not yet implemented. Requires post-quantum scheme to be available.");
+    }
+    /**
+     * Check if hybrid encryption is quantum-resistant
+     *
+     * @returns true (post-quantum component provides quantum resistance)
+     */
+    isQuantumResistant() {
+        return true;
+    }
+    /**
+     * Get algorithm name
+     *
+     * @returns 'hybrid'
+     */
+    getAlgorithmName() {
+        return "hybrid";
+    }
+    /**
+     * Check if hybrid encryption supports homomorphic operations
+     *
+     * @returns true (if both schemes support homomorphic operations)
+     */
+    isHomomorphic() {
+        return (this.classicalScheme.isHomomorphic() &&
+            this.postQuantumScheme.isHomomorphic());
+    }
+    /**
+     * Perform homomorphic addition on hybrid encrypted data
+     *
+     * @param encrypted1 - First hybrid encrypted value
+     * @param encrypted2 - Second hybrid encrypted value
+     * @returns Sum of encrypted values (hybrid encrypted)
+     */
+    async homomorphicAdd(encrypted1, encrypted2) {
+        // TODO: Implement hybrid homomorphic addition
+        // This requires:
+        // 1. Extract classical components from both encrypted values
+        // 2. Extract post-quantum components from both encrypted values
+        // 3. Perform homomorphic addition on both
+        // 4. Combine results into hybrid encrypted data
+        throw new Error("Hybrid homomorphic addition not yet implemented. Requires post-quantum scheme to be available.");
+    }
+}
+exports.HybridEncryption = HybridEncryption;
+/**
+ * Migration Strategy for Hybrid Encryption
+ *
+ * Phase 1 (Current): Classical Only
+ * - Use ElGamal encryption only
+ * - Monitor NIST PQC standards
+ * - Design hybrid scheme architecture
+ *
+ * Phase 2 (Transition): Hybrid Classical/Post-Quantum
+ * - Implement hybrid encryption
+ * - Encrypt with both schemes
+ * - Decrypt with either (backward compatibility)
+ * - Test in non-critical elections
+ *
+ * Phase 3 (Future): Post-Quantum Only
+ * - Migrate to post-quantum only
+ * - Deprecate classical encryption
+ * - Update all protocols
+ *
+ * See: doc/02-technical/architecture/cryptography/voting-post-quantum-migration.md
+ */
+//# sourceMappingURL=hybrid-encryption.js.map

package/dist/lib/crypto/voting/hybrid-encryption.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hybrid-encryption.js","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/hybrid-encryption.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;;AAQH,mEAA4D;AAC5D,6EAAqE;AAkBrE;;;;;;;;GAQG;AACH,MAAa,gBAAgB;IACV,eAAe,CAAoB;IACnC,iBAAiB,CAAwB;IAE1D;QACE,IAAI,CAAC,eAAe,GAAG,IAAI,yCAAiB,EAAE,CAAC;QAC/C,IAAI,CAAC,iBAAiB,GAAG,IAAI,kDAAqB,EAAE,CAAC;IACvD,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,OAAO,CACX,OAAgB,EAChB,SAAoB;QAEpB,oCAAoC;QACpC,iBAAiB;QACjB,kDAAkD;QAClD,qDAAqD;QACrD,+BAA+B;QAC/B,kDAAkD;QAElD,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,OAAO,CACX,aAA4B,EAC5B,UAAsB;QAEtB,oCAAoC;QACpC,iBAAiB;QACjB,yDAAyD;QACzD,4CAA4C;QAC5C,0EAA0E;QAC1E,yDAAyD;QAEzD,MAAM,IAAI,KAAK,CACb,sFAAsF,CACvF,CAAC;IACJ,CAAC;IAED;;;;OAIG;IACH,kBAAkB;QAChB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACH,gBAAgB;QACd,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED;;;;OAIG;IACH,aAAa;QACX,OAAO,CACL,IAAI,CAAC,eAAe,CAAC,aAAa,EAAE;YACpC,IAAI,CAAC,iBAAiB,CAAC,aAAa,EAAE,CACvC,CAAC;IACJ,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,cAAc,CAClB,UAAyB,EACzB,UAAyB;QAEzB,8CAA8C;QAC9C,iBAAiB;QACjB,6DAA6D;QAC7D,gEAAgE;QAChE,0CAA0C;QAC1C,gDAAgD;QAEhD,MAAM,IAAI,KAAK,CACb,gGAAgG,CACjG,CAAC;IACJ,CAAC;CACF;AA9GD,4CA8GC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG"}

package/dist/lib/crypto/voting/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Voting Cryptographic Module
+ *
+ * Exports encryption schemes for Secure Voting System.
+ * Provides modular architecture for algorithm swapping and post-quantum migration.
+ *
+ * Part of: Cryptographic Design Comparison
+ * Status: Module Exports
+ * Last Updated: January 2025
+ */
+export type { EncryptionScheme, PublicKey, PrivateKey, EncryptedData, } from "./encryption-scheme.js";
+export { ElGamalEncryption } from "./elgamal-encryption.js";
+export type { ElGamalPublicKey, ElGamalPrivateKey, ElGamalEncryptedData, ElGamalParams, } from "./elgamal-encryption.js";
+export { PostQuantumEncryption } from "./post-quantum-encryption.js";
+export { HybridEncryption } from "./hybrid-encryption.js";
+export type { HybridEncryptedData } from "./hybrid-encryption.js";
+export { hashVerificationCode, hashElectionRecord, generateFiatShamirChallenge, hashDeviceInfo, } from "./hash-utils.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/crypto/voting/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,YAAY,EACV,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,aAAa,GACd,MAAM,wBAAwB,CAAC;AAEhC,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC5D,YAAY,EACV,gBAAgB,EAChB,iBAAiB,EACjB,oBAAoB,EACpB,aAAa,GACd,MAAM,yBAAyB,CAAC;AAEjC,OAAO,EAAE,qBAAqB,EAAE,MAAM,8BAA8B,CAAC;AAErE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAC;AAC1D,YAAY,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAIlE,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,2BAA2B,EAC3B,cAAc,GACf,MAAM,iBAAiB,CAAC"}

package/dist/lib/crypto/voting/index.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Voting Cryptographic Module
+ *
+ * Exports encryption schemes for Secure Voting System.
+ * Provides modular architecture for algorithm swapping and post-quantum migration.
+ *
+ * Part of: Cryptographic Design Comparison
+ * Status: Module Exports
+ * Last Updated: January 2025
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashDeviceInfo = exports.generateFiatShamirChallenge = exports.hashElectionRecord = exports.hashVerificationCode = exports.HybridEncryption = exports.PostQuantumEncryption = exports.ElGamalEncryption = void 0;
+var elgamal_encryption_js_1 = require("./elgamal-encryption.js");
+Object.defineProperty(exports, "ElGamalEncryption", { enumerable: true, get: function () { return elgamal_encryption_js_1.ElGamalEncryption; } });
+var post_quantum_encryption_js_1 = require("./post-quantum-encryption.js");
+Object.defineProperty(exports, "PostQuantumEncryption", { enumerable: true, get: function () { return post_quantum_encryption_js_1.PostQuantumEncryption; } });
+var hybrid_encryption_js_1 = require("./hybrid-encryption.js");
+Object.defineProperty(exports, "HybridEncryption", { enumerable: true, get: function () { return hybrid_encryption_js_1.HybridEncryption; } });
+// Hash utilities using shared cryptographic library
+// Note: Hash functions use @de-otio/trellis (inlined crypto). ElGamal encryption remains separate (homomorphic requirement).
+var hash_utils_js_1 = require("./hash-utils.js");
+Object.defineProperty(exports, "hashVerificationCode", { enumerable: true, get: function () { return hash_utils_js_1.hashVerificationCode; } });
+Object.defineProperty(exports, "hashElectionRecord", { enumerable: true, get: function () { return hash_utils_js_1.hashElectionRecord; } });
+Object.defineProperty(exports, "generateFiatShamirChallenge", { enumerable: true, get: function () { return hash_utils_js_1.generateFiatShamirChallenge; } });
+Object.defineProperty(exports, "hashDeviceInfo", { enumerable: true, get: function () { return hash_utils_js_1.hashDeviceInfo; } });
+//# sourceMappingURL=index.js.map

package/dist/lib/crypto/voting/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/index.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AASH,iEAA4D;AAAnD,0HAAA,iBAAiB,OAAA;AAQ1B,2EAAqE;AAA5D,mIAAA,qBAAqB,OAAA;AAE9B,+DAA0D;AAAjD,wHAAA,gBAAgB,OAAA;AAGzB,oDAAoD;AACpD,6HAA6H;AAC7H,iDAKyB;AAJvB,qHAAA,oBAAoB,OAAA;AACpB,mHAAA,kBAAkB,OAAA;AAClB,4HAAA,2BAA2B,OAAA;AAC3B,+GAAA,cAAc,OAAA"}

package/dist/lib/crypto/voting/post-quantum-encryption.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Post-Quantum Encryption Stub
+ *
+ * Placeholder for future post-quantum encryption implementation.
+ * This will be implemented when post-quantum homomorphic encryption becomes available.
+ *
+ * Part of: Cryptographic Design Comparison
+ * Status: Stub/Placeholder
+ * Last Updated: January 2025
+ *
+ * Note: Post-quantum homomorphic encryption is still in research phase.
+ * This stub documents requirements and prepares for future implementation.
+ */
+import type { EncryptionScheme, PublicKey, PrivateKey, EncryptedData } from "./encryption-scheme.js";
+/**
+ * Post-Quantum Encryption Class (Stub)
+ *
+ * This is a placeholder for future post-quantum encryption implementation.
+ * Will be implemented when:
+ * 1. Post-quantum homomorphic encryption schemes become available
+ * 2. NIST standards are finalized for homomorphic encryption
+ * 3. Performance is acceptable for production use
+ */
+export declare class PostQuantumEncryption implements EncryptionScheme {
+    /**
+     * Algorithm identifier (to be determined)
+     */
+    private readonly algorithmName;
+    /**
+     * Encrypt a message using post-quantum encryption
+     *
+     * @param message - Message to encrypt
+     * @param publicKey - Post-quantum public key
+     * @returns Encrypted data
+     * @throws Error (not yet implemented)
+     */
+    encrypt(message: unknown, publicKey: PublicKey): Promise<EncryptedData>;
+    /**
+     * Decrypt encrypted data using post-quantum decryption
+     *
+     * @param encryptedData - Encrypted data to decrypt
+     * @param privateKey - Post-quantum private key
+     * @returns Decrypted message
+     * @throws Error (not yet implemented)
+     */
+    decrypt(encryptedData: EncryptedData, privateKey: PrivateKey): Promise<unknown>;
+    /**
+     * Check if post-quantum encryption is quantum-resistant
+     *
+     * @returns true (post-quantum schemes are quantum-resistant)
+     */
+    isQuantumResistant(): boolean;
+    /**
+     * Get algorithm name
+     *
+     * @returns Algorithm identifier
+     */
+    getAlgorithmName(): string;
+    /**
+     * Check if post-quantum encryption supports homomorphic operations
+     *
+     * @returns true (if homomorphic scheme is selected)
+     */
+    isHomomorphic(): boolean;
+    /**
+     * Perform homomorphic addition (if supported)
+     *
+     * @param encrypted1 - First encrypted value
+     * @param encrypted2 - Second encrypted value
+     * @returns Sum of encrypted values (encrypted)
+     * @throws Error (not yet implemented)
+     */
+    homomorphicAdd(encrypted1: EncryptedData, encrypted2: EncryptedData): Promise<EncryptedData>;
+}
+/**
+ * Requirements for Post-Quantum Implementation
+ *
+ * When implementing post-quantum encryption, consider:
+ *
+ * 1. **Algorithm Selection**:
+ *    - Must support homomorphic operations (for vote aggregation)
+ *    - Must be quantum-resistant (NIST-approved or candidate)
+ *    - Must have acceptable performance characteristics
+ *
+ * 2. **NIST Standards**:
+ *    - Monitor NIST PQC standards for homomorphic encryption
+ *    - Use approved algorithms when available
+ *    - Consider hybrid schemes during transition
+ *
+ * 3. **Performance**:
+ *    - Key sizes may be larger than classical schemes
+ *    - Encryption/decryption may be slower
+ *    - Homomorphic operations may have higher overhead
+ *
+ * 4. **Compatibility**:
+ *    - Must support same interface as ElGamalEncryption
+ *    - Must enable algorithm swapping
+ *    - Must support hybrid schemes
+ *
+ * 5. **Migration Path**:
+ *    - Support dual encryption (ElGamal + post-quantum)
+ *    - Maintain backward compatibility
+ *    - Gradual migration strategy
+ *
+ * See: doc/02-technical/architecture/cryptography/nist-pqc-monitoring.md
+ */
+//# sourceMappingURL=post-quantum-encryption.d.ts.map

package/dist/lib/crypto/voting/post-quantum-encryption.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-quantum-encryption.d.ts","sourceRoot":"","sources":["../../../../src/lib/crypto/voting/post-quantum-encryption.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EACV,gBAAgB,EAChB,SAAS,EACT,UAAU,EACV,aAAa,EACd,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;GAQG;AACH,qBAAa,qBAAsB,YAAW,gBAAgB;IAC5D;;OAEG;IACH,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA8B;IAE5D;;;;;;;OAOG;IACG,OAAO,CACX,OAAO,EAAE,OAAO,EAChB,SAAS,EAAE,SAAS,GACnB,OAAO,CAAC,aAAa,CAAC;IAMzB;;;;;;;OAOG;IACG,OAAO,CACX,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,UAAU,GACrB,OAAO,CAAC,OAAO,CAAC;IAMnB;;;;OAIG;IACH,kBAAkB,IAAI,OAAO;IAI7B;;;;OAIG;IACH,gBAAgB,IAAI,MAAM;IAI1B;;;;OAIG;IACH,aAAa,IAAI,OAAO;IAKxB;;;;;;;OAOG;IACG,cAAc,CAClB,UAAU,EAAE,aAAa,EACzB,UAAU,EAAE,aAAa,GACxB,OAAO,CAAC,aAAa,CAAC;CAK1B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG"}