linux下Openssl RSA加密解密实例

合集下载

linu中aes对字段加密解密方法

linu中aes对字段加密解密方法

linu中aes对字段加密解密方法
在Linux中,你可以使用OpenSSL库来实现AES加密和解密。

下面是一个简单的示例,演示了如何使用OpenSSL进行AES加密和解密。

首先,确保你已经安装了OpenSSL库。

在大多数Linux发行版中,你可以使用包管理器来安装它。

例如,在Ubuntu上,你可以使用以下命令安装OpenSSL:
```shell
sudo apt-get install openssl
```
接下来,你可以使用以下命令进行AES加密和解密:
加密:
```shell
echo "待加密的文本" openssl enc -aes-256-cbc -salt -in /dev/stdin -out
```
解密:
```shell
openssl enc -d -aes-256-cbc -in -out
```
这些命令使用AES-256-CBC加密算法,你可以根据需要选择其他加密算法。

在加密命令中,`-salt`选项用于添加盐值,以提高安全性。

`-in /dev/stdin`选项指定输入来自标准输入,`-out `选项指定输出到名为``的文件中。

解密命令与加密命令类似,只是不需要`-salt`选项。

`-d`选项表示解密操作。

解密命令会将加密的输出文件(``)解密为明文输出到名为``的文件中。

请注意,这只是一个简单的示例,你可以根据实际需求进行更多的定制和配置。

还可以查看OpenSSL的文档以获取更多关于AES加密和解密的详细信息。

openssl rsa 用法

openssl rsa 用法

OpenSSL RSA 用法简介OpenSSL 是一个强大且广泛使用的开源加密工具包,提供了一系列密码学功能,包括对 RSA 加密算法的支持。

RSA 是一种非对称加密算法,可以用于生成和管理公钥和私钥对,以及进行加密和解密操作。

本文将详细介绍 OpenSSL 中 RSA 的用法,包括生成 RSA 密钥对、加密和解密数据、签名和验证等操作。

安装 OpenSSL在开始使用 OpenSSL RSA 命令之前,需先安装 OpenSSL 工具包。

具体安装步骤如下:1.在 Linux 系统上,可以通过包管理器直接安装 OpenSSL。

例如,在 Ubuntu上可以使用以下命令进行安装:sudo apt-get install openssl2.在 Windows 系统上,可以从 OpenSSL 官方网站()下载预编译的二进制文件,并按照提示进行安装。

生成 RSA 密钥对要使用 RSA 加密算法,首先需要生成 RSA 密钥对。

RSA 密钥由一个公钥和一个私钥组成,其中公钥可用于加密数据,私钥可用于解密数据。

以下是使用 OpenSSL 生成 RSA 密钥对的步骤:1.打开终端或命令提示符,并执行以下命令:openssl genrsa -out private.pem 2048上述命令将生成一个 2048 位的 RSA 私钥,并保存到名为private.pem的文件中。

2.接下来,可以通过以下命令从私钥中导出公钥:openssl rsa -in private.pem -pubout -out public.pem上述命令将从private.pem文件中读取私钥,并将对应的公钥导出到名为public.pem的文件中。

现在,你已经成功生成了一个 RSA 密钥对,私钥保存在private.pem文件中,公钥保存在public.pem文件中。

加密和解密数据使用 OpenSSL RSA 加密和解密数据非常简单。

以下是使用 OpenSSL 进行 RSA 加密和解密的步骤:1.首先,创建一个文本文件(例如plaintext.txt),并输入要加密的数据。

在Linux上使用Shell脚本实现文件加密与解密

在Linux上使用Shell脚本实现文件加密与解密

在Linux上使用Shell脚本实现文件加密与解密在计算机的日常使用中,文件的安全性和隐私保护是非常重要的。

为了保护文件的机密性,我们可以使用加密技术来对文件进行加密和解密。

在Linux操作系统上,我们可以使用Shell脚本来实现文件的加密和解密功能。

本文将介绍在Linux上使用Shell脚本实现文件加密与解密的方法。

一、文件加密在Linux中,我们可以使用openssl命令来进行文件的加密。

openssl 是一个开源的加密工具包,它提供了各种加密算法和加密函数。

下面是一个使用openssl命令进行文件加密的示例Shell脚本:```bash#!/bin/bash# 获取要加密的文件名read -p "请输入要加密的文件名:" filename# 生成随机的加密密码password=$(openssl rand -base64 32)# 加密文件openssl enc -aes-256-cbc -salt -in $filename -out $filename.enc -pass pass:$passwordecho "文件加密成功!加密密码已保存在password.txt文件中。

"# 将加密密码保存到文件中echo $password > password.txt```在以上示例中,首先通过read命令获取用户输入的要加密的文件名,然后使用openssl rand命令生成一个随机的加密密码。

接下来,使用openssl enc命令对文件进行加密,加密算法使用的是aes-256-cbc,加密后的文件保存为原文件名加上.enc后缀。

最后,将生成的加密密码保存在password.txt文件中。

二、文件解密对于加密后的文件,我们可以使用相同的加密密码来进行解密。

