@cmts-dev/carmentis-sdk-core 1.2.3 → 1.2.5

package/dist/crypto/encoder/signature/hcv/MLDSA65HCVSignatureDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MLDSA65HCVSignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/MLDSA65HCVSignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAGzE;;;;;;;;;GASG;AACH,qBAAa,0BAA2B,SAAQ,yBAAyB;IAErE,OAAO,CAAC,MAAM,CAAC,sBAAsB,CAAa;IAElD;;OAEG;;IAKH,SAAS,CAAC,mBAAmB,CAAC,eAAe,EAAE,UAAU,GAAG,mBAAmB;IAI/E,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,UAAU,GAAG,kBAAkB;CAG/E"}

package/dist/crypto/encoder/signature/hcv/MLDSA65HCVSignatureEncoder.d.ts

@@ -0,0 +1,37 @@
+import { NativeHCVSignatureEncoder } from './NativeHCVSignatureEncoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * HCV encoder for ML-DSA-65 signature keys.
+ *
+ * Handles the encoding of ML-DSA-65 (Module-Lattice-Based Digital Signature Algorithm)
+ * post-quantum cryptography keys into HCV format.
+ *
+ * The generated HCV format is:
+ * - SIG:MLDSA65:SK:<base64_private_key> for private keys
+ * - SIG:MLDSA65:PK:<base64_public_key> for public keys
+ *
+ * ML-DSA-65 is a post-quantum signature scheme based on lattice cryptography,
+ * designed to be secure against attacks by quantum computers.
+ */
+export declare class MLDSA65HCVSignatureEncoder extends NativeHCVSignatureEncoder {
+    /**
+     * Creates a new MLDSA65HCVSignatureEncoder instance.
+     */
+    constructor();
+    /**
+     * Checks if this encoder can handle the given private key.
+     *
+     * @param privateKey - The private key to check
+     * @returns True if the key is a MLDSA65PrivateSignatureKey
+     */
+    isAcceptingPrivateKeyEncodingRequest(privateKey: PrivateSignatureKey): Promise<boolean>;
+    /**
+     * Checks if this encoder can handle the given public key.
+     *
+     * @param publicKey - The public key to check
+     * @returns True if the key is a MLDSA65PublicSignatureKey
+     */
+    isAcceptingPublicKeyEncodingRequest(publicKey: PublicSignatureKey): Promise<boolean>;
+}
+//# sourceMappingURL=MLDSA65HCVSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/MLDSA65HCVSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MLDSA65HCVSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/MLDSA65HCVSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAGzE;;;;;;;;;;;;GAYG;AACH,qBAAa,0BAA2B,SAAQ,yBAAyB;IAErE;;OAEG;;IAKH;;;;;OAKG;IACG,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7F;;;;;OAKG;IACG,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;CAG7F"}

package/dist/crypto/encoder/signature/hcv/NativeHCVSignatureDecoder.d.ts

@@ -0,0 +1,45 @@
+import { BaseHCVSignatureDecoder } from './BaseHCVSignatureDecoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * Abstract decoder for native (non-PKMS) signature keys stored in HCV format.
+ *
+ * This decoder handles keys where the raw cryptographic material is stored directly
+ * in the encoded format, as opposed to keys stored in a key management service.
+ *
+ * Subclasses must implement the bootstrapping methods to create the appropriate
+ * key objects from the decoded byte arrays.
+ */
+export declare abstract class NativeHCVSignatureDecoder extends BaseHCVSignatureDecoder {
+    /**
+     * Creates a private signature key instance from the raw key bytes.
+     *
+     * @param privateKeyBytes - The raw bytes of the private key
+     * @returns A PrivateSignatureKey instance
+     */
+    protected abstract bootstrapPrivateKey(privateKeyBytes: Uint8Array): PrivateSignatureKey;
+    /**
+     * Creates a public signature key instance from the raw key bytes.
+     *
+     * @param publicKeyBytes - The raw bytes of the public key
+     * @returns A PublicSignatureKey instance
+     */
+    protected abstract bootstrapPublicKey(publicKeyBytes: Uint8Array): PublicSignatureKey;
+    /**
+     * Decodes an HCV-encoded private key into a PrivateSignatureKey instance.
+     * Extracts the base64-encoded key bytes and delegates to bootstrapPrivateKey.
+     *
+     * @param encodedPrivateKey - The HCV-encoded private key string
+     * @returns The decoded PrivateSignatureKey
+     */
+    decodePrivateKey(encodedPrivateKey: string): Promise<PrivateSignatureKey>;
+    /**
+     * Decodes an HCV-encoded public key into a PublicSignatureKey instance.
+     * Extracts the base64-encoded key bytes and delegates to bootstrapPublicKey.
+     *
+     * @param encodedPublicKey - The HCV-encoded public key string
+     * @returns The decoded PublicSignatureKey
+     */
+    decodePublicKey(encodedPublicKey: string): Promise<PublicSignatureKey>;
+}
+//# sourceMappingURL=NativeHCVSignatureDecoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/NativeHCVSignatureDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeHCVSignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/NativeHCVSignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAGzE;;;;;;;;GAQG;AACH,8BAAsB,yBAA0B,SAAQ,uBAAuB;IAE3E;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,mBAAmB,CAAC,eAAe,EAAE,UAAU,GAAG,mBAAmB;IAExF;;;;;OAKG;IACH,SAAS,CAAC,QAAQ,CAAC,kBAAkB,CAAC,cAAc,EAAE,UAAU,GAAG,kBAAkB;IAErF;;;;;;OAMG;IACG,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAM/E;;;;;;OAMG;IACG,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAK/E"}

