RubyGems - virgil-crypto - Versions diffs - 2.3.0 → 3.6.2 - Mend

virgil-crypto 2.3.0 → 3.6.2

Files changed (259) hide show

data/ext/native/src/utils/zip.vbs CHANGED

File without changes

data/ext/native/src/virgil-crypto.sublime-project ADDED

@@ -0,0 +1,15 @@
+{
+    "folders":
+    [
+        {
+            "path": ".",
+            "folder_exclude_patterns": ["*build*", ".idea", ".depends_cache"]
+        }
+    ],
+    "settings": {
+        "ClangFormat": {
+            "format_on_save": false
+        },
+        "rulers": [120]
+    }
+}

data/ext/native/src/wrappers/asmjs/CMakeLists.txt CHANGED

@@ -57,11 +57,3 @@ include ("${WRAPPERS_ROOT}/emsdk/CMakeLists.txt")
 # ---------------------------------------------------------------------------
 #   Add specific 'install' options to the target
 # ---------------------------------------------------------------------------
-string (TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE_UPPER)
-if ("${CMAKE_CXX_FLAGS} ${CMAKE_CXX_FLAGS_${CMAKE_BUILD_TYPE_UPPER}}" MATCHES "(-O2|-O3|-Os|-Oz)")
-    install (FILES $<TARGET_FILE:${WRAPPER_TARGET}>.mem DESTINATION "${INSTALL_LIB_DIR_NAME}")
-    install (FILES $<TARGET_FILE:${WRAPPER_TARGET}>.mem DESTINATION "${WRAPPER_DOC_DIR_NAME}/example")
-endif ()

data/ext/native/src/wrappers/emsdk/CMakeLists.txt CHANGED

