tabris 3.9.0-dev.20240205 → 3.9.0-dev.20240206

package/boot.js

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

package/globals.d.ts

@@ -1053,22 +1053,27 @@ declare class SubtleCrypto {
   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.
+   * Converts `CryptoKey` instances into a portable format. If the key's `extractable` is set to `true`,
+   * returns the raw key material in SPKI format or as raw bytes. If the key's `extractable` is set to
+   * `false`, for ECDSA and ECDH keys returns an opaque handle to the key in the device's trusted
+   * execution environment, and throws for other key formats.
    * @param format
    * @param key
    */
-  exportKey(format: 'raw' | 'spki' | 'teeKeyHandle', key: CryptoKey): Promise<ArrayBuffer>;
+  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.
+   * Generates new keys. Currently only supports the Elliptic Curve Diffie-Hellman (ECDH) and Elliptic
+   * Curve Digital Signature Algorithm (ECDSA) algorithms to generate key pairs. When `extractable` is set
+   * to `true`, the raw key material can be exported using `exportKey`. When `extractable` is set to
+   * `false`, for ECDSA and ECDH keys `exportKey` returns an opaque handle to the key in the device's
+   * trusted execution environment, and throws for other key formats.
    * @param algorithm
    * @param extractable
    * @param keyUsages
    * @param options
    */
-  generateKey(algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'}, extractable: boolean, keyUsages: string[], options?: {inTee?: boolean, usageRequiresAuth?: boolean}): Promise<{privateKey: CryptoKey, publicKey: CryptoKey}>;
+  generateKey(algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'}, extractable: boolean, keyUsages: string[], options?: {usageRequiresAuth?: boolean}): Promise<{privateKey: CryptoKey, publicKey: CryptoKey}>;
 
   /**
    * Takes an external key in a portable format and returns a CryptoKey object that can be used with the
@@ -1079,7 +1084,7 @@ declare class SubtleCrypto {
    * @param extractable
    * @param keyUsages
    */
-  importKey(format: 'spki' | 'pkcs8' | 'raw' | 'teeKeyHandle', keyData: ArrayBuffer | TypedArray, algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'} | {name: 'AES-GCM'} | 'HKDF' | 'AES-GCM', extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
+  importKey(format: 'spki' | 'pkcs8' | 'raw', keyData: ArrayBuffer | TypedArray, algorithm: {name: 'ECDH' | 'ECDSA', namedCurve: 'P-256'} | {name: 'AES-GCM'} | 'HKDF' | 'AES-GCM', extractable: boolean, keyUsages: string[]): Promise<CryptoKey>;
 
   /**
    * Signs the given data. Currently only supports creating ECDSA signatures in DER format.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tabris",
-  "version": "3.9.0-dev.20240205+0311",
+  "version": "3.9.0-dev.20240206+0311",
   "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.20240205+0311
+// Type definitions for Tabris.js 3.9.0-dev.20240206+0311
 /// <reference path="globals.d.ts" />
 
 // General helper types

package/tabris.js

@@ -1,5 +1,5 @@
 /*!
- * Tabris.js 3.9.0-dev.20240205+0311
+ * Tabris.js 3.9.0-dev.20240206+0311
  * 
  * Copyright (c) 2014, 2020 EclipseSource Inc.
  * All rights reserved.
@@ -5034,7 +5034,7 @@ class Tabris extends NativeObject {
         this.$publishProxies();
     }
     get version() {
-        return '3.9.0-dev.20240205+0311';
+        return '3.9.0-dev.20240206+0311';
     }
     get started() {
         return !!this._started;
@@ -10485,13 +10485,12 @@ class _CryptoKey extends NativeObject {
             });
         });
     }
-    generate(algorithm, extractable, keyUsages, inTee, usageRequiresAuth) {
+    generate(algorithm, extractable, keyUsages, usageRequiresAuth) {
         return __awaiter(this, void 0, void 0, function* () {
             return new Promise$1((onSuccess, onError) => this._nativeCall('generate', {
                 algorithm,
                 extractable,
                 keyUsages,
-                inTee,
                 usageRequiresAuth,
                 onSuccess,
                 onError: wrapErrorCb(onError)
@@ -10552,7 +10551,7 @@ class SubtleCrypto {
             if (arguments.length !== 5) {
                 throw new TypeError(`Expected 5 arguments, got ${arguments.length}`);
             }
-            allowOnlyValues(format, ['spki', 'pkcs8', 'raw', 'teeKeyHandle'], 'format');
+            allowOnlyValues(format, ['spki', 'pkcs8', 'raw'], 'format');
             checkType(getBuffer(keyData), ArrayBuffer, { name: 'keyData' });
             if (typeof algorithm === 'string') {
                 allowOnlyValues(algorithm, ['AES-GCM', 'HKDF'], 'algorithm');
@@ -10657,7 +10656,7 @@ class SubtleCrypto {
             if (arguments.length !== 2) {
                 throw new TypeError(`Expected 2 arguments, got ${arguments.length}`);
             }
-            allowOnlyValues(format, ['raw', 'spki', 'teeKeyHandle'], 'format');
+            allowOnlyValues(format, ['raw', 'spki'], 'format');
             checkType(key, CryptoKey, { name: 'key' });
             return new Promise$1((onSuccess, onReject) => this._nativeObject.subtleExportKey(format, key, onSuccess, onReject));
         });
@@ -10673,21 +10672,17 @@ class SubtleCrypto {
             checkType(extractable, Boolean, { name: 'extractable' });
             checkType(keyUsages, Array, { name: 'keyUsages' });
             if (options != null) {
-                allowOnlyKeys(options, ['inTee', 'usageRequiresAuth']);
-                if ('inTee' in options) {
-                    checkType(options.inTee, Boolean, { name: 'options.inTee' });
-                }
+                allowOnlyKeys(options, ['usageRequiresAuth']);
                 if ('usageRequiresAuth' in options) {
                     checkType(options.usageRequiresAuth, Boolean, { name: 'options.usageRequiresAuth' });
                 }
-                if (options.usageRequiresAuth && !options.inTee && tabris.device.platform !== 'Android') {
-                    throw new TypeError('options.usageRequiresAuth is only supported for keys not in TEE on Android');
+                if (options.usageRequiresAuth && (extractable || !algorithm.name.startsWith('EC'))) {
+                    throw new TypeError('options.usageRequiresAuth is only supported for non-extractable EC keys');
                 }
             }
-            const inTee = options === null || options === void 0 ? void 0 : options.inTee;
             const usageRequiresAuth = options === null || options === void 0 ? void 0 : options.usageRequiresAuth;
             const nativeObject = new _CryptoKey();
-            yield nativeObject.generate(algorithm, extractable, keyUsages, inTee, usageRequiresAuth);
+            yield nativeObject.generate(algorithm, extractable, keyUsages, usageRequiresAuth);
             const nativePrivate = new _CryptoKey(nativeObject, 'private');
             const nativePublic = new _CryptoKey(nativeObject, 'public');
             return {