edhoc 1.0.0 → 1.0.2

package/src/Suites.cpp

@@ -0,0 +1,153 @@
+#include "Suites.h"
+
+// Cipher Suite 0
+static const struct edhoc_cipher_suite edhoc_cipher_suite_0 = {
+    .value = 0,             // Suite identifier 0
+    .aead_key_length = 16,  // Key length for AES-CCM-16-64-128 (16 bytes)
+    .aead_tag_length = 8,   // Authentication tag length for AES-CCM (8 bytes)
+    .aead_iv_length =
+        13,             // Initialization vector length for AES-CCM (13 bytes)
+    .hash_length = 32,  // Output length for SHA-256 (32 bytes)
+    .mac_length = 8,    // MAC length (8 bytes)
+    .ecc_key_length = 32,  // Elliptic curve key length for X25519 (32 bytes)
+    .ecc_sign_length =
+        64,  // Signature length for EdDSA using X25519 (64 bytes)
+};
+
+// Cipher Suite 1
+static const struct edhoc_cipher_suite edhoc_cipher_suite_1 = {
+    .value = 1,             // Suite identifier 1
+    .aead_key_length = 16,  // Key length for AES-CCM-16-128-128 (16 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for AES-CCM (16 bytes)
+    .aead_iv_length =
+        13,             // Initialization vector length for AES-CCM (13 bytes)
+    .hash_length = 32,  // Output length for SHA-256 (32 bytes)
+    .mac_length = 16,   // MAC length (16 bytes)
+    .ecc_key_length = 32,  // Elliptic curve key length for X25519 (32 bytes)
+    .ecc_sign_length =
+        64,  // Signature length for EdDSA using X25519 (64 bytes)
+};
+
+// Cipher Suite 2
+static const struct edhoc_cipher_suite edhoc_cipher_suite_2 = {
+    .value = 2,             // Suite identifier 2
+    .aead_key_length = 16,  // Key length for AES-CCM-16-64-128 (16 bytes)
+    .aead_tag_length = 8,   // Authentication tag length for AES-CCM (8 bytes)
+    .aead_iv_length =
+        13,             // Initialization vector length for AES-CCM (13 bytes)
+    .hash_length = 32,  // Output length for SHA-256 (32 bytes)
+    .mac_length = 8,    // MAC length (8 bytes)
+    .ecc_key_length = 32,   // Elliptic curve key length for P-256 (32 bytes)
+    .ecc_sign_length = 64,  // Signature length for ES256 using P-256 (64 bytes)
+};
+
+// Cipher Suite 3
+static const struct edhoc_cipher_suite edhoc_cipher_suite_3 = {
+    .value = 3,             // Suite identifier 3
+    .aead_key_length = 16,  // Key length for AES-CCM-16-128-128 (16 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for AES-CCM (16 bytes)
+    .aead_iv_length =
+        13,             // Initialization vector length for AES-CCM (13 bytes)
+    .hash_length = 32,  // Output length for SHA-256 (32 bytes)
+    .mac_length = 16,   // MAC length (16 bytes)
+    .ecc_key_length = 32,   // Elliptic curve key length for P-256 (32 bytes)
+    .ecc_sign_length = 64,  // Signature length for ES256 using P-256 (64 bytes)
+};
+
+// Cipher Suite 4
+static const struct edhoc_cipher_suite edhoc_cipher_suite_4 = {
+    .value = 4,             // Suite identifier 4
+    .aead_key_length = 32,  // Key length for ChaCha20 (32 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for Poly1305 (16 bytes)
+    .aead_iv_length = 12,   // Nonce length for ChaCha20 (12 bytes)
+    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
+    .mac_length = 16,       // MAC length (16 bytes)
+    .ecc_key_length = 32,   // Elliptic curve key length for X25519 (32 bytes)
+    .ecc_sign_length =
+        64,  // Signature length for EdDSA using X25519 (64 bytes)
+};
+
+// Cipher Suite 5
+static const struct edhoc_cipher_suite edhoc_cipher_suite_5 = {
+    .value = 5,             // Suite identifier 5
+    .aead_key_length = 32,  // Key length for ChaCha20 (32 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for Poly1305 (16 bytes)
+    .aead_iv_length = 12,   // Nonce length for ChaCha20 (12 bytes)
+    .hash_length = 32,      // Output length for SHA-256 (32 bytes)
+    .mac_length = 16,       // MAC length (16 bytes)
+    .ecc_key_length = 32,   // Elliptic curve key length for P-256 (32 bytes)
+    .ecc_sign_length = 64,  // Signature length for ES256 using P-256 (64 bytes)
+};
+
+// Cipher Suite 6
+static const struct edhoc_cipher_suite edhoc_cipher_suite_6 = {
+    .value = 6,             // Suite identifier 6
+    .aead_key_length = 16,  // Key length for A128GCM (16 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for A128GCM (16 bytes)
+    .aead_iv_length =
+        12,             // Initialization vector length for A128GCM (12 bytes)
+    .hash_length = 32,  // Output length for SHA-256 (32 bytes)
+    .mac_length = 16,   // MAC length (16 bytes)
+    .ecc_key_length = 32,  // Elliptic curve key length for X25519 (32 bytes)
+    .ecc_sign_length =
+        64,  // Signature length for ES256 using X25519 (64 bytes)
+};
+
+// Cipher Suite 24
+static const struct edhoc_cipher_suite edhoc_cipher_suite_24 = {
+    .value = 24,            // Suite identifier 24
+    .aead_key_length = 32,  // Key length for A256GCM (32 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for A256GCM (16 bytes)
+    .aead_iv_length =
+        12,             // Initialization vector length for A256GCM (12 bytes)
+    .hash_length = 48,  // Output length for SHA-384 (48 bytes)
+    .mac_length = 16,   // MAC length (16 bytes)
+    .ecc_key_length = 48,   // Elliptic curve key length for P-384 (48 bytes)
+    .ecc_sign_length = 96,  // Signature length for ES384 using P-384 (96 bytes)
+};
+
+// Cipher Suite 25
+static const struct edhoc_cipher_suite edhoc_cipher_suite_25 = {
+    .value = 25,            // Suite identifier 25
+    .aead_key_length = 32,  // Key length for ChaCha20 (32 bytes)
+    .aead_tag_length = 16,  // Authentication tag length for Poly1305 (16 bytes)
+    .aead_iv_length = 12,   // Nonce length for ChaCha20 (12 bytes)
+    .hash_length = 64,      // Output length for SHAKE256 (64 bytes)
+    .mac_length = 16,       // MAC length (16 bytes)
+    .ecc_key_length = 56,   // Elliptic curve key length for X448 (56 bytes)
+    .ecc_sign_length =
+        114,  // Signature length for EdDSA using X448 (114 bytes)
+};
+
+const struct edhoc_cipher_suite* suite_pointers[] = {
+    &edhoc_cipher_suite_0,
+    &edhoc_cipher_suite_1,
+    &edhoc_cipher_suite_2,
+    &edhoc_cipher_suite_3,
+    &edhoc_cipher_suite_4,
+    &edhoc_cipher_suite_5,
+    &edhoc_cipher_suite_6,
+    // 7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    nullptr,
+    // 24, 25
+    &edhoc_cipher_suite_24,
+    &edhoc_cipher_suite_25};
+
+const size_t suite_pointers_count =
+    sizeof(suite_pointers) / sizeof(suite_pointers[0]);