下面是一个使用openssl命令进行文件解密的示例Shell脚本:```bash#!/bin/bash# 获取要解密的文件名read -p "请输入要解密的文件名:" filename# 获取加密密码password=$(cat password.txt)# 解密文件openssl enc -d -aes-256-cbc -in $filename -out $filename.dec -pass pass:$passwordecho "文件解密成功!解密后的文件保存为$filename.dec。

openssl 公钥和私钥 用法

openssl 公钥和私钥 用法

openssl 公钥和私钥用法OpenSSL 是一个用于安全通信的开源工具包,它支持多种加密算法,包括公钥和私钥加密。

在本文中,我们将重点讨论OpenSSL 中公钥和私钥的用法。

在使用OpenSSL 进行公钥和私钥加密之前,首先需要生成一对密钥。

生成密钥对的命令如下所示:openssl genpkey -algorithm RSA -out private_key.pemopenssl rsa -in private_key.pem -out public_key.pem -pubout以上命令将生成一个私钥文件private_key.pem 和一个对应的公钥文件public_key.pem。

在生成密钥对之后,可以使用这对密钥进行加密和解密操作。

公钥通常用于加密数据,而私钥则用于解密数据。

接下来,我们将介绍如何使用OpenSSL 进行公钥加密和私钥解密操作。

首先,我们需要准备要加密的数据文件,假设为input.txt,将其加密为output.enc 文件,命令如下所示:openssl rsautl -encrypt -pubin -inkey public_key.pem -in input.txt -outoutput.enc以上命令将使用公钥文件public_key.pem 对input.txt 文件进行加密,并将结果输出到output.enc 文件中。

接下来,我们用私钥解密output.enc 文件,命令如下所示:openssl rsautl -decrypt -inkey private_key.pem -in output.enc -out decrypted_output.txt以上命令将使用私钥文件private_key.pem 对output.enc 文件进行解密,并将结果输出到decrypted_output.txt 文件中。

这样,我们就完成了使用OpenSSL 进行公钥加密和私钥解密的操作。

rsa加密算法详解及例题

rsa加密算法详解及例题

RSA加密算法详解及例题
RSA加密算法是一种非对称加密算法,其安全性基于对极大整数做因数分解的困难性。

以下是RSA加密算法的详解及例题:
1. 密钥生成:
* 随机选择两个质数P和Q,越大越安全。

* 计算它们的乘积N=P*Q。

* 计算欧拉函数φ(N)=(P-1)*(Q-1)。

* 随机选择一个整数E,条件是1<E<φ(N),且E与φ(N)互质。

* 计算E对于φ(N)的模反元素D,使得EDmodφ(N)=1,即D=E-1modφ(N)。

* 公钥为(E, N),私钥为(D, N)。

2. 加解密过程:
* 加密:明文M进行加密后得到密文C,计算公式为C=MemodN。

* 解密:将密文C进行解密后得到明文M,计算公式为M=CdmodN。

例题:在RSA加密体制中,已知素数P=7,Q=11,公钥E=13,试计算私钥D并给出对明文M=5的加密,求其密文。

解:首先,根据上述算法进行密钥生成。

根据素数P和Q得到N=77。

计算φ(N)=60。

因为E小于φ(N)且与φ(N)互质,选择E=13作为公钥。

根据公式计算D模反元素得到D=7。

现在有公钥(E, N)=(13, 77)和私钥(D, N)=(7, 77)。

接下来,用公钥加密明文M=5得到密文C=5^13mod77=15。

所以,密文为15。

此例题仅展示了RSA加密算法的基本原理和步骤,实际应用中需要考虑更多安全因素和操作细节。

openssl编程 示例

openssl编程 示例

openssl编程示例以OpenSSL编程示例为标题的文章是关于如何使用OpenSSL库进行编程的。

OpenSSL是一个开源的加密工具包,提供了许多密码学功能,如加密、解密、签名和验证等。

在本文中,我将介绍OpenSSL 库的基本使用方法,并提供一些编程示例来帮助读者更好地理解。

OpenSSL是一个功能强大且广泛使用的加密库,可以用于开发各种应用程序,包括网络安全、数据传输和身份验证等。

它支持许多密码学算法,如对称加密算法(如AES和DES)、非对称加密算法(如RSA和ECC)以及哈希函数(如MD5和SHA-256)等。

在开始使用OpenSSL之前,我们需要安装OpenSSL库并配置开发环境。

安装OpenSSL库的具体方法因操作系统而异,可以在OpenSSL 官方网站上找到相关的安装指南。

配置开发环境主要包括设置编译器参数和链接库文件等。

一旦环境配置完成,我们就可以开始使用OpenSSL库进行编程了。

下面是一些常用的OpenSSL编程示例:1. 生成密钥对使用OpenSSL库生成非对称加密算法所需的密钥对是一个常见的操作。

以下是一个生成RSA密钥对的示例代码:```c#include <openssl/rsa.h>int main() {RSA* rsa = RSA_generate_key(2048, RSA_F4, NULL, NULL);if (rsa == NULL) {printf("Failed to generate RSA key pair\n");return -1;}// 打印公钥和私钥printf("Public Key:\n%s\n", BN_bn2hex(rsa->n));printf("Private Key:\n%s\n", BN_bn2hex(rsa->d));RSA_free(rsa);return 0;}```2. 加密和解密数据使用OpenSSL库进行数据加密和解密是保护数据安全的常见操作。

Linux命令行下的文件加密和解密技巧

Linux命令行下的文件加密和解密技巧

Linux命令行下的文件加密和解密技巧Linux操作系统提供了强大的命令行工具,使得文件的加密和解密操作变得相对简单和高效。

本文将介绍在Linux命令行下实现文件加密和解密的技巧。

以下是具体内容:一、加密文件1. 使用 OpenSSL 加密文件OpenSSL 是一个强大的开源加密工具包,可以用于加密和解密文件。

要使用 OpenSSL 加密文件,请按照以下步骤操作:(1)打开终端窗口,并导航到要加密的文件所在的目录。

(2)运行以下命令,用于将文件加密,并生成加密后的文件:openssl enc -aes-256-cbc -salt -in 文件名 -out 加密后的文件名其中,-aes-256-cbc 是指使用 AES 256 位加密算法和 CBC 模式进行加密。

您还可以选择其他的加密算法和模式,根据您的具体需求进行调整。

2. 使用 GPG 加密文件GPG(GNU Privacy Guard)是一个开源的加密软件,用于进行文件和文本的加密和解密。

要使用 GPG 加密文件,请按照以下步骤操作:(1)确保您已经安装了 GPG 工具包。

如果没有安装,可以运行以下命令进行安装:sudo apt-get install gnupg(2)打开终端窗口,并导航到要加密的文件所在的目录。

(3)运行以下命令,用于将文件加密,并生成加密后的文件:gpg -c 文件名运行该命令后,系统会提示您输入一个加密密码。

请确保密码的安全性,同时请牢记该密码,因为解密文件时需要使用该密码。

二、解密文件1. 使用 OpenSSL 解密文件要使用 OpenSSL 解密文件,请按照以下步骤操作:(1)打开终端窗口,并导航到要解密的文件所在的目录。

(2)运行以下命令,用于将加密文件解密,并生成解密后的文件: openssl enc -d -aes-256-cbc -in 加密后的文件名 -out 解密后的文件名在运行该命令时,您需要提供正确的加密算法和模式,以确保成功解密文件。

RSA加解密私钥加密公钥解密私加公解C++调用openssl库的代码实例

RSA加解密私钥加密公钥解密私加公解C++调用openssl库的代码实例