package/dist/crypto/encoder/signature/hcv/NativeHCVSignatureEncoder.d.ts

@@ -0,0 +1,31 @@
+import { BaseHCVSignatureEncoder } from './BaseHCVSignatureEncoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * Abstract encoder for native (non-PKMS) signature keys into HCV format.
+ *
+ * This encoder handles keys where the raw cryptographic material is encoded directly
+ * into the HCV format, as opposed to keys stored in a key management service.
+ *
+ * Subclasses must implement the acceptance methods to determine which key types
+ * they can encode.
+ */
+export declare abstract class NativeHCVSignatureEncoder extends BaseHCVSignatureEncoder {
+    /**
+     * Creates a new NativeHCVSignatureEncoder.
+     *
+     * @param labels - The hierarchical labels used to identify this signature type in HCV format
+     */
+    constructor(labels: string[]);
+    /**
+     * Encodes a private signature key into HCV format.
+     * The private key bytes are base64-encoded and prefixed with the appropriate HCV labels.
+     *
+     * @param privateKey - The private key to encode
+     * @returns The HCV-encoded private key string
+     */
+    encodePrivateKey(privateKey: PrivateSignatureKey): Promise<string>;
+    abstract isAcceptingPrivateKeyEncodingRequest(privateKey: PrivateSignatureKey): Promise<boolean>;
+    abstract isAcceptingPublicKeyEncodingRequest(publicKey: PublicSignatureKey): Promise<boolean>;
+}
+//# sourceMappingURL=NativeHCVSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/NativeHCVSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NativeHCVSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/NativeHCVSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAGzE;;;;;;;;GAQG;AACH,8BAAsB,yBAA0B,SAAQ,uBAAuB;IAE3E;;;;OAIG;gBACS,MAAM,EAAE,MAAM,EAAE;IAI5B;;;;;;OAMG;IACG,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;IAOxE,QAAQ,CAAC,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAChG,QAAQ,CAAC,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;CAChG"}

package/dist/crypto/encoder/signature/hcv/PkmsSecp256k1SignatureDecoder.d.ts

@@ -0,0 +1,38 @@
+import { BaseHCVSignatureDecoder } from './BaseHCVSignatureDecoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * HCV decoder for PKMS (Public Key Management Service) Secp256k1 signature keys.
+ *
+ * Handles the decoding of Secp256k1 keys managed by a PKMS service.
+ * Unlike native key storage, PKMS keys store only a key identifier (keyId) for private keys,
+ * while the actual cryptographic material is stored securely in the PKMS service.
+ *
+ * The expected HCV format is:
+ * - SIG:PKMS:SECP256K1:SK:<keyId> for private keys
+ * - SIG:PKMS:SECP256K1:PK:<base64_public_key> for public keys
+ */
+export declare class PkmsSecp256k1SignatureDecoder extends BaseHCVSignatureDecoder {
+    private static label;
+    /**
+     * Creates a new PkmsSecp256k1SignatureDecoder instance.
+     */
+    constructor();
+    /**
+     * Decodes a PKMS private key from HCV format.
+     * Extracts the key identifier that references the key stored in the PKMS service.
+     *
+     * @param encodedPrivateKey - The HCV-encoded PKMS key identifier
+     * @returns A PkmsSecp256k1PrivateSignatureKey instance containing the key ID
+     */
+    decodePrivateKey(encodedPrivateKey: string): Promise<PrivateSignatureKey>;
+    /**
+     * Decodes a PKMS public key from HCV format.
+     * The public key is stored as base64-encoded bytes in the HCV format.
+     *
+     * @param encodedPublicKey - The HCV-encoded public key
+     * @returns A PkmsSecp256k1PublicSignatureKey instance
+     */
+    decodePublicKey(encodedPublicKey: string): Promise<PublicSignatureKey>;
+}
+//# sourceMappingURL=PkmsSecp256k1SignatureDecoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/PkmsSecp256k1SignatureDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PkmsSecp256k1SignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/PkmsSecp256k1SignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAOzE;;;;;;;;;;GAUG;AACH,qBAAa,6BAA8B,SAAQ,uBAAuB;IAEtE,OAAO,CAAC,MAAM,CAAC,KAAK,CAGlB;IAEF;;OAEG;;IAKH;;;;;;OAMG;IACG,gBAAgB,CAAC,iBAAiB,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAM/E;;;;;;OAMG;IACG,eAAe,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAK/E"}

