加密字符串破解
char
ch,name[30],over;
FILE
*fp;
printf("请输入要加密的文件名（正确的做法是：先把解密的数不知道，你想要什么样的加密算法。
AES不错。不过AES是对16个字节长度加密，要是不是16的倍数，处理有点麻烦据保存到字符串里，全部结束之后，一次性把解密
B. 如何解密以前加密通过OpenSSL加密的字符串
#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,65537)) //这里选择奇数65537 { printf("BN_set_word failed\n"); goto FAIL1; } //这里molus的长度选择4096，小于1024的molus长度都是不安全的，容易被破解 if(0==RSA_generate_key_ex(rsa,4096,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_PADDINGEME-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_SSLV23_PADDINGPKCS #1 v1.5 padding with an SSL-specific modification that denotes that the server is SSL3 capable.RSA_NO_PADDINGRaw 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)） //这里分配一个长度为250的字符数组，应该是够用的。 char decrypted_str[250]; int decrypted_len; if(-1=(decrypted_len=RSA_private_decrypt(256,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中的加密算法库，后者是用于成功加载动态库。
C. 字符串加密对方知道加密方式
字符串加密对方知道加密方式具体解决步骤如下：
1、使用单向加密算法：只能加密，不能解密的算法对方就解不了了。
2、使用双向加密算法：能加密，加密的数据能解密得到明文数据，这个方法很难破解。
3、扩展：加密就是将一个明文数据，按照指定的算法，运算得到一个别的隐藏真实信息的密文数据，这个过程称为加密。处理的算法称为加密算法。用到的关键数据称为密钥。
D. 如何使用java实现对字符串的DES加密和解密
java加密字符串可以使用des加密算法，实例如下：
package test;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.security.*;
import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.SecretKey;
/**
* 加密解密
*
* @author shy.qiu
* @since http://blog.csdn.net/qiushyfm
*/
public class CryptTest {
/**
* 进行MD5加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToMD5(String info) {
byte[] digesta = null;
try {
// 得到一个md5的消息摘要
MessageDigest alga = MessageDigest.getInstance("MD5");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
/**
* 进行SHA加密
*
* @param info
* 要加密的信息
* @return String 加密后的字符串
*/
public String encryptToSHA(String info) {
byte[] digesta = null;
try {
// 得到一个SHA-1的消息摘要
MessageDigest alga = MessageDigest.getInstance("SHA-1");
// 添加要进行计算摘要的信息
alga.update(info.getBytes());
// 得到该摘要
digesta = alga.digest();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 将摘要转为字符串
String rs = byte2hex(digesta);
return rs;
}
// //////////////////////////////////////////////////////////////////////////
/**
* 创建密匙
*
* @param algorithm
* 加密算法,可用 DES,DESede,Blowfish
* @return SecretKey 秘密（对称）密钥
*/
public SecretKey createSecretKey(String algorithm) {
// 声明KeyGenerator对象
KeyGenerator keygen;
// 声明 密钥对象
SecretKey deskey = null;
try {
// 返回生成指定算法的秘密密钥的 KeyGenerator 对象
keygen = KeyGenerator.getInstance(algorithm);
// 生成一个密钥
deskey = keygen.generateKey();
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
// 返回密匙
return deskey;
}
/**
* 根据密匙进行DES加密
*
* @param key
* 密匙
* @param info
* 要加密的信息
* @return String 加密后的信息
*/
public String encryptToDES(SecretKey key, String info) {
// 定义 加密算法,可用 DES,DESede,Blowfish
String Algorithm = "DES";
// 加密随机数生成器 (RNG),(可以不写)
SecureRandom sr = new SecureRandom();
// 定义要生成的密文
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
// 参数:(ENCRYPT_MODE, DECRYPT_MODE, WRAP_MODE,UNWRAP_MODE)
c1.init(Cipher.ENCRYPT_MODE, key, sr);
// 对要加密的内容进行编码处理,
cipherByte = c1.doFinal(info.getBytes());
} catch (Exception e) {
e.printStackTrace();
}
// 返回密文的十六进制形式
return byte2hex(cipherByte);
}
/**
* 根据密匙进行DES解密
*
* @param key
* 密匙
* @param sInfo
* 要解密的密文
* @return String 返回解密后信息
*/
public String decryptByDES(SecretKey key, String sInfo) {
// 定义 加密算法,
String Algorithm = "DES";
// 加密随机数生成器 (RNG)
SecureRandom sr = new SecureRandom();
byte[] cipherByte = null;
try {
// 得到加密/解密器
Cipher c1 = Cipher.getInstance(Algorithm);
// 用指定的密钥和模式初始化Cipher对象
c1.init(Cipher.DECRYPT_MODE, key, sr);
// 对要解密的内容进行编码处理
cipherByte = c1.doFinal(hex2byte(sInfo));
} catch (Exception e) {
e.printStackTrace();
}
// return byte2hex(cipherByte);
return new String(cipherByte);
}
// /////////////////////////////////////////////////////////////////////////////
/**
* 创建密匙组，并将公匙，私匙放入到指定文件中
*
* 默认放入mykeys.bat文件中
*/
public void createPairKey() {
try {
// 根据特定的算法一个密钥对生成器
KeyPairGenerator keygen = KeyPairGenerator.getInstance("DSA");
// 加密随机数生成器 (RNG)
SecureRandom random = new SecureRandom();
// 重新设置此随机对象的种子
random.setSeed(1000);
// 使用给定的随机源（和默认的参数集合）初始化确定密钥大小的密钥对生成器
keygen.initialize(512, random);// keygen.initialize(512);
// 生成密钥组
KeyPair keys = keygen.generateKeyPair();
// 得到公匙
PublicKey pubkey = keys.getPublic();
// 得到私匙
PrivateKey prikey = keys.getPrivate();
// 将公匙私匙写入到文件当中
doObjToFile("mykeys.bat", new Object[] { prikey, pubkey });
} catch (NoSuchAlgorithmException e) {
e.printStackTrace();
}
}
/**
* 利用私匙对信息进行签名 把签名后的信息放入到指定的文件中
*
* @param info
* 要签名的信息
* @param signfile
* 存入的文件
*/
public void signToInfo(String info, String signfile) {
// 从文件当中读取私匙
PrivateKey myprikey = (PrivateKey) getObjFromFile("mykeys.bat", 1);
// 从文件中读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile("mykeys.bat", 2);
try {
// Signature 对象可用来生成和验证数字签名
Signature signet = Signature.getInstance("DSA");
// 初始化签署签名的私钥
signet.initSign(myprikey);
// 更新要由字节签名或验证的数据
signet.update(info.getBytes());
// 签署或验证所有更新字节的签名，返回签名
byte[] signed = signet.sign();
// 将数字签名,公匙,信息放入文件中
doObjToFile(signfile, new Object[] { signed, mypubkey, info });
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 读取数字签名文件 根据公匙，签名，信息验证信息的合法性
*
* @return true 验证成功 false 验证失败
*/
public boolean validateSign(String signfile) {
// 读取公匙
PublicKey mypubkey = (PublicKey) getObjFromFile(signfile, 2);
// 读取签名
byte[] signed = (byte[]) getObjFromFile(signfile, 1);
// 读取信息
String info = (String) getObjFromFile(signfile, 3);
try {
// 初始一个Signature对象,并用公钥和签名进行验证
Signature signetcheck = Signature.getInstance("DSA");
// 初始化验证签名的公钥
signetcheck.initVerify(mypubkey);
// 使用指定的 byte 数组更新要签名或验证的数据
signetcheck.update(info.getBytes());
System.out.println(info);
// 验证传入的签名
return signetcheck.verify(signed);
} catch (Exception e) {
e.printStackTrace();
return false;
}
}
/**
* 将二进制转化为16进制字符串
*
* @param b
* 二进制字节数组
* @return String
*/
public String byte2hex(byte[] b) {
String hs = "";
String stmp = "";
for (int n = 0; n < b.length; n++) {
stmp = (java.lang.Integer.toHexString(b[n] & 0XFF));
if (stmp.length() == 1) {
hs = hs + "0" + stmp;
} else {
hs = hs + stmp;
}
}
return hs.toUpperCase();
}
/**
* 十六进制字符串转化为2进制
*
* @param hex
* @return
*/
public byte[] hex2byte(String hex) {
byte[] ret = new byte[8];
byte[] tmp = hex.getBytes();
for (int i = 0; i < 8; i++) {
ret[i] = uniteBytes(tmp[i * 2], tmp[i * 2 + 1]);
}
return ret;
}
/**
* 将两个ASCII字符合成一个字节； 如："EF"--> 0xEF
*
* @param src0
* byte
* @param src1
* byte
* @return byte
*/
public static byte uniteBytes(byte src0, byte src1) {
byte _b0 = Byte.decode("0x" + new String(new byte[] { src0 }))
.byteValue();
_b0 = (byte) (_b0 << 4);
byte _b1 = Byte.decode("0x" + new String(new byte[] { src1 }))
.byteValue();
byte ret = (byte) (_b0 ^ _b1);
return ret;
}
/**
* 将指定的对象写入指定的文件
*
* @param file
* 指定写入的文件
* @param objs
* 要写入的对象
*/
public void doObjToFile(String file, Object[] objs) {
ObjectOutputStream oos = null;
try {
FileOutputStream fos = new FileOutputStream(file);
oos = new ObjectOutputStream(fos);
for (int i = 0; i < objs.length; i++) {
oos.writeObject(objs[i]);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
oos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
/**
* 返回在文件中指定位置的对象
*
* @param file
* 指定的文件
* @param i
* 从1开始
* @return
*/
public Object getObjFromFile(String file, int i) {
ObjectInputStream ois = null;
Object obj = null;
try {
FileInputStream fis = new FileInputStream(file);
ois = new ObjectInputStream(fis);
for (int j = 0; j < i; j++) {
obj = ois.readObject();
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
ois.close();
} catch (IOException e) {
e.printStackTrace();
}
}
return obj;
}
/**
* 测试
*
* @param args
*/
public static void main(String[] args) {
CryptTest jiami = new CryptTest();
// 执行MD5加密"Hello world!"
System.out.println("Hello经过MD5:" + jiami.encryptToMD5("Hello"));
// 生成一个DES算法的密匙
SecretKey key = jiami.createSecretKey("DES");
// 用密匙加密信息"Hello world!"
String str1 = jiami.encryptToDES(key, "Hello");
System.out.println("使用des加密信息Hello为:" + str1);
// 使用这个密匙解密
String str2 = jiami.decryptByDES(key, str1);
System.out.println("解密后为：" + str2);
// 创建公匙和私匙
jiami.createPairKey();
// 对Hello world!使用私匙进行签名
jiami.signToInfo("Hello", "mysign.bat");
// 利用公匙对签名进行验证。
if (jiami.validateSign("mysign.bat")) {
System.out.println("Success!");
} else {
System.out.println("Fail!");
}
}
}
E. 编写函数完成字符串的加密与解密（c语言）
C语言代码和运行结果如下：
输出符合示例，加解密均正确，望采纳~
附源码链接：字符串加解密
F. 字符的加密和解密
创建3个文本框名称分别为:
txtCode 用于显示加密后的字符串
txtRecode 用于显示解密后的字符串
txtInput 用于输入要加密的字符串
创建3个按钮,名称分别为:
cmdcls 清屏
cmdcode 加密
cmdrecode 解密
Dim strInput$, Code$, Record$, c As String * 1
Dim i%, length%, iAsc%
Private Sub cmdcls_Click() '清屏
txtCode.Text = ""
txtRecode.Text = ""
txtInput.Text = ""
End Sub
Private Sub cmdcode_Click() '加密
Dim strInput$, Code$, Record$, c As String * 1
Dim i%, length%, iAsc%
strInput = txtInput.Text
length = Len(RTrim(strInput)) '去掉字符串右边的空格,求真正的长度
Code = ""
For i = 1 To length
c = Mid$(strInput, i, 1) '取第i个字符
Select Case c
Case "A" To "Z" '大写字母加序数5加密
iAsc = Asc(c) + 5
If iAsc > Asc("Z") Then iAsc = iAsc - 26 '加密后字母超过Z
Code = Code + Chr$(iAsc)
Case "a" To "z"
iAsc = Asc(c) + 5 '小写字母加序数5加密
If iAsc > Asc("z") Then iAsc = iAsc - 26
Code = Code + Chr$(iAsc)
Case Else '当第i个字符为其它字符时不加密,与加密字符串的前i-1个字符连接
Code = Code + c
End Select
Next i
txtCode.Text = Code '显示加密后的字符串
End Sub
Private Sub cmdrecode_Click() '解密与加密正好逆处理
Code = txtCode.Text
i = 1
recode = ""
length = Len(RTrim(Code)) '若还未加密,不能解密,出错
If length = 0 Then J = MsgBox("先加密再解密", 48, "解密出错")
Do While (i <= length)
c = Mid$(Code, i, 1)
If (c >= "A" And c <= "Z") Then
iAsc = Asc(c) - 5
If iAsc < Asc("A") Then iAsc = iAsc + 26
recode = Left$(recode, i - 1) + Chr$(iAsc)
ElseIf (c >= "a" And c <= "z") Then
iAsc = Asc(c) - 5
If iAsc < Asc("a") Then iAsc = iAsc + 26
recode = Left$(recode, i - 1) + Chr$(iAsc)
Else
recode = Left$(recode, i - 1) + c
End If
i = i + 1
Loop
txtRecode.Text = recode
End Sub
G. 12:字符串加密、解密
编码： 将计算机中的字符串按照一定的顺序表示成二进制数据的过程
各国字符编码都不一样：
1、计算机-> 表示[英文字母、数字、部分特殊符号]-> ascii编码 [0~256]
2、万国码，统一字符编码[号称可以统一全球范围内任何语言的表示方式]
任何语言中的任何数据，都可以使用一个字符来表示 unicode编码
3、中国有GB2312-> GBK -> GB18030
4、数据传输编码：unicode transfer format 8 bit [UTF-8]
python中的编码解码：
要命的规则：字符串的编码解码，一直都是任何语言中一个难点和重点
任何字符串->都是由字节组成的！
python3中：字符：(str)；字节(bytes)
字符->字节：encode 编码：将一个字符串编码成计算机可以操作的二进制数据
字节->字符：decode 解码：将一个二进制数据按照指定的编码~解码成自然数据
什么是加密： 将一个明文数据，按照指定的算法，运算得到一个其他的可以隐藏真实信息的密文数据，这个过程称为加密；处理的算法称为加密算法；用到的关键数据称为密钥
什么是解密： 按照指定的算法和关键数据，将一个密文数据进行逆向运算得到正确的明文数据的过程成为解密操作
（1）、单向加密算法：只能加密，不能解密的算法
如：用户账号密码(单向加密)存储，此时任何人都不能查看该用户的明文密码
流程->用户输入明文密码->加密->和存储的密文密码进行比较->相等-成功
单向散列加密算法-> MD5加密
单项哈希加密算法-> SHAX加密
（2）、双向加密算法：可以加密，加密的数据可以解密得到明文数据
使用在更多的场景；数据进行加密传输->目标地址->解密得到明文数据进行处理
对称加密：加密和解密使用相同的秘钥；
非对称加密：加密和解密使用不同的秘钥；如HTTPS传输数据
hashlib主要提供字符加密功能，将md5和sha模块整合到了一起，支持md5,sha1, sha224, sha256, sha384, sha512等算法
注意： hashlib 加密啊的字符串类型为二进制编码，直接加密字符串会报如下错误：
有两种方式可以将字符串转化为二进制数据
H. 在java快速和简单的字符串加密/解密问题，怎么解决
publicclassTest{
publicstaticvoidmain(String[]args)throwsException{
Stringa="在java快速和简单的字符串加密/解密问题，怎么解决";
System.out.println("原字符串:"+a);
Stringb=deal(a,(byte)88);//88为加密密钥
System.out.println("加密后字符串:"+b);
Stringc=deal(b,(byte)88);//88为解密密钥，要和加密一致，否则无法解密
System.out.println("解密后字符串:"+c);}
/**
*简单加密加密解密字符串<br/>
*加密解密思路：先将字符串变成byte数组，再将数组每位与key做位运算，得到新的数组就是加密或解密后的byte数组.<br/>
*知识：^是java位运算，可以网络了解下，a=b^skey反之也成立，即b=a^skey
*@paramstr解密/加密字符串
*@paramskey解密/加密密钥（加密解密为同一个密钥才能解密，否则是乱码）
*@return
*@throwsException
*/
staticStringdeal(Stringstr,byteskey)throwsException{
byte[]bytes=str.getBytes("GBK");
for(inti=0;i<bytes.length;i++){
bytes[i]=(byte)(bytes[i]^skey);
}
returnnewString(bytes,"GBK");
}
}