密码算法代码实现java java编写密码程序

Java 中的加密算法用.Net 怎样实现

C#使用SHA1算hash如下：

成都创新互联公司自2013年创立以来，先为源汇等服务建站，源汇等地企业，进行企业商务咨询服务。为源汇企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

byte[] data = new byte[DATA_SIZE];

byte[] result; 

SHA1 sha = new SHA1CryptoServiceProvider(); 

result = sha.ComputeHash(data);

我这其实是从MSDN抄的：

C#的RSA加密，可以参考MSDN，其实和Java差不多，都封装好了的，几行代码搞定:

;cs-lang=csharp#code-snippet-4

如何使用java对密码加密 加密方式aes

Java有相关的实现类：具体原理如下

对于任意长度的明文，AES首先对其进行分组，每组的长度为128位。分组之后将分别对每个128位的明文分组进行加密。

对于每个128位长度的明文分组的加密过程如下：

（1）将128位AES明文分组放入状态矩阵中。

（2）AddRoundKey变换：对状态矩阵进行AddRoundKey变换，与膨胀后的密钥进行异或操作（密钥膨胀将在实验原理七中详细讨论）。

（3）10轮循环：AES对状态矩阵进行了10轮类似的子加密过程。前9轮子加密过程中，每一轮子加密过程包括4种不同的变换，而最后一轮只有3种变换，前9轮的子加密步骤如下：

● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；

● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；

● MixColumns变换：MixColumns变换对状态矩阵的列进行变换；

● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或操作。

最后一轮的子加密步骤如下：

● SubBytes变换：SubBytes变换是一个对状态矩阵非线性的变换；

● ShiftRows变换：ShiftRows变换对状态矩阵的行进行循环移位；

● AddRoundKey变换：AddRoundKey变换对状态矩阵和膨胀后的密钥进行异或操作；

（4）经过10轮循环的状态矩阵中的内容就是加密后的密文。

AES的加密算法的伪代码如下。

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的膨胀后的密钥，这44个字的膨胀后的密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。

三．AES的分组过程

对于任意长度的明文，AES首先对其进行分组，分组的方法与DES相同，即对长度不足的明文分组后面补充0即可，只是每一组的长度为128位。

AES的密钥长度有128比特，192比特和256比特三种标准，其他长度的密钥并没有列入到AES联邦标准中，在下面的介绍中，我们将以128位密钥为例。

四．状态矩阵

状态矩阵是一个4行、4列的字节矩阵，所谓字节矩阵就是指矩阵中的每个元素都是一个1字节长度的数据。我们将状态矩阵记为State，State中的元素记为Sij，表示状态矩阵中第i行第j列的元素。128比特的明文分组按字节分成16块，第一块记为“块0”，第二块记为“块1”，依此类推，最后一块记为“块15”，然后将这16块明文数据放入到状态矩阵中，将这16块明文数据放入到状态矩阵中的方法如图2-2-1所示。

块0

块4

块8

块12

块1

块5

块9

块13

块2

块6

块10

块14

块3

块7

块11

块15

图2-2-1 将明文块放入状态矩阵中

五．AddRoundKey变换

状态矩阵生成以后，首先要进行AddRoundKey变换，AddRoundKey变换将状态矩阵与膨胀后的密钥进行按位异或运算，如下所示。

其中，c表示列数，数组W为膨胀后的密钥，round为加密轮数，Nb为状态矩阵的列数。

它的过程如图2-2-2所示。

图2-2-2 AES算法AddRoundKey变换

六．10轮循环

经过AddRoundKey的状态矩阵要继续进行10轮类似的子加密过程。前9轮子加密过程中，每一轮要经过4种不同的变换，即SubBytes变换、ShiftRows变换、MixColumns变换和AddRoundKey变换，而最后一轮只有3种变换，即SubBytes变换、ShiftRows变换和AddRoundKey变换。AddRoundKey变换已经讨论过，下面分别讨论余下的三种变换。

1．SubBytes变换

SubBytes是一个独立作用于状态字节的非线性变换，它由以下两个步骤组成：