package/dist/crypto/encoder/signature/hcv/PkmsSecp256k1SignatureEncoder.d.ts

@@ -0,0 +1,44 @@
+import { BaseHCVSignatureEncoder } from './BaseHCVSignatureEncoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * HCV encoder for PKMS (Public Key Management Service) Secp256k1 signature keys.
+ *
+ * Handles the encoding of Secp256k1 keys managed by a PKMS service into HCV format.
+ * Unlike native key storage, PKMS private keys encode only the key identifier (keyId),
+ * while the actual cryptographic material is stored securely in the PKMS service.
+ *
+ * The generated HCV format is:
+ * - SIG:PKMS:SECP256K1:SK:<keyId> for private keys
+ * - SIG:PKMS:SECP256K1:PK:<base64_public_key> for public keys
+ */
+export declare class PkmsSecp256k1SignatureEncoder extends BaseHCVSignatureEncoder {
+    /**
+     * Creates a new PkmsSecp256k1SignatureEncoder instance.
+     */
+    constructor();
+    /**
+     * Checks if this encoder can handle the given private key.
+     *
+     * @param privateKey - The private key to check
+     * @returns True if the key is a PkmsSecp256k1PrivateSignatureKey
+     */
+    isAcceptingPrivateKeyEncodingRequest(privateKey: PrivateSignatureKey): Promise<boolean>;
+    /**
+     * Checks if this encoder can handle the given public key.
+     *
+     * @param publicKey - The public key to check
+     * @returns True if the key is a PkmsSecp256k1PublicSignatureKey
+     */
+    isAcceptingPublicKeyEncodingRequest(publicKey: PublicSignatureKey): Promise<boolean>;
+    /**
+     * Encodes a PKMS private key into HCV format.
+     * Only the key identifier is encoded, not the actual key material.
+     *
+     * @param privateKey - The PKMS private key to encode
+     * @returns The HCV-encoded key identifier
+     * @throws Error if the key is not a PkmsSecp256k1PrivateSignatureKey
+     */
+    encodePrivateKey(privateKey: PrivateSignatureKey): Promise<string>;
+}
+//# sourceMappingURL=PkmsSecp256k1SignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/PkmsSecp256k1SignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PkmsSecp256k1SignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/PkmsSecp256k1SignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAOzE;;;;;;;;;;GAUG;AACH,qBAAa,6BAA8B,SAAQ,uBAAuB;IAEtE;;OAEG;;IAQH;;;;;OAKG;IACG,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7F;;;;;OAKG;IACG,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI1F;;;;;;;OAOG;IACG,gBAAgB,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,MAAM,CAAC;CAQ3E"}

package/dist/crypto/encoder/signature/hcv/Secp256k1HCVSignatureDecoder.d.ts

@@ -0,0 +1,10 @@
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+import { NativeHCVSignatureDecoder } from './NativeHCVSignatureDecoder';
+export declare class Secp256k1HCVSignatureDecoder extends NativeHCVSignatureDecoder {
+    private static label;
+    constructor();
+    protected bootstrapPrivateKey(privateKeyBytes: Uint8Array): PrivateSignatureKey;
+    protected bootstrapPublicKey(publicKeyBytes: Uint8Array): PublicSignatureKey;
+}
+//# sourceMappingURL=Secp256k1HCVSignatureDecoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/Secp256k1HCVSignatureDecoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secp256k1HCVSignatureDecoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/Secp256k1HCVSignatureDecoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AACzE,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AAItE,qBAAa,4BAA6B,SAAQ,yBAAyB;IACvE,OAAO,CAAC,MAAM,CAAC,KAAK,CAAc;;IAMlC,SAAS,CAAC,mBAAmB,CAAC,eAAe,EAAE,UAAU,GAAG,mBAAmB;IAI/E,SAAS,CAAC,kBAAkB,CAAC,cAAc,EAAE,UAAU,GAAG,kBAAkB;CAG/E"}