package/src/Utils.cpp

@@ -0,0 +1,115 @@
+#include <condition_variable>
+#include <cstring>
+#include <mutex>
+#include <thread>
+
+#include "Utils.h"
+
+static constexpr const char* kStringThen = "then";
+static constexpr const char* kStringCatch = "catch";
+static constexpr const char* kErrorInputValueMustBeANumberOrABuffer =
+    "Input value must be a number or a buffer";
+
+void Utils::ResetAndRelease(Napi::FunctionReference& funcRef,
+                            Napi::ThreadSafeFunction& tsfn) {
+  if (!funcRef.IsEmpty()) {
+    funcRef.Reset();
+  }
+  if (tsfn != nullptr) {
+    tsfn.Release();
+    tsfn = nullptr;
+  }
+}
+
+void Utils::InvokeJSFunctionWithPromiseHandling(
+    Napi::Env env,
+    Napi::Object jsObject,
+    Napi::Function jsCallback,
+    const std::vector<napi_value>& args,
+    std::function<void(Napi::Env, Napi::Value)> callbackLambda) {
+  auto deferred = Napi::Promise::Deferred::New(env);
+  try {
+    Napi::Value result = jsCallback.Call(jsObject, args);
+    deferred.Resolve(result);
+  } catch (const Napi::Error& e) {
+    deferred.Reject(e.Value());
+  }
+
+  Napi::Promise promise = deferred.Promise();
+
+  auto thenCallback = Napi::Function::New(
+      env, [callbackLambda](const Napi::CallbackInfo& info) {
+        Napi::Env env = info.Env();
+        Napi::HandleScope scope(env);
+        Napi::Value result = info[0];
+        Napi::Promise::Deferred deferred = Napi::Promise::Deferred::New(env);
+        try {
+          callbackLambda(env, result);
+          deferred.Resolve(result);
+        } catch (const Napi::Error& e) {
+          deferred.Reject(e.Value());
+        }
+        return deferred.Promise();
+      });
+
+  auto catchCallback =
+      Napi::Function::New(env, [](const Napi::CallbackInfo& info) {
+        Napi::Error error = info[0].As<Napi::Error>();
+        throw error;
+      });
+
+  promise.Get(kStringThen).As<Napi::Function>().Call(promise, {thenCallback});
+  promise.Get(kStringCatch).As<Napi::Function>().Call(promise, {catchCallback});
+}
+
+void Utils::EncodeInt64ToBuffer(int64_t value,
+                                uint8_t* buffer,
+                                size_t* length) {
+  size_t idx = 0;
+  if (value == 0) {
+    buffer[idx++] = 0;
+  } else {
+    while (value != 0) {
+      buffer[idx++] = value & 0xFF;
+      value >>= 8;
+    }
+  }
+  *length = idx;
+}
+
+struct edhoc_connection_id Utils::ConvertJsValueToEdhocCid(Napi::Value value) {
+  struct edhoc_connection_id cid = {};
+  if (value.IsNumber()) {
+    int64_t numeric = value.As<Napi::Number>().Int64Value();
+    if (numeric >= ONE_BYTE_CBOR_INT_MIN_VALUE &&
+        numeric <= ONE_BYTE_CBOR_INT_MAX_VALUE) {
+      cid = {.encode_type = EDHOC_CID_TYPE_ONE_BYTE_INTEGER,
+             .int_value = (int8_t)numeric};
+    } else {
+      size_t length = 0;
+      Utils::EncodeInt64ToBuffer(numeric, cid.bstr_value, &length);
+      cid.encode_type = EDHOC_CID_TYPE_BYTE_STRING;
+      cid.bstr_length = length;
+    }
+  } else if (value.IsBuffer()) {
+    Napi::Buffer<uint8_t> buffer = value.As<Napi::Buffer<uint8_t>>();
+    cid.encode_type = EDHOC_CID_TYPE_BYTE_STRING;
+    cid.bstr_length = buffer.Length();
+    memcpy(cid.bstr_value, buffer.Data(), cid.bstr_length);
+  } else {
+    throw Napi::TypeError::New(value.Env(),
+                               kErrorInputValueMustBeANumberOrABuffer);
+  }
+  return cid;
+}
+
+Napi::Value Utils::CreateJsValueFromEdhocCid(Napi::Env env,
+                                             struct edhoc_connection_id value) {
+  if (value.encode_type == EDHOC_CID_TYPE_ONE_BYTE_INTEGER) {
+    return Napi::Number::New(env, value.int_value);
+  } else if (value.encode_type == EDHOC_CID_TYPE_BYTE_STRING) {
+    return Napi::Buffer<char>::Copy(
+        env, (const char*)value.bstr_value, value.bstr_length);
+  }
+  return env.Null();
+}

