Linux下使用OpenSSL实现RSA非对称加密【永利电子游

2019-10-05 作者:计算机教程   |   浏览(161)

简单定义:公钥和私钥,加密和解密使用的是两个不同的密钥,所以是非对称。

java与IOS之间的RSA加解密,javaiosrsa解密

    很简单的一个需求,ipad端给密码RSA加密,传到java后台,解密。RSA加密算法是基于一个密钥对的,分为公钥和私钥,一般情况公钥加密,私钥解密,但也可私钥加密,公钥解密。还可以验签,就是先用私钥对数据进行加密,然后对加密后的数据进行签名,得到一个签名值。然后再用公钥先验签,证明是对应私钥加密过的数据才解密。主要是为了防止来源不确定的数据。     根据上面的介绍,大家也都知道,RSA算法的关键就是密钥对,我和IOS的同事各自找了RSA的算法实现代码,都能正常根据密钥对加解密。问题是我们各自使用对方的密钥对就不能加解密成功。IOS同事也是一个新手。连RSA算法是个什么概念都没搞清楚,我也懂点IOS。所以就陪着他一起看代码,找资料。看到底什么原因引起的密钥对不能共用。后来找到下面这篇文章: Java中使用OpenSSL生成的RSA公私钥进行数据加解密
原来在用mac 系统中自带的openssl生成的密钥对文件是X509编码格式的。而我们JAVA所需的私钥文件是PKCS#8编码格式的。。所以要将在mac 系统中生成的私钥文件转下码就行了。转码方式参考上面链接。附下java代码:

Java代码 永利电子游戏网站 1 永利电子游戏网站 2

import java.io.BufferedReader;  

import java.io.IOException;  

import java.io.InputStream;  

import java.io.InputStreamReader;  

import java.security.InvalidKeyException;  

import java.security.KeyFactory;  

import java.security.KeyPair;  

import java.security.KeyPairGenerator;  

import java.security.NoSuchAlgorithmException;  

import java.security.SecureRandom;  

import java.security.interfaces.RSAPrivateKey;  

import java.security.interfaces.RSAPublicKey;  

import java.security.spec.InvalidKeySpecException;  

import java.security.spec.PKCS8EncodedKeySpec;  

import java.security.spec.X509EncodedKeySpec;  

  

import javax.crypto.BadPaddingException;  

import javax.crypto.Cipher;  

import javax.crypto.IllegalBlockSizeException;  

import javax.crypto.NoSuchPaddingException;  

  

import sun.misc.BASE64Decoder;  

import sun.misc.BASE64Encoder;  

  

public class RSAEncrypt {  

    private static final String DEFAULT_PUBLIC_KEY=     

        "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w"   "r"      

        "/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht"   "r"      

        "Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg"   "r"      

        "XIlk3gdhnzh uoEQywIDAQAB"   "r";    

        

    private static final String DEFAULT_PRIVATE_KEY=    

        "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD taAXCfG"   "r"      

        "6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4"   "r"      

        "1rCLtolpGG1XHW44f/ZTfvx xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA"   "r"      

        "ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm"   "r"      

        "u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j"   "r"      

        "DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu LgsOTD11/V/Jr4NJxIudo"   "r"      

        "MBQ3c4cHmOoYv4uzkQJBANR 7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ"   "r"      

        "DvVLOOoAzvtHfAiUp H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM"   "r"      

        "6Leqkmoa 6YpfRb3oxykLBXcWx7DtbX ayKy5OQmnkEG MW8XB8wAdiUl0/tb6cQ"   "r"      

        "FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj aSGtvjzjFnZXK4gIjBjA"   "r"      

        "2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh KBSv76cnEDwLhfLQJlKgEnvqTvX"   "r"      

        "TB0TUw8avlaBAXW34/5sI NUB1hmbgyTK/T/IFcEPXpBWLGO e3pAkAGWLpnH0Zh"   "r"      

        "Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS SYLKwb4gGzYaCxc22vMtYksXHtUeamo"   "r"      

        "1NMLzI2ZfUoX"   "r";    

    

    /**  

     * 私钥  

     */    

    private RSAPrivateKey privateKey;    

    

    /**  

     * 公钥  

     */    