package/dist/crypto/encoder/signature/hcv/Secp256k1HCVSignatureEncoder.d.ts

@@ -0,0 +1,32 @@
+import { NativeHCVSignatureEncoder } from './NativeHCVSignatureEncoder';
+import { PrivateSignatureKey } from '../../../signature/PrivateSignatureKey';
+import { PublicSignatureKey } from '../../../signature/PublicSignatureKey';
+/**
+ * HCV encoder for Secp256k1 signature keys.
+ *
+ * Handles the encoding of Secp256k1 elliptic curve cryptography keys into HCV format.
+ * The generated HCV format is:
+ * - SIG:SECP256K1:SK:<base64_private_key> for private keys
+ * - SIG:SECP256K1:PK:<base64_public_key> for public keys
+ */
+export declare class Secp256k1HCVSignatureEncoder extends NativeHCVSignatureEncoder {
+    /**
+     * Creates a new Secp256k1HCVSignatureEncoder instance.
+     */
+    constructor();
+    /**
+     * Checks if this encoder can handle the given private key.
+     *
+     * @param privateKey - The private key to check
+     * @returns True if the key is a Secp256k1PrivateSignatureKey
+     */
+    isAcceptingPrivateKeyEncodingRequest(privateKey: PrivateSignatureKey): Promise<boolean>;
+    /**
+     * Checks if this encoder can handle the given public key.
+     *
+     * @param publicKey - The public key to check
+     * @returns True if the key is a Secp256k1PublicSignatureKey
+     */
+    isAcceptingPublicKeyEncodingRequest(publicKey: PublicSignatureKey): Promise<boolean>;
+}
+//# sourceMappingURL=Secp256k1HCVSignatureEncoder.d.ts.map

package/dist/crypto/encoder/signature/hcv/Secp256k1HCVSignatureEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Secp256k1HCVSignatureEncoder.d.ts","sourceRoot":"","sources":["../../../../../src/crypto/encoder/signature/hcv/Secp256k1HCVSignatureEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,yBAAyB,EAAC,MAAM,6BAA6B,CAAC;AACtE,OAAO,EAAC,mBAAmB,EAAC,MAAM,wCAAwC,CAAC;AAC3E,OAAO,EAAC,kBAAkB,EAAC,MAAM,uCAAuC,CAAC;AAIzE;;;;;;;GAOG;AACH,qBAAa,4BAA6B,SAAQ,yBAAyB;IAEvE;;OAEG;;IAKH;;;;;OAKG;IACG,oCAAoC,CAAC,UAAU,EAAE,mBAAmB,GAAG,OAAO,CAAC,OAAO,CAAC;IAI7F;;;;;OAKG;IACG,mCAAmC,CAAC,SAAS,EAAE,kBAAkB,GAAG,OAAO,CAAC,OAAO,CAAC;CAG7F"}

package/dist/crypto/encryption/public-key-encryption/HCVPkeEncoder.d.ts

@@ -0,0 +1,18 @@
+import { PkeEncoderInterface } from './PkeEncoderInterface';
+import { AbstractPrivateDecryptionKey, AbstractPublicEncryptionKey } from './PublicKeyEncryptionSchemeInterface';
+import { EncoderInterface } from '../../../utils/encoder';
+export declare class HCVPkeEncoder implements PkeEncoderInterface {
+    private readonly stringEncoder;
+    private static PKE_KEY;
+    private static SK_PKE_KEY;
+    private static PK_PKE_KEY;
+    private static readonly PKE_SCHEMES;
+    static createHexHCVPkeEncoder(): HCVPkeEncoder;
+    static createBase64HCVPkeEncoder(): HCVPkeEncoder;
+    constructor(stringEncoder: EncoderInterface<Uint8Array, string>);
+    decodePrivateDecryptionKey(privateKey: string): Promise<AbstractPrivateDecryptionKey>;
+    decodePublicEncryptionKey(publicKey: string): Promise<AbstractPublicEncryptionKey>;
+    encodePrivateDecryptionKey(privateKey: AbstractPrivateDecryptionKey): Promise<string>;
+    encodePublicEncryptionKey(key: AbstractPublicEncryptionKey): Promise<string>;
+}
+//# sourceMappingURL=HCVPkeEncoder.d.ts.map

