手机设备加密解决方案？急求 MD5的加密解密算法，用C++实现的源代码高分答谢

：暂无数据 2026-10-29 20:40:29 ：2

其实加密解密的问题并不复杂，但是又很多的朋友都不太了解手机设备加密解决方案，因此呢，今天小编就来为大家分享加密解密的一些知识，希望可以帮助到大家，下面我们一起来看看这个问题的分析吧！

本文目录

手机设备加密解决方案
急求 MD5的加密解密算法，用C++实现的源代码高分答谢
文件加密方法大全
凤凰卫士怎么设置自动解密功能
VB MD5加密解密的代码
.net中md5具体怎么使用加密和解密
Java 加密解密的方法都有哪些
高分求java的RSA 和IDEA 加密解密算法
使用第三方软件加密怎么解除
讲讲md5加密

手机设备加密解决方案

根据描述的情况，请您检查手机中是否设置了设备加密或加密SD卡的功能。如有设置，建议先解密设备或解密外置SD卡。
:locked:取消设备加密
取消设备加密。方式:设定-安全-解密设备-点击“解密设备”-输入锁屏密码-再次点击屏幕下方的“解密设备”字样-等待完成。注意:取消设备加密时手机需要连接充电器。
:locked:取消SD卡加密
取消SD卡加密。方式:设定-安全-加密SD卡-点击左下角“关闭”-输入密码-点击“应用”，等待解密，解密后按返回键退出即可。解密设备或外置SD卡后再更改锁屏方式即可。操作:设定-安全--设置屏幕锁定点击后输入锁屏密码--选择其他锁屏方式如“无”即可。

急求 MD5的加密解密算法，用C++实现的源代码高分答谢

