當前位置:首頁 » 操作系統 » 解密演算法測試

解密演算法測試

發布時間: 2023-03-19 18:01:00

『壹』 java 如何採用md5解密

md5隻是消息摘要,不管多長的數據均得到512比特的摘要。
所以md5一般用於驗證,原始消息被修改後,md5的消息摘要會有變化。
md5不是用於加密,也就不能解密,因為有無窮多的數據對應同一個md5消息摘要

『貳』 破解aes密碼

演算法破解就是找到加密演算法的漏洞,進行技巧性的破解。
暴力破解是在知道加密算的情況下,用各種密碼去測試。關於暴力破解也不是真正的暴力,有很多技術巧。如有效的密碼字典就是一例。

AES目前沒有演算法浮出水面。
AES暴力破解與密碼強度(如字串的MD5值就難,簡單字串在密碼字典排序告前,相對容易一些)和計算能力有關。但AES密鑰長度太長,各種排列組合簡直是天文數字,現有能力民間單機不可能破解。當然也可能一買彩票就中大獎,但似乎比那概率小得多。

『叄』 des演算法加密解密的實現

本文介紹了一種國際上通用的加密演算法—DES演算法的原理,並給出了在VC++6.0語言環境下實現的源代碼。最後給出一個示例,以供參考。
關鍵字:DES演算法、明文、密文、密鑰、VC;

本文程序運行效果圖如下:

正文:
當今社會是信息化的社會。為了適應社會對計算機數據安全保密越來越高的要求,美國國家標准局(NBS)於1997年公布了一個由IBM公司研製的一種加密演算法,並且確定為非機要部門使用的數據加密標准,簡稱DES(Data Encrypton Standard)。自公布之日起,DES演算法作為國際上商用保密通信和計算機通信的最常用演算法,一直活躍在國際保密通信的舞台上,扮演了十分突出的角色。現將DES演算法簡單介紹一下,並給出實現DES演算法的VC源代碼。
DES演算法由加密、解密和子密鑰的生成三部分組成。

一.加密

DES演算法處理的數據對象是一組64比特的明文串。設該明文串為m=m1m2…m64 (mi=0或1)。明文串經過64比特的密鑰K來加密,最後生成長度為64比特的密文E。其加密過程圖示如下:

DES演算法加密過程
對DES演算法加密過程圖示的說明如下:待加密的64比特明文串m,經過IP置換後,得到的比特串的下標列表如下:

IP 58 50 42 34 26 18 10 2
60 52 44 36 28 20 12 4
62 54 46 38 30 22 14 6
64 56 48 40 32 24 16 8
57 49 41 33 25 17 9 1
59 51 43 35 27 19 11 3
61 53 45 37 29 21 13 5
63 55 47 39 31 23 15 7

該比特串被分為32位的L0和32位的R0兩部分。R0子密鑰K1(子密鑰的生成將在後面講)經過變換f(R0,K1)(f變換將在下面講)輸出32位的比特串f1,f1與L0做不進位的二進制加法運算。運算規則為:

f1與L0做不進位的二進制加法運算後的結果賦給R1,R0則原封不動的賦給L1。L1與R0又做與以上完全相同的運算,生成L2,R2…… 一共經過16次運算。最後生成R16和L16。其中R16為L15與f(R15,K16)做不進位二進制加法運算的結果,L16是R15的直接賦值。

R16與L16合並成64位的比特串。值得注意的是R16一定要排在L16前面。R16與L16合並後成的比特串,經過置換IP-1後所得比特串的下標列表如下:
IP-1 40 8 48 16 56 24 64 32
39 7 47 15 55 23 63 31
38 6 46 14 54 22 62 30
37 5 45 13 53 21 61 29
36 4 44 12 52 20 60 28
35 3 43 11 51 19 59 27
34 2 42 10 50 18 58 26
33 1 41 9 49 17 57 25

經過置換IP-1後生成的比特串就是密文e.。
下面再講一下變換f(Ri-1,Ki)。
它的功能是將32比特的輸入再轉化為32比特的輸出。其過程如圖所示:

對f變換說明如下:輸入Ri-1(32比特)經過變換E後,膨脹為48比特。膨脹後的比特串的下標列表如下:

E: 32 1 2 3 4 5
4 5 6 7 8 9
8 9 10 11 12 13
12 13 14 15 16 17
16 17 18 19 20 21
20 21 22 23 24 25
24 25 26 27 28 29
28 29 30 31 32 31

膨脹後的比特串分為8組,每組6比特。各組經過各自的S盒後,又變為4比特(具體過程見後),合並後又成為32比特。該32比特經過P變換後,其下標列表如下:

P: 16 7 20 21
29 12 28 17
1 15 23 26
5 18 31 10
2 8 24 14
32 27 3 9
19 13 30 6
22 11 4 25

經過P變換後輸出的比特串才是32比特的f (Ri-1,Ki)。
下面再講一下S盒的變換過程。任取一S盒。見圖:

在其輸入b1,b2,b3,b4,b5,b6中,計算出x=b1*2+b6, y=b5+b4*2+b3*4+b2*8,再從Si表中查出x 行,y 列的值Sxy。將Sxy化為二進制,即得Si盒的輸出。(S表如圖所示)

至此,DES演算法加密原理講完了。在VC++6.0下的程序源代碼為:

for(i=1;i<=64;i++)
m1[i]=m[ip[i-1]];//64位明文串輸入,經過IP置換。