package/dist/crypto/encryption/public-key-encryption/HCVPkeEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"HCVPkeEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/HCVPkeEncoder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAC1D,OAAO,EAAC,4BAA4B,EAAE,2BAA2B,EAAC,MAAM,sCAAsC,CAAC;AAC/G,OAAO,EAAiB,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AAKxE,qBAAa,aAAc,YAAW,mBAAmB;IAiBzC,OAAO,CAAC,QAAQ,CAAE,aAAa;IAhB3C,OAAO,CAAC,MAAM,CAAC,OAAO,CAAS;IAC/B,OAAO,CAAC,MAAM,CAAC,UAAU,CAAQ;IACjC,OAAO,CAAC,MAAM,CAAC,UAAU,CAAQ;IAEjC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,WAAW,CAEjC;IAEF,MAAM,CAAC,sBAAsB;IAI7B,MAAM,CAAC,yBAAyB;gBAIF,aAAa,EAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC;IAE3E,0BAA0B,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC;IAerF,yBAAyB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,2BAA2B,CAAC;IAelF,0BAA0B,CAAC,UAAU,EAAE,4BAA4B,GAAG,OAAO,CAAC,MAAM,CAAC;IAUrF,yBAAyB,CAAC,GAAG,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC;CAQrF"}

package/dist/crypto/encryption/public-key-encryption/MlKemCiphertextEncoder.d.ts

@@ -0,0 +1,13 @@
+type MlKemCiphertextType = {
+    encryptedSharedSecret: Uint8Array;
+    encryptedMessage: Uint8Array;
+};
+export declare class MlKemCiphertextEncoder {
+    private static schema;
+    private serializer;
+    private deserializer;
+    encode(encryptedSharedSecret: Uint8Array, encryptedMessage: Uint8Array): Uint8Array;
+    decode(ciphertext: Uint8Array): MlKemCiphertextType;
+}
+export {};
+//# sourceMappingURL=MlKemCiphertextEncoder.d.ts.map

package/dist/crypto/encryption/public-key-encryption/MlKemCiphertextEncoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MlKemCiphertextEncoder.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/MlKemCiphertextEncoder.ts"],"names":[],"mappings":"AAGA,KAAK,mBAAmB,GAAG;IACvB,qBAAqB,EAAE,UAAU,CAAC;IAClC,gBAAgB,EAAE,UAAU,CAAA;CAC/B,CAAA;AAED,qBAAa,sBAAsB;IAE/B,OAAO,CAAC,MAAM,CAAC,MAAM,CAapB;IAED,OAAO,CAAC,UAAU,CAA2E;IAC7F,OAAO,CAAC,YAAY,CAA6E;IAEjG,MAAM,CAAC,qBAAqB,EAAE,UAAU,EAAE,gBAAgB,EAAE,UAAU,GAAG,UAAU;IAInF,MAAM,CAAC,UAAU,EAAE,UAAU,GAAI,mBAAmB;CAGvD"}

package/dist/crypto/encryption/public-key-encryption/MlKemPrivateDecryptionKey.d.ts

@@ -0,0 +1,24 @@
+import { AbstractPrivateDecryptionKey } from './PublicKeyEncryptionSchemeInterface';
+import { MlKemPublicEncryptionKey } from './MlKemPublicEncryptionKey';
+import { MlKemPublicKeyEncryptionScheme } from './MlKemPublicKeyEncryptionScheme';
+export declare class MlKemPrivateDecryptionKey extends AbstractPrivateDecryptionKey {
+    private readonly seed;
+    /**
+     * Generates a private decryption key from a seed.
+     * @param seed
+     */
+    static genFromSeed(seed: Uint8Array): Promise<MlKemPrivateDecryptionKey>;
+    /**
+     * Generates a random private decryption key.
+     */
+    static gen(): Promise<MlKemPrivateDecryptionKey>;
+    private readonly privateKey;
+    private readonly publicKey;
+    private constructor();
+    getSupportedSeedLength(): number[];
+    getScheme(): MlKemPublicKeyEncryptionScheme;
+    getPublicKey(): Promise<MlKemPublicEncryptionKey>;
+    getRawPrivateKey(): Uint8Array;
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+}
+//# sourceMappingURL=MlKemPrivateDecryptionKey.d.ts.map