要代码，还是要相关的解释资料？
---------------------------------
要代码的话：
两个文件：
--------------------------
1. md5.h：
#pragma once
typedef unsigned long int UINT32;
typedef unsigned short int UINT16;
/* MD5 context. */
typedef struct {
UINT32 state; /* state (ABCD) */
UINT32 count; /* number of bits, modulo 2^64 (lsb first) */
unsigned char buffer; /* input buffer */
} MD5_CTX;
void MD5Init (MD5_CTX *);
void MD5Update (MD5_CTX *, unsigned char *, unsigned int);
void MD5Final (unsigned char , MD5_CTX *);
--------------------------
2. md5.cpp：
#include "md5.h"
#include "memory.h"
#define S11 7
#define S12 12
#define S13 17
#define S14 22
#define S21 5
#define S22 9
#define S23 14
#define S24 20
#define S31 4
#define S32 11
#define S33 16
#define S34 23
#define S41 6
#define S42 10
#define S43 15
#define S44 21
static void MD5Transform (UINT32 a);
static void Encode (unsigned char *, UINT32 *, unsigned int);
static void Decode (UINT32 *, unsigned char *, unsigned int);
static unsigned char PADDING = {
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
#define F(x, y, z) (((x) & (y)) | ((~x) & (z)))
#define G(x, y, z) (((x) & (z)) | ((y) & (~z)))
#define H(x, y, z) ((x) ^ (y) ^ (z))
#define I(x, y, z) ((y) ^ ((x) | (~z)))
#define ROTATE_LEFT(x, n) (((x) 《《 (n)) | ((x) 》》 (32-(n))))
#define FF(a, b, c, d, x, s, ac) { \
(a) += F ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define GG(a, b, c, d, x, s, ac) { \
(a) += G ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define HH(a, b, c, d, x, s, ac) { \
(a) += H ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
#define II(a, b, c, d, x, s, ac) { \
(a) += I ((b), (c), (d)) + (x) + (UINT32)(ac); \
(a) = ROTATE_LEFT ((a), (s)); \
(a) += (b); \
}
void MD5Init (MD5_CTX *context)
{
context-》count = 0;
context-》state = 0x67452301;
context-》state = 0xefcdab89;
context-》state = 0x98badcfe;
context-》state = 0x10325476;
}
void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
unsigned int i, index, partLen;

index = (unsigned int)((context-》count 》》 3) & 0x3F);

if ((context-》count += ((UINT32)inputLen 《《 3))
《 ((UINT32)inputLen 《《 3))
context-》count++;
context-》count += ((UINT32)inputLen 》》 29);

partLen = 64 - index;
if (inputLen 》= partLen) {
memcpy((unsigned char *)&context-》buffer, (unsigned char *)input, partLen);
MD5Transform (context-》state, context-》buffer);

for (i = partLen; i + 63 《 inputLen; i += 64)
MD5Transform (context-》state, &input);

index = 0;
}
else
i = 0;

memcpy((unsigned char *)&context-》buffer,
inputLen-i);
}
void MD5Final (unsigned char digest, MD5_CTX * context)
{
unsigned char bits;
unsigned int index, padLen;

Encode (bits, context-》count, 8);

index = (unsigned int)((context-》count 》》 3) & 0x3f);
padLen = (index 《 56) ? (56 - index) : (120 - index);
MD5Update (context, PADDING, padLen);

MD5Update (context, bits, 8);

Encode (digest, context-》state, 16);

memset ((unsigned char *)context, 0, sizeof (*context));
}
static void MD5Transform (UINT32 state)
{
UINT32 a = state;

Decode (x, block, 64);

/* Round 1 */
FF (a, b, c, d, x, S11, 0xd76aa478); /* 1 */
FF (d, a, b, c, x, S12, 0xe8c7b756); /* 2 */
FF (c, d, a, b, x, S13, 0x242070db); /* 3 */
FF (b, c, d, a, x, S14, 0xc1bdceee); /* 4 */
FF (a, b, c, d, x, S11, 0xf57c0faf); /* 5 */
FF (d, a, b, c, x, S12, 0x4787c62a); /* 6 */
FF (c, d, a, b, x, S13, 0xa8304613); /* 7 */
FF (b, c, d, a, x, S14, 0xfd469501); /* 8 */
FF (a, b, c, d, x, S11, 0x698098d8); /* 9 */
FF (d, a, b, c, x, S12, 0x8b44f7af); /* 10 */
FF (c, d, a, b, x, S13, 0xffff5bb1); /* 11 */
FF (b, c, d, a, x, S14, 0x895cd7be); /* 12 */
FF (a, b, c, d, x, S11, 0x6b901122); /* 13 */
FF (d, a, b, c, x, S12, 0xfd987193); /* 14 */
FF (c, d, a, b, x, S13, 0xa679438e); /* 15 */
FF (b, c, d, a, x, S14, 0x49b40821); /* 16 */

/* Round 2 */
GG (a, b, c, d, x, S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x, S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x, S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x, S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x, S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x, S22, 0x2441453); /* 22 */
GG (c, d, a, b, x, S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x, S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x, S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x, S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x, S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x, S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x, S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x, S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x, S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x, S24, 0x8d2a4c8a); /* 32 */

/* Round 3 */
HH (a, b, c, d, x, S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x, S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x, S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x, S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x, S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x, S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x, S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x, S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x, S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x, S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x, S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x, S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x, S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x, S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x, S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x, S34, 0xc4ac5665); /* 48 */

/* Round 4 */
II (a, b, c, d, x, S41, 0xf4292244); /* 49 */
II (d, a, b, c, x, S42, 0x432aff97); /* 50 */
II (c, d, a, b, x, S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x, S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x, S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x, S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x, S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x, S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x, S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x, S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x, S43, 0xa3014314); /* 59 */
II (b, c, d, a, x, S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x, S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x, S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x, S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x, S44, 0xeb86d391); /* 64 */

state += a;
state += b;
state += c;
state += d;

memset ((unsigned char *)x, 0, sizeof (x));
}
static void Encode (unsigned char *output, UINT32 *input, unsigned int len)
{
unsigned int i, j;

for (i = 0, j = 0; j 《 len; i++, j += 4) {
output & 0xff);
output 》》 8) & 0xff);
output 》》 16) & 0xff);
output 》》 24) & 0xff);
}
}
static void Decode (UINT32 *output, unsigned char *input, unsigned int len)
{
unsigned int i, j;

for (i = 0, j = 0; j 《 len; i++, j += 4)
output) 《《 8) |
(((UINT32)input) 《《 24);
}
--------------------------
就这两个文件。使用的时候把它们加入工程或者makefile，调用时包含md5.h即可，给个简单的例子，输入一个字符串然后计算它的md5值并输出，在VC6.0和GCC4.4下测试通过：
#include 《stdio.h》
#include 《string.h》
#include "md5.h"
int main ()
{
char tmp;
unsigned char digest;

MD5_CTX context;

scanf("%s",tmp);

MD5Init (&context);
MD5Update (&context, (unsigned char*)tmp, strlen(tmp));
MD5Final (digest,&context);
printf("MD5Value:");
for(int i=0; i《16; ++i)
{
printf("%02X",digest);
}
printf("\n");
return 0;
}

