安科网

Linux下使用OpenSSL实现RSA非对称加密

hazing

hazing

2017-01-22

关注 关注

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

系统: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

文件到安科网资源站下载：

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

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

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

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;

            // 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) {
            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/ECB/PKCS1Padding", 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/ECB/PKCS1Padding", 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();
        //加载公钥
        try {
            rsaEncrypt.loadPublicKey(new FileInputStream("rsa_public_key.pem"));
            System.out.println("加载公钥成功");
        } catch (Exception e) {
            System.err.println(e.getMessage());
            System.err.println("加载公钥失败");
        }

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

        //测试字符串
        String encryptStr= "taoshihan";
        System.out.println("加密前:");
        System.out.println(encryptStr);
        try {
            //加密
            byte[] cipher = rsaEncrypt.encrypt(rsaEncrypt.getPublicKey(), encryptStr.getBytes());
            //解密
            byte[] plainText = rsaEncrypt.decrypt(rsaEncrypt.getPrivateKey(), cipher);
            BASE64Encoder encode = new BASE64Encoder();
            String buffer= encode.encode(cipher);
            System.out.println("加密后:");
            System.out.println(new String(buffer));
            System.out.println("解密后:");
            System.out.println(new String(plainText));
        } catch (Exception e) {
            System.err.println(e.getMessage());
        }
    }
}

带包编译和执行

javac -cp bcprov-ext-jdk15on-156.jar RSAEncrypt.java

java -cp .:bcprov-ext-jdk15on-156.jar RSAEncrypt


执行结果:

加载公钥成功

加载私钥成功

加密前:

taoshihan

加密后:

Tt1p5XnamZkkVjGn1cVgEIb7U+CP27Xw93JQQUZyc2Up/rJL4Mx+dA8mxkva1a/I64sUTb7QD//8

gbss4bZY/DHrLityTt2/QjjQUFYD5/Aa1m1QKUBulWY4/C5so5dm6wrRnjolsIFUbY+RfH4B6hp1

taQGBRDum/xEX6OsJ9I=

解密后:

taoshihan

shell使用公钥加密,php使用私钥解密

shell:

openssl rsautl -encrypt -in readme.txt -inkey rsa_public_key.pem -pubin|base64

加密后的字符串

lNJ50ODiofcp+adrtAI943HOsjdDTg3UMfUkt0NI7DhUjxCM+NAlBH08WVQRtYK9W8ZoQOta3QH6

PzmJT4WsI0yfNGiUWYgoYgSOtPURSQMbaCt3DM2Y5mEKqzbKLrhN+S+9Jrtmef1VuBUes8wN6rOD

UHxI+vDwQ+utRJRRo9U=

php:

<?php
$encrypted="lNJ50ODiofcp+adrtAI943HOsjdDTg3UMfUkt0NI7DhUjxCM+NAlBH08WVQRtYK9W8ZoQOta3QH6
PzmJT4WsI0yfNGiUWYgoYgSOtPURSQMbaCt3DM2Y5mEKqzbKLrhN+S+9Jrtmef1VuBUes8wN6rOD
UHxI+vDwQ+utRJRRo9U=";
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";

执行结果:

lNJ50ODiofcp+adrtAI943HOsjdDTg3UMfUkt0NI7DhUjxCM+NAlBH08WVQRtYK9W8ZoQOta3QH6
PzmJT4WsI0yfNGiUWYgoYgSOtPURSQMbaCt3DM2Y5mEKqzbKLrhN+S+9Jrtmef1VuBUes8wN6rOD
UHxI+vDwQ+utRJRRo9U=
解密后:
taoshihan

java使用公钥加密,php解密:

拿上一步java生成的加密后字符串

<?php
$encrypted="Tt1p5XnamZkkVjGn1cVgEIb7U+CP27Xw93JQQUZyc2Up/rJL4Mx+dA8mxkva1a/I64sUTb7QD//8
gbss4bZY/DHrLityTt2/QjjQUFYD5/Aa1m1QKUBulWY4/C5so5dm6wrRnjolsIFUbY+RfH4B6hp1
taQGBRDum/xEX6OsJ9I=";
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";

执行结果:

Tt1p5XnamZkkVjGn1cVgEIb7U+CP27Xw93JQQUZyc2Up/rJL4Mx+dA8mxkva1a/I64sUTb7QD//8

gbss4bZY/DHrLityTt2/QjjQUFYD5/Aa1m1QKUBulWY4/C5so5dm6wrRnjolsIFUbY+RfH4B6hp1

taQGBRDum/xEX6OsJ9I=

解密后:

taoshihan

更多OpenSSL相关内容可以查看以下的有用链接： 

OpenSSL 的详细介绍：请点这里
OpenSSL 的下载地址：请点这里

rsa 非对称加密 openssl linux系统

hazing

hazing

0 关注 0 粉丝 0 动态

关注 关注

相关推荐

python使用rsa非对称加密

# a. lemon_pub为PublicKey对象, lemon_priv为PrivateKey对象。# b. 512为秘钥的位数, 可以自定义指定, 例如: 128、256、512、1024、2048等。cryto_info = rsa.encrypt

taiyangshenniao 2019-12-26

PHP非对称加密

在日常设计及开发中，为确保数据传输和数据存储的安全，可通过特定的算法，将数据明文加密成复杂的密文。目前主流加密手段大致可分为单向加密和双向加密。非对称加密需要公开密钥和私有密钥两组密钥，公开密钥和私有密钥是配对起来的，也就是说使用公开密钥进行数据加密，只有

Nicolase 2019-11-06

iOS中使用RSA对数据进行加密解密