package/dist/bindings.d.ts

@@ -1,5 +0,0 @@
-import { EDHOC } from './edhoc';
-export interface NodeGypBinding {
-    EDHOC: EDHOC;
-}
-//# sourceMappingURL=bindings.d.ts.map

package/dist/bindings.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bindings.d.ts","sourceRoot":"","sources":["../lib/bindings.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAG/B,MAAM,WAAW,cAAc;IAC3B,KAAK,EAAE,KAAK,CAAA;CACf"}

package/dist/bindings.js

@@ -1,10 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_gyp_build_1 = __importDefault(require("node-gyp-build"));
-const path_1 = require("path");
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-const binding = (0, node_gyp_build_1.default)((0, path_1.join)(__dirname, '../'));
-exports.EDHOC = binding.EDHOC;

package/dist/credentials.d.ts

@@ -1,16 +0,0 @@
-import { DefaultEdhocCryptoManager } from './crypto';
-import { EDHOC, EdhocCredentialManager, EdhocCredentials } from './edhoc';
-export declare class X509Credentials {
-    certificate: Buffer;
-    privateKey: Buffer;
-    constructor(certificate: Buffer, privateKey: Buffer);
-}
-export declare class DefaultEdhocCredentialManager implements EdhocCredentialManager {
-    private credentials;
-    private trustRoots;
-    setCredentials(cryptoManager: DefaultEdhocCryptoManager, credentials: X509Credentials, keyID?: Buffer): void;
-    addTrustRoot(certificate: Buffer): void;
-    fetch(edhoc: EDHOC): Promise<EdhocCredentials>;
-    verify(edhoc: EDHOC, credentials: EdhocCredentials): Promise<EdhocCredentials>;
-}
-//# sourceMappingURL=credentials.d.ts.map

