JavaScript
API de chiffrement Web

Remarques

Données cryptographiquement aléatoires

// 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) peut être utilisé avec des instances des classes suivantes (décrites plus loin dans les données binaires ) et générera des valeurs à partir des plages données (les deux extrémités étant incluses):

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

Création de résumés (par exemple 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);
});

Le projet actuel suggère de fournir au moins SHA-1 , SHA-256 , SHA-384 et SHA-512 , mais ceci n’est pas une exigence stricte et peut être modifié. Cependant, la famille SHA peut toujours être considérée comme un bon choix car elle sera probablement prise en charge dans tous les principaux navigateurs.

Génération d'une paire de clés RSA et conversion au format PEM

Dans cet exemple, vous apprendrez à générer une paire de clés RSA-OAEP et à convertir une clé privée de cette paire de clés en base64 afin de pouvoir l'utiliser avec OpenSSL, etc. Veuillez noter que ce processus peut également être utilisé pour une clé publique. utiliser le préfixe et le suffixe ci-dessous:

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

REMARQUE: Cet exemple est entièrement testé dans ces navigateurs: 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);
    });
});

C'est tout! Vous disposez maintenant d'une clé privée RSA-OAEP entièrement compatible et compatible au format PEM que vous pouvez utiliser où vous voulez. Prendre plaisir!

Conversion d'une paire de clés PEM en CryptoKey

Vous êtes-vous déjà demandé comment utiliser votre paire de clés PEM RSA générée par OpenSSL dans l'API Web Cryptography? Si la réponse est oui. Génial! Vous allez découvrir

Remarque: ce processus peut également être utilisé pour la clé publique, il vous suffit de modifier le préfixe et le suffixe pour:

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

Cet exemple suppose que votre paire de clés RSA est générée dans 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);
});

Et maintenant vous avez terminé! Vous pouvez utiliser votre clé importée dans WebCrypto API.