    private RSAPublicKey publicKey;    

        

    /**  

     * 字节数据转字符串专用集合  

     */    

    private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};    

        

    

    /**  

     * 获取私钥  

     * @return 当前的私钥对象  

     */    

    public RSAPrivateKey getPrivateKey() {    

        return privateKey;    

    }    

    

    /**  

     * 获取公钥  

     * @return 当前的公钥对象  

     */    

    public RSAPublicKey getPublicKey() {    

        return publicKey;    

    }    

    

    /**  

     * 随机生成密钥对  

     */    

    public void genKeyPair(){    

        KeyPairGenerator keyPairGen= null;    

        try {    

            keyPairGen= KeyPairGenerator.getInstance("RSA");    

        } catch (NoSuchAlgorithmException e) {    

            e.printStackTrace();    

        }    

        keyPairGen.initialize(1024, new SecureRandom());    

        KeyPair keyPair= keyPairGen.generateKeyPair();    

        this.privateKey= (RSAPrivateKey) keyPair.getPrivate();    

        this.publicKey= (RSAPublicKey) keyPair.getPublic();    

    }    

    

    /**  

     * 从文件中输入流中加载公钥  

     * @param in 公钥输入流  

     * @throws Exception 加载公钥时产生的异常  

     */    

    public void loadPublicKey(InputStream in) throws Exception{    

        try {    

            BufferedReader br= new BufferedReader(new InputStreamReader(in));    

            String readLine= null;    

            StringBuilder sb= new StringBuilder();    

            while((readLine= br.readLine())!=null){    

                if(readLine.charAt(0)=='-'){    

                    continue;    

                }else{    

                    sb.append(readLine);    

                    sb.append('r');    

                }    

            }    

            loadPublicKey(sb.toString());    

        } catch (IOException e) {    

            throw new Exception("公钥数据流读取错误");    

        } catch (NullPointerException e) {    

            throw new Exception("公钥输入流为空");    

        }    

    }    

    

    

    /**  

     * 从字符串中加载公钥  

     * @param publicKeyStr 公钥数据字符串  

     * @throws Exception 加载公钥时产生的异常  

     */    

    public void loadPublicKey(String publicKeyStr) throws Exception{    

        try {    

            BASE64Decoder base64Decoder= new BASE64Decoder();    

            byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);  

            KeyFactory keyFactory= KeyFactory.getInstance("RSA");    

            X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);    

            this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);    

        } catch (NoSuchAlgorithmException e) {    

            throw new Exception("无此算法");    

        } catch (InvalidKeySpecException e) {    

            throw new Exception("公钥非法");    

        } catch (IOException e) {    

            throw new Exception("公钥数据内容读取错误");    

        } catch (NullPointerException e) {    

            throw new Exception("公钥数据为空");    

        }    

    }    

    

    /**  

     * 从文件中加载私钥  

     * @param keyFileName 私钥文件名  

     * @return 是否成功  

     * @throws Exception   

     */    

    public void loadPrivateKey(InputStream in) throws Exception{    

        try {    

            BufferedReader br= new BufferedReader(new InputStreamReader(in));    

            String readLine= null;    

            StringBuilder sb= new StringBuilder();    

            while((readLine= br.readLine())!=null){    

                if(readLine.charAt(0)=='-'){    

                    continue;    

                }else{    

                    sb.append(readLine);    

                    sb.append('r');    

                }    

            }    

            loadPrivateKey(sb.toString());    

        } catch (IOException e) {    

            throw new Exception("私钥数据读取错误");    

        } catch (NullPointerException e) {    

            throw new Exception("私钥输入流为空");    

        }    

    }    

    

    public void loadPrivateKey(String privateKeyStr) throws Exception{    

        try {    

            BASE64Decoder base64Decoder= new BASE64Decoder();    

            byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);    

            PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);    

            KeyFactory keyFactory= KeyFactory.getInstance("RSA");    

            this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);    

        } catch (NoSuchAlgorithmException e) {    

            throw new Exception("无此算法");    

        } catch (InvalidKeySpecException e) {    

            e.printStackTrace();  

            throw new Exception("私钥非法");    

        } catch (IOException e) {    

            throw new Exception("私钥数据内容读取错误");    

        } catch (NullPointerException e) {    

            throw new Exception("私钥数据为空");    

        }    

    }    

    

    /**  

     * 加密过程  

     * @param publicKey 公钥  

     * @param plainTextData 明文数据  

     * @return  

     * @throws Exception 加密过程中的异常信息  

     */    

    public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{    

        if(publicKey== null){    

            throw new Exception("加密公钥为空, 请设置");    

        }    

        Cipher cipher= null;    

        try {    

            cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());    

            cipher.init(Cipher.ENCRYPT_MODE, publicKey);    

            byte[] output= cipher.doFinal(plainTextData);    

            return output;    

        } catch (NoSuchAlgorithmException e) {    

            throw new Exception("无此加密算法");    

        } catch (NoSuchPaddingException e) {    

            e.printStackTrace();    

            return null;    

        }catch (InvalidKeyException e) {    

            throw new Exception("加密公钥非法,请检查");    

        } catch (IllegalBlockSizeException e) {    

            throw new Exception("明文长度非法");    

        } catch (BadPaddingException e) {    

            throw new Exception("明文数据已损坏");    

        }    

    }    

    

    /**  

     * 解密过程  

     * @param privateKey 私钥  

     * @param cipherData 密文数据  

     * @return 明文  

     * @throws Exception 解密过程中的异常信息  

     */    

    public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{    

        if (privateKey== null){    

            throw new Exception("解密私钥为空, 请设置");    

        }    

        Cipher cipher= null;    

        try {    

            cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());    

            cipher.init(Cipher.DECRYPT_MODE, privateKey);    

            byte[] output= cipher.doFinal(cipherData);    

            return output;    

        } catch (NoSuchAlgorithmException e) {    

            throw new Exception("无此解密算法");    

        } catch (NoSuchPaddingException e) {    

            e.printStackTrace();    

            return null;    

        }catch (InvalidKeyException e) {    

            throw new Exception("解密私钥非法,请检查");    

        } catch (IllegalBlockSizeException e) {    

            throw new Exception("密文长度非法");    

        } catch (BadPaddingException e) {    

            throw new Exception("密文数据已损坏");    

        }           

    }    

    

        

    /**  

     * 字节数据转十六进制字符串  

     * @param data 输入数据  

     * @return 十六进制内容  

     */    

    public static String byteArrayToString(byte[] data){    

        StringBuilder stringBuilder= new StringBuilder();    

        for (int i=0; i<data.length; i ){    

            //取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移    

            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);    

            //取出字节的低四位 作为索引得到相应的十六进制标识符    

            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);    

            if (i<data.length-1){    

                stringBuilder.append(' ');    

            }    

        }    

        return stringBuilder.toString();    

    }    

    

    

    public static void main(String[] args){    

        RSAEncrypt rsaEncrypt= new RSAEncrypt();    

        //rsaEncrypt.genKeyPair();    

         

    

        //加载公钥    

        try {    

            rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);    

            System.out.println("加载公钥成功");    

        } catch (Exception e) {    

            System.err.println(e.getMessage());    

            System.err.println("加载公钥失败");    

        }    

    

        //加载私钥    

        try {    

            rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);    

            System.out.println("加载私钥成功");    

        } catch (Exception e) {    

            System.err.println(e.getMessage());    

            System.err.println("加载私钥失败");    

        }    

    

        //测试字符串    

        String encryptStr= "abc";    

        System.out.println("私钥长度:" rsaEncrypt.getPrivateKey().toString().length());  

        System.out.println("公钥长度:" rsaEncrypt.getPublicKey().toString().length());  

        try {    

            //加密    

            byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());    

              

             

            //解密    

            byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);    

  

              

             

            System.out.println("密文长度:"  cipher.length);    

            System.out.println(RSAEncrypt.byteArrayToString(cipher));    

            System.out.println("明文长度:"  plainText.length);    

            System.out.println(RSAEncrypt.byteArrayToString(plainText));    

            System.out.println(new String(plainText));    

        } catch (Exception e) {    

            System.err.println(e.getMessage());    

        }    

    }  

}  

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

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