RSA加解密私钥加密公钥解密私加公解C++调⽤openssl库的代码实例前提:秘钥长度=1024============================================== 对⼀⽚(117字节)明⽂加密私加==============================================// 私钥加密std::string rsa_pri_encrypt(const std::string &clearText, std::string &pubKey){std::string strRet;BIO *keybio = BIO_new_mem_buf((unsigned char *)pubKey.c_str(), -1);// 此处有三种⽅法// 1, 读取内存⾥⽣成的密钥对,再从内存⽣成rsa// 2, 读取磁盘⾥⽣成的密钥对⽂本⽂件,在从内存⽣成rsa// 3,直接从读取⽂件指针⽣成rsa//RSA* pRSAPublicKey = RSA_new();RSA* rsa = RSA_new();rsa = PEM_read_bio_RSAPrivateKey(keybio, &rsa, NULL, NULL);if (!rsa){BIO_free_all(keybio);return std::string("");}int len = RSA_size(rsa);//int len = 1028;char *encryptedText = (char *)malloc(len + 1);memset(encryptedText, 0, len + 1);// 加密int ret = RSA_private_encrypt(clearText.length(), (const unsigned char*)clearText.c_str(), (unsigned char*)encryptedText, rsa, RSA_PKCS1_PADDING);if (ret >= 0)strRet = std::string(encryptedText, ret);// 释放内存free(encryptedText);BIO_free_all(keybio);RSA_free(rsa);return strRet;}============================================== 对⼀⽚(128字节)密⽂解密公解==============================================// 公钥解密std::string rsa_pub_decrypt(const std::string &clearText, std::string &pubKey){std::string strRet;BIO *keybio = BIO_new_mem_buf((unsigned char *)pubKey.c_str(), -1);//keybio = BIO_new_mem_buf((unsigned char *)strPublicKey.c_str(), -1);// 此处有三种⽅法// 1, 读取内存⾥⽣成的密钥对,再从内存⽣成rsa// 2, 读取磁盘⾥⽣成的密钥对⽂本⽂件,在从内存⽣成rsa// 3,直接从读取⽂件指针⽣成rsa//RSA* pRSAPublicKey = RSA_new();RSA* rsa = RSA_new();rsa = PEM_read_bio_RSAPublicKey(keybio, &rsa, NULL, NULL);if (!rsa){BIO_free_all(keybio);return std::string("");}int len = RSA_size(rsa);//int len = 1028;char *encryptedText = (char *)malloc(len + 1);memset(encryptedText, 0, len + 1);//解密int ret = RSA_public_decrypt(clearText.length(), (const unsigned char*)clearText.c_str(), (unsigned char*)encryptedText, rsa, RSA_PKCS1_PADDING);if (ret >= 0)strRet = std::string(encryptedText, ret);// 释放内存free(encryptedText);BIO_free_all(keybio);RSA_free(rsa);return strRet;}============================================== 对整体明⽂加密私加==============================================//私钥加密 + 分⽚std::string rsa_pri_split117_encrypt(const std::string &clearText, std::string &pubKey) {std::string result;std::string input;result.clear();for(int i = 0 ; i < clearText.length()/117; i++){input.clear();input.assign(clearText.begin() + i*117, clearText.begin() + i*117 + 117);result = result + rsa_pri_encrypt(input, pubKey);}if( clearText.length()%117 != 0){int tem1 = clearText.length()/117*117;int tem2 = clearText.length() - tem1;input.clear();input.assign(clearText.begin()+ tem1, clearText.end());result = result + rsa_pri_encrypt(input, pubKey);}return result;}============================================== 对整体密⽂解密公解==============================================//公钥解密 + 分⽚std::string rsa_pub_split128_decrypt(const std::string &clearText, std::string &pubKey) {//Base64 *base = new Base64();std::string result;std::string input;result.clear();for(int i = 0 ; i< clearText.length()/128; i++){input.clear();input.assign(clearText.begin() + i*128, clearText.begin() + i*128 + 128);result = result + rsa_pub_decrypt(input, pubKey);}if(clearText.length()%128 != 0){int tem1 = clearText.length()/128 * 128;int tem2 = clearText.length() - tem1;input.clear();input.assign(clearText.begin()+ tem1, clearText.end());result = result + rsa_pri_encrypt(input, pubKey);}return result;}附1:附2:。

简单的rsa加密解密计算

简单的rsa加密解密计算

简单的rsa加密解密计算
RSA加密算法是一种非对称加密算法,它使用一对密钥(公钥
和私钥)来加密和解密数据。

下面我将简单介绍RSA加密和解密的
计算过程。

1. 生成密钥对,首先,选择两个不同的大质数p和q,并计算
它们的乘积n=pq。

然后选择一个整数e,使得e与(p-1)(q-1)互质,并计算出e的模反元素d。

公钥是(n, e),私钥是(n, d)。

2. 加密,假设要加密的消息为M,首先将消息M转换为整数m,满足0≤m<n。

然后使用公钥(n, e)进行加密,加密后的密文C等于
m的e次方再对n取模,即C≡m^e (mod n)。

3. 解密,接收到密文C后,使用私钥(n, d)进行解密,解密后
的明文M等于C的d次方再对n取模,即M≡C^d (mod n)。

下面我举一个简单的例子来说明RSA加密和解密的计算过程:
假设我们选择两个质数p=11和q=3,计算n=pq=33,然后选择
e=3,并计算d=7。

这样我们得到公钥(n, e)=(33, 3)和私钥(n,
d)=(33, 7)。

现在假设要加密的消息为M=5,将其转换为整数m=5。

使用公钥进行加密,计算C≡5^3 (mod 33),得到C=5。

接收到密文C=5后,使用私钥进行解密,计算M≡5^7 (mod 33),得到M=5。

因此,我们成功地将消息M=5加密为密文C=5,然后再解密回到原始消息M=5。

这就是RSA加密和解密的简单计算过程。

如何使用OpenSSL进行加密解密

如何使用OpenSSL进行加密解密

如何使用OpenSSL进行加密解密OpenSSL是一种开源的加密库,它提供了许多功能和工具,用于加密解密数据和通信,以保护隐私信息不被未授权的人访问。

下面介绍如何使用OpenSSL进行加密解密。

一、生成公钥和私钥OpenSSL通过私钥和公钥加密和解密数据。

私钥是保密的,只有持有者知道,而公钥可以分发给其他人用于加密数据。

