@microsoft/ccf-app 5.0.0-dev5 → 5.0.0-dev6

package/crypto.d.ts

@@ -18,6 +18,10 @@ export declare const generateEddsaKeyPair: (curve: string) => import("./global.j
  * @inheritDoc global!CCFCrypto.wrapKey
  */
 export declare const wrapKey: (key: ArrayBuffer, wrappingKey: ArrayBuffer, wrapAlgo: import("./global.js").WrapAlgoParams) => ArrayBuffer;
+/**
+ * @inheritDoc global!CCFCrypto.unwrapKey
+ */
+export declare const unwrapKey: (key: ArrayBuffer, wrappingKey: ArrayBuffer, wrapAlgo: import("./global.js").WrapAlgoParams) => ArrayBuffer;
 /**
  * @inheritDoc global!CCFCrypto.sign
  */

package/crypto.js

@@ -34,6 +34,10 @@ export const generateEddsaKeyPair = ccf.crypto.generateEddsaKeyPair;
  * @inheritDoc global!CCFCrypto.wrapKey
  */
 export const wrapKey = ccf.crypto.wrapKey;
+/**
+ * @inheritDoc global!CCFCrypto.unwrapKey
+ */
+export const unwrapKey = ccf.crypto.unwrapKey;
 /**
  * @inheritDoc global!CCFCrypto.sign
  */

package/global.d.ts

@@ -308,6 +308,13 @@ export interface CCFCrypto {
      * on the wrapping algorithm that is used (`wrapAlgo`).
      */
     wrapKey(key: ArrayBuffer, wrappingKey: ArrayBuffer, wrapAlgo: WrapAlgoParams): ArrayBuffer;
+    /**
+     * Unwraps a key using a wrapping key.
+     *
+     * Constraints on the `key` and `wrappingKey` parameters depend
+     * on the wrapping algorithm that is used (`wrapAlgo`).
+     */
+    unwrapKey(key: ArrayBuffer, wrappingKey: ArrayBuffer, wrapAlgo: WrapAlgoParams): ArrayBuffer;
     /**
      * Generate a digest (hash) of the given data.
      */

package/kv.d.ts

@@ -36,11 +36,10 @@
 import { KvMap } from "./global.js";
 import { DataConverter } from "./converters.js";
 export declare class TypedKvMap<K, V> {
-    private nameOrMap;
+    private kv;
     private kt;
     private vt;
-    private _kv;
-    constructor(nameOrMap: string | KvMap, kt: DataConverter<K>, vt: DataConverter<V>);
+    constructor(kv: KvMap, kt: DataConverter<K>, vt: DataConverter<V>);
     has(key: K): boolean;
     get(key: K): V | undefined;
     getVersionOfPreviousWrite(key: K): number | undefined;

package/kv.js

@@ -37,47 +37,41 @@
  */
 import { ccf } from "./global.js";
 export class TypedKvMap {
-    _kv() {
-        const kvMap = typeof this.nameOrMap === "string"
-            ? ccf.kv[this.nameOrMap]
-            : this.nameOrMap;
-        return kvMap;
-    }
-    constructor(nameOrMap, kt, vt) {
-        this.nameOrMap = nameOrMap;
+    constructor(kv, kt, vt) {
+        this.kv = kv;
         this.kt = kt;
         this.vt = vt;
     }
     has(key) {
-        return this._kv().has(this.kt.encode(key));
+        return this.kv.has(this.kt.encode(key));
     }
     get(key) {
-        const v = this._kv().get(this.kt.encode(key));
+        const v = this.kv.get(this.kt.encode(key));
         return v === undefined ? undefined : this.vt.decode(v);
     }
     getVersionOfPreviousWrite(key) {
-        return this._kv().getVersionOfPreviousWrite(this.kt.encode(key));
+        return this.kv.getVersionOfPreviousWrite(this.kt.encode(key));
     }
     set(key, value) {
-        this._kv().set(this.kt.encode(key), this.vt.encode(value));
+        this.kv.set(this.kt.encode(key), this.vt.encode(value));
         return this;
     }
     delete(key) {
-        this._kv().delete(this.kt.encode(key));
+        this.kv.delete(this.kt.encode(key));
     }
     clear() {
-        this._kv().clear();
+        this.kv.clear();
     }
     forEach(callback) {
         let kt = this.kt;
         let vt = this.vt;
         let typedMap = this;
-        this._kv().forEach(function (raw_v, raw_k, table) {
+        this.kv.forEach(function (raw_v, raw_k, table) {
             callback(vt.decode(raw_v), kt.decode(raw_k), typedMap);
         });
     }
     get size() {
-        return this._kv().size;
+        return this.kv.size;
     }
 }
 /**
@@ -94,7 +88,8 @@ export class TypedKvMap {
  * @param vt The converter to use for map values.
  */
 export function typedKv(nameOrMap, kt, vt) {
-    return new TypedKvMap(nameOrMap, kt, vt);
+    const kvMap = typeof nameOrMap === "string" ? ccf.kv[nameOrMap] : nameOrMap;
+    return new TypedKvMap(kvMap, kt, vt);
 }
 /**
  * @inheritDoc global!CCF.kv

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/ccf-app",
-  "version": "5.0.0-dev5",
+  "version": "5.0.0-dev6",
   "description": "CCF app support package",
   "main": "index.js",
   "files": [

package/polyfill.js

@@ -252,6 +252,41 @@ class CCFPolyfill {
                     throw new Error("unsupported wrapAlgo.name");
                 }
             },
+            unwrapKey(wrappedKey, unwrappingKey, unwrapAlgo) {
+                if (unwrapAlgo.name == "RSA-OAEP") {
+                    return nodeBufToArrBuf(jscrypto.privateDecrypt({
+                        key: Buffer.from(unwrappingKey),
+                        oaepHash: "sha256",
+                        padding: jscrypto.constants.RSA_PKCS1_OAEP_PADDING,
+                    }, new Uint8Array(wrappedKey)));
+                }
+                else if (unwrapAlgo.name == "AES-KWP") {
+                    const iv = Buffer.from("A65959A6", "hex"); // defined in RFC 5649
+                    const decipher = jscrypto.createDecipheriv("id-aes256-wrap-pad", new Uint8Array(unwrappingKey), iv);
+                    return nodeBufToArrBuf(Buffer.concat([
+                        decipher.update(new Uint8Array(wrappedKey)),
+                        decipher.final(),
+                    ]));
+                }
+                else if (unwrapAlgo.name == "RSA-OAEP-AES-KWP") {
+                    const keyInfo = jscrypto.createPrivateKey(Buffer.from(unwrappingKey));
+                    // asymmetricKeyDetails added in Node.js 15.7.0, we're at 16.
+                    console.log(`Modulus length: `, keyInfo?.asymmetricKeyDetails?.modulusLength);
+                    const modulusLengthInBytes = (keyInfo?.asymmetricKeyDetails?.modulusLength || 2048) / 8;
+                    const wrap1 = wrappedKey.slice(0, modulusLengthInBytes);
+                    const wrap2 = wrappedKey.slice(modulusLengthInBytes);
+                    const aesKey = this.unwrapKey(wrap1, unwrappingKey, {
+                        name: "RSA-OAEP",
+                        label: unwrapAlgo.label,
+                    });
+                    return this.unwrapKey(wrap2, aesKey, {
+                        name: "AES-KWP",
+                    });
+                }
+                else {
+                    throw new Error("unsupported unwrapAlgo.name");
+                }
+            },
             digest(algorithm, data) {
                 if (algorithm === "SHA-256") {
                     return nodeBufToArrBuf(jscrypto.createHash("sha256").update(new Uint8Array(data)).digest());
@@ -456,6 +491,9 @@ class CCFPolyfill {
     wrapKey(key, wrappingKey, parameters) {
         return this.crypto.wrapKey(key, wrappingKey, parameters);
     }
+    unwrapKey(key, wrappingKey, parameters) {
+        return this.crypto.unwrapKey(key, wrappingKey, parameters);
+    }
     digest(algorithm, data) {
         return this.crypto.digest(algorithm, data);
     }