下面進行迭代。由於各次迭代的方法相同只是輸入輸出不同,因此只給出其中一次。以第八次為例://進行第八次迭代。首先進行S盒的運算,輸入32位比特串。
for(i=1;i<=48;i++)//經過E變換擴充,由32位變為48位
RE1[i]=R7[E[i-1]];
for(i=1;i<=48;i++)//與K8按位作不進位加法運算
RE1[i]=RE1[i]+K8[i];
for(i=1;i<=48;i++)
{
if(RE1[i]==2)
RE1[i]=0;
}
for(i=1;i<7;i++)//48位分成8組
{
s11[i]=RE1[i];
s21[i]=RE1[i+6];
s31[i]=RE1[i+12];
s41[i]=RE1[i+18];
s51[i]=RE1[i+24];
s61[i]=RE1[i+30];
s71[i]=RE1[i+36];
s81[i]=RE1[i+42];
}//下面經過S盒,得到8個數。S1,s2,s3,s4,s5,s6,s7,s8分別為S表
s[1]=s1[s11[6]+s11[1]*2][s11[5]+s11[4]*2+s11[3]*4+s11[2]*8];
s[2]=s2[s21[6]+s21[1]*2][s21[5]+s21[4]*2+s21[3]*4+s21[2]*8];
s[3]=s3[s31[6]+s31[1]*2][s31[5]+s31[4]*2+s31[3]*4+s31[2]*8];
s[4]=s4[s41[6]+s41[1]*2][s41[5]+s41[4]*2+s41[3]*4+s41[2]*8];
s[5]=s5[s51[6]+s51[1]*2][s51[5]+s51[4]*2+s51[3]*4+s51[2]*8];
s[6]=s6[s61[6]+s61[1]*2][s61[5]+s61[4]*2+s61[3]*4+s61[2]*8];
s[7]=s7[s71[6]+s71[1]*2][s71[5]+s71[4]*2+s71[3]*4+s71[2]*8];
s[8]=s8[s81[6]+s81[1]*2][s81[5]+s81[4]*2+s81[3]*4+s81[2]*8];
for(i=0;i<8;i++)//8個數變換輸出二進制
{
for(j=1;j<5;j++)
{
temp[j]=s[i+1]%2;
s[i+1]=s[i+1]/2;
}
for(j=1;j<5;j++)
f[4*i+j]=temp[5-j];
}
for(i=1;i<33;i++)//經過P變換
frk[i]=f[P[i-1]];//S盒運算完成
for(i=1;i<33;i++)//左右交換
L8[i]=R7[i];
for(i=1;i<33;i++)//R8為L7與f(R,K)進行不進位二進制加法運算結果
{
R8[i]=L7[i]+frk[i];
if(R8[i]==2)
R8[i]=0;
}

[ 原創文檔 本文適合中級讀者 已閱讀21783次 ] 文檔 代碼 工具

DES演算法及其在VC++6.0下的實現(下)
作者:航天醫學工程研究所四室 朱彥軍

在《DES演算法及其在VC++6.0下的實現(上)》中主要介紹了DES演算法的基本原理,下面讓我們繼續:

二.子密鑰的生成
64比特的密鑰生成16個48比特的子密鑰。其生成過程見圖:

子密鑰生成過程具體解釋如下:
64比特的密鑰K,經過PC-1後,生成56比特的串。其下標如表所示:

PC-1 57 49 41 33 25 17 9
1 58 50 42 34 26 18
10 2 59 51 43 35 27
19 11 3 60 52 44 36
63 55 47 39 31 23 15
7 62 54 46 38 30 22
14 6 61 53 45 37 29
21 13 5 28 20 12 4

該比特串分為長度相等的比特串C0和D0。然後C0和D0分別循環左移1位,得到C1和D1。C1和D1合並起來生成C1D1。C1D1經過PC-2變換後即生成48比特的K1。K1的下標列表為:

PC-2 14 17 11 24 1 5
3 28 15 6 21 10
23 19 12 4 26 8
16 7 27 20 13 2
41 52 31 37 47 55
30 40 51 45 33 48
44 49 39 56 34 53
46 42 50 36 29 32

C1、D1分別循環左移LS2位,再合並,經過PC-2,生成子密鑰K2……依次類推直至生成子密鑰K16。
注意:Lsi (I =1,2,….16)的數值是不同的。具體見下表:

迭代順序 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
左移位數 1 1 2 2 2 2 2 2 1 2 2 2 2 2 2 1

生成子密鑰的VC程序源代碼如下:

for(i=1;i<57;i++)//輸入64位K,經過PC-1變為56位 k0[i]=k[PC_1[i-1]];

56位的K0,均分為28位的C0,D0。C0,D0生成K1和C1,D1。以下幾次迭代方法相同,僅以生成K8為例。 for(i=1;i<27;i++)//循環左移兩位
{
C8[i]=C7[i+2];
D8[i]=D7[i+2];
}
C8[27]=C7[1];
D8[27]=D7[1];
C8[28]=C7[2];
D8[28]=D7[2];
for(i=1;i<=28;i++)
{
C[i]=C8[i];
C[i+28]=D8[i];
}
for(i=1;i<=48;i++)
K8[i]=C[PC_2[i-1]];//生成子密鑰k8

注意:生成的子密鑰不同,所需循環左移的位數也不同。源程序中以生成子密鑰 K8為例,所以循環左移了兩位。但在編程中,生成不同的子密鑰應以Lsi表為准。

三.解密

DES的解密過程和DES的加密過程完全類似,只不過將16圈的子密鑰序列K1,K2……K16的順序倒過來。即第一圈用第16個子密鑰K16,第二圈用K15,其餘類推。
第一圈:

加密後的結果

L=R15, R=L15⊕f(R15,K16)⊕f(R15,K16)=L15
同理R15=L14⊕f(R14,K15), L15=R14。
同理類推:
得 L=R0, R=L0。
其程序源代碼與加密相同。在此就不重寫。

四.示例
例如:已知明文m=learning, 密鑰 k=computer。
明文m的ASCII二進製表示:

m= 01101100 01100101 01100001 01110010
01101110 01101001 01101110 01100111

密鑰k的ASCII二進製表示:

k=01100011 01101111 01101101 01110000
01110101 01110100 01100101 01110010

明文m經過IP置換後,得:

11111111 00001000 11010011 10100110 00000000 11111111 01110001 11011000

等分為左右兩段:

L0=11111111 00001000 11010011 10100110 R0=00000000 11111111 01110001 11011000

經過16次迭代後,所得結果為:

L1=00000000 11111111 01110001 11011000 R1=00110101 00110001 00111011 10100101
L2=00110101 00110001 00111011 10100101 R2=00010111 11100010 10111010 10000111
L3=00010111 11100010 10111010 10000111 R3=00111110 10110001 00001011 10000100
L4= R4=
L5= R5=
L6= R6=
L7= R7=
L8= R8=
L9= R9=
L10= R10=
L11= R11=
L12= R12=
L13= R13=
L14= R14=
L15= R15=
L16= R16=

