JavaScript
Web Cryptography API

Anmärkningar

Kryptografiskt slumpmässiga data

// 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) kan användas med instanser av följande klasser (beskrivs vidare i binära data ) och kommer att generera värden från de givna områdena (båda ändarna inklusive):

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

Skapa digests (t.ex. 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);
});

Det nuvarande utkastet föreslår att åtminstone tillhandahålla SHA-1 , SHA-256 , SHA-384 och SHA-512 , men detta är inget strikt krav och kan ändras. SHA-familjen kan dock fortfarande betraktas som ett bra val eftersom det troligtvis kommer att stöds i alla större webbläsare.

Genererar RSA-nyckelpar och konverterar till PEM-format

I det här exemplet kommer du att lära dig att generera RSA-OAEP-nyckelpar och hur du konverterar privat nyckel från detta nyckelpar till base64 så att du kan använda den med OpenSSL etc. Observera att den här processen också kan användas för den offentliga nyckeln du bara har för att använda prefix och suffix nedan:

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

OBS: Detta exempel är fullständigt testat i dessa webbläsare: 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);
    });
});

Det är allt! Nu har du en fullt fungerande och kompatibel RSA-OAEP privat nyckel i PEM-format som du kan använda var du än vill. Njut av!

Konvertera PEM-nyckelpar till CryptoKey

Så har du någonsin undrat hur du använder ditt PEM RSA-nyckelpar som genererades av OpenSSL i Web Cryptography API? Om svaret är ja. Bra! Du kommer att ta reda på det.

OBS: Den här processen kan också användas för offentlig nyckel, du behöver bara ändra prefix och suffix till:

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

Detta exempel antar att du har ditt RSA-nyckelpar genererat i 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);
});

Och nu är du klar! Du kan använda din importerade nyckel i WebCrypto API.