Ich habe mich gefragt, wie ich dieses Problem lösen kann. Ich erstelle ein RSA-OAEP-Schlüsselpaar mit der WebCrypto-API, exportiere dann einen privaten Schlüssel in pkcs8 aus dem Schlüsselpaar, das als ArrayBuffer exportiert wird, und möchte diesen ArrayBuffer in base64 codieren, damit ich ihn als PEM speichern kann.

In diesem Testbeispiel exportiere ich den Schlüssel als pkcs8 und importiere diesen pkcs8 zurück in CryptoKey. Das Problem ist, dass es manchmal funktioniert und manchmal nicht.

Dies sind die Ergebnisse des Codes: HINWEIS: Nur einer dieser Zustände tritt nicht auf einmal auf. HINWEIS 2: Dieses Beispiel enthält nicht ----- BEGIN PRIVATE KEY ----- Präfix und Suffix. Ich codiere nur den Schlüssel.

Case1: Ungefangene (in Versprechen) URIError: URI fehlerhaft (…) b64DecodeUnicode @ try.php: 20b64toab @ try.php: 70wayBack @ try.php: 66 (anonyme Funktion) @ try.php: 56

Case2: undefined: 1 Ungefangene (in Versprechen) DOMException

Fall 3: OK - funktioniert bis zum letzten Mal.

Ich weiß nicht, was die Fehler verursacht, aber ich denke, es hat etwas mit Base64-Codierung zu tun. Wie gesagt, manchmal erzeugt der private Schlüssel OK und manchmal nicht.

Vielen Dank für jede Hilfe im Voraus.

function b64EncodeUnicode(str) {
    return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, function(match, p1) {
        return String.fromCharCode('0x' + p1);
    }));
}

function b64DecodeUnicode(str) {
    return decodeURIComponent(Array.prototype.map.call(atob(str), function(c) {
        return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
    }).join(''));
}

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

     return finalString;
}

window.crypto.subtle.generateKey(
    {
        name: "RSA-OAEP",
        modulusLength: 2048,
        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
        hash: {name: "SHA-256"}
    },
    true,
    ["encrypt", "decrypt"]
).then(function(keyPair) {
    window.crypto.subtle.exportKey(
        "pkcs8",
        keyPair.privateKey
    ).then(function(exportedPrivateKey) {
        var byteArray = new Uint8Array(exportedPrivateKey);
        console.log(byteArray);
        var byteString = '';
        for(var i=0; i < byteArray.byteLength; i++) {
            byteString += String.fromCodePoint(byteArray[i]);
        }

        wayBack(addNewLines(b64EncodeUnicode(byteString)));
    });
});

function wayBack(pem) {
    var lines = pem.split('\n');
    var encodedString = '';
    for(var i=0; i < lines.length; i++) {
        encodedString += lines[i].trim();
    }
    b64toab(encodedString);
}

function b64toab(b64) {
    var byteString = b64DecodeUnicode(b64);
    console.log(byteString);
    var byteArray = new Uint8Array(byteString.length);
    for(var i=0; i < byteString.length; i++) {
        byteArray[i] = byteString.codePointAt(i);
    }
    console.log(byteArray);

    window.crypto.subtle.importKey(
        "pkcs8",
        byteArray,
        {
            name: "RSA-OAEP",
            hash: {name: "SHA-256"}
        },
        true,
        ["decrypt"]
    ).then(function(importedPrivateKey) {
        console.log(importedPrivateKey);
    });
}