Card Acquiring and Transfers

package com.mbanq;

import javax.crypto.Cipher;
import javax.crypto.spec.OAEPParameterSpec;
import javax.crypto.spec.PSource;
import java.nio.charset.StandardCharsets;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.MGF1ParameterSpec;
import java.security.spec.X509EncodedKeySpec;
import java.util.Base64;

public class Encryption {
	private static final String msf_sRSA_ALGORITHM = "RSA";
	private static final String msf_sRSA_TRANSFORMATION = "RSA/ECB/OAEPPadding";
	private static final Base64.Encoder msf_encoderBase64 = Base64.getUrlEncoder().withoutPadding();
	private static final Base64.Decoder msf_decoderBase64 = Base64.getUrlDecoder();
	public static void main(String[] args) throws Exception {
		final var result = encryptUsingPublicKey("Public Key",
		                                         "Card Number|Expired|CVV");
		System.out.println("Encrypted : " + result);
	}

	public static String encryptUsingPublicKey(String p_sEncodedPublicKey, String p_sData) throws Exception {
		if (p_sEncodedPublicKey != null && p_sEncodedPublicKey.length() != 0) {
			if (p_sData != null && p_sData.length() != 0) {
				byte[] abPublicKey;
				try {
					abPublicKey = msf_decoderBase64.decode(p_sEncodedPublicKey);
				} catch (Throwable var10) {
					throw new Exception("Data", var10);
				}

				try {
					KeyFactory factoryKey = KeyFactory.getInstance("RSA");
					X509EncodedKeySpec specX509EncodedKey = new X509EncodedKeySpec(abPublicKey);
					PublicKey keyPublic = factoryKey.generatePublic(specX509EncodedKey);
					Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPPadding");
					OAEPParameterSpec paramSpec = new OAEPParameterSpec("SHA-256", "MGF1", MGF1ParameterSpec.SHA256, PSource.PSpecified.DEFAULT);
					cipher.init(1, keyPublic, paramSpec);
					byte[] abData = cipher.doFinal(p_sData.getBytes(StandardCharsets.UTF_8));
					return msf_encoderBase64.encodeToString(abData);
				} catch (Throwable var9) {
					throw new Exception("Encrypt Using Public Key", var9);
				}
			} else {
				throw new Exception("Data");
			}
		} else {
			throw new Exception("Public Key");
		}
	}
}

/**
 * @param {string} str
 */
function unescapeBase64(str) {
  // convert Base64 URL-Safe to Base64 regular
  return (str + '==='.slice((str.length + 3) % 4)).replace(/-/g, '+').replace(/_/g, '/');
}

/**
 * @param {string} str
 */
function escapeBase64(str) {
  // convert Base64 regular to Base64 URL-Safe
  return str.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
}

/**
 * @param {string} keyID
 */
function importRSAKey(keyID) {
  // fetch the part of the PEM string between header and footer
  const pemContents = unescapeBase64(keyID)
  // base64 decode the string to get the binary data
  const binaryDerString = window.atob(pemContents);
  // convert from a binary string to an ArrayBuffer
  const binaryDer = stringToArrayBuffer(binaryDerString);

  return window.crypto.subtle.importKey("spki", binaryDer, { name: "RSA-OAEP", hash: "SHA-256" }, true, ["encrypt"]);
}

/**
 * @param {string} str
 */
function stringToArrayBuffer(str) {
  // String to array buffer
  const buf = new ArrayBuffer(str.length);
  const bufView = new Uint8Array(buf);

  for (let i = 0, strLen = str.length; i < strLen; i++) {
    bufView[i] = str.charCodeAt(i);
  }

  return buf;
}

/**
 * @param {string} value
 */
function getStringEncoding(value) {
  let enc = new TextEncoder();
  return enc.encode(value);
}

/**
 * @param {ArrayBuffer} buffer
 */
function arrayBufferToBase64(buffer) {
  let binary = '';
  const bytes = new Uint8Array(buffer);
  const len = bytes.byteLength;
  for (let i = 0; i < len; i++) {
    binary += String.fromCharCode(bytes[i]);
  }
  return window.btoa(binary);
}

(function () {
  // keyID is ASN.1 Format Base64 URL-Safe
  const keyID = 'WcCBIjAnBGkhki...';

  // cardInfo format `${cardAccountNumber}|${cardExpirationDate format('YYYYMM')}|${cardSecurityCode}`
  const cardInfo = '9010100999999995|209912|123';

  importRSAKey(keyID).then(RSAKey => {
    let encoded = getStringEncoding(cardInfo);

    window.crypto.subtle.encrypt({ name: "RSA-OAEP" }, RSAKey, encoded)
      .then(data => {
        // encrypted data
        const dataEncrypted = arrayBufferToBase64(data);

        // use value return from escapeBase64(dataEncrypted) with Tabapay
        console.log(escapeBase64(dataEncrypted))
      });
  });
})();