@breakside/jskit 2024.34.0 → 2024.41.0

package/Frameworks/SecurityKit.jsframework/JS/SECCipher+HTML.js

@@ -17,6 +17,7 @@
 // #import "SECCipher.js"
 // #import "SECHTMLKey.js"
 // #import "SECHash.js"
+// #import "SECASN1Parser.js"
 // #feature window.crypto.subtle
 // jshint browser: true
 /* global crypto */
@@ -44,7 +45,13 @@ var HTMLCryptoAlgorithmNames = {
     }
 };
 
-SECCipher.definePropertiesFromExtensions({
+var HTMLHashAlgorithms = {};
+HTMLHashAlgorithms[SECHash.Algorithm.sha1] = 'SHA-1';
+HTMLHashAlgorithms[SECHash.Algorithm.sha256] = 'SHA-256';
+HTMLHashAlgorithms[SECHash.Algorithm.sha384] = 'SHA-384';
+HTMLHashAlgorithms[SECHash.Algorithm.sha512] = 'SHA-512';
+
+SECCipherAES.definePropertiesFromExtensions({
 
     htmlAlgorithmName: null,
 
@@ -58,7 +65,9 @@ SECCipher.definePropertiesFromExtensions({
         };
         var extractable = true;
         crypto.subtle.generateKey(algorithm, extractable, ["encrypt", "decrypt", "wrapKey", "unwrapKey"]).then(function(htmlKey){
-            completion.call(target, SECHTMLKey.initWithKey(htmlKey));
+            var key = SECHTMLKey.initWithKey(htmlKey);
+            key.id = JSSHA1Hash(UUID.init().bytes).base64URLStringRepresentation();
+            completion.call(target, key);
         }, function(e){
             completion.call(target, null);
         });
@@ -87,30 +96,20 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
 
     htmlAlgorithmName: HTMLCryptoAlgorithmNames.aesCBC,
 
-    _getHTMLEncryptAlgorithm: function(){
-        return {
-            name: HTMLCryptoAlgorithmNames.aesCBC,
-            iv: crypto.getRandomValues(JSData.initWithLength(16))
-        };
-    },
-
-    _getHTMLDecryptAlgorithm: function(prefixedData){
-        return {
-            name: HTMLCryptoAlgorithmNames.aesCBC,
-            iv: prefixedData.subdataInRange(JSRange(0, 16))
-        };
-    },
-
     encrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLEncryptAlgorithm();
+        var iv = this.iv !== null ? this.iv : this.randomIV();
+        var algorithm = {
+            name: HTMLCryptoAlgorithmNames.aesCBC,
+            iv: iv
+        };
         crypto.subtle.encrypt(algorithm, key.htmlKey, data).then(function(encrypted){
             // prefix the encrypted data with the random initializtion vector so
             // it is available to the decrypt function.  The iv does not need
             // to be a secret, it just needs to be random, so prefixing does not affect security.
-            var ivPrefixed = JSData.initWithChunks([algorithm.iv, JSData.initWithBuffer(encrypted)]);
+            var ivPrefixed = JSData.initWithChunks([iv, JSData.initWithBuffer(encrypted)]);
             completion.call(target, ivPrefixed);
         },function(e){
             completion.call(target, null);
@@ -122,9 +121,13 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLDecryptAlgorithm(data);
-        var encrypted = data.subdataInRange(JSRange(16, data.length - 16));
-        crypto.subtle.decrypt(algorithm, key.htmlKey, encrypted).then(function(decrypted){
+        var iv = data.subdataInRange(JSRange(0, this.ivByteLength));
+        var ciphertext = data.subdataInRange(JSRange(this.ivByteLength, data.length - this.ivByteLength));
+        var algorithm = {
+            name: HTMLCryptoAlgorithmNames.aesCBC,
+            iv: iv
+        };
+        crypto.subtle.decrypt(algorithm, key.htmlKey, ciphertext).then(function(decrypted){
             var decryptedData = JSData.initWithBuffer(decrypted);
             completion.call(target, decryptedData);
         }, function(e){
@@ -137,9 +140,13 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLEncryptAlgorithm();
+        var iv = this.iv !== null ? this.iv : this.randomIV();
+        var algorithm = {
+            name: HTMLCryptoAlgorithmNames.aesCBC,
+            iv: iv
+        };
         crypto.subtle.wrapKey("raw", key.htmlKey, wrappingKey.htmlKey, algorithm).then(function(bytes){
-            var ivPrefixed = JSData.initWithChunks([algorithm.iv, JSData.initWithBuffer(bytes)]);
+            var ivPrefixed = JSData.initWithChunks([iv, JSData.initWithBuffer(bytes)]);
             completion.call(target, ivPrefixed);
         }, function(e){
             completion.call(target, null);
@@ -151,10 +158,14 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLDecryptAlgorithm(wrappedKeyData);
+        var iv = wrappedKeyData.subdataInRange(JSRange(0, this.ivByteLength));
+        var ciphertext = wrappedKeyData.subdataInRange(JSRange(16, wrappedKeyData.length - 16));
+        var algorithm = {
+            name: HTMLCryptoAlgorithmNames.aesCBC,
+            iv: iv
+        };
         var unwrappedKeyHTMLAlgorithm = HTMLCryptoAlgorithmNames.fromAlgorithm(unwrappedKeyAlgorithm);
-        wrappedKeyData = wrappedKeyData.subdataInRange(JSRange(16, wrappedKeyData.length - 16));
-        crypto.subtle.unwrapKey("raw", wrappedKeyData, wrappingKey.htmlKey, algorithm, unwrappedKeyHTMLAlgorithm, true, ["encrypt", "decrypt"]).then(function(key){
+        crypto.subtle.unwrapKey("raw", ciphertext, wrappingKey.htmlKey, algorithm, unwrappedKeyHTMLAlgorithm, true, ["encrypt", "decrypt"]).then(function(key){
             completion.call(target, SECHTMLKey.initWithKey(key));
         }, function(e){
             completion.call(target, null);
@@ -274,57 +285,202 @@ SECCipherAESGaloisCounterMode.definePropertiesFromExtensions({
 
     htmlAlgorithmName: HTMLCryptoAlgorithmNames.aesGCM,
 
-    _getHTMLEncryptAlgorithm: function(nonce, _ivLength){
-        if (_ivLength === undefined){
-            _ivLength = nonce.length;
+    encrypt: function(data, key, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
         }
+        var iv = this.iv !== null ? this.iv : this.randomIV();
         var algorithm = {
             name: HTMLCryptoAlgorithmNames.aesGCM,
-            iv: JSData.initWithLength(_ivLength),
-            tagLength: 128
+            iv: iv,
+            tagLength: this.tagByteLength << 3
         };
-        nonce.copyTo(algorithm.iv, 0);
-        return algorithm;
+        if (this.additionalData !== null){
+            algorithm.additionalData = this.additionalData;
+        }
+        crypto.subtle.encrypt(algorithm, key.htmlKey, data).then(function(encrypted){
+            var ivPrefixed = JSData.initWithChunks([iv, JSData.initWithBuffer(encrypted)]);
+            completion.call(target, ivPrefixed);
+        },function(e){
+            completion.call(target, null);
+        });
+        return completion.promise;
     },
 
-    _getHTMLDecryptAlgorithm: function(prefixedData, nonceLength, _ivLength){
-        if (nonceLength === undefined){
-            nonceLength = 8;
+    decrypt: function(data, key, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
         }
-        if (_ivLength === undefined){
-            _ivLength = nonceLength;
+        var iv = data.subdataInRange(JSRange(0, this.ivByteLength));
+        var ciphertext = data.subdataInRange(JSRange(this.ivByteLength, data.length - this.ivByteLength));
+        var algorithm = {
+            name: HTMLCryptoAlgorithmNames.aesGCM,
+            iv: iv,
+            tagLength: this.tagByteLength << 3
+        };
+        if (this.additionalData !== null){
+            algorithm.additionalData = this.additionalData;
+        }
+        crypto.subtle.decrypt(algorithm, key.htmlKey, ciphertext).then(function(decrypted){
+            var decryptedData = JSData.initWithBuffer(decrypted);
+            completion.call(target, decryptedData);
+        }, function(error){
+            completion.call(target, null);
+        });
+        return completion.promise;
+    },
+
+    wrapKey: function(key, wrappingKey, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
         }
-        var nonce = prefixedData.subdataInRange(JSRange(0, nonceLength));
+        var iv = this.iv !== null ? this.iv : this.randomIV();
         var algorithm = {
             name: HTMLCryptoAlgorithmNames.aesGCM,
-            iv: JSData.initWithLength(_ivLength),
-            tagLength: 128
+            iv: iv,
+            tagLength: this.tagByteLength << 3
         };
-        nonce.copyTo(algorithm.iv, 0);
-        return algorithm;
+        crypto.subtle.wrapKey("raw", key.htmlKey, wrappingKey.htmlKey, algorithm).then(function(bytes){
+            var ivPrefixed = JSData.initWithChunks([iv, JSData.initWithBuffer(bytes)]);
+            completion.call(target, ivPrefixed);
+        }, function(e){
+            completion.call(target, null);
+        });
+        return completion.promise;
+    },
+
+    unwrapKey: function(wrappedKeyData, unwrappedKeyAlgorithm, wrappingKey, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var iv = wrappedKeyData.subdataInRange(JSRange(0, this.ivByteLength));
+        var ciphertext = wrappedKeyData.subdataInRange(JSRange(this.ivByteLength, wrappedKeyData.length - this.ivByteLength));
+        var algorithm = {
+            name: HTMLCryptoAlgorithmNames.aesGCM,
+            iv: iv,
+            tagLength: this.tagByteLength << 3
+        };
+        var unwrappedKeyHTMLAlgorithm = HTMLCryptoAlgorithmNames.fromAlgorithm(unwrappedKeyAlgorithm);
+        crypto.subtle.unwrapKey("raw", ciphertext, wrappingKey.htmlKey, algorithm, unwrappedKeyHTMLAlgorithm, true, ["encrypt", "decrypt"]).then(function(key){
+            completion.call(target, SECHTMLKey.initWithKey(key));
+        }, function(e){
+            completion.call(target, null);
+        });
+        return completion.promise;
+    }
+});
+
+SECCipherRSAOAEP.definePropertiesFromExtensions({
+
+    createKey: function(completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var algorithm = {
+            name: "RSA-OAEP",
+            modulusLength: this.modulusLength,
+            publicExponent: bigIntegerFromNumber(this.publicExponent),
+            hash: HTMLHashAlgorithms[this.hash]
+        };
+        crypto.subtle.generateKey(algorithm, true, ["encrypt", "decrypt", "wrapKey", "unwrapKey"]).then(function(htmlPair){
+            var privateKey = SECHTMLKey.initWithKey(htmlPair.privateKey);
+            privateKey.publicKey = SECHTMLKey.initWithKey(htmlPair.publicKey);
+            privateKey.id = privateKey.publicKey.id = JSSHA1Hash(UUID.init().bytes).base64URLStringRepresentation();
+            completion.call(target, privateKey);
+        }, function(e){
+            completion.call(target, null);
+        });
+        return completion.promise;
+    },
+
+    createKeyFromJWK: function(jwk, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var algorithm = {
+            name: "RSA-OAEP",
+            hash: HTMLHashAlgorithms[this.hash]
+        };
+        var usages = jwk.d ? ["decrypt", "unwrapKey"] : ["encrypt", "wrapKey"];
+        crypto.subtle.importKey("jwk", jwk, algorithm, true, usages).then(function(htmlKey){
+            var key = SECHTMLKey.initWithKey(htmlKey);
+            key.id = jwk.kid || null;
+            completion.call(target, key);
+        }, function(e){
+            completion.call(target, null);
+        });
+        return completion.promise;
+    },
+
+    createKeyWithData: function(data, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var algorithm = {
+            name: "RSA-OAEP",
+            hash: HTMLHashAlgorithms[this.hash]
+        };
+        var usages;
+        var parser;
+        try{
+            parser = SECASN1Parser.initWithPEM(data, "RSA PRIVATE KEY");
+            data = parser.der;
+            usages = ["decrypt", "unwrapKey"];
+        }catch (e){
+            try {
+                parser = SECASN1Parser.initWithPEM(data, "RSA PUBLIC KEY");
+                data = parser.der;
+                usages = ["encrypt", "wrapKey"];
+            }catch (e){
+                // assume data was already DER
+                parser = SECASN1Parser.initWithDER(data);
+                var sequence = parser.parse;
+                if (sequence.length > 2){
+                    usages = ["decrypt", "unwrapKey"];
+                }else{
+                    usages = ["encrypt", "wrapKey"];
+                }
+            }
+        }
+        crypto.subtle.importKey("pkcs8", data, algorithm, true, usages).then(function(htmlKey){
+            var key = SECHTMLKey.initWithKey(htmlKey);
+            completion.call(target, key);
+        }, function(e){
+            completion.call(target, null);
+        });
+        return completion.promise;
     },
 
-    encryptWithNonce: function(nonce, data, key, completion, target, _ivLength){
+    encrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLEncryptAlgorithm(nonce, _ivLength);
+        var algorithm = {
+            name: "RSA-OAEP"
+        };
+        if (this.label !== null){
+            algorithm.label = this.label;
+        }
         crypto.subtle.encrypt(algorithm, key.htmlKey, data).then(function(encrypted){
-            var noncePrefixed = JSData.initWithChunks([nonce, JSData.initWithBuffer(encrypted)]);
-            completion.call(target, noncePrefixed);
+            var encryptedData = JSData.initWithBuffer(encrypted);
+            completion.call(target, encryptedData);
         },function(e){
             completion.call(target, null);
         });
         return completion.promise;
     },
 
-    decryptWithNonceLength: function(nonceLength, data, key, completion, target, _ivLength){
+    decrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLDecryptAlgorithm(data, nonceLength, _ivLength);
-        var encrypted = data.subdataInRange(JSRange(nonceLength, data.length - nonceLength));
-        crypto.subtle.decrypt(algorithm, key.htmlKey, encrypted).then(function(decrypted){
+        var algorithm = {
+            name: "RSA-OAEP"
+        };
+        if (this.label !== null){
+            algorithm.label = this.label;
+        }
+        crypto.subtle.decrypt(algorithm, key.htmlKey, data).then(function(decrypted){
             var decryptedData = JSData.initWithBuffer(decrypted);
             completion.call(target, decryptedData);
         }, function(error){
@@ -337,24 +493,15 @@ SECCipherAESGaloisCounterMode.definePropertiesFromExtensions({
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        if (!this.ensureUniqueMessageID()){
-            JSRunLoop.main.schedule(completion, target, null);
-            return completion.promise;
+        var algorithm = {
+            name: "RSA-OAEP"
+        };
+        if (this.label !== null){
+            algorithm.label = this.label;
         }
-        var nonce = JSData.initWithArray([
-            1,
-            ((this.encryptedMessageId / 0x100000000) >> 16) & 0xFF,
-            ((this.encryptedMessageId / 0x100000000) >> 8) & 0xFF,
-            (this.encryptedMessageId / 0x100000000) & 0xFF,
-            (this.encryptedMessageId >> 24) & 0xFF,
-            (this.encryptedMessageId >> 16) & 0xFF,
-            (this.encryptedMessageId >> 8) & 0xFF,
-            this.encryptedMessageId & 0xF
-        ]);
-        var algorithm = this._getHTMLEncryptAlgorithm(nonce, 16);
         crypto.subtle.wrapKey("raw", key.htmlKey, wrappingKey.htmlKey, algorithm).then(function(bytes){
-            var noncePrefixed = JSData.initWithChunks([nonce, JSData.initWithBuffer(bytes)]);
-            completion.call(target, noncePrefixed);
+            var wrapped = JSData.initWithBuffer(bytes);
+            completion.call(target, wrapped);
         }, function(e){
             completion.call(target, null);
         });
@@ -365,20 +512,34 @@ SECCipherAESGaloisCounterMode.definePropertiesFromExtensions({
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var algorithm = this._getHTMLDecryptAlgorithm(wrappedKeyData, 8, 16);
+        var algorithm = {
+            name: "RSA-OAEP"
+        };
+        if (this.label !== null){
+            algorithm.label = this.label;
+        }
         var unwrappedKeyHTMLAlgorithm = HTMLCryptoAlgorithmNames.fromAlgorithm(unwrappedKeyAlgorithm);
-        wrappedKeyData = wrappedKeyData.subdataInRange(JSRange(8, wrappedKeyData.length - 8));
         crypto.subtle.unwrapKey("raw", wrappedKeyData, wrappingKey.htmlKey, algorithm, unwrappedKeyHTMLAlgorithm, true, ["encrypt", "decrypt"]).then(function(key){
             completion.call(target, SECHTMLKey.initWithKey(key));
         }, function(e){
             completion.call(target, null);
         });
         return completion.promise;
-    }
+    }    
+
 });
 
 SECCipher.getRandomData = function(length){
     return crypto.getRandomValues(JSData.initWithLength(length));
 };
 
+var bigIntegerFromNumber = function(n){
+    var elements = [];
+    while (n > 0){
+        elements.unshift(n & 0xFF);
+        n >>>= 8;
+    }
+    return JSData.initWithArray(elements);
+};
+
 })();