package/dist/crypto/encryption/public-key-encryption/MlKemPrivateDecryptionKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MlKemPrivateDecryptionKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/MlKemPrivateDecryptionKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,4BAA4B,EAAC,MAAM,sCAAsC,CAAC;AAIlF,OAAO,EAAC,wBAAwB,EAAC,MAAM,4BAA4B,CAAC;AACpE,OAAO,EAAC,8BAA8B,EAAC,MAAM,kCAAkC,CAAC;AAIhF,qBAAa,yBAA0B,SAAQ,4BAA4B;IAuBnD,OAAO,CAAC,QAAQ,CAAC,IAAI;IAtBzC;;;OAGG;WACU,WAAW,CAAC,IAAI,EAAE,UAAU;IAOzC;;OAEG;WACU,GAAG;IAKhB,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAa;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAa;IAEvC,OAAO;IAOP,sBAAsB,IAAI,MAAM,EAAE;IAIlC,SAAS,IAAI,8BAA8B;IAIrC,YAAY,IAAI,OAAO,CAAC,wBAAwB,CAAC;IAIvD,gBAAgB,IAAI,UAAU;IAIxB,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;CAmB7D"}

package/dist/crypto/encryption/public-key-encryption/MlKemPublicEncryptionKey.d.ts

@@ -0,0 +1,10 @@
+import { AbstractPublicEncryptionKey, AbstractPublicKeyEncryptionScheme } from './PublicKeyEncryptionSchemeInterface';
+export declare class MlKemPublicEncryptionKey extends AbstractPublicEncryptionKey {
+    private readonly publicKey;
+    private static encoder;
+    constructor(publicKey: Uint8Array);
+    encrypt(message: Uint8Array): Promise<Uint8Array>;
+    getRawPublicKey(): Promise<Uint8Array>;
+    getScheme(): AbstractPublicKeyEncryptionScheme;
+}
+//# sourceMappingURL=MlKemPublicEncryptionKey.d.ts.map

package/dist/crypto/encryption/public-key-encryption/MlKemPublicEncryptionKey.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MlKemPublicEncryptionKey.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/MlKemPublicEncryptionKey.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,2BAA2B,EAAE,iCAAiC,EAAC,MAAM,sCAAsC,CAAC;AAQpH,qBAAa,wBAAyB,SAAQ,2BAA2B;IAGzD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAFtC,OAAO,CAAC,MAAM,CAAC,OAAO,CAAyC;gBAElC,SAAS,EAAE,UAAU;IAI5C,OAAO,CAAC,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAQjD,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC;IAI5C,SAAS,IAAI,iCAAiC;CAGjD"}

package/dist/crypto/encryption/public-key-encryption/MlKemPublicKeyEncryptionScheme.d.ts

@@ -0,0 +1,7 @@
+import { AbstractPublicKeyEncryptionScheme } from './PublicKeyEncryptionSchemeInterface';
+import { PublicKeyEncryptionSchemeId } from './PublicKeyEncryptionSchemeId';
+export declare class MlKemPublicKeyEncryptionScheme extends AbstractPublicKeyEncryptionScheme {
+    getSchemeId(): PublicKeyEncryptionSchemeId;
+    getSupportedSeedLength(): number[];
+}
+//# sourceMappingURL=MlKemPublicKeyEncryptionScheme.d.ts.map

package/dist/crypto/encryption/public-key-encryption/MlKemPublicKeyEncryptionScheme.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MlKemPublicKeyEncryptionScheme.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/MlKemPublicKeyEncryptionScheme.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,iCAAiC,EAAC,MAAM,sCAAsC,CAAC;AACvF,OAAO,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAC;AAE1E,qBAAa,8BAA+B,SAAQ,iCAAiC;IACjF,WAAW,IAAI,2BAA2B;IAI1C,sBAAsB,IAAI,MAAM,EAAE;CAGrC"}

package/dist/crypto/encryption/public-key-encryption/PkeEncoderFactory.d.ts

@@ -0,0 +1,13 @@
+import { PkeEncoderInterface } from './PkeEncoderInterface';
+/**
+ * Factory class for creating PKE (Public Key Encryption) encoders.
+ */
+export declare class PkeEncoderFactory {
+    /**
+     * Returns the default encoder instance configured as a Base64 HCVPkeEncoder.
+     *
+     * @return {PkeEncoderInterface} The default encoder implementing the PkeEncoderInterface.
+     */
+    static defaultEncoder(): PkeEncoderInterface;
+}
+//# sourceMappingURL=PkeEncoderFactory.d.ts.map