public class RSAEncrypt {
 private static final String DEFAULT_PUBLIC_KEY=   
        "MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQChDzcjw/rWgFwnxunbKp7/4e8w"   "r"    
        "/UmXx2jk6qEEn69t6N2R1i/LmcyDT1xr/T2AHGOiXNQ5V8W4iCaaeNawi7aJaRht"   "r"    
        "Vx1uOH/2U378fscEESEG8XDqll0GCfB1/TjKI2aitVSzXOtRs8kYgGU78f7VmDNg"   "r"    
        "XIlk3gdhnzh uoEQywIDAQAB"   "r";  

    private static final String DEFAULT_PRIVATE_KEY=  
        "MIICdQIBADANBgkqhkiG9w0BAQEFAASCAl8wggJbAgEAAoGBAKEPNyPD taAXCfG"   "r"    
        "6dsqnv/h7zD9SZfHaOTqoQSfr23o3ZHWL8uZzINPXGv9PYAcY6Jc1DlXxbiIJpp4"   "r"    
        "1rCLtolpGG1XHW44f/ZTfvx xwQRIQbxcOqWXQYJ8HX9OMojZqK1VLNc61GzyRiA"   "r"    
        "ZTvx/tWYM2BciWTeB2GfOH66gRDLAgMBAAECgYBp4qTvoJKynuT3SbDJY/XwaEtm"   "r"    
        "u768SF9P0GlXrtwYuDWjAVue0VhBI9WxMWZTaVafkcP8hxX4QZqPh84td0zjcq3j"   "r"    
        "DLOegAFJkIorGzq5FyK7ydBoU1TLjFV459c8dTZMTu LgsOTD11/V/Jr4NJxIudo"   "r"    
        "MBQ3c4cHmOoYv4uzkQJBANR 7Fc3e6oZgqTOesqPSPqljbsdF9E4x4eDFuOecCkJ"   "r"    
        "DvVLOOoAzvtHfAiUp H3fk4hXRpALiNBEHiIdhIuX2UCQQDCCHiPHFd4gC58yyCM"   "r"    
        "6Leqkmoa 6YpfRb3oxykLBXcWx7DtbX ayKy5OQmnkEG MW8XB8wAdiUl0/tb6cQ"   "r"    
        "FaRvAkBhvP94Hk0DMDinFVHlWYJ3xy4pongSA8vCyMj aSGtvjzjFnZXK4gIjBjA"   "r"    
        "2Z9ekDfIOBBawqp2DLdGuX2VXz8BAkByMuIh KBSv76cnEDwLhfLQJlKgEnvqTvX"   "r"    
        "TB0TUw8avlaBAXW34/5sI NUB1hmbgyTK/T/IFcEPXpBWLGO e3pAkAGWLpnH0Zh"   "r"    
        "Fae7oAqkMAd3xCNY6ec180tAe57hZ6kS SYLKwb4gGzYaCxc22vMtYksXHtUeamo"   "r"    
        "1NMLzI2ZfUoX"   "r";  