package/dist/credentials.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"credentials.d.ts","sourceRoot":"","sources":["../lib/credentials.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,UAAU,CAAC;AACrD,OAAO,EAAE,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAA4D,MAAM,SAAS,CAAC;AAGpI,qBAAa,eAAe;IAEjB,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;gBAEd,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAItD;AAED,qBAAa,6BAA8B,YAAW,sBAAsB;IAExE,OAAO,CAAC,WAAW,CAAsE;IACzF,OAAO,CAAC,UAAU,CAAyB;IAE3C,cAAc,CAAC,aAAa,EAAE,yBAAyB,EAAE,WAAW,EAAE,eAAe,EAAE,KAAK,GAAE,MAAuC;IAYrI,YAAY,CAAC,WAAW,EAAE,MAAM;IAI1B,KAAK,CAAC,KAAK,EAAE,KAAK,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAK9C,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,EAAE,gBAAgB;CAuD3D"}

package/dist/credentials.js

@@ -1,84 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultEdhocCredentialManager = exports.X509Credentials = void 0;
-const edhoc_1 = require("./edhoc");
-const crypto_1 = require("crypto");
-class X509Credentials {
-    certificate;
-    privateKey;
-    constructor(certificate, privateKey) {
-        this.certificate = certificate;
-        this.privateKey = privateKey;
-    }
-}
-exports.X509Credentials = X509Credentials;
-class DefaultEdhocCredentialManager {
-    credentials = new Map();
-    trustRoots = [];
-    setCredentials(cryptoManager, credentials, keyID = Buffer.from('00000001', 'hex')) {
-        cryptoManager.addKey(keyID, credentials.privateKey);
-        let chain = {
-            format: edhoc_1.EdhocCredentialsFormat.x5chain,
-            privateKeyID: keyID,
-            x5chain: {
-                certificates: [credentials.certificate]
-            }
-        };
-        this.credentials.set(keyID.toString('hex'), chain);
-    }
-    addTrustRoot(certificate) {
-        this.trustRoots.push(new crypto_1.X509Certificate(certificate));
-    }
-    async fetch(edhoc) {
-        const credential = this.credentials.values().next().value;
-        return credential;
-    }
-    async verify(edhoc, credentials) {
-        if (credentials.format === edhoc_1.EdhocCredentialsFormat.x5chain) {
-            const x5chain = credentials.x5chain;
-            const certificates = x5chain.certificates;
-            const numCerts = certificates.length;
-            if (numCerts < 1) {
-                throw new Error('Certificate chain must contain at least one certificate.');
-            }
-            let verified = false;
-            // Step 1: Verify each certificate against the next one in the chain, if there are multiple certificates
-            for (let i = 0; i < numCerts - 1; i++) {
-                const currentCert = new crypto_1.X509Certificate(certificates[i]);
-                const nextCert = new crypto_1.X509Certificate(certificates[i + 1]);
-                if (!currentCert.verify(nextCert.publicKey)) {
-                    throw new Error(`Verification failed: Certificate at index ${i} is not signed by the next certificate in the chain.`);
-                }
-            }
-            // Step 2: Verify the last certificate in the chain against the trust roots
-            const lastCert = new crypto_1.X509Certificate(certificates[numCerts - 1]);
-            for (let trustRoot of this.trustRoots) {
-                if (lastCert.verify(trustRoot.publicKey)) {
-                    verified = true;
-                    break; // Exit the loop once verified
-                }
-            }
-            if (!verified) {
-                throw new Error('Certificate chain not verified');
-            }
-            let token = new crypto_1.X509Certificate(certificates[0]).publicKey.export({ format: 'jwk' });
-            if (token.crv === 'P-256') {
-                credentials.publicKey = Buffer.concat([
-                    Buffer.from(token.x, 'base64'),
-                    Buffer.from(token.y, 'base64')
-                ]);
-                return credentials;
-            }
-            else if (token.crv === 'Ed25519') {
-                let publicKey = Buffer.from(token.x, 'base64');
-                credentials.publicKey = publicKey;
-                return credentials;
-            }
-            else {
-                throw new Error('Unsupported curve');
-            }
-        }
-        throw new Error('Credentials format not supported');
-    }
-}
-exports.DefaultEdhocCredentialManager = DefaultEdhocCredentialManager;