其中,f函數的結果為:

f1= f2=
f3= f4=
f5= f6=
f7= f8=
f9= f10=
f11= f12=
f13= f14=
f15= f16=

16個子密鑰為:

K1= K2=
K3= K4=
K5= K6=
K7= K8=
K9= K10=
K11= K12=
K13= K14=
K15= K16=

S盒中,16次運算時,每次的8 個結果為:
第一次:5,11,4,1,0,3,13,9;
第二次:7,13,15,8,12,12,13,1;
第三次:8,0,0,4,8,1,9,12;
第四次:0,7,4,1,7,6,12,4;
第五次:8,1,0,11,5,0,14,14;
第六次:14,12,13,2,7,15,14,10;
第七次:12,15,15,1,9,14,0,4;
第八次:15,8,8,3,2,3,14,5;
第九次:8,14,5,2,1,15,5,12;
第十次:2,8,13,1,9,2,10,2;
第十一次:10,15,8,2,1,12,12,3;
第十二次:5,4,4,0,14,10,7,4;
第十三次:2,13,10,9,2,4,3,13;
第十四次:13,7,14,9,15,0,1,3;
第十五次:3,1,15,5,11,9,11,4;
第十六次:12,3,4,6,9,3,3,0;

子密鑰生成過程中,生成的數值為:

C0=0000000011111111111111111011 D0=1000001101110110000001101000
C1=0000000111111111111111110110 D1=0000011011101100000011010001
C2=0000001111111111111111101100 D2=0000110111011000000110100010
C3=0000111111111111111110110000 D3=0011011101100000011010001000
C4=0011111111111111111011000000 D4=1101110110000001101000100000
C5=1111111111111111101100000000 D5=0111011000000110100010000011
C6=1111111111111110110000000011 D6=1101100000011010001000001101
C7=1111111111111011000000001111 D7=0110000001101000100000110111
C8=1111111111101100000000111111 D8=1000000110100010000011011101
C9=1111111111011000000001111111 D9=0000001101000100000110111011
C10=1111111101100000000111111111 D10=0000110100010000011011101100
C11=1111110110000000011111111111 D11=0011010001000001101110110000
C12=1111011000000001111111111111 D12=1101000100000110111011000000
C13=1101100000000111111111111111 D13=0100010000011011101100000011
C14=0110000000011111111111111111 D14=0001000001101110110000001101
C15=1000000001111111111111111101 D15=0100000110111011000000110100
C16=0000000011111111111111111011 D16=1000001101110110000001101000

解密過程與加密過程相反,所得的數據的順序恰好相反。在此就不贅述。

參考書目:
《計算機系統安全》 重慶出版社 盧開澄等編著
《計算機密碼應用基礎》 科學出版社 朱文余等編著
《Visual C++ 6.0 編程實例與技巧》 機械工業出版社 王華等編著

『肆』 app請求數據解密(AES)一

接下去兩篇文章我們主要介紹安全分析過程中burp抓包完解密 經過加密的請求數據 ,並在新建的消息編輯器中列印輸出。這篇文章主要先介紹測試app中加晌老解密算宴圓升法的分析與還原。

一、分析請求數據的加密演算法

結果如下所示

二、還原加密演算法並測試

在下一篇文章中,將介紹app請求數據解密腔李插件的編寫。該篇文章分析中用到frida腳本與還原後的演算法,如果有需要,可以在公眾號回復" AES Decrypt1 "獲取。

『伍』 字元串的加密與解密(3DES、sha1、MD5) - swift3.1

對於字元串的加密解密,可以給String類擴展方法,方便使用

Swift中使用3DES/sha1/MD5加密解密演算法 必須要引入這個庫 - 在橋接文件中
#import <CommonCrypto/CommonCrypto.h>

3DES的加密是可逆的, sha1和MD5的是不可逆的

使用方法:
直接在xib界面拖一個textFiled的控制項,然後放置3個按鈕,分別是進行MD5、sha1、3DES加密點擊方法,然後分別測試加密解密數據

可以參考文章 http://www.cnblogs.com/jukaiit/p/5039803.html
使用這個第三方來實現 JKEncrypt
** https://github.com/jukai9316/JKEncrypt 。**

『陸』 app請求數據解密(AES)二

這篇文章主要介紹burp解密http請求數據插件的編寫。根據上篇文章分析得到的AES加解密演算法,我們要編寫一個AES解密插件,將指定host的請求數據解密,並在新建的消息編輯器中顯示。

一、AES解密插件用到的介面

二、解密插件的實現與使用

抓取我們過濾的特定的請求包測試

可以看到對特定的每個請求數據解密後在消息編輯器中輸出

綜上所述,該篇文章主要介紹了burp中自定義消息編輯器解密插件的編寫。其中,我們可以依據自己的個人需求來指定需要過濾的請求,比如可以按照請求數據中包含的參數名稱、請求頭中包含的host、user-agent、Content-Type、請求鏈接url等,多個條件一起判斷也可以。有需要插件源碼的童鞋,可以在公眾號回復" AES Decrypt2 "。

『柒』 高分求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->(); $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->(); $C->bmodpow($E,$N);
$c=chr($C);
$dmess.=$c;
}
return \$dmess;
}

my $mess="RSA 娃哈哈哈~~~";
$mess=$ARGV[0] 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 娃哈哈哈~~~
加密串:
解密串:RSA 娃哈哈哈~~~

C:\Temp>perl rsa-test.pl 安全焦點(xfocus)
N=2773 D=847 E=63
原始串:安全焦點(xfocus)
加密串:
解密串:安全焦點(xfocus)

<四>提高

前面已經提到,rsa的安全來源於n足夠大,我們測試中使用的n是非常小的,根本不能保障安全性,
我們可以通過RSAKit、RSATool之類的工具獲得足夠大的N 及D E。
通過工具,我們獲得1024位的N及D E來測試一下:

