Benchmark: dsha256 - MeasureThat.net

HTML Preparation code:

<script src="https://cdnjs.cloudflare.com/ajax/libs/sjcl/1.0.6/sjcl.min.js"></script>
<script 
src="https://cdnjs.cloudflare.com/ajax/libs/cryptico/0.0.1343522940/cryptico.min.js"></script>
<script
 src="https://cdnjs.cloudflare.com/ajax/libs/crypto-js/3.1.9-1/crypto-js.min.js"></script>

Script Preparation code:

var data = new Uint32Array(1024);
  window.crypto.getRandomValues(data);
  var dataBuffer = new Uint8Array(data);
  data = String.fromCharCode.apply(null, dataBuffer);
  
  
  // src: https://developer.mozilla.org/en-US/docs/Web/API/SubtleCrypto/digest
  function hex(buffer) {
    var hexCodes = [];
    var view = new DataView(buffer);
    for (var i = 0; i < view.byteLength; i += 4) {
      // Using getUint32 reduces the number of iterations needed (we process 4 bytes each time)
      var value = view.getUint32(i)
      // toString(16) will give the hex representation of the number without padding
      var stringValue = value.toString(16)
      // We use concatenation and slice for padding
      var padding = '00000000'
      var paddedValue = (padding + stringValue).slice(-padding.length)
      hexCodes.push(paddedValue);
    }
  
    // Join all the hex strings into one
    return hexCodes.join("");
  }

Tests:

Cryptico
SHA256(SHA256(data));
Crypto.js
CryptoJS.SHA256(CryptoJS.SHA256(data));
sjcl
sjcl.hash.sha256.hash(sjcl.hash.sha256.hash(data));
window.crypto
crypto.subtle.digest("SHA-256", crypto.subtle.digest("SHA-256", dataBuffer ) ).then(function (hash) {console.log(hex(hash));});

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
Cryptico
Crypto.js
sjcl
window.crypto

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):

LLMs can make mistakes. Check important info.

Let's break down the benchmark and explain what's being tested, compared, and some pros/cons of each approach.

**Benchmark Overview**

The benchmark tests the performance of four different libraries for generating SHA-256 hashes:

1. `window.crypto`
2. `sjcl` (Simple JavaScript Cryptography Library)
3. `Crypto.js`
4. `Cryptico`

Each library is used to compute two different hash values: `SHA256(data)` and then passing the result through another `SHA256` function.

**Library Descriptions**

1. **`window.crypto`**: This is a Web API that provides cryptographic functions, including hash functions. It's part of the W3C Web Cryptography API.
2. **`sjcl` (Simple JavaScript Cryptography Library)**: Sjcl is a lightweight, modular cryptography library for Node.js and browsers. It provides various cryptographic algorithms, including hash functions.
3. **`Crypto.js`**: Crypto-js is a popular JavaScript library for cryptographic functions, including hash functions. It's designed to be easy to use and provides a simple interface for common cryptographic operations.
4. **`Cryptico`**: Unfortunately, I couldn't find any information on `Cryptico`, so it's unclear what this library actually does.

**Test Cases**

The benchmark defines four test cases:

1. `window.crypto`: This test case uses the Web API to compute two SHA-256 hashes: one with a single hash function call (`SHA256(data)`) and another with two calls (`SHA256(SHA256(data))`).
2. `sjcl`: This test case uses Sjcl's `hash.sha256.hash()` function to compute two SHA-256 hashes: one with a single hash function call (`sha256(data)`) and another with two calls (`sha256(sha256(data))`).
3. `Crypto.js`: This test case uses Crypto-js's `SHA256` function to compute two SHA-256 hashes: one with a single hash function call (`SHA256(data)`) and another with two calls (`SHA256(SHA256(data))`).
4. `Cryptico`: As mentioned earlier, I couldn't find any information on this library.

**Comparison**

The benchmark compares the performance of each library for generating these two types of SHA-256 hashes. The results are presented in terms of executions per second (EPS).

**Pros and Cons**

1. **`window.crypto`**: Pros:
	* Part of the Web Cryptography API, which is designed to be secure and standardized.
	* Uses native Web APIs, which can provide better performance compared to JavaScript libraries.
Cons:
	* Limited support for older browsers or environments that don't have Web Cryptography API support.
2. **`sjcl`**: Pros:
	* Lightweight and modular, making it easy to use and integrate into projects.
	* Provides a simple interface for cryptographic operations.
Cons:
	* Not as widely adopted or supported as other libraries (e.g., Crypto-js).
3. **`Crypto.js`**: Pros:
	* Easy to use and provide a simple interface for cryptographic operations.
	* Well-maintained and widely used library.
Cons:
	* May not be as performant as native Web APIs like `window.crypto`.
4. **`Cryptico`**: Unfortunately, I couldn't find any information on this library, so it's unclear what its pros and cons are.

**Other Alternatives**

If you're looking for alternative libraries or approaches, here are a few options:

* For cryptographic functions in general:
	+ `zlib.js`: A lightweight JavaScript library that provides compression and other utilities.
	+ `crypto-js`: Another popular JavaScript library for cryptographic functions (similar to Crypto-js).
* For Web Cryptography API support:
	+ The [Web Cryptography API](https://developer.mozilla.org/en-US/docs/Web/API/Web_Cryptography_API) is a W3C standard for cryptography in web browsers and environments.
	+ Some popular libraries that provide Web Cryptography API support include `crypto-junction` and `web- crypto-api`.

Please let me know if you'd like me to clarify any of these points or provide more information on specific libraries or topics.

Latest run results:

Run details: (Test run date: 2 years ago)

User agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/96.0.4664.93 Safari/537.36

Browser/OS: Chrome 96 on Windows

View result in a separate tab

Test name	Executions per second
Cryptico	5058.0 Ops/sec
Crypto.js	9827.4 Ops/sec
sjcl	10167.9 Ops/sec
window.crypto	41599.4 Ops/sec

Related benchmarks:

dsha256 (version: 0)

Comparing performance of: Cryptico vs Crypto.js vs sjcl vs window.crypto

Created: 2 years ago by: Guest

Jump to the latest result

Cryptico

Crypto.js

sjcl

window.crypto

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model llama3.2:3b, generated one month ago):