    /** 
     * 私钥 
     */  
    private RSAPrivateKey privateKey;  

    /** 
     * 公钥 
     */  
    private RSAPublicKey publicKey;  

    /** 
     * 字节数据转字符串专用集合 
     */  
    private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};  


    /** 
     * 获取私钥 
     * @return 当前的私钥对象 
     */  
    public RSAPrivateKey getPrivateKey() {  
        return privateKey;  
    }  

    /** 
     * 获取公钥 
     * @return 当前的公钥对象 
     */  
    public RSAPublicKey getPublicKey() {  
        return publicKey;  
    }  

    /** 
     * 随机生成密钥对 
     */  
    public void genKeyPair(){  
        KeyPairGenerator keyPairGen= null;  
        try {  
            keyPairGen= KeyPairGenerator.getInstance("RSA");  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        }  
        keyPairGen.initialize(1024, new SecureRandom());  
        KeyPair keyPair= keyPairGen.generateKeyPair();  
        this.privateKey= (RSAPrivateKey) keyPair.getPrivate();  
        this.publicKey= (RSAPublicKey) keyPair.getPublic();  
    }  

    /** 
     * 从文件中输入流中加载公钥 
     * @param in 公钥输入流 
     * @throws Exception 加载公钥时产生的异常 
     */  
    public void loadPublicKey(InputStream in) throws Exception{  
        try {  
            BufferedReader br= new BufferedReader(new InputStreamReader(in));  
            String readLine= null;  
            StringBuilder sb= new StringBuilder();  
            while((readLine= br.readLine())!=null){  
                if(readLine.charAt(0)=='-'){  
                    continue;  
                }else{  
                    sb.append(readLine);  
                    sb.append('r');  
                }  
            }  
            loadPublicKey(sb.toString());  
        } catch (IOException e) {  
            throw new Exception("公钥数据流读取错误");  
        } catch (NullPointerException e) {  
            throw new Exception("公钥输入流为空");  
        }  
    }  


    /** 
     * 从字符串中加载公钥 
     * @param publicKeyStr 公钥数据字符串 
     * @throws Exception 加载公钥时产生的异常 
     */  
    public void loadPublicKey(String publicKeyStr) throws Exception{  
        try {  
            BASE64Decoder base64Decoder= new BASE64Decoder();  
            byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
            KeyFactory keyFactory= KeyFactory.getInstance("RSA");  
            X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);  
            this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);  
        } catch (NoSuchAlgorithmException e) {  
            throw new Exception("无此算法");  
        } catch (InvalidKeySpecException e) {  
            throw new Exception("公钥非法");  
        } catch (IOException e) {  
            throw new Exception("公钥数据内容读取错误");  
        } catch (NullPointerException e) {  
            throw new Exception("公钥数据为空");  
        }  
    }  

    /** 
     * 从文件中加载私钥 
     * @param keyFileName 私钥文件名 
     * @return 是否成功 
     * @throws Exception  
     */  
    public void loadPrivateKey(InputStream in) throws Exception{  
        try {  
            BufferedReader br= new BufferedReader(new InputStreamReader(in));  
            String readLine= null;  
            StringBuilder sb= new StringBuilder();  
            while((readLine= br.readLine())!=null){  
                if(readLine.charAt(0)=='-'){  
                    continue;  
                }else{  
                    sb.append(readLine);  
                    sb.append('r');  
                }  
            }  
            loadPrivateKey(sb.toString());  
        } catch (IOException e) {  
            throw new Exception("私钥数据读取错误");  
        } catch (NullPointerException e) {  
            throw new Exception("私钥输入流为空");  
        }  
    }  

    public void loadPrivateKey(String privateKeyStr) throws Exception{  
        try {  
            BASE64Decoder base64Decoder= new BASE64Decoder();  
            byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);  
            PKCS8EncodedKeySpec keySpec= new PKCS8EncodedKeySpec(buffer);  
            KeyFactory keyFactory= KeyFactory.getInstance("RSA");  
            this.privateKey= (RSAPrivateKey) keyFactory.generatePrivate(keySpec);  
        } catch (NoSuchAlgorithmException e) {  
            throw new Exception("无此算法");  
        } catch (InvalidKeySpecException e) {  
         e.printStackTrace();
            throw new Exception("私钥非法");  
        } catch (IOException e) {  
            throw new Exception("私钥数据内容读取错误");  
        } catch (NullPointerException e) {  
            throw new Exception("私钥数据为空");  
        }  
    }  

    /** 
     * 加密过程 
     * @param publicKey 公钥 
     * @param plainTextData 明文数据 
     * @return 
     * @throws Exception 加密过程中的异常信息 
     */  
    public byte[] encrypt(RSAPublicKey publicKey, byte[] plainTextData) throws Exception{  
        if(publicKey== null){  
            throw new Exception("加密公钥为空, 请设置");  
        }  
        Cipher cipher= null;  
        try {  
            cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());  
            cipher.init(Cipher.ENCRYPT_MODE, publicKey);  
            byte[] output= cipher.doFinal(plainTextData);  
            return output;  
        } catch (NoSuchAlgorithmException e) {  
            throw new Exception("无此加密算法");  
        } catch (NoSuchPaddingException e) {  
            e.printStackTrace();  
            return null;  
        }catch (InvalidKeyException e) {  
            throw new Exception("加密公钥非法,请检查");  
        } catch (IllegalBlockSizeException e) {  
            throw new Exception("明文长度非法");  
        } catch (BadPaddingException e) {  
            throw new Exception("明文数据已损坏");  
        }  
    }  

    /** 
     * 解密过程 
     * @param privateKey 私钥 
     * @param cipherData 密文数据 
     * @return 明文 
     * @throws Exception 解密过程中的异常信息 
     */  
    public byte[] decrypt(RSAPrivateKey privateKey, byte[] cipherData) throws Exception{  
        if (privateKey== null){  
            throw new Exception("解密私钥为空, 请设置");  
        }  
        Cipher cipher= null;  
        try {  
            cipher= Cipher.getInstance("RSA");//, new BouncyCastleProvider());  
            cipher.init(Cipher.DECRYPT_MODE, privateKey);  
            byte[] output= cipher.doFinal(cipherData);  
            return output;  
        } catch (NoSuchAlgorithmException e) {  
            throw new Exception("无此解密算法");  
        } catch (NoSuchPaddingException e) {  
            e.printStackTrace();  
            return null;  
        }catch (InvalidKeyException e) {  
            throw new Exception("解密私钥非法,请检查");  
        } catch (IllegalBlockSizeException e) {  
            throw new Exception("密文长度非法");  
        } catch (BadPaddingException e) {  
            throw new Exception("密文数据已损坏");  
        }         
    }  


    /** 
     * 字节数据转十六进制字符串 
     * @param data 输入数据 
     * @return 十六进制内容 
     */  
    public static String byteArrayToString(byte[] data){  
        StringBuilder stringBuilder= new StringBuilder();  
        for (int i=0; i<data.length; i  ){  
            //取出字节的高四位 作为索引得到相应的十六进制标识符 注意无符号右移  
            stringBuilder.append(HEX_CHAR[(data[i] & 0xf0)>>> 4]);  
            //取出字节的低四位 作为索引得到相应的十六进制标识符  
            stringBuilder.append(HEX_CHAR[(data[i] & 0x0f)]);  
            if (i<data.length-1){  
                stringBuilder.append(' ');  
            }  
        }  
        return stringBuilder.toString();  
    }  


    public static void main(String[] args){  
        RSAEncrypt rsaEncrypt= new RSAEncrypt();  
        //rsaEncrypt.genKeyPair();  


        //加载公钥  
        try {  
            rsaEncrypt.loadPublicKey(RSAEncrypt.DEFAULT_PUBLIC_KEY);  
            System.out.println("加载公钥成功");  
        } catch (Exception e) {  
            System.err.println(e.getMessage());  
            System.err.println("加载公钥失败");  
        }  

        //加载私钥  
        try {  
            rsaEncrypt.loadPrivateKey(RSAEncrypt.DEFAULT_PRIVATE_KEY);  
            System.out.println("加载私钥成功");  
        } catch (Exception e) {  
            System.err.println(e.getMessage());  
            System.err.println("加载私钥失败");  
        }  

        //测试字符串  
        String encryptStr= "abc";  
        System.out.println("私钥长度:" rsaEncrypt.getPrivateKey().toString().length());
        System.out.println("公钥长度:" rsaEncrypt.getPublicKey().toString().length());
        try {  
            //加密  
            byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());  


            //解密  
            byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);  



            System.out.println("密文长度:"  cipher.length);  
            System.out.println(RSAEncrypt.byteArrayToString(cipher));  
            System.out.println("明文长度:"  plainText.length);  
            System.out.println(RSAEncrypt.byteArrayToString(plainText));  
            System.out.println(new String(plainText));  
        } catch (Exception e) {  
            System.err.println(e.getMessage());  
        }  
    }
}