n=EC3A85F5005D
4C2013433B383B
A50E114705D7E2
BC511951

d=0x10001

e=DD28C523C2995
47B77324E66AFF2
789BD782A592D2B
1965

設原始信息
M=

完成這么大數字的計算依賴於大數運算庫,用perl來運算非常簡單:

A) 用d對M進行加密如下:
c=M**d%n :
C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x11111111111122222222222233
333333333, 0x10001,
D55EDBC4F0
6E37108DD6
);print $x->as_hex"
b73d2576bd
47715caa6b
d59ea89b91
f1834580c3f6d90898

即用d對M加密後信息為:
c=b73d2576bd
47715caa6b
d59ea89b91
f1834580c3f6d90898

B) 用e對c進行解密如下:

m=c**e%n :
C:\Temp>perl -Mbigint -e " $x=Math::BigInt->bmodpow(0x17b287be418c69ecd7c39227ab
5aa1d99ef3
0cb4764414
, 0xE760A
3C29954C5D
7324E66AFF
2789BD782A
592D2B1965, CD15F90
4F017F9CCF
DD60438941
);print $x->as_hex"

(我的P4 1.6G的機器上計算了約5秒鍾)

得到用e解密後的m= == 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[] bytes = new byte[blockSize / 8 + 1];
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[i] = 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] == 0 && toFile.length != (blockSize / 8)) {
temp = new byte[blockSize / 8];
offset = temp.length - toFile.length;
for (int i = toFile.length - 1; (i <= 0) && ((i + offset) <= 0); --i) {
temp[i + offset] = toFile[i];
}
toFile = temp;
}