（1）在GF（28）域，求乘法的逆运算，即对于α∈GF（28）求β∈GF（28），使αβ =βα = 1mod（x8 + x4 + x3 + x + 1）。

（2）在GF（28）域做变换，变换使用矩阵乘法，如下所示：

由于所有的运算都在GF（28）域上进行，所以最后的结果都在GF（28）上。若g∈GF（28）是GF（28）的本原元素，则对于α∈GF（28），α≠0，则存在

β ∈ GF（28），使得：

β = gαmod（x8 + x4 + x3 + x + 1）

由于g255 = 1mod（x8 + x4 + x3 + x + 1）

所以g255-α = β-1mod（x8 + x4 + x3 + x + 1）

根据SubBytes变换算法，可以得出SubBytes的置换表，如表2-2-1所示，这个表也叫做AES的S盒。该表的使用方法如下：状态矩阵中每个元素都要经过该表替换，每个元素为8比特，前4比特决定了行号，后4比特决定了列号，例如求SubBytes(0C)查表的0行C列得FE。

表2-2-1 AES的SubBytes置换表

它的变换过程如图2-2-3所示。

图2-2-3 SubBytes变换

AES加密过程需要用到一些数学基础，其中包括GF(2)域上的多项式、GF（28）域上的多项式的计算和矩阵乘法运算等，有兴趣的同学请参考相关的数学书籍。

2．ShiftRows变换

ShiftRows变换比较简单，状态矩阵的第1行不发生改变，第2行循环左移1字节，第3行循环左移2字节，第4行循环左移3字节。ShiftRows变换的过程如图2-2-4所示。

图2-2-4 AES的ShiftRows变换

3．MixColumns变换

在MixColumns变换中，状态矩阵的列看作是域GF（28）的多项式，模(x4＋1)乘以c（x）的结果：

c(x)＝(03)x3＋(01)x2+(01)x+(02)

这里(03)为十六进制表示，依此类推。c(x)与x4＋1互质，故存在逆：

d(x)=(0B)x3＋(0D)x2＋(0G)x＋(0E)使c(x)•d(x) = (D1)mod(x4＋1)。

设有：

它的过程如图2-2-5所示。

图2-2-5 AES算法MixColumns变换

七．密钥膨胀

在AES算法中，AddRoundKey变换需要使用膨胀后的密钥，膨胀后的密钥记为子密钥，原始的128位密钥经过膨胀会产生44个字（每个字为32位）的子密钥，这44个字的子密钥供11次AddRoundKey变换使用，一次AddRoundKey使用4个字（128位）的膨胀后的密钥。

密钥膨胀算法是以字为基础的（一个字由4个字节组成，即32比特）。128比特的原始密钥经过膨胀后将产生44个字的子密钥，我们将这44个密钥保存在一个字数组中，记为W[44]。128比特的原始密钥分成16份，存放在一个字节的数组：Key[0]，Key[1]……Key[15]中。

在密钥膨胀算法中，Rcon是一个10个字的数组，在数组中保存着算法定义的常数，分别为：

Rcon[0] = 0x01000000

Rcon[1] = 0x02000000

Rcon[2] = 0x04000000

Rcon[3] = 0x08000000

Rcon[4] = 0x10000000

Rcon[5] = 0x20000000

Rcon[6] = 0x40000000

Rcon[7] = 0x80000000

Rcon[8] = 0x1b000000

Rcon[9] = 0x36000000

另外，在密钥膨胀中包括其他两个操作RotWord和SubWord，下面对这两个操作做说明：

RotWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3进行循环移位，即

RotWord( B0,B1,B2,B3 ) = ( B1,B2,B3,B0 )

SubWord( B0,B1,B2,B3 )对4个字节B0,B1,B2,B3使用AES的S盒，即

SubWord( B0,B1,B2,B3 ) = ( B’0,B’1,B’2,B’3 )

其中，B’i = SubBytes（Bi），i = 0,1,2,3。

密钥膨胀的算法如下：

八．解密过程

AES的加密和解密过程并不相同，首先密文按128位分组，分组方法和加密时的分组方法相同，然后进行轮变换。

AES的解密过程可以看成是加密过程的逆过程，它也由10轮循环组成，每一轮循环包括四个变换分别为InvShiftRows变换、InvSubBytes变换、InvMixColumns变换和AddRoundKey变换；