文件加密方法大全

文件加密是一种保护文件安全的方法，下面介绍几种常见的文件加密方法。
:locked:后缀名加密法
将你想保密的文件改为一个任意字符的后缀名，如将123.doc改为456.swc，别人很难知道其中的秘密。
:file_folder:目录欺骗法
新建一个目录，把想保密的文件放入该文件夹，然后将文件夹改名为“123.wav.{00020c01-0000-0000-c000-000000000046}”，你会看到你的这个文件夹会变成一个WAV文件的图标，想浏览该文件需要在“资源管理器”里。
:laptop:文件加密软件
使用一些专业的文件加密软件即可，这一类软件网上多的是，大家可以搜索下载。
:key:硬件加密
利用一些诸如“硬件狗”等这类工具进行相关的设定，使用计算机时必须使用这类硬件才能正常启动电脑和使用。
:electric_plug:USB接口加密锁
微星公司为其主板专门设计的USB接口加密锁，只有当计算机插上这个加密锁之后，才能进操作系统和正常使用。

凤凰卫士怎么设置自动解密功能

凤凰卫士是一款加密解密工具，它可以对文件、文件夹进行加密，同时还支持自动解密功能。要设置凤凰卫士的自动解密功能，可以按照以下步骤进行：
步骤1：打开凤凰卫士软件，点击“设置”按钮。
步骤2：在弹出的设置窗口中，选择“自动解密”选项卡。
步骤3：在自动解密选项卡中，勾选“启用自动解密”选项，并设置解密密码。如果需要，还可以设置自动解密的文件夹路径和解密后的保存路径。
步骤4：点击“确定”按钮保存设置。
通过设置自动解密功能，用户可以方便地将加密的文件自动解密，无需手动输入密码。这在日常使用中非常方便。同时，自动解密功能需要用户输入解密密码，可以保证文件的安全性。
需要注意的是，在设置自动解密功能时，用户需要选择一个相对安全的文件夹路径，以免他人轻易地获取解密后的文件。此外，用户还需要定期更换解密密码，以确保文件的安全性。

VB MD5加密解密的代码

Dim md5 As New MD5CryptoServiceProvider
Dim username As Byte() = (New ASCIIEncoding).GetBytes(TextBox1.Text)
’转换为哈希值Byte数组
Dim mdByte As Byte() = md5.ComputeHash(username)
’Dim mdString As String = System.BitConverter.ToString(mdByte)
Dim mdString As String = (New ASCIIEncoding).GetString(mdByte)
TextBox2.Text = mdString
md5理论上是不可破解的，要对照，只能再次加密后对照，网上也有些专门破解的网站，不过我想你要的不是那个吧

.net中md5具体怎么使用加密和解密