package/dist/crypto/encryption/public-key-encryption/PkeEncoderFactory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PkeEncoderFactory.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/PkeEncoderFactory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,mBAAmB,EAAC,MAAM,uBAAuB,CAAC;AAI1D;;GAEG;AACH,qBAAa,iBAAiB;IAC1B;;;;OAIG;IACH,MAAM,CAAC,cAAc,IAAI,mBAAmB;CAG/C"}

package/dist/crypto/encryption/public-key-encryption/PkeEncoderInterface.d.ts

@@ -0,0 +1,13 @@
+import { EncoderInterface } from '../../../utils/encoder';
+import { AbstractPrivateDecryptionKey, AbstractPublicEncryptionKey } from './PublicKeyEncryptionSchemeInterface';
+export interface PublicEncryptionKeyEncoderInterface extends EncoderInterface<AbstractPublicEncryptionKey, string> {
+}
+export interface PrivateDecryptionKeyEncoderInterface extends EncoderInterface<AbstractPrivateDecryptionKey, string> {
+}
+export interface PkeEncoderInterface {
+    encodePublicEncryptionKey(key: AbstractPublicEncryptionKey): Promise<string>;
+    encodePrivateDecryptionKey(key: AbstractPrivateDecryptionKey): Promise<string>;
+    decodePublicEncryptionKey(key: string): Promise<AbstractPublicEncryptionKey>;
+    decodePrivateDecryptionKey(key: string): Promise<AbstractPrivateDecryptionKey>;
+}
+//# sourceMappingURL=PkeEncoderInterface.d.ts.map

package/dist/crypto/encryption/public-key-encryption/PkeEncoderInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PkeEncoderInterface.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/PkeEncoderInterface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,EAAC,4BAA4B,EAAE,2BAA2B,EAAC,MAAM,sCAAsC,CAAC;AAE/G,MAAM,WAAW,mCAAoC,SAAQ,gBAAgB,CAAC,2BAA2B,EAAE,MAAM,CAAC;CAAG;AACrH,MAAM,WAAW,oCAAqC,SAAQ,gBAAgB,CAAC,4BAA4B,EAAE,MAAM,CAAC;CAAG;AACvH,MAAM,WAAW,mBAAmB;IAChC,yBAAyB,CAAC,GAAG,EAAE,2BAA2B,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7E,0BAA0B,CAAC,GAAG,EAAE,4BAA4B,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC/E,yBAAyB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAC7E,0BAA0B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,4BAA4B,CAAC,CAAC;CAClF"}

package/dist/crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId.d.ts

@@ -0,0 +1,10 @@
+export declare enum PublicKeyEncryptionSchemeId {
+    ML_KEM_768_AES_256_GCM = 0
+}
+/**
+ * @deprecated Will be removed soon!
+ */
+export declare enum PublicKeyEncryptionAlgorithmId {
+    ML_KEM_768_AES_256_GCM = 0
+}
+//# sourceMappingURL=PublicKeyEncryptionSchemeId.d.ts.map

package/dist/crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PublicKeyEncryptionSchemeId.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeId.ts"],"names":[],"mappings":"AAAA,oBAAY,2BAA2B;IACnC,sBAAsB,IAAA;CACzB;AAED;;GAEG;AACH,oBAAY,8BAA8B;IACtC,sBAAsB,IAAqD;CAC9E"}

package/dist/crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeInterface.d.ts

