Client-Side Encryption

// Encryption and submition script
(function (window) {
    function createXhrPost(serviceUrl, resolve) {
        let xhr = new XMLHttpRequest();
        xhr.open("POST", serviceUrl, true);
        xhr.setRequestHeader("Content-Type", "application/json");
        xhr.onreadystatechange = function () {
            if (xhr.readyState === 4 && xhr.status === 200) {
                let json = JSON.parse(xhr.responseText);
                resolve(json);
            }
        };
        return xhr;
    }

    function fetchPublicKey(serviceUrl, apiKeyId) {
        return new Promise((resolve) => {
            let xhr = createXhrPost(serviceUrl, resolve);
            let data = JSON.stringify({
                apiKeyId: apiKeyId,
            });
            xhr.send(data);
        });
    }

    function encryptPlainText(plainText, publicKey) {
        let cryptoSubtle;
        let btoa = window.btoa;
        let atob = window.atob;
        // Fix Apple prefix if needed
        if (
            window.crypto &&
            !window.crypto.subtle &&
            window.crypto.webkitSubtle
        ) {
            cryptoSubtle = window.crypto.subtle;
        } else if (window.crypto && window.crypto.subtle) {
            cryptoSubtle = window.crypto.subtle;
        }

        if (!cryptoSubtle) {
            throw "No crypto api";
        }

        function getMessageEncoding(message) {
            let enc = new TextEncoder();
            return enc.encode(message);
        }

        function encryptMessage(publicKey, message) {
            let encoded = getMessageEncoding(message);
            return cryptoSubtle.encrypt(
                {
                    name: "RSA-OAEP",
                },
                publicKey,
                encoded
            );
        }

        function arrayBufferToBase64(buffer) {
            let binary = "";
            let bytes = new Uint8Array(buffer);
            let len = bytes.byteLength;
            for (let i = 0; i < len; i++) {
                binary += String.fromCharCode(bytes[i]);
            }
            return btoa(binary);
        }

        function strToArrayBuffer(str) {
            const buf = new ArrayBuffer(str.length);
            let bufView = new Uint8Array(buf);
            for (let i = 0, strLen = str.length; i < strLen; i++) {
                bufView[i] = str.charCodeAt(i);
            }
            return buf;
        }

        function importRsaKey(pem) {
            // base64 decode the string to get the binary data
            const binaryDerString = atob(pem);
            // convert from a binary string to an ArrayBuffer
            const binaryDer = strToArrayBuffer(binaryDerString);
            return cryptoSubtle.importKey(
                "spki",
                binaryDer,
                {
                    name: "RSA-OAEP",
                    hash: "SHA-1",
                },
                true,
                ["encrypt"]
            );
        }

        return importRsaKey(publicKey)
            .then((binaryPublicKey) => {
                return encryptMessage(binaryPublicKey, plainText);
            })
            .then((encryptedBytes) => {
                return arrayBufferToBase64(encryptedBytes);
            });
    }

    /**
     * serviceUrl: form post url
     * postPayload: expected content    {
     *  "ENCRYPTEDDATA": base64Message,
     *  "ENCRYPTIONKEYID": encryptionKeyId,
     *  "APIKEYID": apiKeyId
     * };
     * */
    function postEncryptedData(serviceUrl, postPayload) {
        return fetch(serviceUrl, {
            method: "POST",
            headers: {
                Accept: "application/json",
                "Content-Type": "application/json",
            },
            body: JSON.stringify(postPayload),
        })
            .then(async function (response) {
                return await response.json();
            })
            .catch((error) => {
                return { error: error };
            });
    }

    async function preparePayload(cseServiceUrl, apiKeyId, cardInfo) {
        let plainText = JSON.stringify(cardInfo);
        let rsaPublicKey = await cseLib.fetchPublicKey(cseServiceUrl, apiKeyId);
        let encryptedMsd = await cseLib.encryptPlainText(
            plainText,
            rsaPublicKey.encryptionPublicKey
        );
        return {
            ENCRYPTEDDATA: encryptedMsd,
            ENCRYPTIONKEYID: rsaPublicKey.encryptionKeyId,
            APIKEYID: apiKeyId,
        };
    }

    window.cseLib = {
        fetchPublicKey: fetchPublicKey,
        encryptPlainText: encryptPlainText,
        preparePayload: preparePayload,
        postEncryptedData: postEncryptedData,
    };
})(window);