1.【Linux】linux下OpenSSL的RSA密钥生成
2.请问如何实现用javascript实现rsa加解密?
3.å¦ä½å©ç¨OpenSSLåºè¿è¡RSAå å¯å解å¯
4.Python实现DES、DES3、AES、RSA、MD5、SHA、梦幻西游 源码 环境HMAC加密方式及示例
5.å¦ä½å®ç°ç¨javascriptå®ç°rsaå 解å¯
6.RSA加密算法对字符串加密(C++语言)看见你之前回答过这个问题,可不可以把源代码给我?
【Linux】linux下OpenSSL的RSA密钥生成
在Linux系统中,OpenSSL是一个常用的加密工具,本文将指导如何在该环境下生成RSA密钥对。首先,有两条主要的安装途径:源码安装和yum包安装。
1. 源码安装:
- 下载openssl-1.0.0e.tar.gz压缩包,将其放在根目录。
- 使用命令`tar -xzf openssl-openssl-1.0.0e.tar.gz`解压缩,得到openssl-1.0.0e文件夹。
- 进入解压目录并设定安装路径,例如`./config --prefix=/usr/local/openssl`。外汇源码套利
- 确认安装配置无误后,执行`./config -t`,然后编译安装:`make`。
2.
使用yum包安装:
- 可以通过`yum install openssl* -y`快速安装,但本文重点在于自定义密钥生成。
要生成RSA密钥对,首先生成位的私钥:
- 输入`genrsa -out rsa_private_key.pem `,私钥会保存为rsa_private_key.pem,需妥善保管。
接着,根据私钥生成公钥:
- 使用`rsa -in rsa_private_key.pem -pubout -out rsa_public_key.pem`命令,公钥会保存为rsa_public_key.pem。
对于更安全的存储,可以生成PKCS8格式的私钥:
- 执行`pkcs8 -topk8 -inform PEM -in rsa_private_key.pem -outform PEM -nocrypt`,私钥将被转换为PKCS8格式。
生成的公钥可以使用`cat rsa_public_key.pem`查看,注意保持文件格式,传奇假人系统源码以便正确进行加密和解密操作。
总之,通过上述步骤,您可以在Linux下成功生成和管理RSA密钥对,确保开发语言如PHP中的安全使用。
请问如何实现用javascript实现rsa加解密?
分享一个简单的JS加密解密方法,适用于JS字符串内容加解密。此方法使用非常方便,先定义两个字符串属性方法,分别用于加密解密。
加密时,将字符串中每个字符转化为字符对应的编码数值。
解密时,再将编码数值转化成字符。
之后,字符串变量便可直接调用这两个方法进行加密解密。以下是凯元源码破解源码示例:
//JS字符串加密
String.prototype.encode = function () { var bytes = []; for (var i = 0; i < this.length; i++) { bytes.push(this.charCodeAt(i)); } return bytes.join(','); }
//JS字符串解密
String.prototype.decode = function () { return String.fromCharCode.apply(null,this.trim().split(",")); }
通过此方法,可以实现对JS字符串内容的加密与解密。例如:
var str = "JShaman专注于JS代码混淆加密";
console.log("原始字符串:",str);
var encode_str = str.encode();
console.log("加密后的字符串:",encode_str);
var decode_str = encode_str.decode();
console.log("解密后的字符串:",decode_str);
注:此例仅演示加密解密概念,如需增加强度,可对数值进行运算或变化,或使用混淆加密技术提高安全性。
å¦ä½å©ç¨OpenSSLåºè¿è¡RSAå å¯å解å¯
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<openssl/rsa.h>
#include<openssl/engine.h>
int main(int argc, char* argv[])
{
printf("openssl_test begin\n");
RSA* rsa=NULL;
char originstr[]="hello\n"; //è¿æ¯æ们éè¦å å¯çåå§æ°æ®
//allocate RSA structureï¼é¦å éè¦ç³è¯·ä¸ä¸ªRSAç»æé¢ç¨äºåæ¾çæçå ¬ç§é¥ï¼è¿érsaå°±æ¯è¿ä¸ªç»æä½çæé
rsa = RSA_new();
if(rsa==NULL)
{
printf("RSA_new failed\n");
return -1;
}
//generate RSA keys
BIGNUM* exponent;
exponent = BN_new(); //çæRSAå ¬ç§é¥ä¹åéè¦éæ©ä¸ä¸ªå¥æ°ï¼odd numberï¼æ¥ç¨äºçæå ¬ç§é¥
if(exponent ==NULL)
{
printf("BN_new failed\n");
goto FAIL1;
}
if(0==BN_set_word(exponent,)) //è¿ééæ©å¥æ°
{
printf("BN_set_word failed\n");
goto FAIL1;
}
//è¿émodulusçé¿åº¦éæ©ï¼å°äºçmodulusé¿åº¦é½æ¯ä¸å®å ¨çï¼å®¹æè¢«ç ´è§£
if(0==RSA_generate_key_ex(rsa,,exponent,NULL))
{
printf("RSA_generate_key_ex failed\n");
goto FAIL;
}
char* cipherstr = NULL;
//åé ä¸æ®µç©ºé´ç¨äºåå¨å å¯åçæ°æ®ï¼è¿ä¸ªç©ºé´ç大å°ç±RSA_sizeå½æ°æ ¹æ®rsaç®åº
cipherstr = malloc(RSA_size(rsa));
if(cipherstr==NULL)
{
printf("malloc cipherstr buf failed\n");
goto FAIL1;
}
//ä¸é¢æ¯å®é çå å¯è¿ç¨ï¼æåä¸ä¸ªåæ°padding typeï¼æ以ä¸å ç§ã
/
*RSA_PKCS1_PADDINGPKCS #1 v1.5 padding. This currently is the most widely used mode.
RSA_PKCS1_OAEP_PADDING
EME-OAEP as defined in PKCS #1 v2.0 with SHA-1, MGF1 and an empty encoding parameter. This mode is recommended for all new applications.
RSA_SSLV_PADDING
PKCS #1 v1.5 padding with an SSL-specific modification that denotes that the server is SSL3 capable.
RSA_NO_PADDING
Raw RSA encryption. This mode should only be used to implement cryptographically sound padding modes in the application code. Encrypting user data directly with RSA is insecure.
*/
//è¿éé¦å ç¨å ¬é¥è¿è¡å å¯ï¼éæ©äºRSA_PKCS1_PADDING
if(RSA_size(rsa)!=RSA_public_encrypt(strlen(originstr)+1,originstr,cipherstr,rsa,RSA_PKCS1_PADDING))
{
printf("encryption failure\n");
goto FAIL2;
}
printf("the original string is %s\n",originstr);
printf("the encrypted string is %s\n",cipherstr);
//Now, let's decrypt the string with private key
//ä¸é¢æ¥ç¨ç§é¥è§£å¯ï¼é¦å éè¦ä¸ä¸ªbufferç¨äºåå¨è§£å¯åçæ°æ®ï¼è¿ä¸ªbufferçé¿åº¦è¦è¶³å¤ï¼å°äºRSA_size(rsa)ï¼
//è¿éåé ä¸ä¸ªé¿åº¦ä¸ºçå符æ°ç»ï¼åºè¯¥æ¯å¤ç¨çã
char decrypted_str[];
int decrypted_len;
if(-1=(decrypted_len=RSA_private_decrypt(,cipherstr,decrypted_str,rsa,RSA_PKCS1_PADDING)))
{
printf("decryption failure\n");
goto FAIL2;
}
printf("decrypted string length is %d,decryped_str is %s\n",decrypted_len,decrypted_str);
FAIL2:
free(cipherstr);
FAIL1:
BN_free(exponent);
FAIL:
RSA_free(rsa);
return 0;
}
以ä¸æ¯æºä»£ç ï¼ä¸é¢ä½¿ç¨ä¸é¢çç¼è¯å½ä»¤å¨æºç æå¨è·¯å¾ä¸çæå¯æ§è¡æ件
gcc *.c -o openssl_test -lcrypto -ldl -L/usr/local/ssl/lib -I/usr/local/ssl/include
å ¶ä¸ï¼-lcryptoå-ldlæ¯å¿ é¡»çï¼åè æ¯OpenSSLä¸çå å¯ç®æ³åºï¼åè æ¯ç¨äºæåå è½½å¨æåºã
Python实现DES、DES3、AES、RSA、MD5、SHA、HMAC加密方式及示例
本文全面整理了七种加密方式:DES、DES3、AES、RSA、MD5、SHA、ugc审核平台源码HMAC在Python3环境中的实现方法与应用示例。对于前端JavaScript开发者而言,密码加密实现的需要,使得这三种加密方式——AES、RSA、MD5——成为当前最常使用的工具,且它们的嵌套与混合使用场景也颇为常见。 以下是本文对上述加密方式的整理概览,所有案例均经亲自测试,确保其可行性和实用性,并对使用过程中的注意事项进行了标注说明。以下是具体的使用示例,以供参考。为了便于查阅和学习,所有源码已上传至GitHub,读者可通过阅读原文链接或在后台回复“加密”获取。 以下是加密方式的简要介绍与示例代码片段: DES:数据加密标准,使用固定密钥和固定密钥长度(位),适用于对少量数据的加密。 DES3:对DES算法的扩展,使用三个密钥进行加密,提升安全性。 AES:高级加密标准,采用可变密钥长度(、、位),支持多种密钥长度,广泛应用于各类数据加密场景。 RSA:一种基于大数质因数分解难题的非对称加密算法,用于数据加密与数字签名,实现密钥对的生成、加密与解密。 MD5:一种用于生成固定长度摘要(位)的哈希算法,常用于验证数据完整性。 SHA:安全哈希算法,提供更安全的哈希值生成,支持不同输出长度,适合在安全性要求高的场景使用。 HMAC:哈希消息认证码,结合密钥和消息生成,用于数据完整性与身份认证。 具体代码实现与详细示例请参阅GitHub仓库。关注公众号“Python之战”获取更多学习资源与技术支持,专注于Python、网络爬虫与RPA领域的学习与实践。欢迎关注与讨论,共同进步。å¦ä½å®ç°ç¨javascriptå®ç°rsaå 解å¯
å ·ä½å®ç°æè·¯å¦ä¸ï¼1ãæå¡ç«¯çæå ¬é¥ä¸ç§é¥ï¼ä¿åã
2ã客æ·ç«¯å¨è¯·æ±å°ç»å½é¡µé¢åï¼éæºçæä¸å符串ã
3ãåæ¤éæºå符串ä½ä¸ºå¯é¥å å¯å¯ç ï¼åç¨ä»æå¡ç«¯è·åå°çå ¬é¥å å¯çæçéæºå符串ã
4ãå°æ¤ä¸¤æ®µå¯æä¼ å ¥æå¡ç«¯ï¼æå¡ç«¯ç¨ç§é¥è§£åºéæºå符串ï¼åç¨æ¤ç§é¥è§£åºå å¯çå¯æã
è¿å ¶ä¸æä¸ä¸ªå ³é®æ¯è§£å³æå¡ç«¯çå ¬é¥ï¼ä¼ å ¥å®¢æ·ç«¯ï¼å®¢æ·ç«¯ç¨æ¤å ¬é¥å å¯å符串åï¼ååè½å¨æå¡ç«¯ç¨ç§é¥è§£åºã
æ¤æå³ä¸ºå®ç°æ¤æ¥èä½ã
å å¯ç®æ³ä¸ºRSAï¼
1ãæå¡ç«¯çRSA javaå®ç°ã
/***
*/
package com.sunsoft.struts.util;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.security.KeyFactory;
import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.NoSuchAlgorithmException;
import java.security.PrivateKey;
import java.security.PublicKey;
import java.security.SecureRandom;
import java.security.interfaces.RSAPrivateKey;
import java.security.interfaces.RSAPublicKey;
import java.security.spec.InvalidKeySpecException;
import java.security.spec.RSAPrivateKeySpec;
import java.security.spec.RSAPublicKeySpec;
import javax.crypto.Cipher;
/**
* RSA å·¥å ·ç±»ãæä¾å å¯ï¼è§£å¯ï¼çæå¯é¥å¯¹çæ¹æ³ã
* éè¦å°http://www.bouncycastle.orgä¸è½½bcprov-jdk-.jarã
*
*/
public class RSAUtil {
/**
* * çæå¯é¥å¯¹ *
*
* @return KeyPair *
* @throws EncryptException
*/
public static KeyPair generateKeyPair() throws Exception {
try {
KeyPairGenerator keyPairGen = KeyPairGenerator.getInstance("RSA",
new org.bouncycastle.jce.provider.BouncyCastleProvider());
final int KEY_SIZE = ;// 没ä»ä¹å¥½è¯´çäºï¼è¿ä¸ªå¼å ³ç³»å°åå å¯ç大å°ï¼å¯ä»¥æ´æ¹ï¼ä½æ¯ä¸è¦å¤ªå¤§ï¼å¦åæçä¼ä½
keyPairGen.initialize(KEY_SIZE, new SecureRandom());
KeyPair keyPair = keyPairGen.generateKeyPair();
saveKeyPair(keyPair);
return keyPair;
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}
public static KeyPair getKeyPair()throws Exception{
FileInputStream fis = new FileInputStream("C:/RSAKey.txt");
ObjectInputStream oos = new ObjectInputStream(fis);
KeyPair kp= (KeyPair) oos.readObject();
oos.close();
fis.close();
return kp;
}
public static void saveKeyPair(KeyPair kp)throws Exception{
FileOutputStream fos = new FileOutputStream("C:/RSAKey.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);
//çæå¯é¥
oos.writeObject(kp);
oos.close();
fos.close();
}
/**
* * çæå ¬é¥ *
*
* @param modulus *
* @param publicExponent *
* @return RSAPublicKey *
* @throws Exception
*/
public static RSAPublicKey generateRSAPublicKey(byte[] modulus,
byte[] publicExponent) throws Exception {
KeyFactory keyFac = null;
try {
keyFac = KeyFactory.getInstance("RSA",
new org.bouncycastle.jce.provider.BouncyCastleProvider());
} catch (NoSuchAlgorithmException ex) {
throw new Exception(ex.getMessage());
}
RSAPublicKeySpec pubKeySpec = new RSAPublicKeySpec(new BigInteger(
modulus), new BigInteger(publicExponent));
try {
return (RSAPublicKey) keyFac.generatePublic(pubKeySpec);
} catch (InvalidKeySpecException ex) {
throw new Exception(ex.getMessage());
}
}
/**
* * çæç§é¥ *
*
* @param modulus *
* @param privateExponent *
* @return RSAPrivateKey *
* @throws Exception
*/
public static RSAPrivateKey generateRSAPrivateKey(byte[] modulus,
byte[] privateExponent) throws Exception {
KeyFactory keyFac = null;
try {
keyFac = KeyFactory.getInstance("RSA",
new org.bouncycastle.jce.provider.BouncyCastleProvider());
} catch (NoSuchAlgorithmException ex) {
throw new Exception(ex.getMessage());
}
RSAPrivateKeySpec priKeySpec = new RSAPrivateKeySpec(new BigInteger(
modulus), new BigInteger(privateExponent));
try {
return (RSAPrivateKey) keyFac.generatePrivate(priKeySpec);
} catch (InvalidKeySpecException ex) {
throw new Exception(ex.getMessage());
}
}
/**
* * å å¯ *
*
* @param key
* å å¯çå¯é¥ *
* @param data
* å¾ å å¯çæææ°æ® *
* @return å å¯åçæ°æ® *
* @throws Exception
*/
public static byte[] encrypt(PublicKey pk, byte[] data) throws Exception {
try {
Cipher cipher = Cipher.getInstance("RSA",
new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(Cipher.ENCRYPT_MODE, pk);
int blockSize = cipher.getBlockSize();// è·å¾å å¯å大å°ï¼å¦ï¼å å¯åæ°æ®ä¸ºä¸ªbyteï¼èkey_size=
// å å¯å大å°ä¸º
// byte,å å¯å为个byte;å æ¤å ±æ2个å å¯åï¼ç¬¬ä¸ä¸ª
// byte第äºä¸ªä¸º1个byte
int outputSize = cipher.getOutputSize(data.length);// è·å¾å å¯åå å¯åå大å°
int leavedSize = data.length % blockSize;
int blocksSize = leavedSize != 0 ? data.length / blockSize + 1
: data.length / blockSize;
byte[] raw = new byte[outputSize * blocksSize];
int i = 0;
while (data.length - i * blockSize > 0) {
if (data.length - i * blockSize > blockSize)
cipher.doFinal(data, i * blockSize, blockSize, raw, i
* outputSize);
else
cipher.doFinal(data, i * blockSize, data.length - i
* blockSize, raw, i * outputSize);
// è¿éé¢doUpdateæ¹æ³ä¸å¯ç¨ï¼æ¥çæºä»£ç ååç°æ¯æ¬¡doUpdateå并没æä»ä¹å®é å¨ä½é¤äºæbyte[]æ¾å°
// ByteArrayOutputStreamä¸ï¼èæådoFinalçæ¶åæå°ææçbyte[]è¿è¡å å¯ï¼å¯æ¯å°äºæ¤æ¶å å¯å大å°å¾å¯è½å·²ç»è¶ åºäº
// OutputSizeæ以åªå¥½ç¨dofinalæ¹æ³ã
i++;
}
return raw;
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}
/**
* * è§£å¯ *
*
* @param key
* 解å¯çå¯é¥ *
* @param raw
* å·²ç»å å¯çæ°æ® *
* @return 解å¯åçææ *
* @throws Exception
*/
public static byte[] decrypt(PrivateKey pk, byte[] raw) throws Exception {
try {
Cipher cipher = Cipher.getInstance("RSA",
new org.bouncycastle.jce.provider.BouncyCastleProvider());
cipher.init(cipher.DECRYPT_MODE, pk);
int blockSize = cipher.getBlockSize();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
int j = 0;
while (raw.length - j * blockSize > 0) {
bout.write(cipher.doFinal(raw, j * blockSize, blockSize));
j++;
}
return bout.toByteArray();
} catch (Exception e) {
throw new Exception(e.getMessage());
}
}
/**
* * *
*
* @param args *
* @throws Exception
*/
public static void main(String[] args) throws Exception {
RSAPublicKey rsap = (RSAPublicKey) RSAUtil.generateKeyPair().getPublic();
String test = "hello world";
byte[] en_test = encrypt(getKeyPair().getPublic(),test.getBytes());
byte[] de_test = decrypt(getKeyPair().getPrivate(),en_test);
System.out.println(new String(de_test));
}
}
2.æµè¯é¡µé¢ï¼
IndexAction.java
RSA加密算法对字符串加密(C++语言)看见你之前回答过这个问题,可不可以把源代码给我?
我来说几句没代码的吧,另外我是搞JAVA的!
RSA是不对称的加密算法,涉及到一对密钥:公钥和私钥,公钥是公开的,别人想给我发送信息就用公钥进行加密,私钥是自己独有,收到别人发送的密文,就用私钥进行解密。
生成公钥与私钥
选择一对不同的、足够大(是后面的n大于消息数)的素数p、q,计算n=p*q,f(n)=p*q。
找一个与f(n)互质的数e,计算d,让d*e模f(n)=1(打不出同余符号,就是让d*e与1模f(n)结果一样)。
公钥(e,n),私钥(d,n)
设明文为M,
加密:密文=M的e次方 mod n
解密:明文=密文的d次方 mod n
例子:取p=5、q=。
n=,f(n)=,
去e=3
d=,
公钥(3,),私钥(,)
对字符串 “FLY”加密,先将按A-1,B-2……,z-将其数字化,得到6,,
6的3次方mod=,
的3次方mod=,
的3次方mod=5,
密文,,5
解密:
的次方mod=6,
的次方mod=
5的次方mod=,
基本思路就这样,不过实现过程会涉及到大数,推荐一个算mod的方法:
(A+B)的n次方对C取模,设A mod C=0,那么(A+B)的n次方mod C=B的n次方mod C,
以上面的次方mod为例:
的次方=的3次方的9次方=的9次方,=*+,
那么的次方mod=(*+)的9次方mod=的9次方mod,
以此类推,上式继续=的三次方mod=的三次方mod=6;