提供两种方式加载密钥对,可通过字符串或者文件流,文件是指生成的.pem文件才可以哦。 另外附一份IOS中加密方法,不过这里要求的文件是der。 http://blog.yorkgu.me/2011/10/27/rsa-in-ios-using-publick-key-generated-by-openssl/ IOS中加密后返回的NSdata对象,可以对NSdata对象进行base64编码转换成字符串,然后java用BASE64Decoder解码之后,就转换成了byte[],可直接用上面方法解密。。。

http://www.bkjia.com/IOSjc/920406.htmlwww.bkjia.comtruehttp://www.bkjia.com/IOSjc/920406.htmlTechArticlejava与IOS之间的RSA加解密,javaiosrsa解密 很简单的一个需求,ipad端给密码RSA加密,传到java后台,解密。RSA加密算法是基于一个密钥对的,分...

系统:Ubuntu 14.04

软件:openssl java php

生成公钥私钥

使用命令生成私钥:

openssl genrsa -out rsa_private_key.pem 1024

参数:genrsa 生成密钥  -out 输出到文件  rsa_private_key.pem 文件名  1024 长度

从私钥中提取公钥:

openssl rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem

参数: rsa 提取公钥  -in 从文件中读入  rsa_private_key.pem 文件名  -pubout  输出  -out 到文件  rsa_public_key.pem  文件名

