출처1 : https://stackoverflow.com/questions/50394730/pycrypto-rsa-pkcs1-oaep-sha256-interoperability-with-java

출처2 : https://www.javaer101.com/article/1585846.html

출처3 : https://www.npmjs.com/package/node-forge#rsa

출처4 : https://medium.com/@DannyAziz97/rsa-encryption-with-js-python-7e031cbb66bb

출처3을 보면 nodejs에서도 자바의 RSA/ECB/OAEPWithSHA-256AndMGF1Padding 에 대응할 수 있는 것 같다.

출처4를 보면 python + node 예제가 있다. 조금만 더 다듬으면 쓸 수 있겠다.

자바에서 RSA키를 만들어서 주고 파이썬으로 암호화하여 전송한다.

그리고 다시 자바에서 암호화를 푸는 소스이다.

RSA키를 만들다보니 자바는 파이썬하고 nodejs하고 키가 좀 다르게 만들어지는 것 같다.

파이썬하고 nodejs는 openssl 처럼 만들어주는데 자바는 조금 다르더라.

다만 자바로 만든 키로는 공통으로 쓸 수 있는 것 같아서 자바로 키를 만들까 한다.

(bouncycastle 같은걸 쓰면 자바도 동일하게 쓸 수 있을 것 같다. 다만 추가적인 라이브러리라 사용하진 않았다.)

java

import lombok.extern.slf4j.Slf4j;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import java.security.*;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.util.Base64;
import java.util.HashMap;
import java.util.Map;

@Slf4j
public class RSAEncryptHelper {

    private static final String algorithm = "RSA";

    public static Map<String, Object> makeKey() throws NoSuchAlgorithmException, InvalidKeySpecException {
        KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(algorithm);
        keyPairGenerator.initialize(2048);
        KeyPair keyPair = keyPairGenerator.genKeyPair();

        String tmpPublicKey = Base64.getEncoder().encodeToString(keyPair.getPublic().getEncoded()); // 공개키
        String tmpPrivateKey = Base64.getEncoder().encodeToString(keyPair.getPrivate().getEncoded()); // 개인키

        Map<String, Object> pair = new HashMap<String, Object>();
        pair.put("privateKeyString", tmpPrivateKey);
        pair.put("publicKeyString", tmpPublicKey);
        pair.put("privateKey", keyPair.getPrivate().getEncoded());
        pair.put("publicKey", keyPair.getPublic().getEncoded());
        return pair;
    }

    public static byte[] getKeyBytes(String key) {
        return Base64.getDecoder().decode(key);
    }

    public static PrivateKey getPrivateKey(String key) throws InvalidKeySpecException, NoSuchAlgorithmException {
        byte[] decodedKey = Base64.getDecoder().decode(key);
        PrivateKey privKey = KeyFactory.getInstance(algorithm).generatePrivate(new PKCS8EncodedKeySpec(decodedKey));
        return privKey;
    }

    public static PublicKey getPublicKey(String key) throws InvalidKeySpecException, NoSuchAlgorithmException {
        byte[] decodedKey = Base64.getDecoder().decode(key);
        PublicKey publKey = KeyFactory.getInstance(algorithm).generatePublic(new PKCS8EncodedKeySpec(decodedKey));
        return publKey;
    }

    public static String getDecryptMessage(String secretMsg, byte[] privateKey) throws NoSuchAlgorithmException,
            NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException, InvalidAlgorithmParameterException {

        PrivateKey privKey = KeyFactory.getInstance(algorithm).generatePrivate(new PKCS8EncodedKeySpec(privateKey));

        // RSA/ECB/OAEPWithSHA-256AndMGF1Padding
        Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPWithSHA-256AndMGF1Padding");
        cipher.init(Cipher.DECRYPT_MODE, privKey);

        // RSA/ECB/OAEPPadding
//      Cipher cipher = Cipher.getInstance("RSA/ECB/OAEPPadding");
//      OAEPParameterSpec oaepParams = new OAEPParameterSpec("SHA-256", "MGF1", new MGF1ParameterSpec("SHA-256"), PSource.PSpecified.DEFAULT);
//      cipher.init(Cipher.DECRYPT_MODE, privKey, oaepParams);

        byte[] bMsg = Base64.getDecoder().decode(secretMsg);
        byte[] decryptMsg = cipher.doFinal(bMsg);
        return new String(decryptMsg);
    }