using System;\x0d\x0ausing System.Text;\x0d\x0ausing System.Security.Cryptography;\x0d\x0a\x0d\x0anamespace MD5\x0d\x0a{\x0d\x0a public class MD5\x0d\x0a {\x0d\x0a // 32 位\x0d\x0a public static String Encrypt(String s)\x0d\x0a {\x0d\x0a MD5 md5 = new MD5CryptoServiceProvider();\x0d\x0a byte, 16).PadLeft(2, ’0’);\x0d\x0a }\x0d\x0a\x0d\x0a return ret.PadLeft(32, ’0’);\x0d\x0a }\x0d\x0a\x0d\x0a// 16 位\x0d\x0a public static string Encrypt16(string ConvertString)\x0d\x0a {\x0d\x0a MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();\x0d\x0a string t2 = BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes(ConvertString)), 4, 8);\x0d\x0a t2 = t2.Replace("-", "");\x0d\x0a return t2;\x0d\x0a } \x0d\x0a }\x0d\x0a}\x0d\x0a\x0d\x0a-------------------------------------\x0d\x0a引用MD5命名空间\x0d\x0ausing MD5;\x0d\x0a直接用MD5.Encrypt(textbox1.Text);即可加密；\x0d\x0aMD5没有解密的算法，要不然就不用加密了，网上有一些解密的网站，有些能解密，有些解密不了，有些还需要收费才能解密。

Java 加密解密的方法都有哪些

加密解密并非java才有的，所有编程语言都有加密和解密。

目前的加密解密主要可分为以下2大类：

对称秘钥加密：如DES算法，3DES算法，TDEA算法，Blowfish算法，RC5算法，IDEA算法等。其主要特点是加密方和解密方都有同一个密码，加密方和解密方可以使用秘钥任意加密解密。
非对称密码加密：这种加密方式加密方仅有加密秘钥，对加密后的密文无法反向解密，解密方仅有解密秘钥，无法对明文进行加密。

另外还有一些摘要算法，比如MD5和HASH此类算法不可逆，但经常用来作为确认字段或者对一些重要匹配信息签名防止明文内容被修改。

高分求java的RSA 和IDEA 加密解密算法

RSA算法非常简单，概述如下：
找两素数p和q
取n=p*q
取t=(p-1)*(q-1)
取任何一个数e,要求满足e《t并且e与t互素（就是最大公因数为1）
取d*e%t==1
这样最终得到三个数： n d e
设消息为数M (M 《n)
设c=(M**d)%n就得到了加密后的消息c
设m=(c**e)%n则 m == M，从而完成对c的解密。
注：**表示次方,上面两式中的d和e可以互换。
在对称加密中：
n d两个数构成公钥，可以告诉别人；
n e两个数构成私钥，e自己保留，不让任何人知道。
给别人发送的信息使用e加密，只要别人能用d解开就证明信息是由你发送的，构成了签名机制。
别人给你发送信息时使用d加密，这样只有拥有e的你能够对其解密。
rsa的安全性在于对于一个大数n，没有有效的方法能够将其分解
从而在已知n d的情况下无法获得e；同样在已知n e的情况下无法
求得d。
《二》实践
接下来我们来一个实践，看看实际的操作：
找两个素数：
p=47
q=59
这样
n=p*q=2773
t=(p-1)*(q-1)=2668
取e=63，满足e《t并且e和t互素
用perl简单穷举可以获得满主 e*d%t ==1的数d：
C:\Temp》perl -e "foreach $i (1..9999){ print($i),last if $i*63%2668==1 }"
847
即d＝847
最终我们获得关键的
n=2773
d=847
e=63
取消息M=244我们看看
加密：
c=M**d%n = 244**847%2773
用perl的大数计算来算一下：
C:\Temp》perl -Mbigint -e "print 244**847%2773"
465
即用d对M加密后获得加密信息c＝465
解密：
我们可以用e来对加密后的c进行解密，还原M：
m=c**e%n=465**63%2773 ：
C:\Temp》perl -Mbigint -e "print 465**63%2773"
244
即用e对c解密后获得m=244 , 该值和原始信息M相等。
《三》字符串加密
把上面的过程集成一下我们就能实现一个对字符串加密解密的示例了。
每次取字符串中的一个字符的ascii值作为M进行计算，其输出为加密后16进制
的数的字符串形式，按3字节表示，如01F
代码如下：
#!/usr/bin/perl -w
#RSA 计算过程学习程序编写的测试程序
#watercloud 2003-8-12
#
use strict;
use Math::BigInt;
my %RSA_CORE = (n=》2773,e=》63,d=》847); #p=47,q=59
my $N=new Math::BigInt($RSA_CORE{n});
my $E=new Math::BigInt($RSA_CORE{e});
my $D=new Math::BigInt($RSA_CORE{d});
print "N=$N D=$D E=$E\n";
sub RSA_ENCRYPT
{
my $r_mess = shift @_;
my ($c,$i,$M,$C,$cmess);
for($i=0;$i 《 length($$r_mess);$i++)
{
$c=ord(substr($$r_mess,$i,1));
$M=Math::BigInt-》new($c);
$C=$M-》copy(); $C-》bmodpow($D,$N);
$c=sprintf "%03X",$C;
$cmess.=$c;
}
return \$cmess;
}
sub RSA_DECRYPT
{
my $r_mess = shift @_;
my ($c,$i,$M,$C,$dmess);
for($i=0;$i 《 length($$r_mess);$i+=3)
{
$c=substr($$r_mess,$i,3);
$c=hex($c);
$M=Math::BigInt-》new($c);
$C=$M-》copy(); $C-》bmodpow($E,$N);
$c=chr($C);
$dmess.=$c;
}
return \$dmess;
}
my $mess="RSA 娃哈哈哈～～～";
$mess=$ARGV if @ARGV 》= 1;
print "原始串：",$mess,"\n";
my $r_cmess = RSA_ENCRYPT(\$mess);
print "加密串：",$$r_cmess,"\n";
my $r_dmess = RSA_DECRYPT($r_cmess);
print "解密串：",$$r_dmess,"\n";
#EOF
测试一下：
C:\Temp》perl rsa-test.pl
N=2773 D=847 E=63
原始串：RSA 娃哈哈哈～～～
加密串：5CB6CD6BC58A7709470AA74A0AA74A0AA74A6C70A46C70A46C70A4
解密串：RSA 娃哈哈哈～～～
C:\Temp》perl rsa-test.pl 安全焦点（xfocus）
N=2773 D=847 E=63
原始串：安全焦点（xfocus）
加密串：3393EC12F0A466E0AA9510D025D7BA0712DC3379F47D51C325D67B
解密串：安全焦点（xfocus）
《四》提高
前面已经提到，rsa的安全来源于n足够大，我们测试中使用的n是非常小的，根本不能保障安全性，
我们可以通过RSAKit、RSATool之类的工具获得足够大的N 及D E。
通过工具，我们获得1024位的N及D E来测试一下：
n=0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90B66EC3A85F5005D
BDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF1538D4C2013433B383B
47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941D2ED173CCA50E114705D7E2
BC511951
d=0x10001
e=0xE760A3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C2995
4C5D86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF2
C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A592D2B
1965
设原始信息
M=0x11111111111122222222222233333333333
完成这么大数字的计算依赖于大数运算库，用perl来运算非常简单：
A) 用d对M进行加密如下：
c=M**d%n :
C:\Temp》perl -Mbigint -e " $x=Math::BigInt-》bmodpow(0x11111111111122222222222233
333333333, 0x10001, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5F
CD15F90B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F0
17F9CCF1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD6
0438941D2ED173CCA50E114705D7E2BC511951);print $x-》as_hex"
0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd
45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b
3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91
f1834580c3f6d90898
即用d对M加密后信息为：
c=0x17b287be418c69ecd7c39227ab681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd
45692b007f3a2f7c5f5aa1d99ef3866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b
3028f9461a3b1533ec0cb476441465f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91
f1834580c3f6d90898
B) 用e对c进行解密如下：
m=c**e%n ：
C:\Temp》perl -Mbigint -e " $x=Math::BigInt-》bmodpow(0x17b287be418c69ecd7c39227ab
681ac422fcc84bb35d8a632543b304de288a8d4434b73d2576bd45692b007f3a2f7c5f5aa1d99ef3
866af26a8e876712ed1d4cc4b293e26bc0a1dc67e247715caa6b3028f9461a3b1533ec0cb4764414
65f10d8ad47452a12db0601c5e8beda686dd96d2acd59ea89b91f1834580c3f6d90898, 0xE760A
3804ACDE1E8E3D7DC0197F9CEF6282EF552E8CEBBB7434B01CB19A9D87A3106DD28C523C29954C5D
86B36E943080E4919CA8CE08718C3B0930867A98F635EB9EA9200B25906D91B80A47B77324E66AFF
2C4D70D8B1C69C50A9D8B4B7A3C9EE05FFF3A16AFC023731D80634763DA1DCABE9861A4789BD782A
592D2B1965, 0x328C74784DF31119C526D18098EBEBB943B0032B599CEE13CC2BCE7B5FCD15F90
B66EC3A85F5005DBDCDED9BDFCB3C4C265AF164AD55884D8278F791C7A6BFDAD55EDBC4F017F9CCF
1538D4C2013433B383B47D80EC74B51276CA05B5D6346B9EE5AD2D7BE7ABFB36E37108DD60438941
D2ED173CCA50E114705D7E2BC511951);print $x-》as_hex"
0x11111111111122222222222233333333333
(我的P4 1.6G的机器上计算了约5秒钟）
得到用e解密后的m=0x11111111111122222222222233333333333 == M
C) RSA通常的实现
RSA简洁幽雅，但计算速度比较慢，通常加密中并不是直接使用RSA 来对所有的信息进行加密，
最常见的情况是随机产生一个对称加密的密钥，然后使用对称加密算法对信息加密，之后用
RSA对刚才的加密密钥进行加密。
最后需要说明的是，当前小于1024位的N已经被证明是不安全的
自己使用中不要使用小于1024位的RSA，最好使用2048位的。
----------------------------------------------------------
一个简单的RSA算法实现JAVA源代码：
filename:RSA.java
/*
* Created on Mar 3, 2005
*
* TODO To change the template for this generated file go to
* Window - Preferences - Java - Code Style - Code Templates
*/
import java.math.BigInteger;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.FileWriter;
import java.io.FileReader;
import java.io.BufferedReader;
import java.util.StringTokenizer;
/**
* @author Steve
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class RSA {

/**
* BigInteger.ZERO
*/
private static final BigInteger ZERO = BigInteger.ZERO;

