Remove empty transformBlocks array from TransformKeys. Change name of transformKeyToBytes to transformKeyToBytes256 (#14)

Author: ernieturner

CHANGELOG.md

@@ -1,3 +1,18 @@
+## 0.4.0
+
+### Breaking Changes
+
++ Renamed the `transformKeyToBytes` method to `transformKeyToBytes256` to specify that it only works with 256 bit TransformKeys.
++ Removed incorrect empty array from TransformKey objects.
+
+### Added
+
+None
+
+### Changed
+
++ Added `engines`, `os`, and `cpu` keys to `package.json` to specify which Node version and architectures this library will work on.
+
 ## 0.3.0
 
 ### Breaking Changes

index.d.ts

@@ -40,8 +40,8 @@ export interface TransformKey {
 }
 
 export function augmentPublicKey256(publicKey: PublicKey, otherPublicKey: PublicKey): PublicKey;
-export function augmentTransformKey(transformKey: TransformKey, privateKey: PrivateKey): TransformKey;
-export function transformKeyToBytes(transformKey: TransformKey): Buffer;
+export function augmentTransformKey256(transformKey: TransformKey, privateKey: PrivateKey): TransformKey;
+export function transformKeyToBytes256(transformKey: TransformKey): Buffer;
 export class Api256 {
     constructor();
     generateKeyPair(): KeyPair;

native/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "recrypt-node-binding"
-version = "0.3.0"
+version = "0.4.0"
 authors = ["IronCore Labs <[email protected]>"]
 
 [lib]

native/src/api256.rs

@@ -306,7 +306,7 @@ pub fn augment_public_key_256(mut cx: FunctionContext) -> JsResult<JsObject> {
 /// Hash the provided transform key into a buffer of bytes. The various transform key object fields are concatenated
 /// in a specific order in order for transform keys to be signed over.
 ///
-pub fn transform_key_to_bytes(mut cx: FunctionContext) -> JsResult<JsBuffer> {
+pub fn transform_key_to_bytes_256(mut cx: FunctionContext) -> JsResult<JsBuffer> {
     let transform_key_obj: Handle<JsObject> = cx.argument::<JsObject>(0)?;
     let transform_key = util::js_object_to_transform_key(&mut cx, transform_key_obj);
 

native/src/lib.rs

@@ -9,6 +9,6 @@ mod util;
 register_module!(mut cx, {
     cx.export_function("augmentTransformKey256", api256::augment_transform_key_256)?;
     cx.export_function("augmentPublicKey256", api256::augment_public_key_256)?;
-    cx.export_function("transformKeyToBytes", api256::transform_key_to_bytes)?;
+    cx.export_function("transformKeyToBytes256", api256::transform_key_to_bytes_256)?;
     cx.export_class::<api256::Api256>("Api256")
 });

native/src/util.rs

@@ -200,9 +200,6 @@ pub fn transform_key_to_js_object<'a, T: Context<'a>>(
     transform_key_obj.set(cx, "encryptedTempKey", encrypted_temp_key_buffer)?;
     transform_key_obj.set(cx, "hashedTempKey", hashed_temp_key_buffer)?;
     transform_key_obj.set(cx, "publicSigningKey", public_signing_key_buffer)?;
-    //Leaving this empty for now until we need to support multi-level transform blocks
-    let empty_transform_blocks = cx.empty_array();
-    transform_key_obj.set(cx, "transformBlocks", empty_transform_blocks)?;
     transform_key_obj.set(cx, "signature", signature_buffer)?;
     Ok(transform_key_obj)
 }

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@ironcorelabs/recrypt-node-binding",
-    "version": "0.3.0",
+    "version": "0.4.0",
     "description": "Bindings to allow the recrypt-rs library to work via NodeJS.",
     "repository": {
         "type": "git",
@@ -11,6 +11,16 @@
     "license": "AGPL-3.0-only",
     "main": "bin-package/index.node",
     "types": "index.d.ts",
+    "engines": {
+        "node": ">=8.0.0"
+    },
+    "os": [
+        "darwin",
+        "linux"
+    ],
+    "cpu": [
+        "x64"
+    ],
     "scripts": {
         "compile": "neon build -r",
         "clean": "neon clean",

test/recrypt-node.test.js

@@ -92,7 +92,7 @@ describe("Recrypt-Node", () => {
 
                 const transformKey = api.generateTransformKey(fromPrivateKey, toPublicKey, privateSigningKey);
                 expect(transformKey).toBeObject();
-                expect(Object.keys(transformKey)).toHaveLength(7);
+                expect(Object.keys(transformKey)).toHaveLength(6);
 
                 expect(transformKey.toPublicKey).toEqual(toPublicKey);
                 expect(transformKey.publicSigningKey).toEqual(publicSigningKey);
@@ -112,8 +112,6 @@ describe("Recrypt-Node", () => {
 
                 expect(transformKey.signature).toBeInstanceOf(Buffer);
                 expect(transformKey.signature).toHaveLength(64);
-
-                expect(transformKey.transformBlocks).toBeArrayOfSize(0);
             });
         });
 
@@ -413,7 +411,7 @@ describe("Recrypt-Node", () => {
             const augTransformKey = recrypt.augmentTransformKey256(transformKey, augPrivateKey);
 
             expect(augTransformKey).toBeObject();
-            expect(Object.keys(augTransformKey)).toHaveLength(7);
+            expect(Object.keys(augTransformKey)).toHaveLength(6);
 
             expect(augTransformKey.toPublicKey).toEqual(toPublicKey);
             expect(augTransformKey.publicSigningKey).toEqual(publicSigningKey);
@@ -433,8 +431,6 @@ describe("Recrypt-Node", () => {
 
             expect(augTransformKey.signature).toBeInstanceOf(Buffer);
             expect(augTransformKey.signature).toHaveLength(64);
-
-            expect(augTransformKey.transformBlocks).toBeArrayOfSize(0);
         });
     });
 
@@ -457,15 +453,15 @@ describe("Recrypt-Node", () => {
         });
     });
 
-    describe("transformKeyToBytes", () => {
+    describe("transformKeyToBytes256", () => {
         it("returns expected number of bytes", () => {
             const api = new recrypt.Api256();
             const fromPrivateKey = api.generateKeyPair().privateKey;
             const toPublicKey = api.generateKeyPair().publicKey;
 
             const transformKey = api.generateTransformKey(fromPrivateKey, toPublicKey, privateSigningKey);
 
-            const transformKeyBytes = recrypt.transformKeyToBytes(transformKey);
+            const transformKeyBytes = recrypt.transformKeyToBytes256(transformKey);
             expect(transformKeyBytes).toBeInstanceOf(Buffer);
             expect(transformKeyBytes).toHaveLength(672);
         });