因此,首先要生成公钥和私钥。

使用以下命令生成私钥:```openssl genrsa -out private_key.pem 2048```这将生成一个2048位RSA私钥,并将其保存在名为“private_key.pem”的文件中。

然后,使用以下命令从私钥中生成公钥:```openssl rsa -in private_key.pem -pubout -out public_key.pem```这将从“private_key.pem”中提取公钥,并将其保存在名为“public_key.pem”的文件中。

二、加密和解密文件一旦生成了公钥和私钥,就可以使用OpenSSL加密和解密文件。

以下是使用OpenSSL加密和解密文件的步骤:1. 加密文件使用以下命令加密文件:```openssl rsautl -encrypt -in file.txt -out file_encrypted.txt -pubin -inkey public_key.pem```这将使用名为“public_key.pem”的公钥加密名为“file.txt”的文件,并将其保存在名为“file_encrypted.txt”的文件中。

2. 解密文件使用以下命令解密文件:```openssl rsautl -decrypt -in file_encrypted.txt -outfile_decrypted.txt -inkey private_key.pem```这将使用名为“private_key.pem”的私钥解密名为“file_encrypted.txt”的文件,并将其保存在名为“file_decrypted.txt”的文件中。

PHP的Openssl进行 RSA 加密与解密范例

PHP的Openssl进行 RSA 加密与解密范例

//index.php<?php//需要配置PHP.INI文件,打开extension=php_openssl.dll include 'rsaclass.php';//以下是一个简单的测试demo,如果不需要请删除$rsa = new Rsa('D:\......\rsa'); //放项目的PHP目录//私钥加密,公钥解密echo 'source:Testing:Hello World!<br />';$pre = $rsa->privEncrypt('Testing:Hello World!');echo 'Private Encrypted:' . $pre . '<br />';$pud = $rsa->pubDecrypt($pre);echo 'Public Decrypted:' . $pud . '<br />';//公钥加密,私钥解密echo 'source:working in here!<br />';$pue = $rsa->pubEncrypt('working in here!');echo 'Public Encrypt:' . $pue . '<br />';$prd = $rsa->privDecrypt($pue);echo 'Private Decrypt:' . $prd;?>//rsaclass.php<?php/*** 使用openssl实现非对称加密*/class Rsa{private $_privKey; /*** private key*/private $_pubKey; /*** public key*/private $_keyPath; /*** the keys saving path*//*** the construtor,the param $path is the keys saving path*/public function __construct($path){if(empty($path) || !is_dir($path)){throw new Exception('Must set the keys save path');}$this->_keyPath = $path;}/*** create the key pair,save the key to $this->_keyPath*/public function createKey(){$r = openssl_pkey_new();openssl_pkey_export($r, $privKey);file_put_contents($this->_keyPath . DIRECTORY_SEPARATOR . 'key.pem', $privKey);$this->_privKey = openssl_pkey_get_public($privKey);$rp = openssl_pkey_get_details($r);$pubKey = $rp['key'];file_put_contents($this->_keyPath . DIRECTORY_SEPARATOR . 'pub.pem', $pubKey);$this->_pubKey = openssl_pkey_get_public($pubKey);}/*** setup the private key*/public function setupPrivKey(){if(is_resource($this->_privKey)){return true;}$file = $this->_keyPath . DIRECTORY_SEPARATOR . 'key.pem';$prk = file_get_contents($file);$this->_privKey = openssl_pkey_get_private($prk);return true;}/*** setup the public key*/public function setupPubKey(){if(is_resource($this->_pubKey)){return true;}$file = $this->_keyPath . DIRECTORY_SEPARATOR . 'pub.pem';$puk = file_get_contents($file);$this->_pubKey = openssl_pkey_get_public($puk);return true;}/*** encrypt with the private key*/public function privEncrypt($data){if(!is_string($data)){return null;}$this->setupPrivKey();$r = openssl_private_encrypt($data, $encrypted, $this->_privKey);if($r){return base64_encode($encrypted);}return null;}/*** decrypt with the private key*/public function privDecrypt($encrypted){if(!is_string($encrypted)){return null;}$this->setupPrivKey();$encrypted = base64_decode($encrypted);$r = openssl_private_decrypt($encrypted, $decrypted, $this->_privKey);if($r){return $decrypted;}return null;}/*** encrypt with public key*/public function pubEncrypt($data){if(!is_string($data)){return null;}$this->setupPubKey();$r = openssl_public_encrypt($data, $encrypted, $this->_pubKey);if($r){return base64_encode($encrypted);}return null;}/*** decrypt with the public key*/public function pubDecrypt($crypted){if(!is_string($crypted)){return null;}$this->setupPubKey();$crypted = base64_decode($crypted);$r = openssl_public_decrypt($crypted, $decrypted, $this->_pubKey);if($r){return $decrypted;}return null;}public function __destruct(){@ fclose($this->_privKey);@ fclose($this->_pubKey);}}?>加密使用公钥,解密使用私钥签名使用私钥,验证使用公钥私钥可以导出公钥e,通常是3,17,65537G e n e r a t i n g R S A p r i v a t e k e y,1024b i t l o n g m o d u l u s…..++++++……++++++e i s65537(0×10001)。

rsa公钥解密例题

rsa公钥解密例题

rsa公钥解密例题RSA(Rivest-Shamir-Adleman)是一种非对称加密算法,其中公钥用于加密,私钥用于解密。

我将为你提供一个RSA公钥解密的例题。

假设我们有以下RSA公钥参数:公钥,(e, n)。

e,公钥指数。

n,模数。

现在,假设我们要解密的密文为c,我们需要使用私钥进行解密操作。

私钥包含以下参数:私钥,(d, n)。

d,私钥指数。

n,模数。

解密操作的公式为,m = c^d mod n,其中m为解密后的明文。

下面是一个具体的例子:假设我们的RSA公钥参数为:公钥,(e, n) = (7, 187)。

密文,c = 128。

我们需要找到私钥参数:私钥,(d, n)。

首先,我们需要计算私钥指数d。

d满足以下条件,d e ≡ 1 mod φ(n),其中φ(n)为欧拉函数,对于给定的n,φ(n)表示小于n且与n互质的正整数的个数。

对于给定的n,我们需要计算φ(n)。

在本例中,n = 187,我们需要计算φ(187)。

首先,我们需要分解n为其素因数的乘积。