/*if (toFile.length != ((blockSize / 8) + 1)){
temp = new byte[(blockSize / 8) + 1];
System.out.println(toFile.length + " x " + temp.length);
for (int i = 1; i < temp.length; i++) {
temp[i] = toFile[i - 1];
}
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 molar
* 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 molar domain over which to perform this operation
* @return <tt>base</tt>^<sup><tt>pow</tt></sup> within the molar
* 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實現的代碼下載:

1. 來自於 http://www.javafr.com/code.aspx?ID=27020 的RSA演算法實現源代碼包:
http://zeal.newmenbase.net/attachment/JavaFR_RSA_Source.rar

2. 來自於 http://www.ferrara.linux.it/Members/lucabariani/RSA/implementazioneRsa/ 的實現:
http://zeal.newmenbase.net/attachment/sorgentiJava.tar.gz - 源代碼包
http://zeal.newmenbase.net/attachment/algoritmoRSA.jar - 編譯好的jar包

另外關於RSA演算法的php實現請參見文章:
php下的RSA演算法實現

關於使用VB實現RSA演算法的源代碼下載(此程序採用了psc1演算法來實現快速的RSA加密):
http://zeal.newmenbase.net/attachment/vb_PSC1_RSA.rar

RSA加密的JavaScript實現: http://www.ohdave.com/rsa/

『捌』 目前常用的加密解密演算法有哪些

加密演算法

加密技術是對信息進行編碼和解碼的技術,編碼是把原來可讀信息(又稱明文)譯成代碼形式(又稱密文),其逆過程就是解碼(解密)。加密技術的要點是加密演算法,加密演算法可以分為對稱加密、不對稱加密和不可逆加密三類演算法。

對稱加密演算法 對稱加密演算法是應用較早的加密演算法,技術成熟。在對稱加密演算法中,數據發信方將明文(原始數據)和加密密鑰一起經過特殊加密演算法處理後,使其變成復雜的加密密文發送出去。收信方收到密文後,若想解讀原文,則需要使用加密用過的密鑰及相同演算法的逆演算法對密文進行解密,才能使其恢復成可讀明文。在對稱加密演算法中,使用的密鑰只有一個,發收信雙方都使用這個密鑰對數據進行加密和解密,這就要求解密方事先必須知道加密密鑰。對稱加密演算法的特點是演算法公開、計算量小、加密速度快、加密效率高。不足之處是,交易雙方都使用同樣鑰匙,安全性得不到保證。此外,每對用戶每次使用對稱加密演算法時,都需要使用其他人不知道的惟一鑰匙,這會使得發收信雙方所擁有的鑰匙數量成幾何級數增長,密鑰管理成為用戶的負擔。對稱加密演算法在分布式網路系統上使用較為困難,主要是因為密鑰管理困難,使用成本較高。在計算機專網系統中廣泛使用的對稱加密演算法有DES和IDEA等。美國國家標准局倡導的AES即將作為新標准取代DES。

不對稱加密演算法不對稱加密演算法使用兩把完全不同但又是完全匹配的一對鑰匙—公鑰和私鑰。在使用不對稱加密演算法加密文件時,只有使用匹配的一對公鑰和私鑰,才能完成對明文的加密和解密過程。加密明文時採用公鑰加密,解密密文時使用私鑰才能完成,而且發信方(加密者)知道收信方的公鑰,只有收信方(解密者)才是唯一知道自己私鑰的人。不對稱加密演算法的基本原理是,如果發信方想發送只有收信方才能解讀的加密信息,發信方必須首先知道收信方的公鑰,然後利用收信方的公鑰來加密原文;收信方收到加密密文後,使用自己的私鑰才能解密密文。顯然,採用不對稱加密演算法,收發信雙方在通信之前,收信方必須將自己早已隨機生成的公鑰送給發信方,而自己保留私鑰。由於不對稱演算法擁有兩個密鑰,因而特別適用於分布式系統中的數據加密。廣泛應用的不對稱加密演算法有RSA演算法和美國國家標准局提出的DSA。以不對稱加密演算法為基礎的加密技術應用非常廣泛。

不可逆加密演算法 不可逆加密演算法的特徵是加密過程中不需要使用密鑰,輸入明文後由系統直接經過加密演算法處理成密文,這種加密後的數據是無法被解密的,只有重新輸入明文,並再次經過同樣不可逆的加密演算法處理,得到相同的加密密文並被系統重新識別後,才能真正解密。顯然,在這類加密過程中,加密是自己,解密還得是自己,而所謂解密,實際上就是重新加一次密,所應用的「密碼」也就是輸入的明文。不可逆加密演算法不存在密鑰保管和分發問題,非常適合在分布式網路系統上使用,但因加密計算復雜,工作量相當繁重,通常只在數據量有限的情形下使用,如廣泛應用在計算機系統中的口令加密,利用的就是不可逆加密演算法。近年來,隨著計算機系統性能的不斷提高,不可逆加密的應用領域正在逐漸增大。在計算機網路中應用較多不可逆加密演算法的有RSA公司發明的MD5演算法和由美國國家標准局建議的不可逆加密標准SHS(Secure Hash Standard:安全雜亂信息標准)等。

加密技術

加密演算法是加密技術的基礎,任何一種成熟的加密技術都是建立多種加密演算法組合,或者加密演算法和其他應用軟體有機結合的基礎之上的。下面我們介紹幾種在計算機網路應用領域廣泛應用的加密技術。

非否認(Non-repudiation)技術 該技術的核心是不對稱加密演算法的公鑰技術,通過產生一個與用戶認證數據有關的數字簽名來完成。當用戶執行某一交易時,這種簽名能夠保證用戶今後無法否認該交易發生的事實。由於非否認技術的操作過程簡單,而且直接包含在用戶的某類正常的電子交易中,因而成為當前用戶進行電子商務、取得商務信任的重要保證。

PGP(Pretty Good Privacy)技術 PGP技術是一個基於不對稱加密演算法RSA公鑰體系的郵件加密技術,也是一種操作簡單、使用方便、普及程度較高的加密軟體。PGP技術不但可以對電子郵件加密,防止非授權者閱讀信件;還能對電子郵件附加數字簽名,使收信人能明確了解發信人的真實身份;也可以在不需要通過任何保密渠道傳遞密鑰的情況下,使人們安全地進行保密通信。PGP技術創造性地把RSA不對稱加密演算法的方便性和傳統加密體系結合起來,在數字簽名和密鑰認證管理機制方面採用了無縫結合的巧妙設計,使其幾乎成為最為流行的公鑰加密軟體包。

數字簽名(Digital Signature)技術 數字簽名技術是不對稱加密演算法的典型應用。數字簽名的應用過程是,數據源發送方使用自己的私鑰對數據校驗和或其他與數據內容有關的變數進行加密處理,完成對數據的合法「簽名」,數據接收方則利用對方的公鑰來解讀收到的「數字簽名」,並將解讀結果用於對數據完整性的檢驗,以確認簽名的合法性。數字簽名技術是在網路系統虛擬環境中確認身份的重要技術,完全可以代替現實過程中的「親筆簽字」,在技術和法律上有保證。在公鑰與私鑰管理方面,數字簽名應用與加密郵件PGP技術正好相反。在數字簽名應用中,發送者的公鑰可以很方便地得到,但他的私鑰則需要嚴格保密。

PKI(Public Key Infrastructure)技術 PKI技術是一種以不對稱加密技術為核心、可以為網路提供安全服務的公鑰基礎設施。PKI技術最初主要應用在Internet環境中,為復雜的互聯網系統提供統一的身份認證、數據加密和完整性保障機制。由於PKI技術在網路安全領域所表現出的巨大優勢,因而受到銀行、證券、政府等核心應用系統的青睞。PKI技術既是信息安全技術的核心,也是電子商務的關鍵和基礎技術。由於通過網路進行的電子商務、電子政務等活動缺少物理接觸,因而使得利用電子方式驗證信任關系變得至關重要,PKI技術恰好能夠有效解決電子商務應用中的機密性、真實性、完整性、不可否認性和存取控制等安全問題。一個實用的PKI體系還必須充分考慮互操作性和可擴展性。PKI體系所包含的認證中心(CA)、注冊中心(RA)、策略管理、密鑰與證書管理、密鑰備份與恢復、撤銷系統等功能模塊應該有機地結合在一起。

加密的未來趨勢

盡管雙鑰密碼體制比單鑰密碼體制更為可靠,但由於計算過於復雜,雙鑰密碼體制在進行大信息量通信時,加密速率僅為單鑰體制的1/100,甚至是 1/1000。正是由於不同體制的加密演算法各有所長,所以在今後相當長的一段時期內,各類加密體制將會共同發展。而在由IBM等公司於1996年聯合推出的用於電子商務的協議標准SET(Secure Electronic Transaction)中和1992年由多國聯合開發的PGP技術中,均採用了包含單鑰密碼、雙鑰密碼、單向雜湊演算法和隨機數生成演算法在內的混合密碼系統的動向來看,這似乎從一個側面展示了今後密碼技術應用的未來。

在單鑰密碼領域,一次一密被認為是最為可靠的機制,但是由於流密碼體制中的密鑰流生成器在演算法上未能突破有限循環,故一直未被廣泛應用。如果找到一個在演算法上接近無限循環的密鑰流生成器,該體制將會有一個質的飛躍。近年來,混沌學理論的研究給在這一方向產生突破帶來了曙光。此外,充滿生氣的量子密碼被認為是一個潛在的發展方向,因為它是基於光學和量子力學理論的。該理論對於在光纖通信中加強信息安全、對付擁有量子計算能力的破譯無疑是一種理想的解決方法。

由於電子商務等民用系統的應用需求,認證加密演算法也將有較大發展。此外,在傳統密碼體制中,還將會產生類似於IDEA這樣的新成員,新成員的一個主要特徵就是在演算法上有創新和突破,而不僅僅是對傳統演算法進行修正或改進。密碼學是一個正在不斷發展的年輕學科,任何未被認識的加/解密機制都有可能在其中佔有一席之地。

目前,對信息系統或電子郵件的安全問題,還沒有一個非常有效的解決方案,其主要原因是由於互聯網固有的異構性,沒有一個單一的信任機構可以滿足互聯網全程異構性的所有需要,也沒有一個單一的協議能夠適用於互聯網全程異構性的所有情況。解決的辦法只有依靠軟體代理了,即採用軟體代理來自動管理用戶所持有的證書(即用戶所屬的信任結構)以及用戶所有的行為。每當用戶要發送一則消息或一封電子郵件時,代理就會自動與對方的代理協商,找出一個共同信任的機構或一個通用協議來進行通信。在互聯網環境中,下一代的安全信息系統會自動為用戶發送加密郵件,同樣當用戶要向某人發送電子郵件時,用戶的本地代理首先將與對方的代理交互,協商一個適合雙方的認證機構。當然,電子郵件也需要不同的技術支持,因為電子郵件不是端到端的通信,而是通過多個中間機構把電子郵件分程傳遞到各自的通信機器上,最後到達目的地。

『玖』 急求 MD5的加密解密演算法,用C++實現的源代碼 高分答謝

要代碼,還是要相關的解釋資料?

---------------------------------
要代碼的話:

兩個文件:
--------------------------
1. md5.h:

#pragma once

typedef unsigned long int UINT32;
typedef unsigned short int UINT16;

/* MD5 context. */
typedef struct {
UINT32 state[4]; /* state (ABCD) */
UINT32 count[2]; /* number of bits, molo 2^64 (lsb first) */
unsigned char buffer[64]; /* input buffer */
} MD5_CTX;