package/dist/crypto.d.ts

@@ -1,22 +0,0 @@
-import { EDHOC, EdhocCryptoManager, EdhocKeyType } from './edhoc';
-export declare class DefaultEdhocCryptoManager implements EdhocCryptoManager {
-    private keys;
-    private keyIdentifier;
-    constructor();
-    addKey(keyID: Buffer, key: Buffer): void;
-    generateKey(edhoc: EDHOC, keyType: EdhocKeyType, key: Buffer): Promise<Buffer>;
-    destroyKey(edhoc: EDHOC, keyID: Buffer): boolean;
-    makeKeyPair(edhoc: EDHOC, keyID: Buffer, privateKeySize: number, publicKeySize: number): {
-        privateKey: Buffer;
-        publicKey: Buffer;
-    };
-    keyAgreement(edhoc: EDHOC, keyID: Buffer, publicKey: Buffer, privateKeySize: number): Buffer;
-    sign(edhoc: EDHOC, keyID: Buffer, input: Buffer, signatureSize: number): Buffer;
-    verify(edhoc: EDHOC, keyID: Buffer, input: Buffer, signature: Buffer): boolean;
-    extract(edhoc: EDHOC, keyID: Buffer, salt: Buffer, keySize: number): Buffer;
-    expand(edhoc: EDHOC, keyID: Buffer, info: Buffer, keySize: number): Buffer;
-    encrypt(edhoc: EDHOC, keyID: Buffer, nonce: Buffer, aad: Buffer, plaintext: Buffer, size: number): Buffer;
-    decrypt(edhoc: EDHOC, keyID: Buffer, nonce: Buffer, aad: Buffer, ciphertext: Buffer, size: number): Buffer;
-    hash(edhoc: EDHOC, data: Buffer, hashSize: number): Promise<Buffer>;
-}
-//# sourceMappingURL=crypto.d.ts.map

package/dist/crypto.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"crypto.d.ts","sourceRoot":"","sources":["../lib/crypto.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,kBAAkB,EAAE,YAAY,EAAc,MAAM,SAAS,CAAC;AAqB9E,qBAAa,yBAA0B,YAAW,kBAAkB;IAEhE,OAAO,CAAC,IAAI,CAAiB;IAC7B,OAAO,CAAC,aAAa,CAAgB;;IAM9B,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM;IAKlC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,GAAG,EAAE,MAAM;IAqClE,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM;IAStC,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;;;;IAoBtF,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAiBnF,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM;IA4BtE,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM;IAwBpE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IAQlE,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;IASjE,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAqBhG,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM;IAqB3F,IAAI,CAAC,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM;CAG1D"}

package/dist/crypto.js