在本例中,我们可以将187分解为11和17的乘积,即187 = 11 17。

然后,我们可以计算φ(187) = (11-1) (17-1) = 10 16 = 160。

接下来,我们需要找到满足条件d e ≡ 1 mod 160的d值。

我们可以使用扩展欧几里得算法来计算d。

通过计算,我们可以得到d = 23。

现在我们有了私钥参数,(d, n) = (23, 187)。

接下来,我们可以使用解密公式m = c^d mod n来解密密文c。

在本例中,c = 128,d = 23,n = 187。

计算m = 128^23 mod 187,得到m = 65。

因此,解密后的明文为65。

这就是一个RSA公钥解密的例子。

通过使用正确的私钥参数,我们可以成功解密密文并得到明文。

请注意,实际应用中,RSA算法使用更大的素数和更复杂的计算,以提供更高的安全性。

OpenSSL和Python实现RSAKey公钥加密私钥解密

OpenSSL和Python实现RSAKey公钥加密私钥解密

OpenSSL和Python实现RSAKey公钥加密私钥解密基于⾮对称算法的RSA Key主要有两个⽤途,数字签名和验证(私钥签名,公钥验证),以及⾮对称加解密(公钥加密,私钥解密)。

本⽂提供⼀个基于OpenSSL和Python进⾏⾮对称加解密的例⼦。

