Benchmark: web-crypto RSA-PSS

Script Preparation code:

let key256, key512;

(async () => {
key256 = (await crypto.subtle.generateKey({
        name: 'RSA-PSS',
        modulusLength: 2048,
        publicExponent: new Uint8Array([1, 0, 1]),
        hash: 'SHA-256',
    },
    false,
    ['sign', 'verify']
)).privateKey;

key512 = (await crypto.subtle.generateKey({
        name: 'RSA-PSS',
        modulusLength: 2048,
        publicExponent: new Uint8Array([1, 0, 1]),
        hash: 'SHA-512',
    },
    false,
    ['sign', 'verify']
)).privateKey;
})();

async function sign256(path) {
    const encoder = new TextEncoder();
    const data = encoder.encode(path);
    const signature = await crypto.subtle.sign({
        name: 'RSA-PSS',
      	saltLength: 32
    }, key256, data);
    const hashArray = Array.from(new Uint8Array(signature));
    const base64Hash = btoa(String.fromCharCode(...hashArray))

    return base64Hash + '/' + path;
}

async function sign512(path) {
    const encoder = new TextEncoder();
    const data = encoder.encode(path);
    const signature = await crypto.subtle.sign({
        name: 'RSA-PSS',
      	saltLength: 32
    }, key512, data);
    const hashArray = Array.from(new Uint8Array(signature));
    const base64Hash = btoa(String.fromCharCode(...hashArray))

    return base64Hash + '/' + path;
}

Tests:

sha512
sign512('500x500/top/raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png').then(result => result)
sha256
sign256('500x500/top/raw.githubusercontent.com/cshum/imagor/master/testdata/gopher.png').then(result => result)

Rendered benchmark preparation results:

Suite status: <idle, ready to run>

Previous results

Test case name	Result
sha512
sha256

Fastest: N/A

Slowest: N/A

Latest run results:

Run details: (Test run date: 6 days ago)

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

Browser/OS: Opera 117 on Windows

View result in a separate tab

Test name	Executions per second
sha512	85141.5 Ops/sec
sha256	77515.0 Ops/sec

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 days ago):

LLMs can make mistakes. Check important info.

The benchmark provided is focused on testing the performance of two different cryptographic hash functions—SHA-256 and SHA-512—when used with the RSA-PSS signature algorithm in the Web Crypto API. The tests compare how quickly each hash function can generate a signature for the same input data.

### Benchmark Overview

1. **Hash Functions Compared**:
   - **SHA-256**: A member of the SHA-2 family, it produces a 256-bit (32-byte) hash value. It is commonly used in various security applications and protocols, including TLS and SSL.
   - **SHA-512**: Also from the SHA-2 family, this produces a 512-bit (64-byte) hash value. It offers a higher level of security than SHA-256 due to its longer output, making it harder for attackers to perform collision attacks.

### Performance Testing Methodology

- **Key Generation**:
  - Keys for both SHA-256 and SHA-512 are generated using the `crypto.subtle.generateKey` function, which is part of the Web Crypto API. This API allows for secure cryptographic operations directly in the browser, utilizing native implementations for speed and security.
  
- **Signing Process**:
  - Two asynchronous functions, `sign256` and `sign512`, are defined to perform signing using the respective keys and hash functions. They accept a string (the path to an image, in this case), encode it, and then sign it with the private key corresponding to either `key256` or `key512`.

### Alternatives

1. **Other Hash Functions**:
   - Other cryptographic hash functions like SHA-1 or SHA-3 could be tested, but they may be slower or longer and are often considered less secure compared to SHA-256 and SHA-512.

2. **Different Cryptographic Libraries**:
   - **Node.js Crypto Module**: For server-side applications, Node.js provides a `crypto` module that can perform similar operations. It may have different performance characteristics compared to the Web Crypto API.
   - **OpenSSL**: Widely used in backend and server environments, it also has its own library for cryptographic functions.

3. **Non-Public Key Alternatives**:
   - There are alternatives to public key cryptography such as HMAC (Hash-based Message Authentication Code), which combines a cryptographic hash function with a secret key for ensuring data integrity and authenticity.

### Pros and Cons

- **SHA-256**:
  - **Pros**: Faster execution (based on benchmark results), widely supported, sufficient for many applications.
  - **Cons**: Less secure compared to SHA-512 against certain types of attacks (e.g., collision attacks).

- **SHA-512**:
  - **Pros**: More secure against current known attack vectors due to larger hash size, less probability of collisions.
  - **Cons**: Slower performance due to greater computational requirements, which can be a consideration in performance-critical applications.

### Considerations

- The choice between SHA-256 and SHA-512 will often depend on the specific use case. For performance-sensitive applications where security requirements are moderate, SHA-256 might be preferred. Conversely, for applications requiring maximum security, SHA-512 should be used despite the performance trade-offs.
- It’s essential to note that the speed of hashing can also be dependent on other factors such as the underlying hardware, browser implementation of the Web Crypto API, and the complexity of the data being processed.

In summary, this benchmark evaluates the execution speed of cryptographic signatures generated using SHA-256 and SHA-512 with RSA-PSS in a controlled web environment. The results can help software developers make informed decisions about which cryptographic algorithms to implement based on their performance and security requirements.

Related benchmarks:

web-crypto RSA-PSS (version: 1)

comparing sha256 vs sha512 performance based on https://www.measurethat.net/Benchmarks/Show/27514/3/web-crypto

Comparing performance of: sha512 vs sha256

Created: 6 days ago by: Registered User

Jump to the latest result

sha512

sha256

Suite status: <idle, ready to run>

Experimental features:

Fastest: N/A

Slowest: N/A

Autogenerated LLM Summary (model gpt-4o-mini, generated 6 days ago):