这个过程可以描述为如下代码片段所示：

九．InvShiftRows变换

InvShiftRows变换是ShiftRows变换的逆过程，十分简单，指定InvShiftRows的变换如下。

Sr,(c+shift(r,Nb))modNb= Sr,c for 0 r 4 and 0 ≤ c Nb

图2-2-6演示了这个过程。

图2-2-6 AES算法InvShiftRows变换

十．InvSubBytes变换

InvSubBytes变换是SubBytes变换的逆变换，利用AES的S盒的逆作字节置换，表2-2-2为InvSubBytes变换的置换表。

表2-2-2 InvSubBytes置换表

十一．InvMixColumns变换

InvMixColumns变换与MixColumns变换类似，每列乘以d(x)

d(x) = (OB)x3 + (0D)x2 + (0G)x + (0E)

下列等式成立：

( (03)x3 + (01)x2 + (01)x + (02) )⊙d(x) = (01)

上面的内容可以描述为以下的矩阵乘法：

十二．AddRoundKey变换

AES解密过程的AddRoundKey变换与加密过程中的AddRoundKey变换一样，都是按位与子密钥做异或操作。解密过程的密钥膨胀算法也与加密的密钥膨胀算法相同。最后状态矩阵中的数据就是明文。

可变MD5加密(Java实现)

可变在这里含义很简单 就是最终的加密结果是可变的 而非必需按标准MD 加密实现 Java类库security中的MessageDigest类就提供了MD 加密的支持 实现起来非常方便 为了实现更多效果 我们可以如下设计MD 工具类

Java代码

package ** ** util;

import java security MessageDigest;

/**

* 标准MD 加密方法 使用java类库的security包的MessageDigest类处理

* @author Sarin

*/

public class MD {

/**

* 获得MD 加密密码的方法

*/

public static String getMD ofStr(String origString) {

String origMD = null;

try {

MessageDigest md = MessageDigest getInstance( MD );

byte[] result = md digest(origString getBytes());

origMD = byteArray HexStr(result);

} catch (Exception e) {

e printStackTrace();

}

return origMD ;

}

/**

* 处理字节数组得到MD 密码的方法

*/

private static String byteArray HexStr(byte[] bs) {

StringBuffer *** = new StringBuffer();

for (byte b : bs) {

*** append(byte HexStr(b));

}

return *** toString();

}

/**

* 字节标准移位转十六进制方法

*/

private static String byte HexStr(byte b) {

String hexStr = null;

int n = b;

if (n ) {

//若需要自定义加密 请修改这个移位算法即可

n = b x F + ;

}

hexStr = Integer toHexString(n / ) + Integer toHexString(n % );

return hexStr toUpperCase();

}

/**

* 提供一个MD 多次加密方法

*/

public static String getMD ofStr(String origString int times) {

String md = getMD ofStr(origString);

for (int i = ; i times ; i++) {

md = getMD ofStr(md );

}

return getMD ofStr(md );

}

/**

* 密码验证方法

*/

public static boolean verifyPassword(String inputStr String MD Code) {

return getMD ofStr(inputStr) equals(MD Code);

}

/**

* 重载一个多次加密时的密码验证方法

*/

public static boolean verifyPassword(String inputStr String MD Code int times) {

return getMD ofStr(inputStr times) equals(MD Code);

}

/**

* 提供一个测试的主函数

*/

public static void main(String[] args) {

System out println( : + getMD ofStr( ));

System out println( : + getMD ofStr( ));

System out println( sarin: + getMD ofStr( sarin ));

System out println( : + getMD ofStr( ));

}

}

可以看出实现的过程非常简单 因为由java类库提供了处理支持 但是要清楚的是这种方式产生的密码不是标准的MD 码 它需要进行移位处理才能得到标准MD 码 这个程序的关键之处也在这了 怎么可变？调整移位算法不就可变了么！不进行移位 也能够得到 位的密码 这就不是标准加密了 只要加密和验证过程使用相同的算法就可以了