/**
* BigInteger.ONE
*/
private static final BigInteger ONE = BigInteger.ONE;

/**
* Pseudo BigInteger.TWO
*/
private static final BigInteger TWO = new BigInteger("2");

private BigInteger myKey;

private BigInteger myMod;

private int blockSize;

public RSA (BigInteger key, BigInteger n, int b) {
myKey = key;
myMod = n;
blockSize = b;
}

public void encodeFile (String filename) {
byte;
byte temp;
int tempLen;
InputStream is = null;
FileWriter writer = null;
try {
is = new FileInputStream(filename);
writer = new FileWriter(filename + ".enc");
}
catch (FileNotFoundException e1){
System.out.println("File not found: " + filename);
}
catch (IOException e1){
System.out.println("File not found: " + filename + ".enc");
}

/**
* Write encoded message to ’filename’.enc
*/
try {
while ((tempLen = is.read(bytes, 1, blockSize / 8)) 》 0) {
for (int i = tempLen + 1; i 《 bytes.length; ++i) {
bytes = 0;
}
writer.write(encodeDecode(new BigInteger(bytes)) + " ");
}
}
catch (IOException e1) {
System.out.println("error writing to file");
}

/**
* Close input stream and file writer
*/
try {
is.close();
writer.close();
}
catch (IOException e1) {
System.out.println("Error closing file.");
}
}