shell加解密

新建一个readme.txt 内容是taoshihan

使用公钥加密:

openssl rsautl -encrypt -in readme.txt -inkey rsa_public_key.pem -pubin -out hello.en 

参数: rsautl 加解密  -encrypt 加密  -in 从文件输入  readme.txt 文件名  -inkey  输入的密钥  rsa_public_key.pem  上一步生成的公钥  -pubin 表名输入是公钥文件  -out输出到文件  hello.en 输出文件名

使用私钥解密:

openssl rsautl -decrypt -in hello.en -inkey rsa_private_key.pem -out hello.de

参数: -decrypt 解密  -in 从文件输入 hello.en 上一步生成的加密文件  -inkey 输入的密钥 rsa_private_key.pem 上一步生成的私钥  -out输出到文件  hello.de 输出的文件名

cat hello.de // taoshihan

php加解密

$profile="taoshihan";
echo "加密前:{$profile}n";
//公钥加密
$public_key=file_get_contents("rsa_public_key.pem");
$pub_key = openssl_pkey_get_public($public_key);
openssl_public_encrypt($profile,$encrypted,$pub_key);
$encrypted=base64_encode($encrypted);//因为加密后是乱码,所以base64一下
echo "加密后:n";
echo $encrypted."n";

//私钥解密
$private_key=file_get_contents("rsa_private_key.pem");
$pi_key =  openssl_pkey_get_private($private_key);
openssl_private_decrypt(base64_decode($encrypted),$decrypted,$pi_key);
echo "解密后:n";
echo $decrypted."n";

