Encryption

import base64
import xml.etree.ElementTree as ET
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_v1_5


def get_xml_component(xmlstring, field):
    root = ET.fromstring(xmlstring)
    elements = root.findall(field)
    return elements[0].text if elements else ""


def encrypt(data, public_xml):
    if not data:
        raise Exception("Data sent for encryption is empty")

    decoded_string = base64.b64decode(public_xml).decode("utf-8")
    public_xml_key = decoded_string.split("!")[1]

    modulus = base64.b64decode(get_xml_component(public_xml_key, "Modulus"))
    exponent = base64.b64decode(get_xml_component(public_xml_key, "Exponent"))

    key = RSA.construct((
        int.from_bytes(modulus, byteorder="big"),
        int.from_bytes(exponent, byteorder="big"),
    ))

    cipher = PKCS1_v1_5.new(key)
    return base64.b64encode(cipher.encrypt(data.encode("utf-8"))).decode()

<?php
require 'vendor/autoload.php';

use phpseclib3\Crypt\RSA;
use phpseclib3\Math\BigInteger;

function getXmlComponent($xmlstring, $field)
{
    $xml = new SimpleXMLElement($xmlstring);
    $result = $xml->xpath("//$field");
    return ($result && count($result) > 0) ? (string) $result[0] : "";
}

function encryptData($data, $public_xml)
{
    if (!$data) {
        throw new Exception("Data sent for encryption is empty");
    }

    $decoded_string = base64_decode($public_xml);
    $public_xml_key = explode('!', $decoded_string)[1];

    $modulus  = base64_decode(getXmlComponent($public_xml_key, "Modulus"));
    $exponent = base64_decode(getXmlComponent($public_xml_key, "Exponent"));

    $rsa = RSA::loadFormat('raw', [
        'n' => new BigInteger($modulus, 256),
        'e' => new BigInteger($exponent, 256),
    ])->withPadding(RSA::ENCRYPTION_PKCS1);

    return base64_encode($rsa->encrypt($data));
}

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;

import javax.crypto.Cipher;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import java.security.KeyFactory;
import java.security.PublicKey;
import java.security.spec.RSAPublicKeySpec;
import java.util.Base64;

public class EncryptionHelper {

    public static String getXmlComponent(String xmlstring, String field) throws Exception {
        DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
        Document doc = dBuilder.parse(
            new java.io.ByteArrayInputStream(xmlstring.getBytes("UTF-8")));
        doc.getDocumentElement().normalize();

        NodeList nodes = doc.getElementsByTagName(field);
        if (nodes.getLength() == 0) return "";
        return ((Element) nodes.item(0)).getTextContent();
    }

    public static String encrypt(String data, String publicXml) throws Exception {
        if (data == null || data.isEmpty()) {
            throw new Exception("Data sent for encryption is empty");
        }

        String decodedString = new String(Base64.getDecoder().decode(publicXml));
        String publicXmlKey = decodedString.split("!")[1];

        byte[] modulusBytes  = Base64.getDecoder().decode(getXmlComponent(publicXmlKey, "Modulus"));
        byte[] exponentBytes = Base64.getDecoder().decode(getXmlComponent(publicXmlKey, "Exponent"));

        RSAPublicKeySpec keySpec = new RSAPublicKeySpec(
            new java.math.BigInteger(1, modulusBytes),
            new java.math.BigInteger(1, exponentBytes));

        PublicKey publicKey = KeyFactory.getInstance("RSA").generatePublic(keySpec);

        Cipher cipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);

        return Base64.getEncoder().encodeToString(cipher.doFinal(data.getBytes("UTF-8")));
    }
}