public void decodeFile (String filename) {

FileReader reader = null;
OutputStream os = null;
try {
reader = new FileReader(filename);
os = new FileOutputStream(filename.replaceAll(".enc", ".dec"));
}
catch (FileNotFoundException e1) {
if (reader == null)
System.out.println("File not found: " + filename);
else
System.out.println("File not found: " + filename.replaceAll(".enc", "dec"));
}

BufferedReader br = new BufferedReader(reader);
int offset;
byte temp, toFile;
StringTokenizer st = null;
try {
while (br.ready()) {
st = new StringTokenizer(br.readLine());
while (st.hasMoreTokens()){
toFile = encodeDecode(new BigInteger(st.nextToken())).toByteArray();
System.out.println(toFile.length + " x " + (blockSize / 8));

if (toFile == 0 && toFile.length != (blockSize / 8)) {
temp = new byte;
offset = temp.length - toFile.length;
for (int i = toFile.length - 1; (i 《= 0) && ((i + offset) 《= 0); --i) {
temp;
}
toFile = temp;
}

/*if (toFile.length != ((blockSize / 8) + 1)){
temp = new byte;
System.out.println(toFile.length + " x " + temp.length);
for (int i = 1; i 《 temp.length; i++) {
temp;
}
toFile = temp;
}
else
System.out.println(toFile.length + " " + ((blockSize / 8) + 1));*/
os.write(toFile);
}
}
}
catch (IOException e1) {
System.out.println("Something went wrong");
}

/**
* close data streams
*/
try {
os.close();
reader.close();
}
catch (IOException e1) {
System.out.println("Error closing file.");
}
}