MD 加密还是很安全的 像CMD 那些穷举破解的只是针对标准MD 加密的结果进行的 如果自定义移位算法后 它还有效么？可以说是无解的了 所以MD 非常安全可靠

为了更可变 还提供了多次加密的方法 可以在MD 基础之上继续MD 就是对 位的第一次加密结果再MD 恩 这样去破解？没有任何意义

这样在MIS系统中使用 安全可靠 欢迎交流 希望对使用者有用

我们最后看看由MD 加密算法实现的类 那是非常庞大的

Java代码

import java lang reflect *;

/**

* **********************************************

* md 类实现了RSA Data Security Inc 在提交给IETF

* 的RFC 中的MD message digest 算法

* ***********************************************

*/

public class MD {

/* 下面这些S S 实际上是一个 * 的矩阵 在原始的C实现中是用#define 实现的

这里把它们实现成为static final是表示了只读 切能在同一个进程空间内的多个

Instance间共享*/

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final int S = ;

static final byte[] PADDING = {

};

/* 下面的三个成员是MD 计算过程中用到的 个核心数据 在原始的C实现中

被定义到MD _CTX结构中

*/

private long[] state = new long[ ]; // state (ABCD)

private long[] count = new long[ ]; // number of bits modulo ^ (l *** first)

private byte[] buffer = new byte[ ]; // input buffer

/* digestHexStr是MD 的唯一一个公共成员 是最新一次计算结果的

进制ASCII表示

*/

public String digestHexStr;

/* digest 是最新一次计算结果的 进制内部表示 表示 bit的MD 值

*/

private byte[] digest = new byte[ ];

/*

getMD ofStr是类MD 最主要的公共方法 入口参数是你想要进行MD 变换的字符串

返回的是变换完的结果 这个结果是从公共成员digestHexStr取得的．

*/

public String getMD ofStr(String inbuf) {

md Init();

md Update(inbuf getBytes() inbuf length());

md Final();

digestHexStr = ;

for (int i = ; i ; i++) {

digestHexStr += byteHEX(digest[i]);

}

return digestHexStr;

}

// 这是MD 这个类的标准构造函数 JavaBean要求有一个public的并且没有参数的构造函数

public MD () {

md Init();

return;

}

/* md Init是一个初始化函数 初始化核心变量 装入标准的幻数 */

private void md Init() {

count[ ] = L;

count[ ] = L;

///* Load magic initialization constants

state[ ] = x L;

state[ ] = xefcdab L;

state[ ] = x badcfeL;

state[ ] = x L;

return;

}

/* F G H I 是 个基本的MD 函数 在原始的MD 的C实现中 由于它们是

简单的位运算 可能出于效率的考虑把它们实现成了宏 在java中 我们把它们

实现成了private方法 名字保持了原来C中的 */

private long F(long x long y long z) {

return (x y) | ((~x) z);

}

private long G(long x long y long z) {

return (x z) | (y (~z));

}

private long H(long x long y long z) {

return x ^ y ^ z;

}

private long I(long x long y long z) {

return y ^ (x | (~z));

}

/*

FF GG HH和II将调用F G H I进行近一步变换

FF GG HH and II transformations for rounds and

Rotation is separate from addition to prevent reputation

*/

private long FF(long a long b long c long d long x long s long ac) {

a += F(b c d) + x + ac;

a = ((int) a s) | ((int) a ( s));

a += b;

return a;

}

private long GG(long a long b long c long d long x long s long ac) {

a += G(b c d) + x + ac;

a = ((int) a s) | ((int) a ( s));

a += b;

return a;

}

private long HH(long a long b long c long d long x long s long ac) {

a += H(b c d) + x + ac;

a = ((int) a s) | ((int) a ( s));

a += b;

return a;

}

private long II(long a long b long c long d long x long s long ac) {

a += I(b c d) + x + ac;

a = ((int) a s) | ((int) a ( s));

a += b;

return a;

}

/*

md Update是MD 的主计算过程 inbuf是要变换的字节串 inputlen是长度 这个

函数由getMD ofStr调用 调用之前需要调用md init 因此把它设计成private的

*/

private void md Update(byte[] inbuf int inputLen) {

int i index partLen;

byte[] block = new byte[ ];

index = (int) (count[ ] ) x F;

// /* Update number of bits */

if ((count[ ] += (inputLen )) (inputLen ))

count[ ]++;

count[ ] += (inputLen );

partLen = index;

// Transform as many times as possible

if (inputLen = partLen) {

md Memcpy(buffer inbuf index partLen);

md Transform(buffer);

for (i = partLen; i + inputLen; i += ) {

md Memcpy(block inbuf i );

md Transform(block);

}

index = ;

} else

i = ;

///* Buffer remaining input */

md Memcpy(buffer inbuf index i inputLen i);

}

/*

md Final整理和填写输出结果

*/

private void md Final() {

byte[] bits = new byte[ ];

int index padLen;

///* Save number of bits */

Encode(bits count );

///* Pad out to mod

index = (int) (count[ ] ) x f;

padLen = (index ) ? ( index) : ( index);

md Update(PADDING padLen);

///* Append length (before padding) */

md Update(bits );

///* Store state in digest */

Encode(digest state );

}

/* md Memcpy是一个内部使用的byte数组的块拷贝函数 从input的inpos开始把len长度的

字节拷贝到output的outpos位置开始

*/

private void md Memcpy(byte[] output byte[] input int outpos int inpos int len) {

int i;

for (i = ; i len; i++)

output[outpos + i] = input[inpos + i];

}

/*

md Transform是MD 核心变换程序 有md Update调用 block是分块的原始字节

*/

private void md Transform(byte block[]) {

long a = state[ ] b = state[ ] c = state[ ] d = state[ ];

long[] x = new long[ ];

Decode(x block );

/* Round */

a = FF(a b c d x[ ] S xd aa L); /* */

d = FF(d a b c x[ ] S xe c b L); /* */

c = FF(c d a b x[ ] S x dbL); /* */

b = FF(b c d a x[ ] S xc bdceeeL); /* */

a = FF(a b c d x[ ] S xf c fafL); /* */

d = FF(d a b c x[ ] S x c aL); /* */

c = FF(c d a b x[ ] S xa L); /* */

b = FF(b c d a x[ ] S xfd L); /* */

a = FF(a b c d x[ ] S x d L); /* */

d = FF(d a b c x[ ] S x b f afL); /* */

c = FF(c d a b x[ ] S xffff bb L); /* */

b = FF(b c d a x[ ] S x cd beL); /* */

a = FF(a b c d x[ ] S x b L); /* */

d = FF(d a b c x[ ] S xfd L); /* */

c = FF(c d a b x[ ] S xa eL); /* */

b = FF(b c d a x[ ] S x b L); /* */

/* Round */

a = GG(a b c d x[ ] S xf e L); /* */

d = GG(d a b c x[ ] S xc b L); /* */

c = GG(c d a b x[ ] S x e a L); /* */

b = GG(b c d a x[ ] S xe b c aaL); /* */

a = GG(a b c d x[ ] S xd f dL); /* */

d = GG(d a b c x[ ] S x L); /* */

c = GG(c d a b x[ ] S xd a e L); /* */

b = GG(b c d a x[ ] S xe d fbc L); /* */

a = GG(a b c d x[ ] S x e cde L); /* */

d = GG(d a b c x[ ] S xc d L); /* */

c = GG(c d a b x[ ] S xf d d L); /* */

b = GG(b c d a x[ ] S x a edL); /* */

a = GG(a b c d x[ ] S xa e e L); /* */

d = GG(d a b c x[ ] S xfcefa f L); /* */

c = GG(c d a b x[ ] S x f d L); /* */

b = GG(b c d a x[ ] S x d a c aL); /* */

/* Round */

a = HH(a b c d x[ ] S xfffa L); /* */

d = HH(d a b c x[ ] S x f L); /* */

c = HH(c d a b x[ ] S x d d L); /* */

b = HH(b c d a x[ ] S xfde cL); /* */

a = HH(a b c d x[ ] S xa beea L); /* */

d = HH(d a b c x[ ] S x bdecfa L); /* */

c = HH(c d a b x[ ] S xf bb b L); /* */

b = HH(b c d a x[ ] S xbebfbc L); /* */

a = HH(a b c d x[ ] S x b ec L); /* */

d = HH(d a b c x[ ] S xeaa faL); /* */

c = HH(c d a b x[ ] S xd ef L); /* */

b = HH(b c d a x[ ] S x d L); /* */

a = HH(a b c d x[ ] S xd d d L); /* */

d = HH(d a b c x[ ] S xe db e L); /* */

c = HH(c d a b x[ ] S x fa cf L); /* */

b = HH(b c d a x[ ] S xc ac L); /* */

/* Round */

a = II(a b c d x[ ] S xf L); /* */

d = II(d a b c x[ ] S x aff L); /* */

c = II(c d a b x[ ] S xab a L); /* */

b = II(b c d a x[ ] S xfc a L); /* */

a = II(a b c d x[ ] S x b c L); /* */

d = II(d a b c x[ ] S x f ccc L); /* */

c = II(c d a b x[ ] S xffeff dL); /* */

b = II(b c d a x[ ] S x dd L); /* */

a = II(a b c d x[ ] S x fa e fL); /* */

d = II(d a b c x[ ] S xfe ce e L); /* */

c = II(c d a b x[ ] S xa L); /* */

b = II(b c d a x[ ] S x e a L); /* */

a = II(a b c d x[ ] S xf e L); /* */

d = II(d a b c x[ ] S xbd af L); /* */

c = II(c d a b x[ ] S x ad d bbL); /* */

b = II(b c d a x[ ] S xeb d L); /* */

state[ ] += a;

state[ ] += b;

state[ ] += c;

state[ ] += d;

}

/*Encode把long数组按顺序拆成byte数组 因为java的long类型是 bit的

只拆低 bit 以适应原始C实现的用途

*/

private void Encode(byte[] output long[] input int len) {

int i j;

for (i = j = ; j len; i++ j += ) {

output[j] = (byte) (input[i] xffL);

output[j + ] = (byte) ((input[i] ) xffL);

output[j + ] = (byte) ((input[i] ) xffL);

output[j + ] = (byte) ((input[i] ) xffL);

}

}

/*Decode把byte数组按顺序合成成long数组 因为java的long类型是 bit的

只合成低 bit 高 bit清零 以适应原始C实现的用途

*/

private void Decode(long[] output byte[] input int len) {

int i j;

for (i = j = ; j len; i++ j += )

output[i] = b iu(input[j]) | (b iu(input[j + ]) ) | (b iu(input[j + ]) )

| (b iu(input[j + ]) );

return;

}

/*

b iu是我写的一个把byte按照不考虑正负号的原则的＂升位＂程序 因为java没有unsigned运算

*/

public static long b iu(byte b) {

return b ? b x F + : b;

}

/*byteHEX() 用来把一个byte类型的数转换成十六进制的ASCII表示

因为java中的byte的toString无法实现这一点 我们又没有C语言中的

sprintf(outbuf % X ib)

*/

public static String byteHEX(byte ib) {

char[] Digit = { A B C D E F };

char[] ob = new char[ ];

ob[ ] = Digit[(ib ) X F];

ob[ ] = Digit[ib X F];

String s = new String(ob);

return s;

}

public static void main(String args[]) {

MD m = new MD ();

if (Array getLength(args) == ) { //如果没有参数 执行标准的Test Suite

System out println( MD Test suite: );

System out println( MD (\ \ ): + m getMD ofStr( ));

System out println( MD (\ a\ ): + m getMD ofStr( a ));

System out println( MD (\ abc\ ): + m getMD ofStr( abc ));

System out println( MD (\ \ ): + m getMD ofStr( ));

System out println( MD (\ \ ): + m getMD ofStr( ));

System out println( MD (\ message digest\ ): + m getMD ofStr( message digest ));

System out println( MD (\ abcdefghijklmnopqrstuvwxyz\ ): + m getMD ofStr( abcdefghijklmnopqrstuvwxyz ));

System out println( MD (\ ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz \ ):

+ m getMD ofStr( ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ));

} else

System out println( MD ( + args[ ] + )= + m getMD ofStr(args[ ]));

}

lishixinzhi/Article/program/Java/hx/201311/26604