tabris 3.9.0-dev.20211115 → 3.9.0-dev.20211119

package/boot.js

@@ -1,5 +1,5 @@
 /*!
- * Tabris.js 3.9.0-dev.20211115+0310
+ * Tabris.js 3.9.0-dev.20211119+0310
  * 
  * Copyright (c) 2014, 2020 EclipseSource Inc.
  * All rights reserved.

package/globals.d.ts

@@ -590,6 +590,38 @@ declare class Crypto {
 
 declare var crypto: Crypto;
 
+// CryptoKey
+
+/**
+ * Represents an in-memory cryptographic key to be used with the ${doc:SubtleCrypto} API.
+ */
+declare class CryptoKey {
+
+  /**
+   * Represents an in-memory cryptographic key to be used with the ${doc:SubtleCrypto} API.
+   */
+  private constructor();
+
+  /**
+   * @constant
+   */
+  readonly algorithm: {name: 'ECDH', namedCurve: 'P-256'};
+
+
+  extractable: boolean;
+
+  /**
+   * @constant
+   */
+  readonly type: 'secret' | 'private' | 'public';
+
+  /**
+   * @constant
+   */
+  readonly usages: string[];
+}
+
+
 // File
 
 /**
@@ -956,6 +988,25 @@ declare class SubtleCrypto {
    */
   private constructor();
 