/**
* Performs 《tt》base《/tt》^《sup》《tt》pow《/tt》《/sup》 within the modular
* domain of 《tt》mod《/tt》.
*
* @param base the base to be raised
* @param pow the power to which the base will be raisded
* @param mod the modular domain over which to perform this operation
* @return 《tt》base《/tt》^《sup》《tt》pow《/tt》《/sup》 within the modular
* domain of 《tt》mod《/tt》.
*/
public BigInteger encodeDecode(BigInteger base) {
BigInteger a = ONE;
BigInteger s = base;
BigInteger n = myKey;

while (!n.equals(ZERO)) {
if(!n.mod(TWO).equals(ZERO))
a = a.multiply(s).mod(myMod);

s = s.pow(2).mod(myMod);
n = n.divide(TWO);
}

return a;
}

}
在这里提供两个版本的RSA算法JAVA实现的代码下载：
***隐藏网址***
***隐藏网址***
***隐藏网址***
***隐藏网址***
***隐藏网址***
另外关于RSA算法的php实现请参见文章:
php下的RSA算法实现
关于使用VB实现RSA算法的源代码下载(此程序采用了psc1算法来实现快速的RSA加密):
***隐藏网址***
***隐藏网址***

使用第三方软件加密怎么解除

解除第三方软件加密的方法取决于具体的加密方式和所使用的软件。以下是一些可能的方法：

找到加密软件的设置或选项，查看是否有关于解密的选项或命令。有些加密软件可能提供了特定的解密命令或选项，可以用来解除加密。
尝试使用反向工程工具来解密。这些工具可以分析加密软件的行为，并尝试找出加密算法或密钥，从而解密数据。但是，这种方法需要一定的技术知识和经验，而且不一定能够成功。
联系加密软件的开发者或技术支持团队，寻求帮助。如果加密软件有开发者或技术支持团队，他们可能能够提供解密的帮助或建议。
尝试使用密码恢复工具来解密。有些加密软件使用了密码保护来加密数据，可以使用密码恢复工具来尝试解密。但是，这种方法需要知道正确的密码或能够尝试正确的密码组合。

