@microsoft/ccf-app 6.0.9 → 6.0.11

package/converters.js

@@ -20,6 +20,7 @@
  * @module
  */
 import { ccf } from "./global.js";
+import { toArrayBuffer } from "./utils.js";
 function checkBoolean(val) {
     if (typeof val !== "boolean") {
         throw new TypeError(`Value ${val} is not a boolean`);
@@ -230,7 +231,7 @@ class TypedArrayConverter {
         this.clazz = clazz;
     }
     encode(val) {
-        return val.buffer.slice(val.byteOffset, val.byteOffset + val.byteLength);
+        return toArrayBuffer(val.buffer.slice(val.byteOffset, val.byteOffset + val.byteLength));
     }
     decode(buf) {
         return new this.clazz(buf);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/ccf-app",
-  "version": "6.0.9",
+  "version": "6.0.11",
   "description": "CCF app support package",
   "main": "index.js",
   "files": [
@@ -20,7 +20,7 @@
   "devDependencies": {
     "@types/chai": "^5.0.0",
     "@types/mocha": "^10.0.0",
-    "@types/node": "^24.0.3",
+    "@types/node": "^24.2.0",
     "@types/node-forge": "^1.0.0",
     "chai": "^5.0.0",
     "colors": "1.4.0",
@@ -29,8 +29,8 @@
     "mocha": "^11.0.1",
     "node-forge": "^1.2.0",
     "ts-node": "^10.4.0",
-    "typedoc": "^0.28.1",
-    "typescript": "^5.7.2"
+    "typedoc": "^0.28.10",
+    "typescript": "^5.9.2"
   },
   "bin": {
     "ccf-build-bundle": "scripts/build_bundle.js"

package/polyfill.js

@@ -16,6 +16,7 @@
  */
 import * as jscrypto from "crypto";
 import { TextEncoder, TextDecoder } from "util";
+import { toArrayBuffer } from "./utils.js";
 // JavaScript's Map uses reference equality for non-primitive types,
 // whereas CCF compares the content of the ArrayBuffer.
 // To achieve CCF's semantics, all keys are base64-encoded.
@@ -98,7 +99,7 @@ class CCFPolyfill {
                         .toLowerCase();
                     const hmac = jscrypto.createHmac(hashAlg, key);
                     hmac.update(new Uint8Array(data));
-                    return hmac.digest();
+                    return nodeBufToArrBuf(hmac.digest());
                 }
                 let padding = undefined;
                 const privKey = jscrypto.createPrivateKey(key);
@@ -124,17 +125,17 @@ class CCFPolyfill {
                     throw new Error("unrecognized signing algorithm");
                 }
                 if (algorithm.name === "EdDSA") {
-                    return jscrypto.sign(null, new Uint8Array(data), privKey);
+                    return nodeBufToArrBuf(jscrypto.sign(null, new Uint8Array(data), privKey));
                 }
                 const hashAlg = algorithm.hash.replace("-", "").toLowerCase();
                 const signer = jscrypto.createSign(hashAlg);
                 signer.update(new Uint8Array(data));
-                return signer.sign({
+                return nodeBufToArrBuf(signer.sign({
                     key: privKey,
                     dsaEncoding: "ieee-p1363",
                     padding: padding,
                     saltLength: algorithm.saltLength ?? 0,
-                });
+                }));
             },
             verifySignature(algorithm, key, signature, data) {
                 let padding = undefined;
@@ -539,7 +540,7 @@ function nodeBufToArrBuf(buf) {
     return arrBuf;
 }
 function typedArrToArrBuf(ta) {
-    return ta.buffer.slice(ta.byteOffset, ta.byteOffset + ta.byteLength);
+    return toArrayBuffer(ta.buffer.slice(ta.byteOffset, ta.byteOffset + ta.byteLength));
 }
 function base64(buf) {
     return Buffer.from(buf).toString("base64");

package/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function toUint8ArrayBuffer(buffer: Uint8Array<ArrayBufferLike>): Uint8Array<ArrayBuffer>;
+export declare function toArrayBuffer(buffer: ArrayBufferLike | Buffer | Uint8Array): ArrayBuffer;

package/utils.js

@@ -0,0 +1,32 @@
+// Copyright (c) Microsoft Corporation. All rights reserved.
+// Licensed under the Apache 2.0 License.
+// toUint8ArrayBuffer(buffer) converts the buffer into a Uint8Array<ArrayBuffer>
+// If the input is already a Uint8Array<ArrayBuffer>, it returns it directly
+// Otherwise it will copy the data into a new Uint8Array<ArrayBuffer>
+export function toUint8ArrayBuffer(buffer) {
+    if (buffer.buffer instanceof ArrayBuffer) {
+        return buffer;
+    }
+    if (buffer.buffer instanceof SharedArrayBuffer) {
+        const view = new Uint8Array(new ArrayBuffer(buffer.buffer.byteLength));
+        view.set(buffer);
+        return new Uint8Array(view.buffer, buffer.byteOffset, buffer.byteLength);
+    }
+    throw new Error("Unsupported buffer type");
+}
+// toArrayBuffer(buffer) converts the buffer to an ArrayBuffer
+// If the input is already an ArrayBuffer, it returns it directly
+// Otherwise it will copy the data into a new ArrayBuffer
+export function toArrayBuffer(buffer) {
+    if (buffer instanceof ArrayBuffer) {
+        return buffer;
+    }
+    if (buffer instanceof SharedArrayBuffer) {
+        const view = new Uint8Array(buffer);
+        return toUint8ArrayBuffer(view).buffer;
+    }
+    if (buffer instanceof Uint8Array || buffer instanceof Buffer) {
+        return toArrayBuffer(buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength));
+    }
+    throw new Error("Unsupported buffer type");
+}