rsa encryption interworking between php and java [turn]

The following classes are packaged php, is introduced can be used

? <PHP
/ **
* OF: PJP
* E-mail: [email protected]
* /
class {the RSA
Private privateKey $ = ''; // private key (used to encrypt the user)
Private $ publicKey = ''; // public key (used to decrypt the data server)

the __construct function public () {
$ this-> privateKey = openssl_pkey_get_private (file_get_contents ( 'php_private.pem')); // private key used to encrypt
$ this-> publicKey = openssl_pkey_get_public (file_get_contents ( 'php_public.pem')); // public key for decrypting
}

/ **
* private key encryption
* @param original data data $
* @return ciphertext result String
* /
public function encryptByPrivateKey ($ data) {
openssl_private_encrypt (data $, $ eNCRYPTED, the this $ -> privateKey, OPENSSL_PKCS1_PADDING); // private key encryption
$ encrypted = base64_encode ($ encrypted) ; // encrypted contents generally contain the special character, the need for transcoding, the network is to be noted between the base64 encoding when transmitted through url whether url safe
return $ eNCRYPTED;
}

/ **
* private key to decrypt
* @param ciphertext data $
* @return description data results String
* /
function decryptByPrivateKey public ($ Data) {
$ = Data base64_decode ($ Data);
openssl_private_decrypt ($ Data, ENCRYPTED $, $ this-> privateKey, OPENSSL_PKCS1_PADDING); // private key to
return $ ENCRYPTED;
}

/ **
* private key signature
* @param $ Unknown Data
* /
public function signByPrivateKey ($ Data) {
openssl_sign ($ Data, signature $, $ this-> privateKey);
$ = eNCRYPTED the base64_encode ($ signature); // encrypted contents generally contain the special character, need to code conversion, to the attention of the network between the url if base64 encoding is transmitted through url safe
return $ eNCRYPTED;
}

/ **
* public key encryption
* @param description data data $
* @return encryption result String
* /
public function encryptByPublicKey ($ data) {
openssl_public_encrypt ($ data, $ decrypted, $ this-> publicKey, OPENSSL_PKCS1_PADDING); // public key encryption
return the base64_encode ($ DECRYPTED);
}

/ **
* public key to decrypt
* @param ciphertext Data $
* @return description Results String
* /
public function decryptByPublicKey ($ Data) {
$ = Data base64_decode ($ Data);
openssl_public_decrypt (Data $, $ dECRYPTED, $ this-> publicKey, OPENSSL_PKCS1_PADDING); // public key to decrypt
return $ dECRYPTED;
}

/ **
* public inspection check
* @param Unknown Data $
* @param sign Unknown $
* /
public function verifyByPublicKey (Data $, $ sign) {
$ base64_decode = sign ($ sign);
return openssl_verify (Data $, $ sign, the this $ -> publicKey);
}

public function __destruct(){
openssl_free_key($this->privateKey);
openssl_free_key($this->publicKey);
}
}

php public key file contents (php_public.pem)

Public and private keys Jieke regenerate themselves

php private key file contents (php_private.pem)

PRIVATE KEY ----- ----- Begin
MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKbVhyEl0dXL2Jew
N9B8wQHaZ07nC5oSKpQR6sc7sdsoqS + G4h9zuFpBXlspOIpnvoWeSRckwX6icytC
uuqThOJaVhmiKV6w8zzyOvTVn0yaHMpXu9ZuhWFhx3xzDYy5rQfAAzKX1MO3k4ta
ZPTQLj8u7vaVEvbVq / RUN-OFF + + YNCgCpAgMBAAECgYB1x4s1eJiyAc4wEITm2Bv Lez /
BBfptmd + z0NbUiZW3VbLqcLbh3ufpERzwR8cfu8 / L6bUAuvjddYutVZ2Ip0Nd7dG
5rrktH + 7R8UT89fn87bUa5NlLee + egyoz / PJ63X4JjEg5OJbkXMbK4YrTypS0IAx
nZv + 7BeSsCrzNlpWAQJBANgmHMDNrIWvU3qVf7u8SS / g + WrlvKMWOXtYjH2OqWoO
Vtmh4Or1PbaPIMnPAXFYiYYW8wcLYnVmVCez5qaysWkCQQDFl9XONZIMFAvdJ5S2
UFk63bEYtCroKZjddTlE6K / j + Vj2IaCFm94i4x1YzJR0KrykrtBTLRi7nuWmdJMJ
r61BAkA7dxDGAk + KX9fJi8OedIh2AaDcxeOFwqGBy7Sq / kqhgNxn918XhOy7gtj0
bFzrP/5lw36M25b00XgpjBbSmaqxAkBnBN/TUHjh1T3OQ0m0uDWdjGI+KAlK3A04
QVrng43ZBXMNeMDRiE+Lzu/JEXjBDFsoXYB+LT/86j5/x721yiNBAkEAgi0F5BvA
wYZQXqAx3iyuj8R9uUKpLePafyBRHnLNrFux2VD0ZX3pXCmfDDmtM/NMO491dI84
6NbVOvxWcNPQ/Q==
-----END PRIVATE KEY-----

