java生成RSA密钥对,前台js加密,后端javajava解密-使用

import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.Security;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import java.util.HashMap;
 
import javax.crypto.Cipher;
 
public class RSAUtils {
    /** 
     * 生成公钥和私钥 
     * @throws NoSuchAlgorithmException  
     * 
     */ 
    public static HashMap<String, Object> getKeys() throws NoSuchAlgorithmException{
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        HashMap<String, Object> map = new HashMap<String, Object>();  
        KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());  
        keyPairGen.initialize(1024);  
        KeyPair keyPair = keyPairGen.generateKeyPair();  
        RSAPublicKey publicKey = (RSAPublicKey) keyPair.getPublic();  
        RSAPrivateKey privateKey = (RSAPrivateKey) keyPair.getPrivate();  
        map.put("public", publicKey);  
        map.put("private", privateKey);  
        return map;  
    }  
    /** 
     * 使用模和指数生成RSA公钥 
     * @param modulus  模 
     * @param exponent  指数 
     * @return 
     */ 
    public static RSAPublicKey getPublicKey(String modulus, String exponent) {  
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        try {  
            BigInteger b1 = new BigInteger(modulus);  
            BigInteger b2 = new BigInteger(exponent);  
            KeyFactory keyFactory = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            RSAPublicKeySpec keySpec = new RSAPublicKeySpec(b1, b2);  
            return (RSAPublicKey) keyFactory.generatePublic(keySpec);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
   
    /** 
     * 使用模和指数生成RSA私钥 
     * /None/NoPadding
     * @param modulus     模 
     * @param exponent   指数 
     * @return 
     */ 
    public static RSAPrivateKey getPrivateKey(String modulus, String exponent) {  
        try {  
            Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
            BigInteger b1 = new BigInteger(modulus);  
            BigInteger b2 = new BigInteger(exponent);  
            KeyFactory keyFactory = KeyFactory.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());  
            RSAPrivateKeySpec keySpec = new RSAPrivateKeySpec(b1, b2);  
            return (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
        } catch (Exception e) {  
            e.printStackTrace();  
            return null;  
        }  
    }  
   
    /** 
     * 公钥加密 
     *  
     * @param data 
     * @param publicKey 
     * @return 
     * @throws Exception 
     */ 
    public static String encryptByPublicKey(String data, RSAPublicKey publicKey)  
            throws Exception {  
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());  
        cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
        // 模长  
        int key_len = publicKey.getModulus().bitLength() / 8;  
        // 加密数据长度 <= 模长-11  
        String[] datas = splitString(data, key_len - 11);  
        String mi = "";  
        //如果明文长度大于模长-11则要分组加密  
        for (String s : datas) {  
            mi += bcd2Str(cipher.doFinal(s.getBytes()));  
        }  
        return mi;  
    }  
   
    /** 
     * 私钥解密 
     *  
     * @param data 
     * @param privateKey 
     * @return 
     * @throws Exception 
     */ 
    public static String decryptByPrivateKey(String data, RSAPrivateKey privateKey)  
            throws Exception { 
        Security.addProvider(new org.bouncycastle.jce.provider.BouncyCastleProvider());
        Cipher cipher = Cipher.getInstance("RSA", new org.bouncycastle.jce.provider.BouncyCastleProvider());  
        cipher.init(Cipher.DECRYPT_MODE, privateKey);  
        //模长  
        int key_len = privateKey.getModulus().bitLength() / 8;  
        byte[] bytes = data.getBytes();  
        byte[] bcd = ASCII_To_BCD(bytes, bytes.length);  
        //System.err.println(bcd.length);  
        //如果密文长度大于模长则要分组解密  
        String ming = "";  
        byte[][] arrays = splitArray(bcd, key_len);  
        for(byte[] arr : arrays){  
            ming += new String(cipher.doFinal(arr));  
        }  
        return ming;  
    }  
    /** 
     * ASCII码转BCD码 
     *  
     */ 
    public static byte[] ASCII_To_BCD(byte[] ascii, int asc_len) {  
        byte[] bcd = new byte[asc_len / 2];  
        int j = 0;  
        for (int i = 0; i < (asc_len + 1) / 2; i++) {  
            bcd[i] = asc_to_bcd(ascii[j++]);  
            bcd[i] = (byte) (((j >= asc_len) ? 0x00 : asc_to_bcd(ascii[j++])) + (bcd[i] << 4));  
        }  
        return bcd;  
    }  
    public static byte asc_to_bcd(byte asc) {  
        byte bcd;  
   
        if ((asc >= '0') && (asc <= '9'))  
            bcd = (byte) (asc - '0');  
        else if ((asc >= 'A') && (asc <= 'F'))  
            bcd = (byte) (asc - 'A' + 10);  
        else if ((asc >= 'a') && (asc <= 'f'))  
            bcd = (byte) (asc - 'a' + 10);  
        else 
            bcd = (byte) (asc - 48);  
        return bcd;  
    }  
    /** 
     * BCD转字符串 
     */ 
    public static String bcd2Str(byte[] bytes) {  
        char temp[] = new char[bytes.length * 2], val;  
   
        for (int i = 0; i < bytes.length; i++) {  
            val = (char) (((bytes[i] & 0xf0) >> 4) & 0x0f);  
            temp[i * 2] = (char) (val > 9 ? val + 'A' - 10 : val + '0');  
   
            val = (char) (bytes[i] & 0x0f);  
            temp[i * 2 + 1] = (char) (val > 9 ? val + 'A' - 10 : val + '0');  
        }  
        return new String(temp);  
    }  
    /** 
     * 拆分字符串 
     */ 
    public static String[] splitString(String string, int len) {  
        int x = string.length() / len;  
        int y = string.length() % len;  
        int z = 0;  
        if (y != 0) {  
            z = 1;  
        }  
        String[] strings = new String[x + z];  
        String str = "";  
        for (int i=0; i<x+z; i++) {  
            if (i==x+z-1 && y!=0) {  
                str = string.substring(i*len, i*len+y);  
            }else{  
                str = string.substring(i*len, i*len+len);  
            }  
            strings[i] = str;  
        }  
        return strings;  
    }  
    /** 
     *拆分数组  
     */ 
    public static byte[][] splitArray(byte[] data,int len){  
        int x = data.length / len;  
        int y = data.length % len;  
        int z = 0;  
        if(y!=0){  
            z = 1;  
        }  
        byte[][] arrays = new byte[x+z][];  
        byte[] arr;  
        for(int i=0; i<x+z; i++){  
            arr = new byte[len];  
            if(i==x+z-1 && y!=0){  
                System.arraycopy(data, i*len, arr, 0, y);  
            }else{  
                System.arraycopy(data, i*len, arr, 0, len);  
            }  
            arrays[i] = arr;  
        }  
        return arrays;  
    }
    public static void main(String[] args) throws Exception{
        HashMap<String, Object> map = getKeys();  
        //生成公钥和私钥  
        RSAPublicKey publicKey = (RSAPublicKey) map.get("public");  
        RSAPrivateKey privateKey = (RSAPrivateKey) map.get("private"); 
           
        //模  
        String modulus = publicKey.getModulus().toString();  
        System.out.println("pubkey modulus="+modulus);
        //公钥指数  
        String public_exponent = publicKey.getPublicExponent().toString();
        System.out.println("pubkey exponent="+public_exponent);
        //私钥指数  
        String private_exponent = privateKey.getPrivateExponent().toString();  
        System.out.println("private exponent="+private_exponent);
        //明文  
        String ming = "你好世界";  
        //使用模和指数生成公钥和私钥  
        RSAPublicKey pubKey = RSAUtils.getPublicKey("modulus", "public_exponent");  
        RSAPrivateKey priKey = RSAUtils.getPrivateKey("modulus", "private_exponent"); 
        //加密后的密文  
        System.out.println(pubKey);
        String mi = RSAUtils.encryptByPublicKey(ming, pubKey);  
        System.out.println("mi="+mi);  
        //解密后的明文  
        System.out.println(mi.length());
        String ming2 = RSAUtils.decryptByPrivateKey(mi, priKey);  
        System.out.println("ming2="+ming2);  
         //解决中文乱码问题
        String result = java.net.URLDecoder.decode(ming2 ,"UTF-8");
        System.out.println(result);
    }
}

 