RSA算法是一种非对称加密算法,常被用于加密数据传输.如果配合上数字摘要算法, 也可以用于文件签名.本文将讨论如何在iOS中使用RSA传输加密数据.openssl-1.0.1j, openssl需要使用1.x版本, 推荐使用[homebrew]安装.iOS

风随花落 2015-01-02

使用Python的OpenSSL库来进行RSA加密

使用Python的OpenSSL库可以很便捷地对数据进行RSA的加密，方法如下：。openssl genrsa -out private.pem -f4 1024 #生成私钥，指数值为10001. d=sign#d为经过SHA1算法进行摘要、使用私钥进行签

helen0 2012-05-01

Python中使用rsa加密

后记: 通常使用中, 会先对数据进行bas64加密, 再对加密后的内容使用rsa加密, 最后对rsa解密后的内容

sulindong0 2020-07-04

一台电脑如何使用多个git账号？

git相信大家都在用，一般公司有一个账号，放公司自己架的服务器中，员工自己还有一个github或者gitee的账号，存放自己的一些私有代码。本篇文章总结一下，本人在公司开发机上，使用多个git账号的干货，有需要的可以参考参考，避免采坑。将以前设置的glob

hulao 2020-06-12

多个ssh key 配置多个网址

多个 ssh key 配置多个网站。ssh-keygen -t rsa -C "你的邮箱" -f ~/.ssh/id_rsa_one. # 不添加-f 参数 会默认将私钥保存在~/.ssh/id_rsa. Port 22 # ssh

STchaoL 2020-06-04

python RSA加密，字节格式和base64编码格式

return crypt_text # 返回的是字节。lase_text = rsa.decrypt.decode() # 注意，这里如果结果是bytes类型，就需要进行decode()转化为str. #create_keys() # 生成公钥和私钥

逍遥友 2020-06-02

python 实现RSA公钥加密，私钥解密

from Crypto.Cipher import PKCS1_v1_5 as Cipher_pkcs1_v1_5. cipher_text = base64.b64encode(cipher.encrypt(message.encode())).deco

singer 2020-05-30

python实现爱奇艺登陆的密码RSA加密

加企鹅群695185429即可免费获取，资料全在群文件里。资料可以领取包括不限于Python实战演练、PDF电子文档、面试集锦、学习资料等。本期，笔者通过Python实现对大麦网近期全国演唱会数据进行爬取，通过分析，我们发现大麦网属于Python爬虫策略中

dailinqing 2020-05-26

Python实现常见的几种加密算法(MD5，SHA-1，HMAC，DES/AES，RSA和ECC)

生活中我们经常会遇到一些加密算法，今天我们就聊聊这些加密算法的Python实现。部分常用的加密方法基本都有对应的Python库，基本不再需要我们用代码实现具体算法。md5加密算法是不可逆的，所以解密一般都是通过暴力穷举方法，通过网站的接口实现解密。对于长度

yuanran0 2020-05-09

python rsa加解密

encryptd_msg = rsa.encrypt(msg.encode(), public_key). encryptd_msg_str = base64.b64encode(encryptd_msg).decode(). msg = rsa.decr

LULUBAO 2020-05-05

GitLab配置ssh key

cd ~/.sshls查看公钥：cat id_rsa.pub 或者vim id_rsa.pub. 获取到的那一大段，就是我们需要的ssh key，复制下来,包括前面和后面的，给到下图配置，即可完成GitLab配置ssh key. 在个人中心的prof

happyfreeangel 2020-04-26

VUE内使用RSA加解密

前后端统一使用公钥加密，私钥解密

前端学习笔记 2020-04-20

Git 如何配置做个ssh-key

first_rsa为自己定义的密钥存储文件。修改.ssh/下的config文件：。以上为自己Windows系统的配置过程

风吹草动 2020-03-26

linux 或者windows 设置git的ssh

ssh-rsa ……………………复制公钥的内容，粘贴到github。The authenticity of host ‘github.com ‘ can‘t be established.Are you sure you want to continue

BraveWangDev 2020-03-08

RSA加密算法

周五在上c语言课的时候，有幸接触了著名的rsa加密算法。rsa算法作为目前最有影响力的公钥加密算法，它能够抵抗到目前为止已知的绝大多数密码攻击，已被ISO推荐为公钥数据加密标准。回寝室后我感觉这种算法很有趣并且以我们目前的学习进度可以进行编写，便进行了尝试

rein0 2020-01-29

支付宝接口

tab=info. '. '

cindycinderella 2020-01-14

Python使用rsa模块实现非对称加密与解密

RSA加密算法是一种非对称加密算法 是由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制。加密密钥PK是公开信息，而解密密钥SK是需要保密的。RSA密钥至少为500位长，一般推荐使用1024位。RSA密钥长度随着保密级别提高，增加很快。由于RSA的特

magicandy 2020-01-02

Linux系统ssh远程免密登录

　　在Linux运行过程中，有些特殊情况需要让不同Linux主机之间进行SSH免密登录，直观来看是免密登录，确切的说是通过秘钥验证登录。私钥用来解密，放置在A主机本地，公钥用来加密，放置在远端B主机。在A主机执行命令ssh-keygen -b 1024 -

mmyCSDN 2020-01-06
hazing

hazing

W3CSchool教程
HTML 教程
CSS 教程
Bootstrap 教程
Javascript 教程
jQuery 教程
后端教程
C 教程
Java 教程
PHP 教程
Python 教程
Go 教程
移动开发
Android 教程
Swift 教程
Kotlin 教程
jQuery Mobile 教程
ionic 教程
关于我们
新闻动态
联系方式
招聘英才
安科实验室
帮助与反馈

安科网(Ancii)，中国第一极客网

Copyright © 2013 - 2019 Ancii.com

京ICP备18063983号 京公网安备11010802014868号