@@ -1,177 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultEdhocCryptoManager = void 0;
-const edhoc_1 = require("./edhoc");
-const ed25519_1 = require("@noble/curves/ed25519");
-const p256_1 = require("@noble/curves/p256");
-const sha256_1 = require("@noble/hashes/sha256");
-const hkdf_1 = require("@noble/hashes/hkdf");
-const crypto_1 = require("crypto");
-class DefaultEdhocCryptoManager {
-    keys = {};
-    keyIdentifier = 1000;
-    constructor() {
-        this.keys = {};
-    }
-    addKey(keyID, key) {
-        const kid = keyID.toString('hex');
-        this.keys[kid] = key;
-    }
-    async generateKey(edhoc, keyType, key) {
-        // Key Identifier
-        const keyBuffer = Buffer.alloc(4);
-        keyBuffer.writeInt32LE(this.keyIdentifier++);
-        const keyID = keyBuffer.toString('hex');
-        // Key Exchange Curve
-        const curveKE = [edhoc_1.EdhocSuite.Suite2, edhoc_1.EdhocSuite.Suite3, edhoc_1.EdhocSuite.Suite5].includes(edhoc.selectedSuite) ? p256_1.p256 :
-            [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite1, edhoc_1.EdhocSuite.Suite4, edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? ed25519_1.x25519 : null;
-        // Signature Curve
-        const curveSIG = [edhoc_1.EdhocSuite.Suite2, edhoc_1.EdhocSuite.Suite3, edhoc_1.EdhocSuite.Suite5, edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? p256_1.p256 :
-            [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite1, edhoc_1.EdhocSuite.Suite4].includes(edhoc.selectedSuite) ? ed25519_1.ed25519 : null;
-        if (null == curveKE || null == curveSIG) {
-            throw new Error('Unsupported suite');
-        }
-        switch (keyType) {
-            case edhoc_1.EdhocKeyType.MakeKeyPair:
-                this.keys[keyID] = curveKE.utils.randomPrivateKey();
-                break;
-            case edhoc_1.EdhocKeyType.KeyAgreement:
-                this.keys[keyID] = key.byteLength > 0 ? Buffer.from(key) : curveKE.utils.randomPrivateKey();
-                break;
-            case edhoc_1.EdhocKeyType.Signature:
-                this.keys[keyID] = key.byteLength > 0 ? Buffer.from(key) : curveSIG.utils.randomPrivateKey();
-                break;
-            default:
-                this.keys[keyID] = Buffer.from(key);
-        }
-        return keyBuffer;
-    }
-    destroyKey(edhoc, keyID) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        delete this.keys[kid];
-        return true;
-    }
-    makeKeyPair(edhoc, keyID, privateKeySize, publicKeySize) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        try {
-            const curveKE = [edhoc_1.EdhocSuite.Suite2, edhoc_1.EdhocSuite.Suite3, edhoc_1.EdhocSuite.Suite5].includes(edhoc.selectedSuite) ? p256_1.p256 :
-                [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite1, edhoc_1.EdhocSuite.Suite4, edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? ed25519_1.x25519 : null;
-            return {
-                privateKey: Buffer.from(this.keys[kid]),
-                publicKey: Buffer.from(curveKE.getPublicKey(this.keys[kid])).subarray(curveKE === p256_1.p256 ? 1 : 0)
-            };
-        }
-        catch (error) {
-            throw new Error(`Wrong key type`);
-        }
-    }
-    keyAgreement(edhoc, keyID, publicKey, privateKeySize) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        // Key Exchange Curve
-        const curveKE = [edhoc_1.EdhocSuite.Suite2, edhoc_1.EdhocSuite.Suite3, edhoc_1.EdhocSuite.Suite5].includes(edhoc.selectedSuite) ? p256_1.p256 :
-            [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite1, edhoc_1.EdhocSuite.Suite4, edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? ed25519_1.x25519 : null;
-        const publicKeyBuffer = (curveKE === p256_1.p256) ? Buffer.concat([Buffer.from([publicKey.byteLength == 64 ? 0x04 : 0x02]), publicKey]) : publicKey;
-        const sharedSecrect = Buffer.from(curveKE.getSharedSecret(this.keys[kid], new Uint8Array(publicKeyBuffer)));
-        return sharedSecrect.subarray(curveKE === p256_1.p256 ? 1 : 0);
-    }
-    sign(edhoc, keyID, input, signatureSize) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        // Signature Curve
-        const curveSIG = [edhoc_1.EdhocSuite.Suite2, edhoc_1.EdhocSuite.Suite3, edhoc_1.EdhocSuite.Suite5, edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? p256_1.p256 :
-            [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite1, edhoc_1.EdhocSuite.Suite4].includes(edhoc.selectedSuite) ? ed25519_1.ed25519 : null;
-        if (null === curveSIG) {
-            throw new Error('Unsupported suite');
-        }
-        const signature = curveSIG.sign((0, sha256_1.sha256)(input), new Uint8Array(this.keys[kid]));
-        if (signature instanceof Uint8Array) {
-            return Buffer.from(signature);
-        }
-        else if ('toCompactRawBytes' in signature) {
-            return Buffer.from(signature.toCompactRawBytes());
-        }
-        else {
-            throw new Error('Unsupported signature type');
-        }
-    }
-    verify(edhoc, keyID, input, signature) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        // Signature Curve
-        const curveSIG = [edhoc_1.EdhocSuite.Suite2, edhoc_1.EdhocSuite.Suite3, edhoc_1.EdhocSuite.Suite5, edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? p256_1.p256 :
-            [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite1, edhoc_1.EdhocSuite.Suite4].includes(edhoc.selectedSuite) ? ed25519_1.ed25519 : null;
-        if (null === curveSIG) {
-            throw new Error('Unsupported suite');
-        }
-        const publicKey = this.keys[kid];
-        const publicKeyBuffer = (curveSIG === p256_1.p256) ? Buffer.concat([Buffer.from([publicKey.byteLength == 64 ? 0x04 : 0x02]), publicKey]) : publicKey;
-        if (!curveSIG.verify(new Uint8Array(signature), (0, sha256_1.sha256)(input), new Uint8Array(publicKeyBuffer))) {
-            throw new Error('Signature not verified');
-        }
-        return true;
-    }
-    extract(edhoc, keyID, salt, keySize) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        return Buffer.from((0, hkdf_1.extract)(sha256_1.sha256, new Uint8Array(this.keys[kid]), new Uint8Array(salt)));
-    }
-    expand(edhoc, keyID, info, keySize) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        const expanded = Buffer.from((0, hkdf_1.expand)(sha256_1.sha256, new Uint8Array(this.keys[kid]), new Uint8Array(info), keySize));
-        return expanded;
-    }
-    encrypt(edhoc, keyID, nonce, aad, plaintext, size) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        const tagLength = [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite2].includes(edhoc.selectedSuite) ? 8 : 16;
-        const algorithm = [edhoc_1.EdhocSuite.Suite4, edhoc_1.EdhocSuite.Suite5].includes(edhoc.selectedSuite) ? 'chacha20-poly1305' :
-            [edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? 'aes-128-gcm' : 'aes-128-ccm';
-        const cipher = (0, crypto_1.createCipheriv)(algorithm, this.keys[kid], nonce, { authTagLength: tagLength });
-        cipher.setAAD(aad, { plaintextLength: Buffer.byteLength(plaintext) });
-        const encrypted = Buffer.concat([
-            cipher.update(plaintext),
-            cipher.final(),
-            cipher.getAuthTag()
-        ]);
-        return encrypted;
-    }
-    decrypt(edhoc, keyID, nonce, aad, ciphertext, size) {
-        const kid = keyID.toString('hex');
-        if (kid in this.keys === false) {
-            throw new Error(`Key '${kid}' not found`);
-        }
-        const tagLength = [edhoc_1.EdhocSuite.Suite0, edhoc_1.EdhocSuite.Suite2].includes(edhoc.selectedSuite) ? 8 : 16;
-        const algorithm = [edhoc_1.EdhocSuite.Suite4, edhoc_1.EdhocSuite.Suite5].includes(edhoc.selectedSuite) ? 'chacha20-poly1305' :
-            [edhoc_1.EdhocSuite.Suite6].includes(edhoc.selectedSuite) ? 'aes-128-gcm' : 'aes-128-ccm';
-        const decipher = (0, crypto_1.createDecipheriv)(algorithm, this.keys[kid], nonce, { authTagLength: tagLength });
-        decipher.setAuthTag(ciphertext.subarray(ciphertext.length - tagLength));
-        decipher.setAAD(aad, { plaintextLength: ciphertext.length - tagLength });
-        let decrypted = decipher.update(ciphertext.subarray(0, ciphertext.length - tagLength));
-        decipher.final();
-        return decrypted;
-    }
-    async hash(edhoc, data, hashSize) {
-        return Buffer.from((0, sha256_1.sha256)(data));
-    }
-}
-exports.DefaultEdhocCryptoManager = DefaultEdhocCryptoManager;