Java生成密钥的实例    //产生单钥加密密钥(myKey)   KeyGenerator keyGenerator = KeyGenerator.getInstance("DESede"); //采用DESede算法   keyGenerator.init(168); //选择DESede算法,密钥长度为112位或168位   Key myKey = keyGenerator.generateKey(); //生成密钥   System.out.println("得到单钥加密密钥");   //产生双钥的密钥对(keyPair)   KeyPairGenerator keyPairGenerator=KeyPairGenerator.getInstance("RSA"); //采用RSA算法   keyPairGenerator.initialize(1024); //指定密钥长度为1024位   KeyPair keyPair = keyPairGenerator.generateKeyPair(); //生成密钥对   System.out.println("生成张三的公钥对");   //保存公钥的字节数组   File f = new File("publicKey.dat"); //保存公钥到文件publicKey.dat   FileOutputStream fout = new FileOutputStream(f);   fout.write(keyPair.getPublic().getEncoded()); //得到公钥的字节数组   fout.close(); //关闭文件输出流   System.out.println("保存公钥到文件: " f.getAbsolutePath());   //用Java对象序列化保存私钥,通常应对私钥加密后再保存   ObjectOutputStream oout = new ObjectOutputStream(new FileOutputStream("privateKey.dat")); //保存私钥到文件privateKey.dat   oout.writeObject(keyPair.getPrivate()); //序列化私钥   oout.close(); //关闭输出流   System.err.println("保存私钥到: privateKey.dat");   //从文件中得到公钥编码的字节数组   FileInputStream fin = new FileInputStream("publicKey.dat"); //打天publicKey.dat   ByteArrayOutputStream baout = new ByteArrayOutputStream(); //用于写入文件的字节流   int aByte = 0;   while ((aByte = fin.read())!= -1) //从文件读取一个字节   {    baout.write(aByte); //写入一个字节   }   fin.close(); //关闭文件输入流   byte[] keyBytes = baout.toByteArray(); //得到公钥的字节数组   baout.close(); //关闭字节数组输出流
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值