void MD5Init (MD5_CTX *);
void MD5Update (MD5_CTX *, unsigned char *, unsigned int);
void MD5Final (unsigned char [16], 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[4], unsigned char b[64]);
static void Encode (unsigned char *, UINT32 *, unsigned int);
static void Decode (UINT32 *, unsigned char *, unsigned int);

static unsigned char PADDING[64] = {
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->count[1] = 0;

context->state[0] = 0x67452301;
context->state[1] = 0xefcdab89;
context->state[2] = 0x98badcfe;
context->state[3] = 0x10325476;
}

void MD5Update (MD5_CTX *context, unsigned char *input, unsigned int inputLen)
{
unsigned int i, index, partLen;

index = (unsigned int)((context->count[0] >> 3) & 0x3F);

if ((context->count[0] += ((UINT32)inputLen << 3))
< ((UINT32)inputLen << 3))
context->count[1]++;
context->count[1] += ((UINT32)inputLen >> 29);

partLen = 64 - index;

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

for (i = partLen; i + 63 < inputLen; i += 64)
MD5Transform (context->state, &input[i]);

index = 0;
}
else
i = 0;

memcpy((unsigned char *)&context->buffer[index], (unsigned char *)&input[i],
inputLen-i);
}

void MD5Final (unsigned char digest[16], MD5_CTX * context)
{
unsigned char bits[8];
unsigned int index, padLen;

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

index = (unsigned int)((context->count[0] >> 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[4], unsigned char block[64])
{
UINT32 a = state[0], b = state[1], c = state[2], d = state[3], x[16];

Decode (x, block, 64);

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

/* Round 2 */
GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */

/* Round 3 */
HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */

/* Round 4 */
II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */

state[0] += a;
state[1] += b;
state[2] += c;
state[3] += 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[j] = (unsigned char)(input[i] & 0xff);
output[j+1] = (unsigned char)((input[i] >> 8) & 0xff);
output[j+2] = (unsigned char)((input[i] >> 16) & 0xff);
output[j+3] = (unsigned char)((input[i] >> 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[i] = ((UINT32)input[j]) | (((UINT32)input[j+1]) << 8) |
(((UINT32)input[j+2]) << 16) | (((UINT32)input[j+3]) << 24);
}

--------------------------
就這兩個文件。使用的時候把它們加入工程或者makefile,調用時包含md5.h即可,給個簡單的例子,輸入一個字元串然後計算它的md5值並輸出,在VC6.0和GCC4.4下測試通過:

#include <stdio.h>
#include <string.h>

#include "md5.h"

int main ()
{
char tmp[128];
unsigned char digest[16];

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[i]);
}
printf("\n");

return 0;
}

『拾』 加密解密字元串的演算法原理

我們經常需要一種措施來保護我們的數據,防止被一些懷有不良用心的人所看到或者破壞。在信息時代,信息可以幫助團體或個人,使他們受益,同樣,信息也可以用來對他們構成威脅,造成破壞。在競爭激烈的大公司中,工業間諜經常會獲取對方的情報。因此,在客觀上就需要一種強有力的安全措施來保護機密數據不被竊取或篡改。數據加密與解密從宏觀上講是非常簡單的,很容易理解。加密與解密的一些方法是非常直接的,很容易掌握,可以很方便的對機密數據進行加密和解密。

一:數據加密方法

在傳統上,我們有幾種方法來加密數據流。所有這些方法都可以用軟體很容易的實現,但是當我們只知道密文的時候,是不容易破譯這些加密演算法的(當同時有原文和密文時,破譯加密演算法雖然也不是很容易,但已經是可能的了)。最好的加密演算法對系統性能幾乎沒有影響,並且還可以帶來其他內在的優點。例如,大家都知道的pkzip,它既壓縮數據又加密數據。又如,dbms的一些軟體包總是包含一些加密方法以使復制文件這一功能對一些敏感數據是無效的,或者需要用戶的密碼。所有這些加密演算法都要有高效的加密和解密能力。

幸運的是,在所有的加密演算法中最簡單的一種就是「置換表」演算法,這種演算法也能很好達到加密的需要。每一個數據段(總是一個位元組)對應著「置換表」中的一個偏移量,偏移量所對應的值就輸出成為加密後的文件。加密程序和解密程序都需要一個這樣的「置換表」。事實上,80x86 cpu系列就有一個指令『xlat』在硬體級來完成這樣的工作。這種加密演算法比較簡單,加密解密速度都很快,但是一旦這個「置換表」被對方獲得,那這個加密方案就完全被識破了。更進一步講,這種加密演算法對於黑客破譯來講是相當直接的,只要找到一個「置換表」就可以了。這種方法在計算機出現之前就已經被廣泛的使用。

對這種「置換表」方式的一個改進就是使用2個或者更多的「置換表」,這些表都是基於數據流中位元組的位置的,或者基於數據流本身。這時,破譯變的更加困難,因為黑客必須正確的做幾次變換。通過使用更多的「置換表」,並且按偽隨機的方式使用每個表,這種改進的加密方法已經變的很難破譯。比如,我們可以對所有的偶數位置的數據使用a表,對所有的奇數位置使用b表,即使黑客獲得了明文和密文,他想破譯這個加密方案也是非常困難的,除非黑客確切的知道用了兩張表。

與使用「置換表」相類似,「變換數據位置」也在計算機加密中使用。但是,這需要更多的執行時間。從輸入中讀入明文放到一個buffer中,再在buffer中對他們重排序,然後按這個順序再輸出。解密程序按相反的順序還原數據。這種方法總是和一些別的加密演算法混合使用,這就使得破譯變的特別的困難,幾乎有些不可能了。例如,有這樣一個詞,變換起字母的順序,slient 可以變為listen,但所有的字母都沒有變化,沒有增加也沒有減少,但是字母之間的順序已經變化了。

但是,還有一種更好的加密演算法,只有計算機可以做,就是字/位元組循環移位和xor操作。如果我們把一個字或位元組在一個數據流內做循環移位,使用多個或變化的方向(左移或右移),就可以迅速的產生一個加密的數據流。這種方法是很好的,破譯它就更加困難!而且,更進一步的是,如果再使用xor操作,按位做異或操作,就就使破譯密碼更加困難了。如果再使用偽隨機的方法,這涉及到要產生一系列的數字,我們可以使用fibbonaci數列。對數列所產生的數做模運算(例如模3),得到一個結果,然後循環移位這個結果的次數,將使破譯次密碼變的幾乎不可能!但是,使用fibbonaci數列這種偽隨機的方式所產生的密碼對我們的解密程序來講是非常容易的。

在一些情況下,我們想能夠知道數據是否已經被篡改了或被破壞了,這時就需要產生一些校驗碼,並且把這些校驗碼插入到數據流中。這樣做對數據的防偽與程序本身都是有好處的。但是感染計算機程序的病毒才不會在意這些數據或程序是否加過密,是否有數字簽名。所以,加密程序在每次load到內存要開始執行時,都要檢查一下本身是否被病毒感染,對與需要加、解密的文件都要做這種檢查!很自然,這樣一種方法體制應該保密的,因為病毒程序的編寫者將會利用這些來破壞別人的程序或數據。因此,在一些反病毒或殺病毒軟體中一定要使用加密技術。

循環冗餘校驗是一種典型的校驗數據的方法。對於每一個數據塊,它使用位循環移位和xor操作來產生一個16位或32位的校驗和 ,這使得丟失一位或兩個位的錯誤一定會導致校驗和出錯。這種方式很久以來就應用於文件的傳輸,例如 xmodem-crc。 這是方法已經成為標准,而且有詳細的文檔。但是,基於標准crc演算法的一種修改演算法對於發現加密數據塊中的錯誤和文件是否被病毒感染是很有效的。

二.基於公鑰的加密演算法

一個好的加密演算法的重要特點之一是具有這種能力:可以指定一個密碼或密鑰,並用它來加密明文,不同的密碼或密鑰產生不同的密文。這又分為兩種方式:對稱密鑰演算法和非對稱密鑰演算法。所謂對稱密鑰演算法就是加密解密都使用相同的密鑰,非對稱密鑰演算法就是加密解密使用不同的密鑰。非常著名的pgp公鑰加密以及rsa加密方法都是非對稱加密演算法。加密密鑰,即公鑰,與解密密鑰,即私鑰,是非常的不同的。從數學理論上講,幾乎沒有真正不可逆的演算法存在。例如,對於一個輸入『a』執行一個操作得到結果『b』,那麼我們可以基於『b』,做一個相對應的操作,導出輸入『a』。在一些情況下,對於每一種操作,我們可以得到一個確定的值,或者該操作沒有定義(比如,除數為0)。對於一個沒有定義的操作來講,基於加密演算法,可以成功地防止把一個公鑰變換成為私鑰。因此,要想破譯非對稱加密演算法,找到那個唯一的密鑰,唯一的方法只能是反復的試驗,而這需要大量的處理時間。

rsa加密演算法使用了兩個非常大的素數來產生公鑰和私鑰。即使從一個公鑰中通過因數分解可以得到私鑰,但這個運算所包含的計算量是非常巨大的,以至於在現實上是不可行的。加密演算法本身也是很慢的,這使得使用rsa演算法加密大量的數據變的有些不可行。這就使得一些現實中加密演算法都基於rsa加密演算法。pgp演算法(以及大多數基於rsa演算法的加密方法)使用公鑰來加密一個對稱加密演算法的密鑰,然後再利用一個快速的對稱加密演算法來加密數據。這個對稱演算法的密鑰是隨機產生的,是保密的,因此,得到這個密鑰的唯一方法就是使用私鑰來解密。

我們舉一個例子:假定現在要加密一些數據使用密鑰『12345』。利用rsa公鑰,使用rsa演算法加密這個密鑰『12345』,並把它放在要加密的數據的前面(可能後面跟著一個分割符或文件長度,以區分數據和密鑰),然後,使用對稱加密演算法加密正文,使用的密鑰就是『12345』。當對方收到時,解密程序找到加密過的密鑰,並利用rsa私鑰解密出來,然後再確定出數據的開始位置,利用密鑰『12345』來解密數據。這樣就使得一個可靠的經過高效加密的數據安全地傳輸和解密。

一些簡單的基於rsa演算法的加密演算法可在下面的站點找到:

ftp://ftp.funet.fi/pub/crypt/cryptography/asymmetric/rsa

三.一個嶄新的多步加密演算法

現在又出現了一種新的加密演算法,據說是幾乎不可能被破譯的。這個演算法在1998年6月1日才正式公布的。下面詳細的介紹這個演算法:

使用一系列的數字(比如說128位密鑰),來產生一個可重復的但高度隨機化的偽隨機的數字的序列。一次使用256個表項,使用隨機數序列來產生密碼轉表,如下所示:

把256個隨機數放在一個距陣中,然後對他們進行排序,使用這樣一種方式(我們要記住最初的位置)使用最初的位置來產生一個表,隨意排序的表,表中的數字在0到255之間。如果不是很明白如何來做,就可以不管它。但是,下面也提供了一些原碼(在下面)是我們明白是如何來做的。現在,產生了一個具體的256位元組的表。讓這個隨機數產生器接著來產生這個表中的其餘的數,以至於每個表是不同的。下一步,使用"shotgun technique"技術來產生解碼表。基本上說,如果 a映射到b,那麼b一定可以映射到a,所以b[a[n]] = n.(n是一個在0到255之間的數)。在一個循環中賦值,使用一個256位元組的解碼表它對應於我們剛才在上一步產生的256位元組的加密表。

使用這個方法,已經可以產生這樣的一個表,表的順序是隨機,所以產生這256個位元組的隨機數使用的是二次偽隨機,使用了兩個額外的16位的密碼.現在,已經有了兩張轉換表,基本的加密解密是如下這樣工作的。前一個位元組密文是這個256位元組的表的索引。或者,為了提高加密效果,可以使用多餘8位的值,甚至使用校驗和或者crc演算法來產生索引位元組。假定這個表是256*256的數組,將會是下面的樣子:

crypto1 = a[crypto0][value]

變數'crypto1'是加密後的數據,'crypto0'是前一個加密數據(或著是前面幾個加密數據的一個函數值)。很自然的,第一個數據需要一個「種子」,這個「種子」 是我們必須記住的。如果使用256*256的表,這樣做將會增加密文的長度。或者,可以使用你產生出隨機數序列所用的密碼,也可能是它的crc校驗和。順便提及的是曾作過這樣一個測試: 使用16個位元組來產生表的索引,以128位的密鑰作為這16個位元組的初始的"種子"。然後,在產生出這些隨機數的表之後,就可以用來加密數據,速度達到每秒鍾100k個位元組。一定要保證在加密與解密時都使用加密的值作為表的索引,而且這兩次一定要匹配。

加密時所產生的偽隨機序列是很隨意的,可以設計成想要的任何序列。沒有關於這個隨機序列的詳細的信息,解密密文是不現實的。例如:一些ascii碼的序列,如「eeeeeeee"可能被轉化成一些隨機的沒有任何意義的亂碼,每一個位元組都依賴於其前一個位元組的密文,而不是實際的值。對於任一個單個的字元的這種變換來說,隱藏了加密數據的有效的真正的長度。

如果確實不理解如何來產生一個隨機數序列,就考慮fibbonacci數列,使用2個雙字(64位)的數作為產生隨機數的種子,再加上第三個雙字來做xor操作。 這個演算法產生了一系列的隨機數。演算法如下:

unsigned long dw1, dw2, dw3, dwmask;

int i1;

unsigned long arandom[256];

dw1 = {seed #1};

dw2 = {seed #2};

dwmask = {seed #3};

// this gives you 3 32-bit "seeds", or 96 bits total

for(i1=0; i1 < 256; i1++)

{

dw3 = (dw1 + dw2) ^ dwmask;

arandom[i1] = dw3;

dw1 = dw2;

dw2 = dw3;

}

如果想產生一系列的隨機數字,比如說,在0和列表中所有的隨機數之間的一些數,就可以使用下面的方法:

int __cdecl mysortproc(void *p1, void *p2)

{

unsigned long **pp1 = (unsigned long **)p1;

unsigned long **pp2 = (unsigned long **)p2;

if(**pp1 < **pp2)

return(-1);

else if(**pp1 > *pp2)

return(1);

return(0);

}

...

int i1;

unsigned long *aprandom[256];

unsigned long arandom[256]; // same array as before, in this case

int aresult[256]; // results go here

for(i1=0; i1 < 256; i1++)

{

aprandom[i1] = arandom + i1;

}

// now sort it

qsort(aprandom, 256, sizeof(*aprandom), mysortproc);

// final step - offsets for pointers are placed into output array

for(i1=0; i1 < 256; i1++)

{

aresult[i1] = (int)(aprandom[i1] - arandom);

}

...

變數'aresult'中的值應該是一個排過序的唯一的一系列的整數的數組,整數的值的范圍均在0到255之間。這樣一個數組是非常有用的,例如:對一個位元組對位元組的轉換表,就可以很容易並且非常可靠的來產生一個短的密鑰(經常作為一些隨機數的種子)。這樣一個表還有其他的用處,比如說:來產生一個隨機的字元,計算機游戲中一個物體的隨機的位置等等。上面的例子就其本身而言並沒有構成一個加密演算法,只是加密演算法一個組成部分。

作為一個測試,開發了一個應用程序來測試上面所描述的加密演算法。程序本身都經過了幾次的優化和修改,來提高隨機數的真正的隨機性和防止會產生一些短的可重復的用於加密的隨機數。用這個程序來加密一個文件,破解這個文件可能會需要非常巨大的時間以至於在現實上是不可能的。

四.結論:

由於在現實生活中,我們要確保一些敏感的數據只能被有相應許可權的人看到,要確保信息在傳輸的過程中不會被篡改,截取,這就需要很多的安全系統大量的應用於政府、大公司以及個人系統。數據加密是肯定可以被破解的,但我們所想要的是一個特定時期的安全,也就是說,密文的破解應該是足夠的困難,在現實上是不可能的,尤其是短時間內。

熱點內容
如何讓刷機解不開密碼 發布:2023-04-02 01:24:44 瀏覽:975
指紋解鎖忘記密碼怎麼辦 發布:2023-04-02 01:24:36 瀏覽:418
我的世界國際如何免費開伺服器 發布:2023-04-02 01:23:54 瀏覽:667
jdkftp 發布:2023-04-02 01:17:41 瀏覽:656
安卓手機哪個品牌有暴露通知 發布:2023-04-02 01:16:23 瀏覽:419
存儲空間下 發布:2023-04-02 01:14:15 瀏覽:991
apriori演算法的java 發布:2023-04-02 01:09:40 瀏覽:337
歐明眼鏡得無線網密碼是多少 發布:2023-04-02 01:09:25 瀏覽:287
加密視頻提取有密碼 發布:2023-04-02 01:07:50 瀏覽:328
系統下載網站源碼 發布:2023-04-02 01:07:33 瀏覽:538