需要注意的是，解除第三方软件加密可能会涉及法律问题，尤其是如果加密软件是用于保护版权或知识产权的情况下。因此，在使用任何解密方法之前，建议先了解相关的法律法规和道德规范。

讲讲md5加密

分类: 电脑/网络》》反病毒
解析:

一、MD5是何方神圣？

所谓MD5，即"Message-Digest Algorithm 5（信息-摘要算法）"，它由MD2、MD3、MD4发展而来的一种单向函数算法（也就是HASH算法），它是国际著名的公钥加密算法标准RSA的第一设计者R.Rivest于上个世纪90年代初开发出来的。MD5的最大作用在于，将不同格式的大容量文件信息在用数字签名软件来签署私人密钥前"压缩"成一种保密的格式，关键之处在于——这种"压缩"是不可逆的。

为了让读者朋友对MD5的应用有个直观的认识，笔者以一个比方和一个实例来简要描述一下其工作过程：

大家都知道，地球上任何人都有自己独一无二的指纹，这常常成为公安机关鉴别罪犯身份最值得信赖的方法；与之类似，MD5就可以为任何文件（不管其大小、格式、数量）产生一个同样独一无二的"数字指纹"，如果任何人对文件做了任何改动，其MD5值也就是对应的"数字指纹"都会发生变化。
我们常常在某些软件下载站点的某软件信息中看到其MD5值，它的作用就在于我们可以在下载该软件后，对下载回来的文件用专门的软件（如Windows MD5 Check等）做一次MD5校验，以确保我们获得的文件与该站点提供的文件为同一文件。利用MD5算法来进行文件校验的方案被大量应用到软件下载站、论坛数据库、系统文件安全等方面。

笔者上面提到的例子只是MD5的一个基本应用，实际上MD5还被用于加密解密技术上，如Unix、各类BSD系统登录密码（在MD5诞生前采用的是DES加密算法，后因MD5安全性更高，DES被淘汰）、通信信息加密（如大家熟悉的即时通信软件MyIM）、数字签名等诸多方面。

二、MD5的消亡之路

实际上，从MD5诞生之日起，来自美国名为Van Oorschot和Wiener的两位密码学专家就发现了一个暴力搜寻冲突的函数，并预算出"使用一个专门用来搜索MD5冲突的机器可以平均每24天就找到一个冲突"。不过由于该方案仅仅从理论上证明了MD5的不安全性，且实现的代价及其夸张（当时要制造这种专门的计算机，成本需要100万美元），于是MD5自其诞生十多年来一直未有新版本或者被其它算法彻底取代。

在接下来的日子里，有关MD5的破译又诞生了"野蛮攻击"，也就是用"穷举法"从所有可能产生的结果中找到被MD5加密的原始明文，不过由于MD5采用128位加密方法，即使一台机器每秒尝试10亿条明文，那么要破译出原始明文大概需要10的22次方年，而一款名为"MD5爆破工具"的软件，每秒进行的运算仅仅为2万次！

经过无数MD5算法研究专家的努力，先后又诞生了"生日攻击"、"微分攻击"等多种破译方法（相关信息大家可以参考研究成果，大大推进了md5算法消亡的进程。尽管在研究报告中并没有提及具体的实现方法，我们可以认为，md5被彻底攻破已经扫除了技术上的障碍，剩下的仅仅是时间和精力上的问题。/" target=_blank》md5crk）。此次山东大学几位教授的最新研究成果，大大推进了MD5算法消亡的进程。尽管在研究报告中并没有提及具体的实现方法，我们可以认为，MD5被彻底攻破已经扫除了技术上的障碍，剩下的仅仅是时间和精力上的问题。