@@ -53,7 +53,7 @@ set (WRAPPER_DOC_DIR_NAME "${INSTALL_DOC_DIR_NAME}/${WRAPPER_TARGET}/${VIRGIL_VE
 set (ORIGINAL_EMBIND_FILE "${EMSCRIPTEN}/system/include/emscripten/bind.h")
 set (VIRGIL_EMBIND_FILE "${CMAKE_CURRENT_BINARY_DIR}/virgil_bind.h")
-message (STATUS "To be able support of custom exception handling\n"
+message (STATUS "To be able support custom exception handling\n"
     "       patched header '${VIRGIL_EMBIND_FILE}' is used,\n"
     "       instead of '${ORIGINAL_EMBIND_FILE}' header."
 )
@@ -90,7 +90,7 @@ target_link_libraries (${WRAPPER_TARGET} ${WRAPPED_LIB_NAME})
 target_compile_options (${WRAPPER_TARGET} PUBLIC -s DISABLE_EXCEPTION_CATCHING=0)
 set_property (TARGET ${WRAPPER_TARGET} APPEND_STRING PROPERTY
-        LINK_FLAGS " --bind -s DISABLE_EXCEPTION_CATCHING=0")
+        LINK_FLAGS " --bind -s SINGLE_FILE=1 -s DISABLE_EXCEPTION_CATCHING=0 -s MODULARIZE=1 -s 'EXPORT_NAME=\"__virgilCrypto\"'")
 em_link_js_library (${WRAPPER_TARGET} ${CMAKE_CURRENT_LIST_DIR}/error.js)
 em_link_post_js (${WRAPPER_TARGET} ${CMAKE_CURRENT_LIST_DIR}/helpers.js)

data/ext/native/src/wrappers/emsdk/error.js CHANGED

File without changes

data/ext/native/src/wrappers/emsdk/example.html CHANGED

@@ -1,13 +1,20 @@
 <!doctype html>
 <html>
+    <head>
+        <title>VirgilCrypto browser test</title>
+        <script src="https://unpkg.com/lodash@4.17.5/lodash.js"></script>
+        <script src="https://unpkg.com/benchmark@2.1.4/benchmark.js"></script>
+        <script src="@WRAPPER_TARGET@.js"></script>
+    </head>
+    <body>
     <script type="text/javascript">
-        function test_encryption() {
+        function test_encryption(lib) {
             console.time("encryption/decryption");
-            var pwd = Module.VirgilByteArray.fromUTF8("password");
-            var keys = Module.VirgilKeyPair.generateRecommended(pwd);
-            var certId = Module.VirgilByteArray.fromUTF8("17648c7e-9ca3-4707-bdc6-a5c57b7a18fc");
-            var data = Module.VirgilByteArray.fromUTF8("data to be encrypted");
-            var cipher = new Module.VirgilCipher();
+            var pwd = lib.VirgilByteArray.fromUTF8("password");
+            var keys = lib.VirgilKeyPair.generateRecommended(pwd);
+            var certId = lib.VirgilByteArray.fromUTF8("17648c7e-9ca3-4707-bdc6-a5c57b7a18fc");
+            var data = lib.VirgilByteArray.fromUTF8("data to be encrypted");
+            var cipher = new lib.VirgilCipher();
             cipher.addKeyRecipient(certId, keys.publicKey());
             var encryptedData = cipher.encrypt(data, true);
             var decryptedData = cipher.decryptWithKey(encryptedData, certId, keys.privateKey(), pwd);
@@ -21,25 +28,25 @@
             decryptedData.delete();
             console.timeEnd("encryption/decryption");
         };
-        function test_stream_encryption() {
+        function test_stream_encryption(lib) {
             console.time("stream encryption/decryption");
-            var pwd = Module.VirgilByteArray.fromUTF8("password");
-            var keys = Module.VirgilKeyPair.generateRecommended(pwd);
-            var certId = Module.VirgilByteArray.fromUTF8("17648c7e-9ca3-4707-bdc6-a5c57b7a18fc");
-            var data = Module.VirgilByteArray.fromUTF8("data to be encrypted");
-            var cipher = new Module.VirgilStreamCipher();
+            var pwd = lib.VirgilByteArray.fromUTF8("password");
+            var keys = lib.VirgilKeyPair.generateRecommended(pwd);
+            var certId = lib.VirgilByteArray.fromUTF8("17648c7e-9ca3-4707-bdc6-a5c57b7a18fc");
+            var data = lib.VirgilByteArray.fromUTF8("data to be encrypted");
+            var cipher = new lib.VirgilStreamCipher();
             cipher.addKeyRecipient(certId, keys.publicKey());
-            var dataSource = new Module.VirgilStreamDataSource(data.toUint8Array(), 1);
-            var dataSink = new Module.VirgilStreamDataSink();
+            var dataSource = new lib.VirgilStreamDataSource(data.toUint8Array(), 1);
+            var dataSink = new lib.VirgilStreamDataSink();
             cipher.encrypt(dataSource, dataSink, true);
-            var encrypedDataSource = new Module.VirgilStreamDataSource(dataSink.getBytes(), 2);
-            var decryptedDataSink = new Module.VirgilStreamDataSink();
+            var encrypedDataSource = new lib.VirgilStreamDataSource(dataSink.getBytes(), 2);
+            var decryptedDataSink = new lib.VirgilStreamDataSink();
             cipher.decryptWithKey(encrypedDataSource, decryptedDataSink, certId, keys.privateKey(), pwd);
-            var decryptedData = Module.VirgilByteArray.fromUint8Array(decryptedDataSink.getBytes());
+            var decryptedData = lib.VirgilByteArray.fromUint8Array(decryptedDataSink.getBytes());
             console.log(decryptedData.toUTF8());
             pwd.delete();
@@ -54,30 +61,144 @@
             decryptedDataSink.delete();
             console.timeEnd("stream encryption/decryption");
         };
-        function test_sign() {
+        function test_sign(lib) {
             console.time("sign/verify");
-            var pwd = Module.VirgilByteArray.fromUTF8("");
-            var keys = Module.VirgilKeyPair.generateRecommended(pwd);
-            var certId = Module.VirgilByteArray.fromUTF8("17648c7e-9ca3-4707-bdc6-a5c57b7a18fc");
-            var data = Module.VirgilByteArray.fromUTF8("data to be signed");
-            var signer = new Module.VirgilSigner();
+            var pwd = lib.VirgilByteArray.fromUTF8("");
+            var keys = lib.VirgilKeyPair.generateRecommended(pwd);
+            var data = lib.VirgilByteArray.fromUTF8("data to be signed");
+            var signer = new lib.VirgilSigner();
             var sign = signer.sign(data, keys.privateKey(), pwd);
             var verified = signer.verify(data, sign, keys.publicKey());
             console.log("Data verification " + (verified ? "passed" : "failed"));
             pwd.delete();
             keys.delete();
-            certId.delete();
             data.delete();
             signer.delete();
             sign.delete();
             console.timeEnd("sign/verify");
         };
-        var Module = {
-            onRuntimeInitialized: function() {
-                console.log(Module.VirgilVersion.asString())
-            }
-        };
+        function encrypt(lib, data, publicKey, certId) {
+            var cipher = new lib.VirgilCipher();
+            cipher.addKeyRecipient(certId, publicKey);
+            var ciphertext = cipher.encrypt(data, true);
+            cipher.delete();
+            return ciphertext;
+        }
+        function decrypt(lib, ciphertext, privateKey, certId) {
+            var cipher = new lib.VirgilCipher();
+            var decrypted = cipher.decryptWithKey(ciphertext, certId, privateKey, lib.VirgilByteArray.fromUTF8(''));
+            cipher.delete();
+            return decrypted;
+        }
+        function calcSignature(lib, data, privateKey) {
+            var signer = new lib.VirgilSigner();
+            var signature = signer.sign(data, privateKey, lib.VirgilByteArray.fromUTF8(""));
+            signer.delete();
+            return signature;
+        }
+        function verifySignature(lib, data, signature, publicKey) {
+            var signer = new lib.VirgilSigner();
+            var verified = signer.verify(data, signature, publicKey);
+            signer.delete();
+            return verified;
+        }
+        function runTests(instance) {
+            console.log('Starting tests');
+            test_encryption(instance);
+            test_stream_encryption(instance);
+            test_sign(instance);
+        }
+        function runBenchmarks(instance) {
+            console.log('Starting benchmarks');
+            var suite = new Benchmark.Suite();
+            // key pair for encryption / decryption
+            var eKeypair = instance.VirgilKeyPair.generateRecommended(
+                instance.VirgilByteArray.fromUTF8('')
+            );
+            // key pair for generating / verifying signature
+            var sKeypair = instance.VirgilKeyPair.generateRecommended(
+                instance.VirgilByteArray.fromUTF8('')
+            );
+            // 32 random bytes to be used as RECIPIENT_ID
+            var eCertId = instance.VirgilByteArray.fromUint8Array(
+                window.crypto.getRandomValues(new Uint8Array(32))
+            );
+            // 1kB of data to encrypt / decrypt
+            var eData = instance.VirgilByteArray.fromUint8Array(
+                window.crypto.getRandomValues(new Uint8Array(1024))
+            );
+            var eCiphertext = encrypt(instance, eData, eKeypair.publicKey(), eCertId);
+            // 1kB of data to sign / verify
+            var sData = instance.VirgilByteArray.fromUint8Array(
+                window.crypto.getRandomValues(new Uint8Array(1024))
+            );
+            var sSignature = calcSignature(instance, sData, sKeypair.privateKey());
+            suite.add('KeyPair#generateRecommended without password', function () {
+                var keypair = instance.VirgilKeyPair.generateRecommended(
+                    instance.VirgilByteArray.fromUTF8('')
+                );
+                keypair.delete();
+            })
+            .add('KeyPair#generateRecommended with password', function () {
+                var keypair = instance.VirgilKeyPair.generateRecommended(
+                    instance.VirgilByteArray.fromUTF8('passphrase')
+                );
+                keypair.delete();
+            })
+            .add('KeyPair#generate NIST-256 without password', function() {
+                var keypair = instance.VirgilKeyPair.generate(
+                    instance.VirgilKeyPair.Type.EC_SECP256R1,
+                    instance.VirgilByteArray.fromUTF8('')
+                );
+                keypair.delete();
+            })
+            .add('KeyPair#generate NIST-256 with password', function() {
+                var keypair = instance.VirgilKeyPair.generate(
+                    instance.VirgilKeyPair.Type.EC_SECP256R1,
+                    instance.VirgilByteArray.fromUTF8('passphrase')
+                );
+                keypair.delete();
+            })
+            .add('Cipher#encrypt', function () {
+                encrypt(instance, eData, eKeypair.publicKey(), eCertId).delete();
+            })
+            .add('Cipher#decryptWithKey', function () {
+                decrypt(instance, eCiphertext, eKeypair.privateKey(), eCertId).delete();
+            })
+            .add('Signer#sign', function () {
+                calcSignature(instance, sData, sKeypair.privateKey()).delete();
+            })
+            .add('Signer#verify', function () {
+                verifySignature(instance, sData, sSignature, sKeypair.publicKey());
+            })
+            .on('cycle', function (event) {
+              console.log(String(event.target));
+            })
+            .on('complete', function () {
+              console.log('Done');
+            })
+            .run();
+        }
+        __virgilCrypto().then(function (instance) {
+            console.log(instance.VirgilVersion.asString());
+            runTests(instance);
+            console.log('');
+            runBenchmarks(instance);
+        });
     </script>
-    <script async type="text/javascript" src="@WRAPPER_TARGET@.js"></script>
-</body>
+    </body>
 </html>

data/ext/native/src/wrappers/emsdk/helpers.js CHANGED

@@ -34,139 +34,144 @@
  * Lead Maintainer: Virgil Security Inc. <support@virgilsecurity.com>
  */
-function virgil_init () {
-    Module['VirgilByteArray']['fromUTF8'] = function(string) {
-        var ba = new Module.VirgilByteArray();
-        ba.fromUTF8(string);
-        return ba;
-    };
-    Module['VirgilByteArray']['prototype']['fromUTF8'] = function(string) {
-        var s = unescape(encodeURIComponent(string));
-        var charList = s.split('');
-        var uintArray = [];
-        for (var i = 0; i < charList.length; ++i) {
-            uintArray.push(charList[i].charCodeAt(0));
-        }
-        this.assign(new Uint8Array(uintArray));
-    };
-    Module['VirgilByteArray']['prototype']['toUTF8'] = function() {
-        var encodedString = String.fromCharCode.apply(null, this.data());
-        return decodeURIComponent(escape(encodedString));
-    };
-    Module['VirgilByteArray']['fromUint8Array'] = function(uint8Array) {
-        var byteArray = new Module.VirgilByteArray;
-        byteArray.assign(uint8Array);
-        return byteArray;
-    };
-    Module['VirgilByteArray']['prototype']['fromUint8Array'] = function(uint8Array) {
-        this.assign(uint8Array);
-    };
-    Module['VirgilByteArray']['prototype']['toUint8Array'] = function() {
-        var size = this.size();
-        var array = new Uint8Array(size);
-        for (var i = 0; i < size; ++i) {
-            array[i] = this.get(i);
-        }
-        return array;
-    };
-    Module['VirgilStreamDataSource'] = Module.VirgilDataSource.extend("VirgilDataSource", {
-        __construct: function(uint8Array, chunkSize) {
-            this.__parent.__construct.call(this);
-            this.position = 0;
-            this.chunkSize = chunkSize || 1024 * 1024; // 1MB by default
-            this.bytes = uint8Array;
-        },
-        hasData: function() {
-            return this.position < this.bytes.length;
-        },
-        read: function() {
-            var start = this.position;
-            var end = start + this.chunkSize;
-            var chunk = this._slice(start, end);
-            var bytesRead = chunk.length;
-            var byteArray = Module.VirgilByteArray.fromUint8Array(chunk);
-            this.seek(this.position + bytesRead);
-            return byteArray;
-        },
-        seek: function(offset) {
-            if (offset < 0) {
-                offset = this.bytes.length + offset;
-            }
-            this.position = offset;
-        },
-        _slice: function(start, end) {
-            if (typeof this.bytes.slice === 'function') {
-                return this.bytes.slice(start, end);
-            }
-            var source = this.bytes;
-            var len = source.length;
-            var relativeStart = start;
-            var k = (relativeStart < 0) ? Math.max(len + relativeStart, 0) : Math.min(relativeStart, len);
-            var relativeEnd = (end === undefined) ? len : end;
-            var final = (relativeEnd < 0) ? Math.max(len + relativeEnd, 0) : Math.min(relativeEnd, len);
-            var count = final - k;
-            var dest = new Uint8Array(count);
-            var n = 0;
-            while (k < final) {
-                dest[n] = source[k];
-                ++k;
-                ++n;
-            }
-            return dest;
+(function() {
+    function virgil_init () {
+      Module['VirgilByteArray']['fromUTF8'] = function(string) {
+          var ba = new Module['VirgilByteArray']();
+          ba.fromUTF8(string);
+          return ba;
+      };
+      Module['VirgilByteArray']['prototype']['fromUTF8'] = function(string) {
+          var s = unescape(encodeURIComponent(string));
+          var charList = s.split('');
+          var uintArray = [];
+          for (var i = 0; i < charList.length; ++i) {
+              uintArray.push(charList[i].charCodeAt(0));
+          }
+          this.assign(new Uint8Array(uintArray));
+      };
+      Module['VirgilByteArray']['prototype']['toUTF8'] = function() {
+          var encodedString = String.fromCharCode.apply(null, this.data());
+          return decodeURIComponent(escape(encodedString));
+      };
+      Module['VirgilByteArray']['fromUint8Array'] = function(uint8Array) {
+          var byteArray = new Module['VirgilByteArray'];
+          byteArray.assign(uint8Array);
+          return byteArray;
+      };
+      Module['VirgilByteArray']['prototype']['fromUint8Array'] = function(uint8Array) {
+          this.assign(uint8Array);
+      };
+      Module['VirgilByteArray']['prototype']['toUint8Array'] = function() {
+          var size = this.size();
+          var array = new Uint8Array(size);
+          for (var i = 0; i < size; ++i) {
+              array[i] = this.get(i);
+          }
+          return array;
+      };
+      Module['VirgilStreamDataSource'] = Module['VirgilDataSource'].extend("VirgilDataSource", {
+          __construct: function(uint8Array, chunkSize) {
+              this.__parent.__construct.call(this);
+              this.position = 0;
+              this.chunkSize = chunkSize || 1024 * 1024; // 1MB by default
+              this.bytes = uint8Array;
+          },
+          hasData: function() {
+              return this.position < this.bytes.length;
+          },
+          read: function() {
+              var start = this.position;
+              var end = start + this.chunkSize;
+              var chunk = this._slice(start, end);
+              var bytesRead = chunk.length;
+              var byteArray = Module['VirgilByteArray'].fromUint8Array(chunk);
+              this.seek(this.position + bytesRead);
+              return byteArray;
+          },
+          seek: function(offset) {
+              if (offset < 0) {
+                  offset = this.bytes.length + offset;
+              }
+              this.position = offset;
+          },
+          _slice: function(start, end) {
+              if (typeof this.bytes.slice === 'function') {
+                  return this.bytes.slice(start, end);
+              }
+              var source = this.bytes;
+              var len = source.length;
+              var relativeStart = start;
+              var k = (relativeStart < 0) ? Math.max(len + relativeStart, 0) : Math.min(relativeStart, len);
+              var relativeEnd = (end === undefined) ? len : end;
+              var final = (relativeEnd < 0) ? Math.max(len + relativeEnd, 0) : Math.min(relativeEnd, len);
+              var count = final - k;
+              var dest = new Uint8Array(count);
+              var n = 0;
+              while (k < final) {
+                  dest[n] = source[k];
+                  ++k;
+                  ++n;
+              }
+              return dest;
+          }
+      });
+      Module['VirgilStreamDataSink'] = Module['VirgilDataSink'].extend("VirgilDataSink", {
+          __construct: function() {
+              this.__parent.__construct.call(this);
+              this.bytes = new Uint8Array(0);
+          },
+          isGood: function() {
+              return true;
+          },
+          write: function(bytes) {
+              var chunk = bytes.toUint8Array();
+              this._append(chunk);
+          },
+          getBytes: function () {
+              return this.bytes;
+          },
+          _append: function (uint8Array) {
+              var result;
+              var totalLength = this.bytes.length + uint8Array.length;
+              result = new Uint8Array(totalLength);
+              result.set(this.bytes, 0);
+              result.set(uint8Array, this.bytes.length);
+              this.bytes = result;
+          }
+      });
+      Module['VirgilKeyPair']['Type'] = Module['VirgilKeyPairType']
+      Module['VirgilPBKDF']['Algorithm'] = Module['VirgilPBKDFAlgorithm']
+      Module['VirgilHash']['Algorithm'] = Module['VirgilHashAlgorithm']
+      Module['VirgilTinyCipher']['PackageSize'] = Module['VirgilTinyCipherPackageSize']
+      Module['VirgilHash']['Algorithm'] = Module['VirgilHashAlgorithm']
+      Module['VirgilPBE']['Algorithm'] = Module['VirgilPBEAlgorithm']
+      Module['VirgilSymmetricCipher']['Algorithm'] = Module['VirgilSymmetricCipherAlgorithm']
+      Module['VirgilSymmetricCipher']['Padding'] = Module['VirgilSymmetricCipherPadding']
+    }
+    if (Module['VirgilVersion']) {
+      // initialized synchronously (asmjs)
+      virgil_init();
+    } else {
+      // initialized asynchronously (wasm)
+      var originalOnInit = Module['onRuntimeInitialized'];
+      Module['onRuntimeInitialized'] = function onRuntimeInitialized() {
+        virgil_init();
+        if (typeof originalOnInit === 'function') {
+          originalOnInit();
         }
-    });
-    Module['VirgilStreamDataSink'] = Module.VirgilDataSink.extend("VirgilDataSink", {
-        __construct: function() {
-            this.__parent.__construct.call(this);
-            this.bytes = new Uint8Array(0);
-        },
-        isGood: function() {
-            return true;
-        },
-        write: function(bytes) {
-            var chunk = bytes.toUint8Array();
-            this._append(chunk);
-        },
-        getBytes: function () {
-            return this.bytes;
-        },
-        _append: function (uint8Array) {
-            var result;
-            var totalLength = this.bytes.length + uint8Array.length;
-            result = new Uint8Array(totalLength);
-            result.set(this.bytes, 0);
-            result.set(uint8Array, this.bytes.length);
-            this.bytes = result;
-        }
-    });
-    Module['VirgilKeyPair']['Type'] = Module['VirgilKeyPairType']
-    Module['VirgilPBKDF']['Algorithm'] = Module['VirgilPBKDFAlgorithm']
-    Module['VirgilHash']['Algorithm'] = Module['VirgilHashAlgorithm']
-    Module['VirgilTinyCipher']['PackageSize'] = Module['VirgilTinyCipherPackageSize']
-    Module['VirgilHash']['Algorithm'] = Module['VirgilHashAlgorithm']
-    Module['VirgilPBE']['Algorithm'] = Module['VirgilPBEAlgorithm']
-    Module['VirgilSymmetricCipher']['Algorithm'] = Module['VirgilSymmetricCipherAlgorithm']
-    Module['VirgilSymmetricCipher']['Padding'] = Module['VirgilSymmetricCipherPadding']
-}
-if (Module['VirgilVersion']) {
-    // AsmJS path
-    virgil_init ();
-} else {
-    // WebAssembly path
-    Module['postRun'].push(virgil_init);
-}
+      };
+    }
+})();