1. OpenSSL实现⾮对称加解密1.1 ⽣成私钥,并导出公钥⽣成2048 bit的PEM格式的RSA Key:Key.pem$ openssl genrsa -out Key.pem -f4 2048Generating RSA private key, 2048 bit long modulus.+++ ...................................................................+++e is 65537 (0x10001)从私钥导出公钥:Key_pub.pem$ openssl rsa -in Key.pem -pubout -out Key_pub.pemwriting RSA key1.2 准备测试数据为了简便起见,这⾥将字符串”Hello Rocky!”存放到⽂件msg.bin作为测试数据:echo−n"HelloRocky!">msg.bin hexdump -Cv msg.bin00000000 48 65 6c 6c 6f 20 52 6f 63 6b 79 21 |Hello Rocky!|0000000c1.3 公钥加密使⽤公钥Key_pub.pem对测试数据msg.bin进⾏加密⽣成msg.bin.enc,并查看加密后的数据:opensslrsautl−inmsg.bin−outmsg.bin.enc−inkeyKey p ub.pem−pubin−encrypt−pkcs hexdump -Cv msg.bin.enc00000000 8d a3 c8 7f fd 4c 32 ee 29 58 c8 38 56 bd 8b 78 |.....L2.)X.8V..x|00000010 cc eb ae f5 fa 1f 79 bb 4c 9c f1 39 34 75 94 62 |......y.L..94u.b|00000020 97 59 c7 28 b3 c4 6a 0c 41 18 d6 2d 04 45 6d e1 |.Y.(..j.A..-.Em.|00000030 3f 03 94 74 fa ac 02 f1 fb 10 1a a2 6b 6b 57 56 |?..t........kkWV|00000040 39 a4 cb 7f e0 34 a6 b1 68 c7 2b 67 20 ee 31 70 |9....4..h.+g .1p|00000050 1f c4 da 37 af 20 d6 49 1a f1 56 4f e2 37 80 39 |...7. .I..VO.7.9|00000060 ab 85 9b c8 d0 33 57 1e 64 cd ea 43 c8 3e 3d 21 |.....3W.d..C.>=!|00000070 a8 0f 95 ec e3 60 45 43 80 55 c6 7f d9 ad 6e 4c |.....`EC.U....nL|00000080 df 51 4e 70 ea c7 89 24 55 6b ba d0 cc e4 32 1f |....2.|000000908880d27e72ead94a6bacd4dfc8832557|...r..Jk......|000000f0 28 2d b3 1e 60 e3 5e 04 82 fc 48 55 38 3e ae de |(-..`.^...HU8>..|00000100这⾥使⽤:- -in 选项指定原始数据⽂件msg.bin- -out 选项指定加密后的输出⽂件msg.bin.enc- -inkey 选项指定⽤于加密的公钥Key_pub.pem,由于输⼊是公钥,所以需要使⽤选项-pubin来指出- -encrypt 选项表明这⾥是进⾏加密操作- -pkcs 选项指定加密处理过程中数据的填充⽅式,对于填充,可选项有:-pkcs, -oaep, -ssl, -raw,默认是-pkcs,即按照PKCS#1 v1.5规范进⾏填充1.4 私钥解密使⽤私钥Key.pem对加密后的数据msg.bin.enc进⾏解密,并将结果存放到msg.bin.dec⽂件中:opensslrsautl−inmsg.bin.enc−outmsg.bin.dec−inkeyKey.pem−decrypt−pkcs hexdump -Cv msg.bin.dec00000000 48 65 6c 6c 6f 20 52 6f 63 6b 79 21 |Hello Rocky!|0000000c这⾥使⽤:- -in 选项指定待解密的数据⽂件msg.bin.enc- -out 选项指定解密后的输出⽂件msg.bin.dec- -inkey 选项指定⽤于解密的私钥Key.pem,由于输⼊是私钥,所以不再需要使⽤选项-pubin- -decrypt 选项表明这⾥是进⾏解密操作- -pkcs 选项指定解密处理过程中数据的填充⽅式,对于填充,可选项有:-pkcs, -oaep, -ssl, -raw,默认是-pkcs,即按照PKCS#1 v1.5规范进⾏填充从上⾯hexdump的结果可见,已经成功解密,另外也可以通过对原始数据和解密后的数据计算md5校验和来确定:$ md5sum msg.bin msg.bin.dec53fdc7c239dbd79fe76cb9525fadcd85 msg.bin53fdc7c239dbd79fe76cb9525fadcd85 msg.bin.dec显然,msg.bin和msg.bin.dec的md5校验和是⼀样的额。

Linux命令行数据加密技巧使用加密和解密工具

Linux命令行数据加密技巧使用加密和解密工具

Linux命令行数据加密技巧使用加密和解密工具在今天的数字时代,数据的安全性变得越来越重要。

无论是个人用户还是企业组织,都需要确保其敏感数据的保密性和完整性。

为了满足这一需求,Linux命令行提供了多种加密和解密工具,可以帮助我们对数据进行加密,以确保其机密性。

在本文中,我们将介绍一些常见的Linux命令行数据加密技巧,以及如何使用加密和解密工具。

1. 敏感数据的加密意义数据加密是一种将原始数据转换为密文,以防止未经授权的用户访问其内容的过程。

通过使用加密算法,我们可以将敏感数据转化为不可读的形式,只能通过解密算法来恢复原始数据。

这种加密技术可以帮助我们保护个人隐私、公司机密等重要信息。

2. Linux命令行下常用的加密算法以下是一些常见的Linux命令行下常用的加密算法:- AES(Advanced Encryption Standard):AES是一种对称加密算法,被广泛使用于保护机密数据的加密和解密过程中。

它支持不同密钥长度,包括128位、192位和256位。

- RSA(Rivest-Shamir-Adleman):RSA是一种非对称加密算法,其中使用了两个密钥,一个用于加密,另一个用于解密。

RSA算法被广泛应用于身份验证和密钥交换等领域。

- Blowfish:Blowfish是一种快速的对称加密算法,可用于加密大量数据。

它支持不同的密钥长度,包括32位到448位。

除了上述算法外,Linux命令行还支持其他加密算法,如DES (Data Encryption Standard)、3DES(Triple DES)等。

3. 使用GPG进行文件加密和解密GPG(GNU Privacy Guard)是一个开源的加密软件,可以用于加密和解密文件。

它采用了OpenPGP标准,并支持多个加密算法。

要使用GPG加密文件,可以使用以下命令:```gpg -c file.txt```上述命令将使用默认的对称加密算法对文件进行加密,并生成一个.gpg文件。

利用openssl进行RSA加密解密

利用openssl进行RSA加密解密

利⽤openssl进⾏RSA加密解密openssl是⼀个功能强⼤的⼯具包,它集成了众多密码算法及实⽤⼯具。

我们即可以利⽤它提供的命令台⼯具⽣成密钥、证书来加密解密⽂件,也可以在利⽤其提供的API接⼝在代码中对传输信息进⾏加密。

RSA是⼀个⾮对称加密算法。

简单说来,⾮对称加密算法就是说加密解密⼀个⽂件需要有两个密钥,⼀个⽤来加密,为公钥,⼀个⽤来解密,为私钥。

证书可以⽤来授权公钥的使⽤。

今天⼩研究了下openssl的rsa加密,其中主要涉及利⽤公钥和密钥加解密⽂件,没有涉及对证书的操作。

想要集体了解的可以去:---------------------------------------------------------------------------------------------------------------------⾸先介绍下命令台下openssl⼯具的简单使⽤:⽣成⼀个密钥:openssl genrsa -out test.key 1024这⾥-out指定⽣成⽂件的。

需要注意的是这个⽂件包含了公钥和密钥两部分,也就是说这个⽂件即可⽤来加密也可以⽤来解密。

后⾯的1024是⽣成密钥的长度。

openssl可以将这个⽂件中的公钥提取出来:openssl rsa -in test.key -pubout -out test_pub.key-in指定输⼊⽂件,-out指定提取⽣成公钥的⽂件名。

⾄此,我们⼿上就有了⼀个公钥,⼀个私钥(包含公钥)。

现在可以将⽤公钥来加密⽂件了。

我在⽬录中创建⼀个hello的⽂本⽂件,然后利⽤此前⽣成的公钥加密⽂件:openssl rsautl -encrypt -in hello -inkey test_pub.key -pubin -out hello.en-in指定要加密的⽂件,-inkey指定密钥,-pubin表明是⽤纯公钥⽂件加密,-out为加密后的⽂件。

Linux命令行中的文本加密和解密技巧

Linux命令行中的文本加密和解密技巧

Linux命令行中的文本加密和解密技巧随着互联网的普及和信息安全的关注度不断提升,数据的加密和解密已经成为了一个非常重要的话题。

在Linux操作系统中,我们可以利用一些命令行工具来实现文本的加密和解密操作。

本文将介绍几种常用的Linux命令行中的文本加密和解密技巧。

一、文本加密技巧1. Caesar密码加密Caesar密码是一种最简单的替换密码方法,它是通过将每个字母按照字母表顺序向后移动固定的位数来实现加密。

在Linux命令行中,我们可以使用`tr`命令来实现Caesar密码加密。

```shell$ echo "Hello, World!" | tr 'A-Za-z' 'N-ZA-Mn-za-m'```上述命令将文本“Hello, World!”使用Caesar密码加密,输出结果为“Uryyb, Jbeyq!”。

2. Base64编码Base64是一种常用的编码方式,可以将任意二进制数据转换为可打印字符。

在Linux命令行中,我们可以使用`base64`命令来实现Base64编码。

```shell$ echo "Hello, World!" | base64```上述命令将文本“Hello, World!”使用Base64编码,输出结果为“SGVsbG8sIFdvcmxkIQ==”。

3. OpenSSL加密OpenSSL是一个开源的加密工具包,可以实现多种加密算法。

在Linux命令行中,我们可以使用`openssl`命令来进行文本加密。

```shell$ echo "Hello, World!" | openssl enc -e -base64```上述命令使用OpenSSL进行文本加密,并使用Base64编码输出结果。

二、文本解密技巧1. Caesar密码解密Caesar密码的解密就是将每个字母按照字母表顺序向前移动固定的位数。

如何在Linux终端中进行文件的加密和解密

如何在Linux终端中进行文件的加密和解密

如何在Linux终端中进行文件的加密和解密在Linux终端中,文件加密和解密是保护敏感数据的关键步骤。

通过加密文件,您可以确保只有授权的人能够访问文件内容,而在需要使用文件时,您可以解密文件以重新恢复其原始状态。

本文将介绍一些常用的加密和解密方法,以帮助您在Linux终端中保护文件的安全性。

1. 了解加密算法在选择加密和解密方法之前,首先需要了解不同的加密算法。

常用的加密算法包括AES(Advanced Encryption Standard)、DES(Data Encryption Standard)和RSA(Rivest-Shamir-Adleman)。

这些算法具有不同的加密强度和加密速度,请根据您的需求选择。

2. 安装加密工具在Linux终端中进行文件加密和解密,您需要安装相应的加密工具。

常用的加密工具有GPG(GNU Privacy Guard)和OpenSSL。

您可以使用以下命令在终端中安装这些工具:```sudo apt-get install gpgsudo apt-get install openssl```3. 使用GPG进行文件加密和解密GPG是一个强大的加密工具,它支持对文件和目录进行加密和解密操作。

下面是使用GPG进行文件加密和解密的步骤:- 加密文件:```gpg -c 文件名```这将创建一个加密的文件,您需要输入密码来保护文件。

- 解密文件:```gpg 文件名.gpg```这将解密加密的文件,您需要输入正确的密码才能访问文件内容。

4. 使用OpenSSL进行文件加密和解密OpenSSL是另一个强大的加密工具,它支持多种加密算法和文件格式。

下面是使用OpenSSL进行文件加密和解密的步骤:- 加密文件:```openssl enc -aes-256-cbc -in 文件名 -out 文件名.enc```这将创建一个加密的文件,其中使用了AES-256-CBC加密算法。

Linux中的Openssl命令及实例代码

Linux中的Openssl命令及实例代码

Linux中的Openssl命令及实例代码openssl命令的格式是"openssl command command-options args",command部分有很多种命令,这些命令需要依赖于openssl命令才能执⾏,所以称为伪命令(pseudo-command),每个伪命令都有各⾃的功能,⼤部分command都可以直接man command查看命令的⽤法和功能。

OpenSSL是⼀个强⼤的安全套接字层密码库,囊括主要的密码算法、常⽤的密钥和证书封装管理功能及SSL协议,并提供丰富的应⽤程序供测试或其它⽬的使⽤。

在OpenSSL被曝出现严重安全漏洞后,发现多数通过SSL协议加密的⽹站使⽤名为OpenSSL的开源软件包。

由于这是互联⽹应⽤最⼴泛的安全传输⽅法,被⽹银、在线⽀付、电商⽹站、门户⽹站、电⼦邮件等重要⽹站⼴泛使⽤,所以该漏洞影响范围⼴⼤。

OpenSSL有两种运⾏模式:交互模式和批处理模式。

直接输⼊openssl回车进⼊交互模式,输⼊带命令选项的openssl进⼊批处理模式。

OpenSSL整个软件包⼤概可以分成三个主要的功能部分:密码算法库、SSL协议库以及应⽤程序。

OpenSSL的⽬录结构⾃然也是围绕这三个功能部分进⾏规划的。

对称加密算法OpenSSL⼀共提供了8种对称加密算法,其中7种是分组加密算法,仅有的⼀种流加密算法是RC4。

这7种分组加密算法分别是AES、DES、Blowfish、CAST、IDEA、RC2、RC5,都⽀持电⼦密码本模式(ECB)、加密分组链接模式(CBC)、加密反馈模式(CFB)和输出反馈模式(OFB)四种常⽤的分组密码加密模式。

其中,AES使⽤的加密反馈模式(CFB)和输出反馈模式(OFB)分组长度是128位,其它算法使⽤的则是64位。

事实上,DES算法⾥⾯不仅仅是常⽤的DES算法,还⽀持三个密钥和两个密钥3DES算法。

⾮对称加密算法OpenSSL⼀共实现了4种⾮对称加密算法,包括DH算法、RSA算法、DSA算法和椭圆曲线算法(EC)。

Linux下SHA256计算哈希值和RSA加密天使羊波波闪耀光芒

Linux下SHA256计算哈希值和RSA加密天使羊波波闪耀光芒

Linux下SHA256计算哈希值和RSA加密天使羊波波闪耀光芒2010月/165Linux下SHA256计算哈希值和RSA加密项目中遇到系统之间文件传输要使用SHA256 with RSA1024加密,计算签名。

详细了解了一下。

1、SHA256哈希算法用于计算信息摘要。

因为md5和sha1有被碰撞和破解的可能性,所以使用sha256。

1.1、使用sha256sum命令计算哈希值输入:一个文件或一个字符串输出:SHA256输出256bit,32个字节,显示为64个16进制字符1)当对字符串计算哈希值时,字符串不变,计算出的哈希值结果是一致的2)当对两个文件计算时,文件生成时间不同,但文件内容相同,计算出的哈希值是一致的3)当对两个相同内容的文件,分别打包压缩成tar.gz格式后,计算出的哈希值结果不一致应该是在tar打包压缩时,添加了随机数,造成两个文件的哈希值不一致2、RSA加密RSA每次生成的密文都不一致?公钥相同,明文相同,每次RSA加密的结果都不一致。