The following is the method java packaged

/ **
* Author: pjp
* E-mail: [email protected]
* /
Package Penalty for crypt;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.security.KeyFactory;
import java.security.Signature;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.Cipher;

Rsa class {public

Private String prikey;
Private String pubkey;

public static void main (String [] args) {
Rsa Rsa rsa = new new ();
String str = "I want to encrypt this text.";
System.out.println ( "original:" + "I want to encrypt this text.");
String crypt = rsa.encryptByPrivateKey (str);
System.out.println ( "private key encryption cipher text:" + crypt);
String = rsa.decryptByPublicKey the Result (crypt);
System.out.println ( "original:" + the Result);

System.out.println ( "---");

str =. "I want to encrypt this text";
System.out.println ( " original: "+" I want to encrypt this text ");.
crypt = rsa.encryptByPublicKey (str);
System.out.println (" public-key encryption cipher text: "+ crypt);
the Result = rsa.decryptByPrivateKey (crypt) ;
System.out.println("原文:"+result);

System.out.println ( "---");

str = "I want to sign this text.";
System.out.println ( "Original:" + str);
String str1 = rsa.signByPrivateKey (str);
System .out.println ( "signature result:" + str1);
IF (rsa.verifyByPublicKey (str1, STR)) {
System.out.println ( "success");
} the else {
System.out.println ( "failure") ;
}
}

public Rsa(){
priKey = readStringFromFile("java_private.pem");
pubKey = readStringFromFile("java_public.pem");
}

/**
* 使用私钥加密
* @see decByPriKey
*/
public String encryptByPrivateKey(String data) {
// 加密
String str = "";
try {
byte[] pribyte = base64decode(priKey.trim());
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pribyte);
KeyFactory fac = KeyFactory.getInstance("RSA");
RSAPrivateKey privateKey = (RSAPrivateKey) fac.generatePrivate(keySpec);
Cipher c1 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
c1.init(Cipher.ENCRYPT_MODE, privateKey);
str = base64encode(c1.doFinal(data.getBytes()));
} catch (Exception e) {
e.printStackTrace();

}
return str;
}

/**
* 使用私钥解密
* @see decByPriKey
*/
public String decryptByPrivateKey(String data) {
// 加密
String str = "";
try {
byte[] pribyte = base64decode(priKey.trim());
PKCS8EncodedKeySpec keySpec = new PKCS8EncodedKeySpec(pribyte);
KeyFactory fac = KeyFactory.getInstance("RSA");
RSAPrivateKey privateKey = (RSAPrivateKey) fac.generatePrivate(keySpec);
Cipher c1 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
c1.init(Cipher.DECRYPT_MODE, privateKey);
byte[] temp = c1.doFinal(base64decode(data));
str = new String(temp);
} catch (Exception e) {
e.printStackTrace();

}
return str;
}

/**
* 使用公钥加密
* @see decByPriKey
*/
public String encryptByPublicKey(String data) {
// 加密
String str = "";
try {
byte[] pubbyte = base64decode(pubKey.trim());
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pubbyte);
KeyFactory fac = KeyFactory.getInstance("RSA");
RSAPublicKey rsaPubKey = (RSAPublicKey) fac.generatePublic(keySpec);
Cipher c1 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
c1.init(Cipher.ENCRYPT_MODE, rsaPubKey);
str = base64encode(c1.doFinal(data.getBytes()));
} catch (Exception e) {
e.printStackTrace();

}
return str;
}

