import BigNumber from 'bignumber.js'; /** * Interface for a cryptographic system * @template SecretKey - The type of the secret key * @template SecretKeyShare - The type of the secret key share * @template PublicKey - The type of the public key * @template PlainText - The type of the plaintext * @template CipherText - The type of the ciphertext * @template PartialDecryptionResult - The type of the partial decryption result * @interface ICryptoSystem * @description This interface defines the methods and properties that a cryptographic system should implement. * It includes methods for encryption, decryption, serialization, and deserialization of keys and ciphertexts. * It also includes methods for converting between plaintext and ciphertext, and for combining partial decryptions. */ interface ICryptoSystem { /** * Generates a secret key * @returns A secret key */ keygen(): SecretKey; /** * Generates a public key from a secret key * @param secret_key A secret key to be used for generating the public key * @returns A public key */ keygen(secret_key: SecretKey): PublicKey; /** * Generates secret key shares from a secret key for threshold setting * @param secret_key A secret key to be used for generating the secret key shares * @param threshold The threshold for the secret key shares * @param total The total number of parties * @returns An array of arrays of secret key shares for each party for each threshold combination */ keygen(secret_key: SecretKey, threshold: number, total: number): SecretKeyShare[][]; /** * Converts normal float number to a plaintext object * @param value A number to be converted to a plaintext * @returns A plaintext object * @throws TypeError if the value is not a number * @throws RangeError if the value is not in the range of the plaintext */ make_plaintext: (value: bigint) => PlainText; /** * * Converts a plaintext object to a normal BigNumber * @param plaintext A plaintext object to be converted to a number * @returns A BigNumber object representing the plaintext value * @throws TypeError if the plaintext is not a correct plaintext object */ get_plaintext_value: (plaintext: PlainText) => BigNumber; /** * Encrypts a plaintext object using the public key * @param pk A public key to be used for encryption * @param plaintext A plaintext object to be encrypted * @returns A ciphertext object * @throws TypeError if the plaintext is not a correct plaintext object or/and the public key is not a correct public key object */ encrypt: (pk: PublicKey, pt: PlainText) => CipherText; /** * Combine partial decryptions to get the final plaintext * @param ciphertext A ciphertext object to be decrypted * @param partial_decryptions An array of partial decryptions to be combined * @returns A plaintext object * @throws TypeError if the ciphertext is not a correct ciphertext object or/and the partial decryptions are not correct partial decryption objects * @throws CoFHEValueError if the partial decryptions are not correct partial decryption objects */ combine_partial_decryption_results: (ciphertext: CipherText, partial_decryptions: PartialDecryptionResult[]) => PlainText; /** * Deserializes a secret key from a byte array * @param serialized_secret_key A byte array to be deserialized * @returns A secret key object * @throws TypeError if the byte array is not a correct byte array * @throws CoFHEValueError if the byte array is not a correct byte array */ deserialize_public_key: (serialized_pub_key: Uint8Array) => PublicKey; /** * Serializes a ciphertext to a byte array * @param ciphertext A ciphertext object to be serialized * @returns A byte array * @throws TypeError if the ciphertext is not a correct ciphertext object */ serialize_ciphertext: (ciphertext: CipherText) => Uint8Array; /** * Deserializes a ciphertext from a byte array * @param serialized_ciphertext A byte array to be deserialized * @returns A ciphertext object * @throws TypeError if the byte array is not a correct byte array */ deserialize_ciphertext: (serialized_ciphertext: Uint8Array) => CipherText; /** * Serializes a partial decryption result to a byte array * @param partial_decryption_result A partial decryption result to be serialized * @returns A byte array * @throws TypeError if the partial decryption result is not a correct partial decryption result object */ serialize_partial_decryption_result: (partial_decryption_result: PartialDecryptionResult) => Uint8Array; /** * Deserializes a partial decryption result from a byte array * @param serialized_partial_decryption_result A byte array to be deserialized * @throws TypeError if the byte array is not a correct byte array * @throws CoFHEValueError if the byte array is not a correct byte array */ deserialize_partial_decryption_result: (serialized_partial_decryption_result: Uint8Array) => PartialDecryptionResult; } declare class QFI { private a_m; private b_m; private c_m; constructor(a: bigint, b: bigint, c: bigint); clone(): QFI; a(): bigint; b(): bigint; c(): bigint; /** * Calculates the discriminant of the form */ discriminant(): bigint; /** * Checks if the form is the neutral element of the class group */ is_one(): boolean; /** * Makes the form negative */ neg(): void; /** * Returns ax^2 + bxy + cy^2 * @param x * @param y */ eval(x: bigint, y: bigint): bigint; lift(l: bigint): void; lift_2exp(k: number): void; to_maximal_order(l: bigint, deltaK: bigint, with_reduction?: boolean): void; to_maximal_order_2exp(k: number, deltaK: bigint, with_reduction?: boolean): void; kernel_representative(l: bigint, deltaK: bigint): bigint; kernel_representative_2exp(k: number, deltaK: bigint): bigint; set_c_from_disc(disc: bigint): void; normalize(): void; rho(): void; reduction(): void; prime_to(l: bigint): void; prime_to_2exp(): void; static nucomp(f1: QFI, f2: QFI, L: bigint, negf2: boolean): QFI; static nudupl(f: QFI, L: bigint): QFI; static nupow(f: QFI, n: bigint, L: bigint): QFI; static nupow_2_forms(f0: QFI, n0: bigint, f1: QFI, n1: bigint, L: bigint): QFI; static nupow_2_forms_2exp(f: QFI, n: bigint, d: number, e: number, fe: QFI, fd: QFI, fed: QFI, L: bigint): QFI; } declare class ClassGroup { kronecker(l: bigint): void; private disc_m; private default_nucomp_bound_m; private class_number_bound_m; constructor(disc_in: bigint, class_number_bound?: bigint); disc(): bigint; default_nucomp_bound(): bigint; one(): QFI; primeform(l: bigint): QFI; class_number_bound(): bigint; private calc_class_number_bound; nucomp(f1: QFI, f2: QFI): QFI; nucompinv(f1: QFI, f2: QFI): QFI; nudupl(f: QFI): QFI; nudupl_niter(f: QFI, niter: number): QFI; nupow(f: QFI, n: bigint): QFI; nupow_2_forms(f0: QFI, n0: bigint, f1: QFI, n1: bigint): QFI; nupow_2_forms_2exp(f: QFI, n: bigint, d: number, e: number, fe: QFI, fd: QFI, fed: QFI): QFI; } declare class RandGen { random_bigint(n: bigint): bigint; random_bigint_2exp(n: number): bigint; random_bytes(n: number): Uint8Array; random_bool(): boolean; random_prime(nbits_: number): bigint; private static get_bytes; } declare class CLHSM2kSecretKey { private sk_m; constructor(sk: bigint); get sk(): bigint; static create_new(cs: CLHSM2k, randgen: RandGen): CLHSM2kSecretKey; } declare class CLHSM2kPublicKey { private pk_m; private d_m; private e_m; private pk_e_precomp_m; private pk_d_precomp_m; private pk_de_precomp_m; constructor(pk: QFI, cs: CLHSM2k); get pk(): QFI; exponentiation(cs: CLHSM2k, n: bigint): QFI; static create_new(cs: CLHSM2k, sk: CLHSM2kSecretKey): CLHSM2kPublicKey; } declare class CLHSM2kCleartext { private m_m; constructor(m: bigint); get m(): bigint; static create_new(m: bigint): CLHSM2kCleartext; static decrypt(cs: CLHSM2k, sk: CLHSM2kSecretKey, ct: CLHSM2kCiphertext): CLHSM2kCleartext; } declare class CLHSM2kCiphertext { private c1_m; private c2_m; constructor(c1: QFI, c2: QFI); get c1(): QFI; get c2(): QFI; static create_new(cs: CLHSM2k, pk: CLHSM2kPublicKey, m: CLHSM2kCleartext, r: bigint): CLHSM2kCiphertext; static add_ciphertexts(cs: CLHSM2k, pk: CLHSM2kPublicKey, ct1: CLHSM2kCiphertext, ct2: CLHSM2kCiphertext, r: bigint): CLHSM2kCiphertext; static scal_ciphertexts(cs: CLHSM2k, pk: CLHSM2kPublicKey, pt: CLHSM2kCleartext, ct: CLHSM2kCiphertext, r: bigint): CLHSM2kCiphertext; } type CLHSM2kSecretKeyShare = bigint; type CLHSM2kPartialDecryptionResult = QFI; declare class CLHSM2k { private randgen; private large_message_variant_used_m; private n_m; private k_m; private m_m; private cl_delta_k_m; private cl_delta_m; private h_m; private distance_m; private exponent_bound_m; private d_m; private e_m; private h_e_precomp_m; private h_d_precomp_m; private h_de_precomp_m; constructor(n: bigint, k: number, cl_delta_k_class_number_bound?: bigint); static create(sec_bits: number, k: number): CLHSM2k; get large_message_variant_used(): boolean; get n(): bigint; get k(): number; get m(): bigint; get delta_k(): bigint; get delta(): bigint; get cl_delta_k(): ClassGroup; get cl_delta(): ClassGroup; get cl_g(): ClassGroup; get h(): QFI; get secretkey_bound(): bigint; get cleartext_bound(): bigint; get encrypt_randomness_bound(): bigint; get lambda_distance(): bigint; power_of_h(n: bigint): QFI; power_of_f(m: bigint): QFI; dlog_in_F(fm: QFI): bigint; from_Cl_DeltaK_to_Cl_Delta(f: QFI): QFI; keygen(): CLHSM2kSecretKey; keygen(sk: CLHSM2kSecretKey): CLHSM2kPublicKey; keygen(sk: CLHSM2kSecretKey, t: number, n: number): CLHSM2kSecretKeyShare[][]; create_cleartext(m: bigint): CLHSM2kCleartext; encrypt(pk: CLHSM2kPublicKey, m: CLHSM2kCleartext, r?: bigint): CLHSM2kCiphertext; decrypt(sk: CLHSM2kSecretKey, ct: CLHSM2kCiphertext): CLHSM2kCleartext; partial_decryption(ski: CLHSM2kSecretKeyShare, ct: CLHSM2kCiphertext): CLHSM2kPartialDecryptionResult; combine_partial_decryption_results(ct: CLHSM2kCiphertext, ds: CLHSM2kPartialDecryptionResult[]): CLHSM2kCleartext; add_ciphertexts(pk: CLHSM2kPublicKey, ca: CLHSM2kCiphertext, cb: CLHSM2kCiphertext): CLHSM2kCiphertext; scal_ciphertexts(pk: CLHSM2kPublicKey, pt: CLHSM2kCleartext, ct: CLHSM2kCiphertext): CLHSM2kCiphertext; private static random_n; private compute_delta_k; private compute_delta; private raise_to_power_m; private F_kerphi_square; private F_kerphi_div; } declare class CPUCryptoSystem implements ICryptoSystem { private k_m; private clhsm2k; constructor(sec_bits: number, k: number, clhsm2k?: CLHSM2k); static create_from_n(n: bigint, k: number, cl_delta_k_class_number?: bigint): CPUCryptoSystem; keygen(secret_key?: CLHSM2kSecretKey, t?: number, n?: number): CLHSM2kSecretKey & CLHSM2kPublicKey & bigint[][]; make_plaintext(value: bigint): CLHSM2kCleartext; get_plaintext_value(plaintext: CLHSM2kCleartext): BigNumber; encrypt(pk: CLHSM2kPublicKey, pt: CLHSM2kCleartext): CLHSM2kCiphertext; combine_partial_decryption_results(ciphertext: CLHSM2kCiphertext, partial_decryptions: CLHSM2kPartialDecryptionResult[]): CLHSM2kCleartext; deserialize_public_key(serialized_pub_key: Uint8Array): CLHSM2kPublicKey; serialize_partial_decryption_result(partial_decryption_result: CLHSM2kPartialDecryptionResult): Uint8Array; deserialize_partial_decryption_result(serialized_partial_decryption_result: Uint8Array): CLHSM2kPartialDecryptionResult; serialize_ciphertext(ciphertext: CLHSM2kCiphertext): Uint8Array; deserialize_ciphertext(serialized_ciphertext: Uint8Array): CLHSM2kCiphertext; serialize_qfi_binary(qfi: QFI): Uint8Array; private deserialize_qfi_binary; } declare function fetch_class_bound_from_addon_service(url: string): Promise; interface Reencryptor { reencrypt: (partial_decryption_result: PartialDecryptionResult, pkc_public_key: PKCPublicKey) => Promise; decrypt: (reencrypted_partial_decryption_results: Uint8Array[], ct: CipherText, reencryption_private_key: PKCSecretKey) => Promise; generate_reencryption_key_pair(): Promise<{ public_key: PKCPublicKey; secret_key: PKCSecretKey; }>; serialize_reencryption_private_key: (sk: PKCSecretKey) => Promise<Uint8Array>; serialize_reencryption_public_key: (pk: PKCPublicKey) => Promise<Uint8Array>; deserialize_reencryption_private_key: (serialized_reencryption_private_key: Uint8Array) => Promise<PKCSecretKey>; deserialize_reencryption_public_key: (serialized_reencryption_public_key: Uint8Array) => Promise<PKCPublicKey>; concatenate_reencrypted_partial_decryption_results: (reencrypted_partial_decryption_results: Uint8Array[]) => Promise<Uint8Array>; split_reencrypted_partial_decryption_results: (reencrypted_partial_decryption_results: Uint8Array) => Promise<Uint8Array[]>; } declare enum ComputeOperationType { UNARY = 0, BINARY = 1, TERNARY = 2 } declare enum ComputeOperation { DECRYPT = 0, REENCRYPT = 1, ADD = 2, SUBTRACT = 3, MULTIPLY = 4, DIVIDE = 5, LT = 6, GT = 7, EQ = 8, NEQ = 9, LTEQ = 10, GTEQ = 11 } declare enum DataType { SINGLE = 0, TENSOR = 1, TENSOR_ID = 2 } declare enum DataEncryptionType { PLAINTEXT = 0, CIPHERTEXT = 1 } declare class ComputeOperationOperand { data_type: DataType; encryption_type: DataEncryptionType; data: Uint8Array; constructor(data_type: DataType, encryption_type: DataEncryptionType, data: Uint8Array); to_string(): Uint8Array; static from_string(str: Uint8Array): ComputeOperationOperand; static from_string(str: Uint8Array, num_operands: number): ComputeOperationOperand[]; } declare class ComputeOperationInstance { operation_type: ComputeOperationType; operation: ComputeOperation; operands: ComputeOperationOperand[]; constructor(operation_type: ComputeOperationType, operation: ComputeOperation, operands: ComputeOperationOperand[]); to_string(): Uint8Array; static from_string(str: Uint8Array): ComputeOperationInstance; } declare class ComputeRequest { operation: ComputeOperationInstance; constructor(operation: ComputeOperationInstance); to_string(): Uint8Array; static from_string(str: Uint8Array): ComputeRequest; } declare enum ComputeResponseStatus { SUCCESS = 0, ERROR = 1 } declare class ComputeResponse { status: ComputeResponseStatus; data: Uint8Array; constructor(status: ComputeResponseStatus, data: Uint8Array); to_string(): Uint8Array; static from_string(str: Uint8Array): ComputeResponse; } declare enum NodeType { SETUP_NODE = 0, CoFHE_NODE = 1, COMPUTE_NODE = 2, CLIENT_NODE = 3 } interface NodeDetails { ip: string; port: string; type: NodeType; } declare enum ReencryptorType { RSA = 0 } interface ReencryptorDetails { type: ReencryptorType; key_size: number; } declare enum CryptoSystemType { CoFHE_CPU = 0 } interface CryptoSystemDetails { type: CryptoSystemType; public_key: Uint8Array; security_level: number; k: number; threshold: number; total_nodes: number; N: string; } declare class NetworkDetails { private self_node_m; private nodes_m; private cryptosystem_details_m; private secret_key_shares_m; private reencryption_details_m; constructor(self_node_m: NodeDetails, nodes_m: NodeDetails[], cryptosystem_details_m: CryptoSystemDetails, secret_key_shares_m: Uint8Array[], reencryption_details_m: ReencryptorDetails); get self_node(): NodeDetails; get nodes(): NodeDetails[]; get cryptosystem_details(): CryptoSystemDetails; get secret_key_shares(): Uint8Array[]; get reencryption_details(): ReencryptorDetails; to_json(): object; to_string(): string; static from_string(json_dump: string): NetworkDetails; } interface Computer { usable: boolean; connect(): Promise<void>; compute(req: ComputeRequest): Promise<ComputeResponse>; fetch_network_details(): Promise<NetworkDetails>; } declare class ClientNode<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey> { private cryptosystem_m; private reencryptor_m; private network_encryption_key_m; private computer_m; constructor(cryptosystem: ICryptoSystem<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult>, reencryptor: Reencryptor<CipherText, PlainText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey>, network_encryption_key: PublicKey, computer: Computer | null); get cryptosystem(): ICryptoSystem<SecretKey, SecretKeyShare, PublicKey, PlainText, CipherText, PartialDecryptionResult>; get reencryptor(): Reencryptor<CipherText, PlainText, PartialDecryptionResult, PKCSecretKey, PKCPublicKey>; get network_encryption_key(): PublicKey; compute(req: ComputeRequest): Promise<ComputeResponse>; } declare class NodeJsTCPComputer implements Computer { private setup_node_address; private setup_node_port; private compute_node_address; private compute_node_port; private compute_client; private keep_alive; private usable_m; constructor(setup_node_address: string, setup_node_port: number, keep_alive?: boolean); get usable(): boolean; connect(): Promise<void>; compute(req_: ComputeRequest): Promise<ComputeResponse>; fetch_network_details(): Promise<NetworkDetails>; } declare enum ProtocolVersion { V1 = 0 } declare enum ServiceType { COMPUTE_REQUEST = 0, COFHE_REQUEST = 1, SETUP_REQUEST = 2 } declare enum ResponseStatus { OK = 0, ERROR = 1 } declare class ResponseHeader { private ver_m; private type_m; private status_m; private data_size_m; constructor(ver_m: ProtocolVersion, type_m: ServiceType, status_m: ResponseStatus, data_size_m: bigint); get protocol_version(): ProtocolVersion; get type(): ServiceType; get status(): ResponseStatus; get data_size(): bigint; to_string(): Uint8Array; static from_string(str: Uint8Array): ResponseHeader; } declare class Response { private header_m; private data_m; constructor(header_m: ResponseHeader, data_m: Uint8Array); get header(): ResponseHeader; get protocol_version(): ProtocolVersion; get type(): ServiceType; get status(): ResponseStatus; get data_size(): bigint; get data(): Uint8Array; to_string(): Uint8Array; static from_string(str: Uint8Array): Response; } declare class RequestHeader { private ver_m; private type_m; private data_size_m; constructor(ver_m: ProtocolVersion, type_m: ServiceType, data_size_m: bigint); get protocol_version(): ProtocolVersion; get type(): ServiceType; get data_size(): bigint; to_string(): Uint8Array; static from_string(str: Uint8Array): RequestHeader; } declare class Request { private header_m; private data_m; constructor(header_m: RequestHeader, data_m: Uint8Array); get header(): RequestHeader; get protocol_version(): ProtocolVersion; get type(): ServiceType; get data_size(): bigint; get data(): Uint8Array; to_string(): Uint8Array; static from_string(str: Uint8Array): Request; } declare enum NetworkDetailsResponseStatus { OK = 0, ERROR = 1 } declare class NetworkDetailsResponseHeader { private status_m; private data_size_m; constructor(status_m: NetworkDetailsResponseStatus, data_size_m: bigint); get status(): NetworkDetailsResponseStatus; get data_size(): bigint; to_string(): Uint8Array; static from_string(str: Uint8Array): NetworkDetailsResponseHeader; } declare class NetworkDetailsResponse { private header_m; private data_m; constructor(header_m: NetworkDetailsResponseHeader, data_m: Uint8Array); get header(): NetworkDetailsResponseHeader; get status(): NetworkDetailsResponseStatus; get data_size(): bigint; get data(): Uint8Array; to_string(): Uint8Array; static from_string(str: Uint8Array): NetworkDetailsResponse; } declare enum NetworkDetailsRequestType { GET = 0, SET = 1 } declare class NetworkDetailsRequestHeader { private type_m; private data_size_m; constructor(type_m: NetworkDetailsRequestType, data_size_m: bigint); get type(): NetworkDetailsRequestType; get data_size(): bigint; to_string(): Uint8Array; static from_string(str: Uint8Array): NetworkDetailsRequestHeader; } declare class NetworkDetailsRequest { private header_m; private data_m; constructor(header_m: NetworkDetailsRequestHeader, data_m: Uint8Array); get header(): NetworkDetailsRequestHeader; get type(): NetworkDetailsRequestType; get data_size(): bigint; get data(): Uint8Array; to_string(): Uint8Array; static from_string(str: Uint8Array): NetworkDetailsRequest; } declare enum SetupResponseStatus { OK = 0, ERROR = 1 } declare class SetupResponseHeader { private status_m; private data_size_m; constructor(status_m: SetupResponseStatus, data_size_m: bigint); get status(): SetupResponseStatus; get data_size(): bigint; to_string(): Uint8Array; static from_string(str: Uint8Array): SetupResponseHeader; } declare class SetupResponse { private header_m; private data_m; constructor(header_m: SetupResponseHeader, data_m: Uint8Array); get header(): SetupResponseHeader; get status(): SetupResponseStatus; get data_size(): bigint; get data(): Uint8Array; to_string(): Uint8Array; static from_string(str: Uint8Array): SetupResponse; } declare enum SetupRequestType { BEAVERS_TRIPLET_REQUEST = 0, COMPARISION_PAIR_REQUEST = 1, JOIN_AS_NODE_REQUEST = 2, NETWORK_DETAILS_REQUEST = 3 } declare class SetupRequestHeader { private type_m; private data_size_m; constructor(type_m: SetupRequestType, data_size_m: bigint); get type(): SetupRequestType; get data_size(): bigint; to_string(): Uint8Array; static from_string(str: Uint8Array): SetupRequestHeader; } declare class SetupRequest { private header_m; private data_m; constructor(header_m: SetupRequestHeader, data_m: Uint8Array); get header(): SetupRequestHeader; get type(): SetupRequestType; get data_size(): bigint; get data(): Uint8Array; to_string(): Uint8Array; static from_string(str: Uint8Array): SetupRequest; } declare class HTTPRelayComputer implements Computer { private url; constructor(url: string); get usable(): boolean; connect(): Promise<void>; compute(req_: ComputeRequest): Promise<ComputeResponse>; fetch_network_details(): Promise<NetworkDetails>; } type RSAEncryptorPublicKey = CryptoKey; type RSAEncryptorPrivateKey = CryptoKey; declare class CPUCryptoSystemRSAReencryptorClientNode extends ClientNode<CLHSM2kSecretKey, CLHSM2kSecretKeyShare, CLHSM2kPublicKey, CLHSM2kCleartext, CLHSM2kCiphertext, CLHSM2kPartialDecryptionResult, RSAEncryptorPrivateKey, RSAEncryptorPublicKey> { constructor(security_level: number, k: number, N: string, reencryptor_key_size: number, computer: Computer | null, network_encryption_key: Uint8Array, cl_delta_k_class_number?: bigint); } declare function make_cpu_crypto_system_rsa_reencryptor_client_node(computer: Computer, cl_delta_k_class_number?: bigint): Promise<CPUCryptoSystemRSAReencryptorClientNode>; export { CLHSM2k, CLHSM2kCiphertext, CLHSM2kCleartext, CLHSM2kPublicKey, CLHSM2kSecretKey, CPUCryptoSystem, CPUCryptoSystemRSAReencryptorClientNode, ComputeOperation, ComputeOperationInstance, ComputeOperationOperand, ComputeOperationType, ComputeRequest, ComputeResponse, ComputeResponseStatus, DataEncryptionType, DataType, HTTPRelayComputer, NetworkDetails, NetworkDetailsRequest, NetworkDetailsRequestHeader, NetworkDetailsRequestType, NetworkDetailsResponse, NetworkDetailsResponseStatus, NodeJsTCPComputer, NodeType, ProtocolVersion, ReencryptorType, Request, Response, ResponseHeader, ResponseStatus, ServiceType, SetupRequest, SetupRequestHeader, SetupRequestType, SetupResponse, SetupResponseStatus, fetch_class_bound_from_addon_service, make_cpu_crypto_system_rsa_reencryptor_client_node }; export type { CryptoSystemDetails, ICryptoSystem, ReencryptorDetails };