@@ -0,0 +1,52 @@
+import { PublicKeyEncryptionSchemeId } from './PublicKeyEncryptionSchemeId';
+import { EncoderInterface } from '../../../utils/encoder';
+export interface PublicKeyEncryptionScheme {
+    /**
+     * Returns the identifier of the scheme.
+     */
+    getSchemeId(): PublicKeyEncryptionSchemeId;
+}
+export declare abstract class AbstractPublicKeyEncryptionScheme implements PublicKeyEncryptionScheme {
+    /**
+     * Returns the identifier of the scheme.
+     */
+    abstract getSchemeId(): PublicKeyEncryptionSchemeId;
+}
+export interface PublicEncryptionKey {
+    getScheme(): PublicKeyEncryptionScheme;
+    encrypt(message: Uint8Array): Promise<Uint8Array>;
+    getRawPublicKey(): Promise<Uint8Array>;
+    encode(encoder?: EncoderInterface<Uint8Array, string>): Promise<string>;
+}
+export declare abstract class AbstractPublicEncryptionKey implements PublicEncryptionKey {
+    abstract getScheme(): AbstractPublicKeyEncryptionScheme;
+    abstract encrypt(message: Uint8Array): Promise<Uint8Array>;
+    abstract getRawPublicKey(): Promise<Uint8Array>;
+    encode(encoder?: EncoderInterface<Uint8Array, string>): Promise<string>;
+    getSchemeId(): PublicKeyEncryptionSchemeId;
+}
+export interface PrivateDecryptionKey {
+    getScheme(): AbstractPublicKeyEncryptionScheme;
+    decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+    getRawPrivateKey(): Uint8Array;
+    getPublicKey(): Promise<AbstractPublicEncryptionKey>;
+    encode(encoder: EncoderInterface<Uint8Array, string>): string;
+    /**
+     * Returns the supported seed lengths for the scheme.
+     * @returns {number[]} An array of supported seed lengths.
+     */
+    getSupportedSeedLength(): number[];
+}
+export declare abstract class AbstractPrivateDecryptionKey implements PrivateDecryptionKey {
+    abstract getScheme(): AbstractPublicKeyEncryptionScheme;
+    abstract decrypt(ciphertext: Uint8Array): Promise<Uint8Array>;
+    abstract getRawPrivateKey(): Uint8Array;
+    abstract getPublicKey(): Promise<AbstractPublicEncryptionKey>;
+    encode(encoder?: EncoderInterface<Uint8Array, string>): string;
+    /**
+     * Returns the supported seed lengths for the scheme.
+     * @returns {number[]} An array of supported seed lengths.
+     */
+    abstract getSupportedSeedLength(): number[];
+}
+//# sourceMappingURL=PublicKeyEncryptionSchemeInterface.d.ts.map

package/dist/crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeInterface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PublicKeyEncryptionSchemeInterface.d.ts","sourceRoot":"","sources":["../../../../src/crypto/encryption/public-key-encryption/PublicKeyEncryptionSchemeInterface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,2BAA2B,EAAC,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAiB,gBAAgB,EAAC,MAAM,wBAAwB,CAAC;AAExE,MAAM,WAAW,yBAAyB;IACtC;;OAEG;IACH,WAAW,IAAI,2BAA2B,CAAC;CAC9C;AAED,8BAAsB,iCAAkC,YAAW,yBAAyB;IACxF;;OAEG;IACH,QAAQ,CAAC,WAAW,IAAI,2BAA2B;CACtD;AAED,MAAM,WAAW,mBAAmB;IAChC,SAAS,IAAI,yBAAyB,CAAC;IACvC,OAAO,CAAE,OAAO,EAAE,UAAU,GAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IACpD,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAAC;IACvC,MAAM,CAAC,OAAO,CAAC,EAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CAC3E;AAED,8BAAsB,2BAA4B,YAAW,mBAAmB;IAC5E,QAAQ,CAAC,SAAS,IAAI,iCAAiC;IACvD,QAAQ,CAAC,OAAO,CAAE,OAAO,EAAE,UAAU,GAAI,OAAO,CAAC,UAAU,CAAC;IAC5D,QAAQ,CAAC,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC;IAEzC,MAAM,CAAC,OAAO,GAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAgD,GAAG,OAAO,CAAC,MAAM,CAAC;IAI3H,WAAW;CAGd;AAED,MAAM,WAAW,oBAAoB;IACjC,SAAS,IAAI,iCAAiC,CAAC;IAE/C,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAErD,gBAAgB,IAAI,UAAU,CAAC;IAE/B,YAAY,IAAI,OAAO,CAAC,2BAA2B,CAAC,CAAC;IAErD,MAAM,CAAC,OAAO,EAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAC,GAAG,MAAM,CAAC;IAE9D;;;OAGG;IACH,sBAAsB,IAAI,MAAM,EAAE,CAAC;CACtC;AAED,8BAAsB,4BAA6B,YAAW,oBAAoB;IAC9E,QAAQ,CAAC,SAAS,IAAI,iCAAiC;IACvD,QAAQ,CAAC,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;IAC7D,QAAQ,CAAC,gBAAgB,IAAI,UAAU;IACvC,QAAQ,CAAC,YAAY,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAC7D,MAAM,CAAC,OAAO,GAAE,gBAAgB,CAAC,UAAU,EAAE,MAAM,CAAgD,GAAG,MAAM;IAI5G;;;OAGG;IACH,QAAQ,CAAC,sBAAsB,IAAI,MAAM,EAAE;CAC9C"}