/**
* 使用公钥解密
* @see decByPriKey
*/
public String decryptByPublicKey(String data) {
// 加密
String str = "";
try {
byte[] pubbyte = base64decode(pubKey.trim());
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pubbyte);
KeyFactory fac = KeyFactory.getInstance("RSA");
RSAPublicKey rsaPubKey = (RSAPublicKey) fac.generatePublic(keySpec);
Cipher c1 = Cipher.getInstance("RSA/ECB/PKCS1Padding");
c1.init(Cipher.DECRYPT_MODE, rsaPubKey);
byte[] temp = c1.doFinal(base64decode(data));
str = new String(temp);
} catch (Exception e) {
e.printStackTrace();

}
return str;
}
/**
* 本方法使用SHA1withRSA签名算法产生签名
* @Param String src signature of the original string
* @return String signed return results (hex encoded). When generating a signature error, returns null.
* /
Public String signByPrivateKey (String the src) {
the try {
the Signature sigEng = Signature.getInstance ( "SHA1withRSA");
byte [] = pribyte base64decode (priKey.trim ());
PKCS8EncodedKeySpec with keySpec PKCS8EncodedKeySpec with new new = (pribyte);
the KeyFactory FAC = KeyFactory.getInstance ( "the RSA");
RSAPrivateKey The privateKey = (RSAPrivateKey The) fac.generatePrivate (keySpec);
sigEng.initSign (privateKey);
sigEng.update (src.getBytes ());
byte [] Signature = sigEng.sign () ;
return Base64Encode (Signature);
} the catch (Exception E) {
e.printStackTrace ();
return null;
}
}

/**
* 使用共钥验证签名
* @param sign
* @param src
* @return
*/
public boolean verifyByPublicKey(String sign, String src) {
try {
Signature sigEng = Signature.getInstance("SHA1withRSA");
byte[] pubbyte = base64decode(pubKey.trim());
X509EncodedKeySpec keySpec = new X509EncodedKeySpec(pubbyte);
KeyFactory fac = KeyFactory.getInstance("RSA");
RSAPublicKey rsaPubKey = (RSAPublicKey) fac.generatePublic(keySpec);
sigEng.initVerify(rsaPubKey);
sigEng.update(src.getBytes());
byte[] sign1 = base64decode(sign);
return sigEng.verify(sign1);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}

/**
* base64加密
* @param bstr
* @return
*/
@SuppressWarnings("restriction")
private String base64encode(byte[] bstr) {
String str = new sun.misc.BASE64Encoder().encode(bstr);
str = str.replaceAll("\r\n", "").replaceAll("\r", "").replaceAll("\n", "");
return str;
}

/**
* base64解密
* @param str
* @return byte[]
*/
@SuppressWarnings("restriction")
private byte[] base64decode(String str) {
byte[] bt = null;
try {
sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
bt = decoder.decodeBuffer(str);
} catch (IOException e) {
e.printStackTrace();
}

return bt;
}

/**
* 从文件中读取所有字符串
* @param fileName
* @return String
*/
private String readStringFromFile(String fileName){
StringBuffer str = new StringBuffer();
try {
File file = new File(fileName);
FileReader fr = new FileReader(file);
char[] temp = new char[1024];
while (fr.read(temp) != -1) {
str.append(temp);
}
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();

}
return str.toString();
}
}

java public key file contents (java_public.pem)

MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCm1YchJdHVy9iXsDfQfMEB2mdO
5wuaEiqUEerHO7HbKKkvhuIfc7haQV5bKTiKZ76FnkkXJMF+onMrQrrqk4TiWlYZ
oilesPM88jr01Z9MmhzKV7vWboVhYcd8cw2Mua0HwAMyl9TDt5OLWmT00C4/Lu72
lRL21avxRTvmDQoAqQIDAQAB

java private key file contents (java_private.pem)

MIICdgIBADANBgkqhkiG9w0BAQEFAASCAmAwggJcAgEAAoGBAKbVhyEl0dXL2Jew
N9B8wQHaZ07nC5oSKpQR6sc7sdsoqS + G4h9zuFpBXlspOIpnvoWeSRckwX6icytC
uuqThOJaVhmiKV6w8zzyOvTVn0yaHMpXu9ZuhWFhx3xzDYy5rQfAAzKX1MO3k4ta
ZPTQLj8u7vaVEvbVq / RUN-OFF + YNCgCpAgMBAAECgYB1x4s1eJiyAc4wEITm2Bv + Lez /
BBfptmd + z0NbUiZW3VbLqcLbh3ufpERzwR8cfu8 / L6bUAuvjddYutVZ2Ip0Nd7dG
5rrktH + 7R8UT89fn87bUa5NlLee + egyoz / PJ63X4JjEg5OJbkXMbK4YrTypS0IAx
nZv + 7BeSsCrzNlpWAQJBANgmHMDNrIWvU3qVf7u8SS / g + WrlvKMWOXtYjH2OqWoO
Vtmh4Or1PbaPIMnPAXFYiYYW8wcLYnVmVCez5qaysWkCQQDFl9XONZIMFAvdJ5S2
UFk63bEYtCroKZjddTlE6K / j + Vj2IaCFm94i4x1YzJR0KrykrtBTLRi7nuWmdJMJ
r61BAkA7dxDGAk + KX9fJi8OedIh2AaDcxeOFwqGBy7Sq / kqhgNxn918XhOy7gtj0
bFzrP / 5lw36M25b00XgpjBbSmaqxAkBnBN / TUHjh1T3OQ0m0uDWdjGI + KAlK3A04
QVrng43ZBXMNeMDRiE+Lzu/JEXjBDFsoXYB+LT/86j5/x721yiNBAkEAgi0F5BvA
wYZQXqAx3iyuj8R9uUKpLePafyBRHnLNrFux2VD0ZX3pXCmfDDmtM/NMO491dI84
6NbVOvxWcNPQ/Q==

Description:

java and php version of RSA encryption and decryption has been tested all. And can encrypt and decrypt each other.
The server keeps the private key is the public key can be issued to the corresponding client can even be public.
It uses private key encryption - "public key cryptography and public key to decrypt -" private key to decrypt the encryption method.
However, if the client is a need for higher security payment system, it should be used two pairs of keys.
Each party were its own private key and the other party's public key, private key encryption and signature adopted - "signed public key to decrypt and verify the way.

Note: given two versions of the two pairs of keys, is really just a pair of keys. The key difference is that java head and tail removed comments. PHP is the key to retain the head and tail notes.

from：https://blog.csdn.net/panjiapengfly/article/details/75318930

rsa encryption interworking between php and java [turn]

Guess you like