新建rsa.php的文件

执行后结果:

加密前:taoshihan

加密后:

ShjsdlTceurVfO0ocENqHGl9RXrQRm3vuprqchhuVOdX1ldJC2O2sIvjjpQfPWOkF1WA tqdyIl9YJQ0/2DqAp4zaqI1TCNsXduGn2iUZQ88g7B5eSI7r/iWKcX527pLe95EBvFMw/D65tlYscI5RClcp3KrOw2fqDQZ3D3nKAI=

解密后:

taoshihan

java加解密:

准备jar包 bcprov-ext-jdk15on-156.jar

文件到Linux公社资源站下载:

------------------------------------------分割线------------------------------------------

免费下载地址在 http://linux.linuxidc.com/

用户名与密码都是www.linuxidc.com

具体下载目录在 /2017年资料/1月/22日/Linux下使用OpenSSL实现RSA非对称加密/

下载方法见 http://www.linuxidc.com/Linux/2013-07/87684.htm

------------------------------------------分割线------------------------------------------

RSAEncrypt.java 文件

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.FileInputStream; 
import java.io.FileOutputStream;
import java.security.InvalidKeyException;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.security.KeyFactory;
import java.security.interfaces.RSAPrivateKey;
import java.security.spec.RSAPrivateKeySpec;

import org.bouncycastle.asn1.ASN1Sequence;
import org.bouncycastle.asn1.pkcs.RSAPrivateKeyStructure;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;

import org.bouncycastle.jce.provider.BouncyCastleProvider;

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

public class RSAEncrypt {
    /**
    * 私钥
    */
    private RSAPrivateKey privateKey;

    /**
    * 公钥
    */
    private RSAPublicKey publicKey;
   
    /**
    * 字节数据转字符串专用集合
    */
    private static final char[] HEX_CHAR= {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};    

    /**
    * 获取私钥
    * @return 当前的私钥对象
    */
    public RSAPrivateKey getPrivateKey() {
        return privateKey;
    }

