@breakside/jskit 2024.34.0 → 2024.40.0

package/Root/Frameworks/SecurityKit/SECCipher+Node.js

@@ -16,6 +16,8 @@
 // #import Foundation
 // #import "SECCipher.js"
 // #import "SECNodeKey.js"
+// #import "SECASN1Parser.js"
+// #import "SECJSONWebAlgorithms.js"
 // jshint node: true
 'use strict';
 
@@ -27,7 +29,9 @@ SECCipher.definePropertiesFromExtensions({
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        this.encrypt(key.keyData, wrappingKey, completion, target);
+        key.getData(function(keyData){
+            this.encrypt(keyData, wrappingKey, completion, target);
+        }, this);
         return completion.promise;
     },
 
@@ -45,15 +49,21 @@ SECCipher.definePropertiesFromExtensions({
         return completion.promise;
     },
 
+});
+
+SECCipherAES.definePropertiesFromExtensions({
+
     createKey: function(completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        crypto.randomBytes(this.keyByteLength, function(error, keyBytes){
+        crypto.generateKey("aes", {length: this.keyBitLength}, function(error, nodeKeyObject){
             if (error){
                 completion.call(target, null);
             }else{
-                completion.call(target, SECNodeKey.initWithData(JSData.initWithNodeBuffer(keyBytes)));
+                var key = SECNodeKey.initWithNodeKeyObject(nodeKeyObject);
+                key.id = JSSHA1Hash(UUID.init().bytes).base64URLStringRepresentation();
+                completion.call(target, key);
             }
         });
         return completion.promise;
@@ -71,8 +81,8 @@ SECCipher.definePropertiesFromExtensions({
 
 SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
 
-    _cipherNameForKey: function(key){
-        switch (key.keyData.length){
+    nodeCipherName: JSLazyInitProperty(function(){
+        switch (this.keyByteLength){
             case 16:
                 return 'AES-128-CBC';
             case 24:
@@ -81,26 +91,20 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
                 return 'AES-256-CBC';
         }
         return null;
-    },
+    }),
 
     encrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var name = this._cipherNameForKey(key);
-        crypto.randomBytes(16, function(error, iv){
-            if (error){
-                completion.call(target, null);
-                return;
-            }
-            if (name === null){
-                completion.call(target, null);
-                return;
-            }
-            var cipher = crypto.createCipheriv(name, key.keyData, iv);
-            var chunks = [iv, cipher.update(data), cipher.final()];
-            completion.call(target, JSData.initWithChunks(chunks));
-        });
+        if (this.nodeCipherName === null){
+            JSRunLoop.main.schedule(completion, target, null);
+            return completion.promise;
+        }
+        var iv = this.iv !== null ? this.iv : this.randomIV();
+        var cipher = crypto.createCipheriv(this.nodeCipherName, key.nodeKeyObject, iv);
+        var chunks = [iv, cipher.update(data), cipher.final()];
+        JSRunLoop.main.schedule(completion, target, JSData.initWithChunks(chunks));
         return completion.promise;
     },
 
@@ -109,14 +113,14 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
             completion = Promise.completion(Promise.resolveNonNull);
         }
         try{
-            var name = this._cipherNameForKey(key);
-            if (name === null){
+            if (this.nodeCipherName === null){
                 JSRunLoop.main.schedule(completion, target, null);
                 return completion.promise;
             }
-            var iv = data.subdataInRange(JSRange(0, 16));
-            var cipher = crypto.createDecipheriv(name, key.keyData, iv);
-            var chunks = [cipher.update(data.subdataInRange(JSRange(16, data.length - 16))), cipher.final()];
+            var iv = data.subdataInRange(JSRange(0, this.ivByteLength));
+            var ciphertext = data.subdataInRange(JSRange(this.ivByteLength, data.length - this.ivByteLength));
+            var cipher = crypto.createDecipheriv(this.nodeCipherName, key.nodeKeyObject, iv);
+            var chunks = [cipher.update(ciphertext), cipher.final()];
             JSRunLoop.main.schedule(completion, target, JSData.initWithChunks(chunks));
         }catch (e){
             JSRunLoop.main.schedule(completion, target, null);
@@ -128,8 +132,8 @@ SECCipherAESCipherBlockChaining.definePropertiesFromExtensions({
 
 SECCipherAESCounter.definePropertiesFromExtensions({
 
-    _cipherNameForKey: function(key){
-        switch (key.keyData.length){
+    nodeCipherName: JSLazyInitProperty(function(){
+        switch (this.keyByteLength){
             case 16:
                 return 'AES-128-CTR';
             case 24:
@@ -138,7 +142,7 @@ SECCipherAESCounter.definePropertiesFromExtensions({
                 return 'AES-256-CTR';
         }
         return null;
-    },
+    }),
 
     encrypt: function(data, key, completion, target){
         if (!completion){
@@ -148,8 +152,7 @@ SECCipherAESCounter.definePropertiesFromExtensions({
             JSRunLoop.main.schedule(completion, target, null);
             return completion.promise;
         }
-        var name = this._cipherNameForKey(key);
-        if (name === null){
+        if (this.nodeCipherName === null){
             JSRunLoop.main.schedule(completion, target, null);
             return completion.promise;
         }
@@ -165,7 +168,7 @@ SECCipherAESCounter.definePropertiesFromExtensions({
         ]);
         var iv = JSData.initWithLength(16);
         nonce.copyTo(iv, 0);
-        var cipher = crypto.createCipheriv(name, key.keyData, iv);
+        var cipher = crypto.createCipheriv(this.nodeCipherName, key.nodeKeyObject, iv);
         var chunks = [nonce, cipher.update(data), cipher.final()];
         JSRunLoop.main.schedule(completion, target, JSData.initWithChunks(chunks));
         return completion.promise;
@@ -176,15 +179,14 @@ SECCipherAESCounter.definePropertiesFromExtensions({
             completion = Promise.completion(Promise.resolveNonNull);
         }
         try{
-            var name = this._cipherNameForKey(key);
-            if (name === null){
+            if (this.nodeCipherName === null){
                 JSRunLoop.main.schedule(completion, target, null);
                 return completion.promise;
             }
             var nonce = data.subdataInRange(JSRange(0, 8));
             var iv = JSData.initWithLength(16);
             nonce.copyTo(iv, 0);
-            var cipher = crypto.createDecipheriv(name, key.keyData, iv);
+            var cipher = crypto.createDecipheriv(this.nodeCipherName, key.nodeKeyObject, iv);
             var chunks = [cipher.update(data.subdataInRange(JSRange(8, data.length - 8))), cipher.final()];
             JSRunLoop.main.schedule(completion, target, JSData.initWithChunks(chunks));
         }catch (e){
@@ -197,8 +199,8 @@ SECCipherAESCounter.definePropertiesFromExtensions({
 
 SECCipherAESGaloisCounterMode.definePropertiesFromExtensions({
 
-    _cipherNameForKey: function(key){
-        switch (key.keyData.length){
+    nodeCipherName: JSLazyInitProperty(function(){
+        switch (this.keyByteLength){
             case 16:
                 return 'id-aes128-GCM';
             case 24:
@@ -207,53 +209,47 @@ SECCipherAESGaloisCounterMode.definePropertiesFromExtensions({
                 return 'id-aes256-GCM';
         }
         return null;
-    },
+    }),
 
-    encryptWithNonce: function(nonce, data, key, completion, target, _ivLength){
+    encrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        var name = this._cipherNameForKey(key);
-        if (name === null){
+        if (this.nodeCipherName === null){
             JSRunLoop.main.schedule(completion, target, null);
             return completion.promise;
         }
-        if (_ivLength === undefined){
-            _ivLength = nonce.length;
+        var iv = this.iv !== null ? this.iv : this.randomIV();
+        var cipher = crypto.createCipheriv(this.nodeCipherName, key.nodeKeyObject, iv);
+        if (this.additionalData){
+            cipher.setAAD(this.additionalData);
         }
-        var iv = JSData.initWithLength(_ivLength);
-        nonce.copyTo(iv, 0);
-        var cipher = crypto.createCipheriv(name, key.keyData, iv);
-        var chunks = [nonce, cipher.update(data), cipher.final()];
-        var tagLength = 16;
-        var tag = JSData.initWithLength(tagLength);
+        var chunks = [iv, cipher.update(data), cipher.final()];
+        var tag = JSData.initWithLength(this.tagByteLength);
         cipher.getAuthTag().copyTo(tag, 0);
         chunks.push(tag);
         JSRunLoop.main.schedule(completion, target, JSData.initWithChunks(chunks));
         return completion.promise;
     },
 
-    decryptWithNonceLength: function(nonceLength, data, key, completion, target, _ivLength){
+    decrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
         try{
-            var name = this._cipherNameForKey(key);
-            if (name === null){
+            if (this.nodeCipherName === null){
                 JSRunLoop.main.schedule(completion, target, null);
                 return completion.promise;
             }
-            var nonce = data.subdataInRange(JSRange(0, nonceLength));
-            if (_ivLength === undefined){
-                _ivLength = nonceLength;
+            var iv = data.subdataInRange(JSRange(0, this.ivByteLength));
+            var ciphertext = data.subdataInRange(JSRange(this.ivByteLength, data.length - this.ivByteLength - this.tagByteLength));
+            var tag = data.subdataInRange(JSRange(data.length - this.tagByteLength, this.tagByteLength));
+            var cipher = crypto.createDecipheriv(this.nodeCipherName, key.nodeKeyObject, iv);
+            if (this.additionalData){
+                cipher.setAAD(this.additionalData);
             }
-            var iv = JSData.initWithLength(_ivLength);
-            nonce.copyTo(iv, 0);
-            var cipher = crypto.createDecipheriv(name, key.keyData, iv);
-            var tagLength = 16;
-            var tag = data.subdataInRange(JSRange(data.length - tagLength, tagLength));
             cipher.setAuthTag(tag);
-            var chunks = [cipher.update(data.subdataInRange(JSRange(nonceLength, data.length - nonceLength - tagLength))), cipher.final()];
+            var chunks = [cipher.update(ciphertext), cipher.final()];
             JSRunLoop.main.schedule(completion, target, JSData.initWithChunks(chunks));
         }catch(e){
             JSRunLoop.main.schedule(completion, target, null);
@@ -263,6 +259,105 @@ SECCipherAESGaloisCounterMode.definePropertiesFromExtensions({
 
 });
 
+SECCipherRSAOAEP.definePropertiesFromExtensions({
+
+    encrypt: function(data, key, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var options = {
+            key: key.nodeKeyObject,
+            oaepHash: this.hash
+        };
+        if (this.label !== null){
+            options.oaepLabel = this.label;
+        }
+        var encryptedBuffer = crypto.publicEncrypt(options, data);
+        JSRunLoop.main.schedule(completion, target, JSData.initWithNodeBuffer(encryptedBuffer));
+        return completion.promise;
+    },
+
+    decrypt: function(data, key, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var options = {
+            key: key.nodeKeyObject,
+            oaepHash: this.hash
+        };
+        if (this.label !== null){
+            options.oaepLabel = this.label;
+        }
+        var decryptedBuffer = crypto.privateDecrypt(options, data);
+        JSRunLoop.main.schedule(completion, target, JSData.initWithNodeBuffer(decryptedBuffer));
+        return completion.promise;
+    },
+
+    createKey: function(completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var options = {
+            modulusLength: this.modulusLength,
+            publicExponent: this.publicExponent
+        };
+        crypto.generateKeyPair("rsa", options, function(err, publicNodeKey, privateNodeKey){
+            if (err){
+                completion.call(target, null);
+                return;
+            }
+            var privateKey = SECNodeKey.initWithNodeKeyObject(privateNodeKey, {alg: SECJSONWebAlgorithms.Algorithm.rsaOAEP});
+            privateKey.publicKey = SECNodeKey.initWithNodeKeyObject(publicNodeKey, {alg: SECJSONWebAlgorithms.Algorithm.rsaOAEP});
+            privateKey.id = privateKey.publicKey.id = JSSHA1Hash(UUID.init().bytes).base64URLStringRepresentation();
+            completion.call(target, privateKey);
+        });
+        return completion.promise;
+    },
+
+    createKeyWithData: function(data, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var parser;
+        var key;
+        try{
+            parser = SECASN1Parser.initWithPEM(data, "RSA PRIVATE KEY");
+            key = crypto.createPrivateKey({key: parser.der, format: "der"});
+        }catch (e){
+            try {
+                parser = SECASN1Parser.initWithPEM(data, "RSA PUBLIC KEY");
+                key = crypto.createPublicKey({key: parser.der, format: "der"});
+            }catch (e){
+                parser = SECASN1Parser.initWithDER(data);
+                var sequence = parser.parse();
+                if (sequence.length > 2){
+                    key = crypto.createPrivateKey({key: parser.der, format: "der"});
+                }else{
+                    key = crypto.createPublicKey({key: parser.der, format: "der"});
+                }
+            }
+        }
+        JSRunLoop.main.schedule(completion, target, SECNodeKey.initWithNodeKeyObject(key));
+        return completion.promise;
+    },
+
+    createKeyFromJWK: function(jwk, completion, target){
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        var key = null;
+        if (jwk.d){
+            key = crypto.createPrivateKey({key: jwk, format: "jwk"});
+        }else{
+            key = crypto.createPublicKey({key: jwk, format: "jwk"});
+        }
+        key.id = jwk.kid || null;
+        JSRunLoop.main.schedule(completion, target, SECNodeKey.initWithNodeKeyObject(key));
+        return completion.promise;
+    },
+
+});
+
 SECCipher.getRandomData = function(length){
     return JSData.initWithNodeBuffer(crypto.randomBytes(length));
 };

package/Root/Frameworks/SecurityKit/SECCipher.js

@@ -21,31 +21,34 @@
 
 JSClass("SECCipher", JSObject, {
 
-    initWithAlgorithm: function(algorithm, keyBitLength){
-        if (keyBitLength === undefined){
-            keyBitLength = 256;
+    algorithm: null,
+
+    initWithAlgorithm: function(algorithm, options){
+        if (options === undefined){
+            options = {};
+        }else if (typeof(options) === "number"){
+            options = {
+                keyBitLength: options
+            };
         }
-        if (keyBitLength % 8 !== 0){
+        if (options.keyBitLength !== undefined && (options.keyBitLength % 8 !== 0)){
             throw new Error("Invalid keyBitLength, must be a multiple of 8");
         }
         switch (algorithm){
             case SECCipher.Algorithm.aesCipherBlockChaining:
-                return SECCipherAESCipherBlockChaining.initWithKeyBitLength(keyBitLength);
+                return SECCipherAESCipherBlockChaining.initWithOptions(options);
             case SECCipher.Algorithm.aesCounter:
-                return SECCipherAESCounter.initWithKeyBitLength(keyBitLength);
+                return SECCipherAESCounter.initWithOptions(options);
             case SECCipher.Algorithm.aesGaloisCounterMode:
-                return SECCipherAESGaloisCounterMode.initWithKeyBitLength(keyBitLength);
+                return SECCipherAESGaloisCounterMode.initWithOptions(options);
             case SECCipher.Algorithm.rivestCipher4:
-                return SECCipherRC4.initWithKeyBitLength(keyBitLength);
+                return SECCipherRC4.init();
+            case SECCipher.Algorithm.rsaOAEP:
+                return SECCipherRSAOAEP.initWithOptions(options);
         }
         return null;
     },
 
-    initWithKeyBitLength: function(keyBitLength){
-        this.keyBitLength = keyBitLength;
-        this.keyByteLength = keyBitLength >> 3;
-    },
-
     encrypt: function(data, key, completion, target){
         // Implemented in subclasses
         if (!completion){
@@ -122,6 +125,53 @@ JSClass("SECCipher", JSObject, {
         return completion.promise;
     },
 
+    createKeyFromJWK: function(jwk, completion, target){
+        // Implemented in subclasses
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        JSRunLoop.main.schedule(completion, target, null);
+        return completion.promise;
+    },
+
+    createKeyFromKeystore: function(keystore, kid, completion, target){
+        // Implemented in subclasses
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        JSRunLoop.main.schedule(completion, target, null);
+        return completion.promise;
+    },
+
+    createKeyWithPassphrase: function(passphrase, salt, iterations, hash, completion, target){
+        // Implemented in subclasses
+        if (!completion){
+            completion = Promise.completion(Promise.resolveNonNull);
+        }
+        JSRunLoop.main.schedule(completion, target, null);
+        return completion.promise;
+    },
+
+});
+
+SECCipher.Algorithm = {
+    aesCipherBlockChaining: 'aes_cbc',
+    aesCounter: 'aes_ctr',
+    aesGaloisCounterMode: 'aes_gcm',
+    rivestCipher4: 'rc4',
+    rsaOAEP: "rsa_oaep"
+};
+
+JSClass("SECCipherAES", SECCipher, {
+
+    keyBitLength: null,
+    keyByteLength: null,
+
+    initWithOptions: function(options){
+        this.keyBitLength = options.keyBitLength || 256;
+        this.keyByteLength = this.keyBitLength >> 3;
+    },
+
     createKeyFromJWK: function(jwk, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
@@ -184,11 +234,29 @@ JSClass("SECCipher", JSObject, {
 
 });
 
-JSClass("SECCipherAESCipherBlockChaining", SECCipher, {
+JSClass("SECCipherAESCipherBlockChaining", SECCipherAES, {
+
+    algorithm: SECCipher.Algorithm.aesCipherBlockChaining,
+    ivByteLength: 16,
+    iv: null,
+
+    initWithOptions: function(options){
+        SECCipherAESCipherBlockChaining.$super.initWithOptions.call(this, options);
+        if (options.iv){
+            this.iv = options.iv;
+            this.ivByteLength = this.iv.length;
+        }
+    },
+
+    randomIV: function(){
+        return SECCipher.getRandomData(this.ivByteLength);
+    },
+
 });
 
-JSClass("SECCipherAESCounter", SECCipher, {
+JSClass("SECCipherAESCounter", SECCipherAES, {
 
+    algorithm: SECCipher.Algorithm.aesCounter,
     encryptedMessageId: 0,
 
     ensureUniqueMessageID: function(){
@@ -201,49 +269,57 @@ JSClass("SECCipherAESCounter", SECCipher, {
 
 });
 
-JSClass("SECCipherAESGaloisCounterMode", SECCipher, {
+JSClass("SECCipherAESGaloisCounterMode", SECCipherAES, {
 
-    encryptedMessageId: 0,
+    algorithm: SECCipher.Algorithm.aesGaloisCounterMode,
+    iv: null,
+    ivByteLength: 16,
+    tagByteLength: 16,
+    additionalData: null,
 
-    ensureUniqueMessageID: function(){
-        if (this.encryptedMessageId == 9007199254740991){
-            return false;
+    initWithOptions: function(options){
+        SECCipherAESGaloisCounterMode.$super.initWithOptions.call(this, options);
+        if (options.tagByteLength){
+            this.tagByteLength = options.tagByteLength;
         }
-        ++this.encryptedMessageId;
-        return true;
+        if (options.additionalData){
+            this.additionalData = options.additionalData;
+        }
+        if (options.iv){
+            this.iv = options.iv;
+            this.ivByteLength = this.iv.length;
+        }else if (options.ivByteLength){
+            this.ivByteLength = options.ivByteLength;
+        }
+    },
+
+    randomIV: function(){
+        return SECCipher.getRandomData(this.ivByteLength);
     },
 
     encrypt: function(data, key, completion, target){
-        if (!completion){
-            completion = Promise.completion(Promise.resolveNonNull);
-        }
-        if (!this.ensureUniqueMessageID()){
-            JSRunLoop.main.schedule(completion, target, null);
-            return completion.promise;
-        }
-        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
-        ]);
-        this.encryptWithNonce(nonce, data, key, completion, target, 16);
-        return completion.promise;
     },
 
     decrypt: function(data, key, completion, target){
-        return this.decryptWithNonceLength(8, data, key, completion, target, 16);
     },
 
-    encryptWithNonce: function(nonce, data, key, completion, target){
-    },
+});
 
-    decryptWithNonceLength: function(nonceLength, data, key, completion, target){
-    },
+JSClass("SECCipherRSAOAEP", SECCipher, {
+
+    hash: null,
+    label: null,
+    modulusLength: null,
+    publicExponent: null,
+
+    initWithOptions: function(options){
+        if (options.label){
+            this.label = options.label;
+        }
+        this.hash = options.hash || SECHash.Algorithm.sha1;
+        this.modulusLength = options.modulusLength || 2048;
+        this.publicExponent = options.publicExponent || 0x10001;
+    }
 
 });
 
@@ -252,6 +328,8 @@ JSClass("SECCipherAESGaloisCounterMode", SECCipher, {
 // to read the PDFs that already use it.
 JSClass("SECCipherRC4", SECCipher, {
 
+    algorithm: SECCipher.Algorithm.rivestCipher4,
+
     encrypt: function(data, key, completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
@@ -265,7 +343,7 @@ JSClass("SECCipherRC4", SECCipher, {
         var j = 0;
         var tmp;
         for (i = 0; i < 256; ++i){
-            j = (j + S[i] + key.keyData[i % key.keyData.length]) & 0xFF;
+            j = (j + S[i] + key.data[i % key.data.length]) & 0xFF;
             tmp = S[i];
             S[i] = S[j];
             S[j] = tmp;
@@ -302,13 +380,6 @@ JSClass("SECCipherRC4", SECCipher, {
 
 });
 
-SECCipher.Algorithm = {
-    aesCipherBlockChaining: 'aes_cbc',
-    aesCounter: 'aes_ctr',
-    aesGaloisCounterMode: 'aes_gcm',
-    rivestCipher4: 'rc4'
-};
-
 SECCipher.getRandomData = function(length){
     // Implemented in environment extensions
 };

package/Root/Frameworks/SecurityKit/SECDataKey.js

@@ -18,22 +18,23 @@
 
 JSClass("SECDataKey", SECKey, {
 
-    keyData: null,
+    data: null,
+    type: SECKey.KeyType.secret,
 
     initWithData: function(data){
-        this.keyData = JSData.initWithCopyOfData(data);
+        this.data = JSData.initWithCopyOfData(data);
     },
 
     getData: function(completion, target){
         if (!completion){
             completion = Promise.completion(Promise.resolveNonNull);
         }
-        JSRunLoop.main.schedule(completion, target, this.keyData);
+        JSRunLoop.main.schedule(completion, target, this.data);
         return completion.promise;
     },
 
     destroy: function(){
-        this.keyData.zero();
+        this.data.zero();
     }
 
 });