因为RSA 算法,加密前对明文进行了随机数填充,解密的结果不会受到影响。

输入:一个文件或一个字符串输出:RSA 1024输出密文1024bit,128个字节的16进制字符因为RSA key长度是1024,所以输出的密文也是1024吗?2.1、使用openssl命令计算RSA加解密genrsa 生成的文件并不包含公钥,但是包含了私钥的详细信息。

rsa命令可以根据这个文件生成对应的公钥。

生成私钥:openssl genrsa -out test.key 1024生成公钥:openssl rsa -in test.key -pubout -out test_pub.key用公钥加密:openssl rsautl -encrypt -pubin -inkey test_pub.key -in aaa.txt -out en.txt用私钥解密:openssl rsautl -decrypt -inkey test.key -in en.txt -out de.txt结果:de.txt文件内容与aaa.txt内容一样2.2、公私钥的使用加密--公钥解密--私钥签名--私钥验证--公钥参考资料:/s/blog_8d05143b01012xqf.html/topgun_chenlingyun/article/details/43270549/defonds/article/details/42775183 分类: LINUX发表评论。

密码学应用-非对称加密算法RSA的应用

密码学应用-非对称加密算法RSA的应用

密码学应用-非对称加密算法RSA的应用实验虚拟主机用户密码如下:H-basiclinux--1主机:用户:root 密码:123456第一步,打开拓扑、启动basiclinux主机,用root登录主机第二步,使用openssl命令生成密钥1)执行#openssl genrsa -out test.key 1024注:这里-out指定生成文件的。

需要注意的是这个文件包含了公钥和密钥两部分,也就是说这个文件即可用来加密也可以用来解密。

后面的1024是生成密钥的长度。

2)查看公私钥文件3)提取公钥执行#openssl rsa -in test.key -pubout -out test_pub.key注:-in指定输入文件,-out指定提取生成公钥的文件名。

至此,我们手上就有了一个公钥,一个私钥(包含公钥)。

现在可以将用公钥来加密文件了。

4)查看公钥文件第三步、创建要被加密文件、对文件进行加密解密。