    /**
    * 获取公钥
    * @return 当前的公钥对象
    */
    public RSAPublicKey getPublicKey() {
        return publicKey;
    }

    /**
    * 随机生成密钥对
    */
    public void genKeyPair(){
        KeyPairGenerator keyPairGen= null;
        try {
            keyPairGen= KeyPairGenerator.getInstance("RSA");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        keyPairGen.initialize(1024, new SecureRandom());
        KeyPair keyPair= keyPairGen.generateKeyPair();
        this.privateKey= (RSAPrivateKey) keyPair.getPrivate();
        this.publicKey= (RSAPublicKey) keyPair.getPublic();
    }

    /**
    * 从文件中输入流中加载公钥
    * @param in 公钥输入流
    * @throws Exception 加载公钥时产生的异常
    */
    public void loadPublicKey(InputStream in) throws Exception{
        try {
            BufferedReader br= new BufferedReader(new InputStreamReader(in));
            String readLine= null;
            StringBuilder sb= new StringBuilder();
            while((readLine= br.readLine())!=null){
                if(readLine.charAt(0)=='-'){
                    continue;
                }else{
                    sb.append(readLine);
                    sb.append('r');
                }
            }
            loadPublicKey(sb.toString());
        } catch (IOException e) {
            throw new Exception("公钥数据流读取错误");
        } catch (NullPointerException e) {
            throw new Exception("公钥输入流为空");
        }
    }

    /**
    * 从字符串中加载公钥
    * @param publicKeyStr 公钥数据字符串
    * @throws Exception 加载公钥时产生的异常
    */
    public void loadPublicKey(String publicKeyStr) throws Exception{
        try {
            BASE64Decoder base64Decoder= new BASE64Decoder();
            byte[] buffer= base64Decoder.decodeBuffer(publicKeyStr);
            KeyFactory keyFactory= KeyFactory.getInstance("RSA");
            X509EncodedKeySpec keySpec= new X509EncodedKeySpec(buffer);
            this.publicKey= (RSAPublicKey) keyFactory.generatePublic(keySpec);
        } catch (NoSuchAlgorithmException e) {
            throw new Exception("无此算法");
        } catch (InvalidKeySpecException e) {
            throw new Exception("公钥非法");
        } catch (IOException e) {
            throw new Exception("公钥数据内容读取错误");
        } catch (NullPointerException e) {
            throw new Exception("公钥数据为空");
        }
    }

    /**
    * 从文件中加载私钥
    * @param keyFileName 私钥文件名
    * @return 是否成功
    * @throws Exception
    */
    public void loadPrivateKey(InputStream in) throws Exception{
        try {
            BufferedReader br= new BufferedReader(new InputStreamReader(in));
            String readLine= null;
            StringBuilder sb= new StringBuilder();
            while((readLine= br.readLine())!=null){
                if(readLine.charAt(0)=='-'){
                    continue;
                }else{
                    sb.append(readLine);
                    sb.append('r');
                }
            }
            loadPrivateKey(sb.toString());
        } catch (IOException e) {
            throw new Exception("私钥数据读取错误");
        } catch (NullPointerException e) {
            throw new Exception("私钥输入流为空");
        }
    }

    public void loadPrivateKey(String privateKeyStr) throws Exception{
        try {
            BASE64Decoder base64Decoder= new BASE64Decoder();
            byte[] buffer= base64Decoder.decodeBuffer(privateKeyStr);

            RSAPrivateKeyStructure asn1PrivKey = new RSAPrivateKeyStructure((ASN1Sequence) ASN1Sequence.fromByteArray(buffer));
            RSAPrivateKeySpec rsaPrivKeySpec = new RSAPrivateKeySpec(asn1PrivKey.getModulus(), asn1PrivKey.getPrivateExponent());
            KeyFactory keyFactory= KeyFactory.getInstance("RSA");
            RSAPrivateKey  priKey=(RSAPrivateKey) keyFactory.generatePrivate(rsaPrivKeySpec);
            this.privateKey=priKey;

本文由永利电子游戏网站发布于计算机教程,转载请注明出处:Linux下使用OpenSSL实现RSA非对称加密【永利电子游

关键词: