Java RSA generated public key private key encoding and Base64 encoding

RSA generates public and private keys

Reference: https://www.cnblogs.com/only-jlk/p/5960900.html

import java.security.Key;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.util.HashMap;
import java.util.Map;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class CreateSecrteKey {

  public class Keys {

  }

  public static final String KEY_ALGORITHM = "RSA";

  //public static final String SIGNATURE_ALGORITHM = "MD5withRSA";

  private static final String PUBLIC_KEY = "RSAPublicKey";

  private static final String PRIVATE_KEY = "RSAPrivateKey";

  //获得公钥
  public static String getPublicKey(Map<String, Object> keyMap) throws Exception {

    //获得map中的公钥对象 转为key对象
    Key key = (Key) keyMap.get(PUBLIC_KEY);

    //byte[] publicKey = key.getEncoded();
    //编码返回字符串
    return encryptBASE64(key.getEncoded());
  }

  //获得私钥
  public static String getPrivateKey(Map<String, Object> keyMap) throws Exception {

    //获得map中的私钥对象 转为key对象
    Key key = (Key) keyMap.get(PRIVATE_KEY);

    //byte[] privateKey = key.getEncoded();
    //编码返回字符串
    return encryptBASE64(key.getEncoded());
  }

  //解码返回byte
  public static byte[] decryptBASE64(String key) throws Exception {
    return (new BASE64Decoder()).decodeBuffer(key);
  }

  //编码返回字符串
  public static String encryptBASE64(byte[] key) throws Exception {
    return (new BASE64Encoder()).encodeBuffer(key);
  }

  //map对象中存放公私钥
  public static Map<String, Object> initKey() throws Exception {

    //获得对象 KeyPairGenerator 参数 RSA 1024个字节
    KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance(KEY_ALGORITHM);
    keyPairGen.initialize(1024);

    //通过对象 KeyPairGenerator 获取对象KeyPair
    KeyPair keyPair = keyPairGen.generateKeyPair();

    //通过对象 KeyPair 获取RSA公私钥对象RSAPublicKey RSAPrivateKey
    RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();
    RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();

    //公私钥对象存入map中
    Map<String, Object> keyMap = new HashMap<String, Object>(2);
    keyMap.put(PUBLIC_KEY, publicKey);
    keyMap.put(PRIVATE_KEY, privateKey);
    return keyMap;
  }

  public static void main(String[] args) {

    Map<String, Object> keyMap;
    try {
      keyMap = initKey();
      String publicKey = getPublicKey(keyMap);
      System.out.println(publicKey);
      String privateKey = getPrivateKey(keyMap);
      System.out.println(privateKey);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
}

 

 

RSA encryption and decryption (Java implementation)

https://blog.csdn.net/qy20115549/article/details/83105736

 

Base64 encoding

The apache.commons-codex package provides many encoding format conversions, such as Base64.

 

The following is the Base64 encoding table
. The procedure for encoding and decoding strings using apache.commons-codex for Base64 is as follows:

import org.apache.commons.codec.binary.Base64;

public class Base64Coded {
	public static void main(String[] args) {
		String string = "pbyang123456";
		//编码
		String encode = encode(string.getBytes());
		System.out.println(string + "\t编码后的字符串为：" + encode);
		//解码
		String decode = decode(encode.getBytes());
		System.out.println(encode + "\t字符串解码后为：" + decode);
	}
	//base64 解码
    public static String decode(byte[] bytes) {  
        return new String(Base64.decodeBase64(bytes));  
    }  
  
    //base64 编码
    public static String encode(byte[] bytes) {  
        return new String(Base64.encodeBase64(bytes));  
    }  
}