1)创建 hello文件,查看用 cat 命令2)然后利用此前生成的公钥加密文件执行#openssl rsautl -encrypt -in hello -inkey test_pub.key -pubin -out hello.en 注:-in指定要加密的文件,-inkey指定密钥,-pubin表明是用纯公钥文件加密,-out为加密后的文件。

3)查看加密结果4)解密文件执行#openssl rsautl -decrypt -in hello.en -inkey test.key -out hello.de注:-in指定被加密的文件,-inkey指定私钥文件,-out为解密后的文件。

4)查看解密文件第四步、公私钥文件格式了解私钥经过PEM编码后在文件头尾都添加了标签,用以说明当前的文件格式。

从 test.key可以看出私钥是不加密的,因为没有“ENCRYPTED”。

中间的私钥内容是经过BASE64编码的,这样方便私钥的传递,例如在网络上传输,数据复制粘贴。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

1、生成秘钥文件
openssl genrsa -out secret.key 1024
openssl genrsa是生成密钥的命令,-out是指定所生成的密钥文件,secret.key这个文件里包含了公钥和密钥两部分,就是说这个文件即可用来加密也可以用来解密,如果想分开也可以用下面的命令将公钥导出。

命令中的1024是指生成的密钥的长度。

2、将公钥导出
openssl rsa -in secret.key -pubout -out secret_pub.key
将公钥从secret.key中导出,-in指定输入文件,-out指定提取生成公钥的文件名。

这样我们就有了一个公钥和一个私钥(包含公钥)。

下面我们就可以用公钥来加密文件了。

3.
下面是一个用C实现的OpenSSL RSA加密的程序,程序实现的是公钥加密,私钥解密的过程,当然也可以实现私钥加密,公钥解密,大家可以根据程序后面的函数解释来进行各种更改。

下面将通过第一部分生成的加密文件中的公钥secret_pub.key来实现对字符串的加密,用密钥文件secret.key来实现字符串的解密,程序已经经过编译运行,可以直接实验、运行。

myRSA.h:
1 #ifndef _MY_RSA_H_
2 #define _MY_RSA_H_
3
4 #include <stdio.h>
5 #include <string.h>
6 #include <stdlib.h>
7 #include <openssl/rsa.h>
8 #include <openssl/pem.h>
9 #include <openssl/err.h>
10
11 #define BUFFSIZE 1024
12 #define PUBLICKEY “secret_pub.key”
13 #define OPENSSLKEY “secret.key”
14
15 char* my_EncryptFunc(char *str,char *path_key); //加密函数
16 char* my_DecryptFunc(char *str,char *path_key); //解密函数
17
18
19 #endif
myRSA.c:
1 #include “myRSA.h”
2
3
4 int main(void)
5 {
6 char *p_Src = (char *)”This is my test !”;
7 char *p_EnStr,*p_DeStr;
8
9 printf(“Source is : [%s]\n”,p_Src);
10
11 p_EnStr = my_EncryptFunc(p_Src, PUBLICKEY);
12 printf(“Encryption : [%s]\n”,p_EnStr);
13
14 p_DeStr = my_DecryptFunc(p_EnStr, OPENSSLKEY);
15 printf(“Decryption : [%s]\n”,p_DeStr);
16
17 if(p_EnStr!=NULL)
18 {
19 free(p_EnStr);
20 }
21 if(p_DeStr!=NULL)
22 {
23 free(p_DeStr);
24 }
25
26 return 0;
27 }
28
29
30 char *my_EncryptFunc(char *str,char *path_key)
31 {
32 RSA *p_Rsa;
33 char *p_En;
34 FILE *file;
35 int rsa_len;
36
37 if((file=fop en(path_key,”r”))==NULL)
38 {
39 perror(“open key file error”);
40 return NULL;
41 }
42
43
44 #ifndef RSA_NEW
45
46 if((p_Rsa=PEM_read_RSA_PUBKEY(file,NULL,NULL,NULL))==N ULL)
47 {
48 ERR_print_errors_fp(stdout);
49 return NULL;
50 }
51 else
52 {
53 printf(“PEM read success!\n”);
54 }
55
56 #else
57
58 p_Rsa = RSA_new();
59 if(PEM_read_RSA_PUBKEY(file, &p_Rsa, 0, 0) == NULL)
60 {
61 return NULL;
62 }
63 else
64 {
65 printf(“PEM read new success\n”);
66 }
67
68 #endif
69
70 rsa_len=RSA_size(p_Rsa);
71
72 p_En = (char *)malloc(rsa_len+1);
73 memset(p_En,0,rsa_len+1);
74
75 if(RSA_public_encrypt(rsa_len, (unsigned char *)str, (unsigned char*)p_En, p_Rsa, RSA_NO_PADDING) < 0)
76 {
77 return NULL;
78 }
79
80 RSA_free(p_Rsa);
81 fclose(file);
82
83 return p_En;
84
85 }
86
87 char *my_DecryptFunc(char *str,char *path_key)
88 {
89 RSA *p_Rsa;
90 char *p_De;
91 FILE *file;
92 int rsa_len;
93
94 if((file=fopen(path_key,”r”))==NU LL){
95 perror(“open key file error”);
96 return NULL;
97 }
98
99 if((p_Rsa=PEM_read_RSAPrivateKey(file,NULL,NULL,NULL))==N ULL){
100 ERR_print_errors_fp(stdout);
101 return NULL;
102 }
103
104 rsa_len=RSA_size(p_Rsa);
105 p_De=(char *)malloc(rsa_len+1);
106 memset(p_De,0,rsa_len+1);
107
108 if(RSA_private_decrypt(rsa_len,(unsigned char *)str,(unsigned char*)p_De,p_Rsa,RSA_NO_PADDING)<0){
109 return NULL;
110 }
111
112 RSA_free(p_Rsa);
113 fclose(file);
114
115 return p_De;
116 }
4. linux下编译
gcc myRSA.c -o exe -lssl
1)如果出现如openssl/rsa.h : no such file or direction,则需要安装
openssl-devel
sudo yum install openssl-devel
2) 如果出现:
undefined reference to symbol 'RSA_size@@libcrypto.so.10'
/usr/lib64/libcrypto.so.10: error adding symbols: DSO missing f rom command line
使用新命令:gcc myRSA.c -o exe -lssl -lcrypto
5.运行:./exe
6.结果;。

相关文档
最新文档