JavaScript
API di crittografia Web

Osservazioni

Dati crittografici casuali

// Create an array with a fixed size and type.
var array = new Uint8Array(5);

// Generate cryptographically random values
crypto.getRandomValues(array);

// Print the array to the console
console.log(array);

crypto.getRandomValues(array) può essere utilizzato con istanze delle seguenti classi (descritte ulteriormente in Dati binari ) e genererà valori dagli intervalli dati (entrambi i fini inclusi):

• Int8Array : -2 ⁷ a 2 ⁷ -1
• Uint8Array : da 0 a 2 ⁸ -1
• Int16Array : -2 ¹⁵ a 2 ¹⁵ -1
• Uint16Array : da 0 a 2 ¹⁶ -1
• Int32Array : -2 ³¹ a 2 ³¹ -1
• Uint32Array : da 0 a 2 ³¹ -1

Creazione di digest (ad es. SHA-256)

// Convert string to ArrayBuffer. This step is only necessary if you wish to hash a string, not if you aready got an ArrayBuffer such as an Uint8Array.
var input = new TextEncoder('utf-8').encode('Hello world!');

// Calculate the SHA-256 digest
crypto.subtle.digest('SHA-256', input)
// Wait for completion
.then(function(digest) {
  // digest is an ArrayBuffer. There are multiple ways to proceed.

  // If you want to display the digest as a hexadecimal string, this will work:
  var view = new DataView(digest);
  var hexstr = '';
  for(var i = 0; i < view.byteLength; i++) {
    var b = view.getUint8(i);
    hexstr += '0123456789abcdef'[(b & 0xf0) >> 4];
    hexstr += '0123456789abcdef'[(b & 0x0f)];
  }
  console.log(hexstr);

  // Otherwise, you can simply create an Uint8Array from the buffer:
  var digestAsArray = new Uint8Array(digest);
  console.log(digestAsArray);
})
// Catch errors
.catch(function(err) {
  console.error(err);
});

La bozza attuale suggerisce di fornire almeno SHA-1 , SHA-256 , SHA-384 e SHA-512 , ma questo non è un requisito rigoroso e soggetto a modifiche. Tuttavia, la famiglia SHA può ancora essere considerata una buona scelta in quanto probabilmente sarà supportata in tutti i principali browser.

Generazione della coppia di chiavi RSA e conversione in formato PEM

In questo esempio imparerai come generare una coppia di chiavi RSA-OAEP e come convertire la chiave privata da questa coppia di chiavi a base64 in modo da poterla utilizzare con OpenSSL ecc. Si noti che questo processo può essere utilizzato anche per la chiave pubblica che hai appena utilizzare prefisso e suffisso di seguito:

-----BEGIN PUBLIC KEY-----
-----END PUBLIC KEY-----

NOTA: questo esempio è completamente testato in questi browser: Chrome, Firefox, Opera, Vivaldi

function arrayBufferToBase64(arrayBuffer) {
    var byteArray = new Uint8Array(arrayBuffer);
    var byteString = '';
    for(var i=0; i < byteArray.byteLength; i++) {
        byteString += String.fromCharCode(byteArray[i]);
    }
    var b64 = window.btoa(byteString);

    return b64;
}

function addNewLines(str) {
    var finalString = '';
    while(str.length > 0) {
        finalString += str.substring(0, 64) + '\n';
        str = str.substring(64);
    }

    return finalString;
}

function toPem(privateKey) {
    var b64 = addNewLines(arrayBufferToBase64(privateKey));
    var pem = "-----BEGIN PRIVATE KEY-----\n" + b64 + "-----END PRIVATE KEY-----";
    
    return pem;
}

// Let's generate the key pair first
window.crypto.subtle.generateKey(
    {
        name: "RSA-OAEP",
        modulusLength: 2048, // can be 1024, 2048 or 4096
        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
        hash: {name: "SHA-256"} // or SHA-512
    },
    true,
    ["encrypt", "decrypt"]
).then(function(keyPair) {
    /* now when the key pair is generated we are going
       to export it from the keypair object in pkcs8
    */
    window.crypto.subtle.exportKey(
        "pkcs8",
        keyPair.privateKey
    ).then(function(exportedPrivateKey) {
        // converting exported private key to PEM format
        var pem = toPem(exportedPrivateKey);
        console.log(pem);
    }).catch(function(err) {
        console.log(err);
    });
});

Questo è tutto! Ora hai una chiave privata RSA-OAEP completamente funzionante e compatibile in formato PEM che puoi usare dove vuoi. Godere!

Conversione della coppia di chiavi PEM in CryptoKey

Quindi, ti sei mai chiesto come utilizzare la coppia di chiavi PEM RSA generata da OpenSSL in Web Cryptography API? Se le risposte sono sì. Grande! Lo scoprirai.

NOTA: questo processo può essere utilizzato anche per la chiave pubblica, è sufficiente modificare prefisso e suffisso per:

-----BEGIN PUBLIC KEY-----
-----END PUBLIC KEY-----

In questo esempio si presuppone che la coppia di chiavi RSA sia generata in PEM.

function removeLines(str) {
    return str.replace("\n", "");
}

function base64ToArrayBuffer(b64) {
    var byteString = window.atob(b64);
    var byteArray = new Uint8Array(byteString.length);
    for(var i=0; i < byteString.length; i++) {
        byteArray[i] = byteString.charCodeAt(i);
    }

    return byteArray;
}

function pemToArrayBuffer(pem) {
    var b64Lines = removeLines(pem);
    var b64Prefix = b64Lines.replace('-----BEGIN PRIVATE KEY-----', '');
    var b64Final = b64Prefix.replace('-----END PRIVATE KEY-----', '');

    return base64ToArrayBuffer(b64Final);
}

window.crypto.subtle.importKey(
    "pkcs8",
    pemToArrayBuffer(yourprivatekey),
    {
        name: "RSA-OAEP",
        hash: {name: "SHA-256"} // or SHA-512
    },
    true,
    ["decrypt"]
).then(function(importedPrivateKey) {
    console.log(importedPrivateKey);
}).catch(function(err) {
    console.log(err);
});

E ora hai finito! È possibile utilizzare la chiave importata nell'API WebCrypto.