+  /**
+   * Decrypts the given raw data. Currently only supports the AES-GCM algorithm.
+   * @param algorithm
+   * @param key
+   * @param data
+   */
+  decrypt(algorithm: {name: 'AES-GCM', iv: ArrayBuffer | TypedArray, tagLength?: number}, key: CryptoKey, data: ArrayBuffer | TypedArray): Promise<ArrayBuffer>;
+
+  /**
+   * Takes a master key and derives a secret key from it using the given algorithm. Currently only
+   * supports the Elliptic Curve Diffie-Hellman (ECDH) algorithm.
+   * @param algorithm
+   * @param baseKey
+   * @param derivedKeyAlgorithm
+   * @param extractable
+   * @param keyUsages
+   */
+  deriveKey(algorithm: {name: 'ECDH', namedCurve: 'P-256', public: CryptoKey}, baseKey: CryptoKey, derivedKeyAlgorithm: {name: 'AES-GCM', length: number}, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+
   /**
    * Provides the digest value of the given data as an ArrayBuffer. Fo this the method uses the hashing
    * algorithms provided by the operating system.
@@ -963,6 +1014,43 @@ declare class SubtleCrypto {
    * @param data The data to be digested.
    */
   digest(algorithm: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512', data: TypedArray | ArrayBuffer): Promise<ArrayBuffer>;
+
+  /**
+   * Encrypts the given raw data. Currently only supports the AES-GCM algorithm.
+   * @param algorithm
+   * @param key
+   * @param data
+   */
+  encrypt(algorithm: {name: 'AES-GCM', iv: ArrayBuffer | TypedArray, tagLength?: number}, key: CryptoKey, data: ArrayBuffer | TypedArray): Promise<ArrayBuffer>;
+
+  /**
+   * Converts a CryptoKey instances into a portable format. To export a key, the key must have extractable
+   * set to true. Supports the spki format or raw bytes.
+   * @param format
+   * @param key
+   */
+  exportKey(format: 'raw' | 'spki', key: CryptoKey): Promise<ArrayBuffer>;
+
+  /**
+   * Generates new keys. Currently only supports the Elliptic Curve Diffie-Hellman (ECDH) algorithm to
+   * generate key pairs.
+   * @param algorithm
+   * @param extractable
+   * @param keyUsages
+   */
+  generateKey(algorithm: {name: 'ECDH', namedCurve: 'P-256'}, extractable: boolean, keyUsages: string[]): Promise<{privateKey: CryptoKey, publicKey: CryptoKey}>;
+
+  /**
+   * Takes an external key in a portable format and returns a CryptoKey object that can be used with the
+   * SubtleCrypto API. Currently only supports the Elliptic Curve Diffie-Hellman (ECDH) algorithm. Keys
+   * may be in spki or pkcs8 format.
+   * @param format
+   * @param keyData
+   * @param algorithm
+   * @param extractable
+   * @param keyUsages
+   */
+  importKey(format: 'spki' | 'pkcs8', keyData: ArrayBuffer | TypedArray, algorithm: {name: 'ECDH', namedCurve: 'P-256'}, extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabris",
-  "version": "3.9.0-dev.20211115+0310",
+  "version": "3.9.0-dev.20211119+0310",
   "description": "Mobile apps with native UIs in JavaScript",
   "keywords": [
     "native",

package/tabris.d.ts

@@ -1,4 +1,4 @@
-// Type definitions for Tabris.js 3.9.0-dev.20211115+0310
+// Type definitions for Tabris.js 3.9.0-dev.20211119+0310
 /// <reference path="globals.d.ts" />
 
 // General helper types

package/tabris.js

@@ -1,5 +1,5 @@
 /*!
- * Tabris.js 3.9.0-dev.20211115+0310
+ * Tabris.js 3.9.0-dev.20211119+0310
  * 
  * Copyright (c) 2014, 2020 EclipseSource Inc.
  * All rights reserved.
@@ -962,11 +962,11 @@ function setBytes(blob, bytes$$1) {
  */
 function allowOnlyKeys(target, keys) {
     if (typeof target !== 'object') {
-        throw new Error(toValueString(target) + ' is not an object');
+        throw new TypeError(toValueString(target) + ' is not an object');
     }
     for (const key in target) {
         if (keys.indexOf(/** @type {U} */ (key)) === -1) {
-            throw new Error(`${toValueString(target)} contains unexpected entry "${key}"`);
+            throw new TypeError(`${toValueString(target)} contains unexpected entry "${key}"`);
         }
     }
     return target;
@@ -979,8 +979,10 @@ function allowOnlyKeys(target, keys) {
  */
 function allowOnlyValues(value, allowed, valueName = 'Value') {
     if (allowed && allowed.indexOf(value) === -1) {
-        const expected = `"${allowed.slice(0, -1).join('", "')}" or "${allowed.slice(-1)}"`;
-        throw new Error(`${valueName} must be ${expected}", got ${toValueString(value)}`);
+        const expected = allowed.length === 1
+            ? `"${allowed}"`
+            : `"${allowed.slice(0, -1).join('", "')}" or "${allowed.slice(-1)}"`;
+        throw new TypeError(`${valueName} must be ${expected}, got ${toValueString(value)}`);
     }
     return value;
 }
@@ -998,6 +1000,22 @@ function setNativeObject(object, nativeObject$$1) {
 function getNativeObject(object) {
     return object instanceof Object ? object[nativeObject] : null;
 }
+/**
+ * @param {object} object
+ * @returns {string}
+ */
+function getCid(object) {
+    return getNativeObject(object).cid;
+}
+/**
+ * @param {ArrayBuffer | ArrayLike<number>} data
+ * @returns {ArrayBuffer}
+ */
+function getBuffer(object) {
+    return object instanceof ArrayBuffer
+        ? object
+        : ArrayBuffer.isView(object) ? object.buffer : null;
+}
 /**
  * @param {Function} cb
  * @param {object=} target
@@ -5008,7 +5026,7 @@ class Tabris extends NativeObject {
         this.$publishProxies();
     }
     get version() {
-        return '3.9.0-dev.20211115+0310';
+        return '3.9.0-dev.20211119+0310';
     }
     get started() {
         return !!this._started;
@@ -10378,6 +10396,69 @@ NativeObject.defineProperties(CameraView.prototype, {
     }
 });
 
+class CryptoKey {
+    constructor(nativeObject, data) {
+        if (!(nativeObject instanceof _CryptoKey)) {
+            throw new TypeError('Illegal constructor');
+        }
+        setNativeObject(this, nativeObject);
+        Object.assign(this, data);
+        Object.freeze(this);
+    }
+}
+class _CryptoKey extends NativeObject {
+    constructor(keyPair, type) {
+        super(keyPair ? { parent: keyPair.cid, type } : {});
+    }
+    get _nativeType() {
+        return 'tabris.CryptoKey';
+    }
+    import(format, keyData, algorithm, extractable, keyUsages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise$1((onSuccess, onError) => this._nativeCall('import', {
+                format,
+                keyData: getBuffer(keyData),
+                algorithm,
+                extractable,
+                keyUsages,
+                onSuccess,
+                onError: wrapErrorCb(onError)
+            }));
+        });
+    }
+    derive(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise$1((onSuccess, onError) => this._nativeCall('derive', {
+                algorithm: Object.assign(Object.assign({}, algorithm), { public: getCid(algorithm.public) }),
+                baseKey: getCid(baseKey),
+                derivedKeyAlgorithm,
+                extractable,
+                keyUsages,
+                onSuccess,
+                onError: wrapErrorCb(onError)
+            }));
+        });
+    }
+    generate(algorithm, extractable, keyUsages) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise$1((onSuccess, onError) => this._nativeCall('generate', {
+                algorithm,
+                extractable,
+                keyUsages,
+                onSuccess,
+                onError: wrapErrorCb(onError)
+            }));
+        });
+    }
+}
+NativeObject.defineProperties(_CryptoKey.prototype, {
+    parent: { type: 'string', const: true, nocache: true },
+    type: { type: 'string', const: true, nocache: true, choice: ['public', 'private'] }
+});
+function wrapErrorCb(onError) {
+    return (reason) => onError(new Error(String(reason)));
+}
+
 class Crypto {
     constructor() {
         Object.defineProperties(this, {
@@ -10389,7 +10470,9 @@ class Crypto {
         if (arguments.length === 0) {
             throw new Error('Not enough arguments to Crypto.getRandomValues');
         }
-        if (!isIntArray(typedArray)) {
+        if (!ArrayBuffer.isView(typedArray)
+            || typedArray instanceof Float32Array
+            || typedArray instanceof Float64Array) {
             throw new Error(`Argument ${toValueString(typedArray)} is not an accepted array type`);
         }
         return this._nativeObject.getRandomValues(typedArray);
@@ -10410,12 +10493,116 @@ class SubtleCrypto {
             if (!validAlgorithms.has(algorithm)) {
                 return Promise$1.reject(new TypeError(`Algorithm: Unrecognized name ${algorithm}`));
             }
-            if (!isIntArray(data) && !(data instanceof ArrayBuffer)) {
+            if (!getBuffer(data)) {
                 return Promise$1.reject(new TypeError(`Argument ${toValueString(data)} is not an accepted array type`));
             }
             return new Promise$1((resolve, reject) => this._nativeObject.subtleDigest({ algorithm, data, resolve, reject }));
         });
     }
+    importKey(format, keyData, algorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 5) {
+                throw new TypeError(`Expected 5 arguments, got ${arguments.length}`);
+            }
+            allowOnlyValues(format, ['spki', 'pkcs8'], 'format');
+            checkType(getBuffer(keyData), ArrayBuffer, { name: 'keyData' });
+            allowOnlyKeys(algorithm, ['name', 'namedCurve']);
+            allowOnlyValues(algorithm.name, ['ECDH'], 'algorithm.name');
+            allowOnlyValues(algorithm.namedCurve, ['P-256'], 'algorithm.namedCurve');
+            checkType(extractable, Boolean, { name: 'extractable' });
+            checkType(keyUsages, Array, { name: 'keyUsages' });
+            const nativeObject = new _CryptoKey();
+            yield nativeObject.import(format, keyData, algorithm, extractable, keyUsages);
+            return new CryptoKey(nativeObject, {
+                algorithm,
+                extractable,
+                usages: Object.freeze(keyUsages.concat())
+            });
+        });
+    }
+    deriveKey(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 5) {
+                throw new TypeError(`Expected 5 arguments, got ${arguments.length}`);
+            }
+            allowOnlyKeys(algorithm, ['name', 'namedCurve', 'public']);
+            allowOnlyValues(algorithm.name, ['ECDH'], 'algorithm.name');
+            allowOnlyValues(algorithm.namedCurve, ['P-256'], 'algorithm.namedCurve');
+            checkType(algorithm.public, CryptoKey, { name: 'algorithm.public' });
+            allowOnlyKeys(derivedKeyAlgorithm, ['name', 'length']);
+            allowOnlyValues(derivedKeyAlgorithm.name, ['AES-GCM'], 'derivedKeyAlgorithm.name');
+            checkType(derivedKeyAlgorithm.length, Number, { name: 'derivedKeyAlgorithm.length' });
+            checkType(baseKey, CryptoKey, { name: 'baseKey' });
+            checkType(extractable, Boolean, { name: 'extractable' });
+            checkType(keyUsages, Array, { name: 'keyUsages' });
+            const nativeObject = new _CryptoKey();
+            yield nativeObject.derive(algorithm, baseKey, derivedKeyAlgorithm, extractable, keyUsages);
+            return new CryptoKey(nativeObject, {
+                algorithm,
+                extractable,
+                type: 'secret',
+                usages: Object.freeze(keyUsages.concat())
+            });
+        });
+    }
+    decrypt(algorithm, key, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 3) {
+                throw new TypeError(`Expected 3 arguments, got ${arguments.length}`);
+            }
+            allowOnlyKeys(algorithm, ['name', 'iv', 'tagLength']);
+            allowOnlyValues(algorithm.name, ['AES-GCM'], 'algorithm.name');
+            checkType(algorithm.tagLength, Number, { name: 'algorithm.tagLength', nullable: true });
+            checkType(getBuffer(algorithm.iv), ArrayBuffer, { name: 'algorithm.iv' });
+            checkType(key, CryptoKey, { name: 'key' });
+            checkType(getBuffer(data), ArrayBuffer, { name: 'data' });
+            return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleDecrypt(algorithm, key, data, onSuccess, onReject));
+        });
+    }
+    encrypt(algorithm, key, data) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 3) {
+                throw new TypeError(`Expected 3 arguments, got ${arguments.length}`);
+            }
+            allowOnlyKeys(algorithm, ['name', 'iv', 'tagLength']);
+            allowOnlyValues(algorithm.name, ['AES-GCM'], 'algorithm.name');
+            checkType(algorithm.tagLength, Number, { name: 'algorithm.tagLength', nullable: true });
+            checkType(getBuffer(algorithm.iv), ArrayBuffer, { name: 'algorithm.iv' });
+            checkType(key, CryptoKey, { name: 'key' });
+            checkType(getBuffer(data), ArrayBuffer, { name: 'data' });
+            return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleEncrypt(algorithm, key, data, onSuccess, onReject));
+        });
+    }
+    exportKey(format, key) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 2) {
+                throw new TypeError(`Expected 2 arguments, got ${arguments.length}`);
+            }
+            allowOnlyValues(format, ['raw', 'spki'], 'format');
+            checkType(key, CryptoKey, { name: 'key' });
+            return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleExportKey(format, key, onSuccess, onReject));
+        });
+    }
+    generateKey(algorithm, extractable, keyUsages) {
+        return __awaiter(this, arguments, void 0, function* () {
+            if (arguments.length !== 3) {
+                throw new TypeError(`Expected 3 arguments, got ${arguments.length}`);
+            }
+            allowOnlyKeys(algorithm, ['name', 'namedCurve']);
+            allowOnlyValues(algorithm.name, ['ECDH'], 'algorithm.name');
+            allowOnlyValues(algorithm.namedCurve, ['P-256'], 'algorithm.namedCurve');
+            checkType(extractable, Boolean, { name: 'extractable' });
+            checkType(keyUsages, Array, { name: 'keyUsages' });
+            const nativeObject = new _CryptoKey();
+            yield nativeObject.generate(algorithm, extractable, keyUsages);
+            const nativePrivate = new _CryptoKey(nativeObject, 'private');
+            const nativePublic = new _CryptoKey(nativeObject, 'public');
+            return {
+                privateKey: new CryptoKey(nativePrivate, { algorithm, extractable }),
+                publicKey: new CryptoKey(nativePublic, { algorithm, extractable })
+            };
+        });
+    }
 }
 class NativeCrypto extends NativeObject {
     static getInstance() {
@@ -10449,15 +10636,42 @@ class NativeCrypto extends NativeObject {
             onError: (reason) => arg.reject(new Error(String(reason)))
         });
     }
-}
-function isIntArray(value) {
-    return (value instanceof Int8Array) ||
-        (value instanceof Uint8Array) ||
-        (value instanceof Uint8ClampedArray) ||
-        (value instanceof Int16Array) ||
-        (value instanceof Uint16Array) ||
-        (value instanceof Int32Array) ||
-        (value instanceof Uint32Array);
+    subtleDecrypt(algorithm, key, data, onSuccess, onError) {
+        const { name, iv, tagLength } = algorithm;
+        this._nativeCall('subtleDecrypt', {
+            algorithm: {
+                name,
+                iv: getBuffer(iv),
+                tagLength: isNaN(tagLength) ? 128 : tagLength
+            },
+            key: getNativeObject(key).cid,
+            data: ArrayBuffer.isView(data) ? data.buffer : data,
+            onSuccess,
+            onError: (reason) => onError(new Error(String(reason)))
+        });
+    }
+    subtleExportKey(format, key, onSuccess, onError) {
+        this._nativeCall('subtleExportKey', {
+            format,
+            key: getCid(key),
+            onSuccess,
+            onError: (reason) => onError(new Error(String(reason)))
+        });
+    }
+    subtleEncrypt(algorithm, key, data, onSuccess, onError) {
+        const { name, iv, tagLength } = algorithm;
+        this._nativeCall('subtleEncrypt', {
+            algorithm: {
+                name,
+                iv: getBuffer(iv),
+                tagLength: isNaN(tagLength) ? 128 : tagLength
+            },
+            key: getCid(key),
+            data: getBuffer(data),
+            onSuccess,
+            onError: (reason) => onError(new Error(String(reason)))
+        });
+    }
 }
 
 class Drawer extends ContentView {
@@ -13211,6 +13425,7 @@ const POPUPS = Object.freeze({
 const WHATWG = Object.freeze({
     Blob,
     Crypto,
+    CryptoKey,
     Event,
     File,
     FormData,