    public static String getDecryptMessage(String secretMsg, String privateKey) throws NoSuchAlgorithmException,
            NoSuchPaddingException, InvalidKeyException, IllegalBlockSizeException, BadPaddingException, InvalidKeySpecException {
        Cipher cipher = Cipher.getInstance(algorithm);
        PrivateKey pk = getPrivateKey(privateKey);
        cipher.init(Cipher.DECRYPT_MODE, pk);
        byte[] bMsg = Base64.getDecoder().decode(secretMsg);
        byte[] decryptMsg = cipher.doFinal(bMsg);
        return new String(decryptMsg);
    }

}

python

import requests
import base64
import binascii
from base64 import b64decode,b64encode
import json
from Crypto.PublicKey import RSA
from Crypto.Random import get_random_bytes
from Crypto.Cipher import AES, PKCS1_OAEP
from Crypto.Hash import SHA256, SHA1
from Crypto.Signature import pss

company_id = "AAAAAAAAAAAAAAAAAAAAAA==" # base64로 인코딩 된 고객사 ID

def shake():
    """RSA 공개키를 받아오는 함수

    Returns : RSA PublicKey encode Base64
    """
    r = requests.post("http://localhost:8080/api/auth/v1/shake")
    res = json.loads(r.text)
    return res['data']['rsaKey']

def encryptString(publicKeyBase64, company_id):
    keyDER = b64decode(publicKeyBase64)
    keyPub = RSA.importKey(keyDER)

    # 자바의 rsa는 기본적으로 Hash=SHA256, MGF1=SHA1 을 사용한다고 한다
    # https://stackoverflow.com/questions/50394730/pycrypto-rsa-pkcs1-oaep-sha256-interoperability-with-java
    encryptor = PKCS1_OAEP.new(key=keyPub,hashAlgo=SHA256, mgfunc=lambda x, y: pss.MGF1(x, y, SHA1))
    encrypted = encryptor.encrypt(str.encode(company_id))
    encoded_encrypted_msg = base64.b64encode(encrypted)
    return encoded_encrypted_msg.decode()

class RequestData:
    def toJSON(self):
        return json.dumps(self, default=lambda o: o.__dict__, sort_keys=True, indent=4)


def main():
    # 공개키 받기
    publicKey = shake()
    print("publicKey : " + publicKey)

    # 암호화
    enc_company_id = encryptString(publicKey, company_id)

    # requst body 생성
    req = RequestData()
    req.LoginId = 'aaa'
    req.RsaKey = publicKey
    req.Password = enc_company_id#.decode('ascii')
    print(req.toJSON())

    r = requests.post("http://localhost:8080/api/_test/v1/login"
        , headers={'Content-Type': 'application/json;charset=utf-8'}
        , data=req.toJSON()
    )

    res = json.loads(r.text)
    print(res)


if __name__ == "__main__":
    main()

nodejs

// node-forge
// encrypt sample
// https://medium.com/@DannyAziz97/rsa-encryption-with-js-python-7e031cbb66bb

var publicKey = forge.pki.publicKeyFromPem('-----BEGIN PUBLIC KEY----- ' + rsaKey + ' -----END PUBLIC KEY-----')

// java의 RSA/ECB/OAEPWithSHA-256AndMGF1Padding 대응
var encData = publicKey.encrypt(pass, 'RSA-OAEP', {
    md: forge.md.sha256.create(),
    mgf1: {
        md: forge.md.sha1.create()
    }
    })

// java의 RSA/ECB/OAEPPadding
// var encData = publicKey.encrypt(pass, 'RSA-OAEP', {
//   md: forge.md.sha256.create(),
//   mgf1: forge.mgf1.create()
// })

var base64 = forge.util.encode64(encData)
console.log(base64)

[Java + Python] RSA 암호화 연동