「加密算法java」加密算法分成常规密码算法和公钥密码算法正确吗

admin 2022-12-29 17:21:08 742

本篇文章给大家谈谈加密算法java，以及加密算法分成常规密码算法和公钥密码算法正确吗对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

1、java项目如何加密？
2、java最常用的几种加密算法
3、java加密的几种方式
4、java中使用MD5加密算法进行加密
5、JAVA版MD5加密算法
6、可变MD5加密(Java实现)

java项目如何加密？

Java基本的单向加密算法：

1.BASE64 严格地说，属于编码格式，而非加密算法

2.MD5(Message Digest algorithm 5，信息摘要算法)

3.SHA(Secure Hash Algorithm，安全散列算法)

4.HMAC(Hash Message Authentication Code，散列消息鉴别码)

按照RFC2045的定义，Base64被定义为：Base64内容传送编码被设计用来把任意序列的8位字节描述为一种不易被人直接识别的形式。（The Base64 Content-Transfer-Encoding is designed to represent arbitrary sequences of octets in a form that need not be humanly readable.）

常见于邮件、http加密，截取http信息，你就会发现登录操作的用户名、密码字段通过BASE64加密的。

主要就是BASE64Encoder、BASE64Decoder两个类，我们只需要知道使用对应的方法即可。另，BASE加密后产生的字节位数是8的倍数，如果不够位数以=符号填充。

MD5

MD5 -- message-digest algorithm 5 （信息-摘要算法）缩写，广泛用于加密和解密技术，常用于文件校验。校验？不管文件多大，经过MD5后都能生成唯一的MD5值。好比现在的ISO校验，都是MD5校验。怎么用？当然是把ISO经过MD5后产生MD5的值。一般下载linux-ISO的朋友都见过下载链接旁边放着MD5的串。就是用来验证文件是否一致的。

HMAC

HMAC(Hash Message Authentication Code，散列消息鉴别码，基于密钥的Hash算法的认证协议。消息鉴别码实现鉴别的原理是，用公开函数和密钥产生一个固定长度的值作为认证标识，用这个标识鉴别消息的完整性。使用一个密钥生成一个固定大小的小数据块，即MAC，并将其加入到消息中，然后传输。接收方利用与发送方共享的密钥进行鉴别认证等。

java最常用的几种加密算法

简单的Java加密算法有：

第一种. BASE

Base是网络上最常见的用于传输Bit字节代码的编码方式之一，大家可以查看RFC～RFC，上面有MIME的详细规范。Base编码可用于在HTTP环境下传递较长的标识信息。例如，在Java Persistence系统Hibernate中，就采用了Base来将一个较长的唯一标识符（一般为-bit的UUID）编码为一个字符串，用作HTTP表单和HTTP GET URL中的参数。在其他应用程序中，也常常需要把二进制数据编码为适合放在URL（包括隐藏表单域）中的形式。此时，采用Base编码具有不可读性，即所编码的数据不会被人用肉眼所直接看到。

第二种. MD

MD即Message-Digest Algorithm （信息-摘要算法），用于确保信息传输完整一致。是计算机广泛使用的杂凑算法之一（又译摘要算法、哈希算法），主流编程语言普遍已有MD实现。将数据（如汉字）运算为另一固定长度值，是杂凑算法的基础原理，MD的前身有MD、MD和MD。

MD算法具有以下特点：

压缩性：任意长度的数据，算出的MD值长度都是固定的。

容易计算：从原数据计算出MD值很容易。

抗修改性：对原数据进行任何改动，哪怕只修改个字节，所得到的MD值都有很大区别。

弱抗碰撞：已知原数据和其MD值，想找到一个具有相同MD值的数据（即伪造数据）是非常困难的。

强抗碰撞：想找到两个不同的数据，使它们具有相同的MD值，是非常困难的。

MD的作用是让大容量信息在用数字签名软件签署私人密钥前被”压缩”成一种保密的格式（就是把一个任意长度的字节串变换成一定长的十六进制数字串）。除了MD以外，其中比较有名的还有sha-、RIPEMD以及Haval等。

第三种.SHA

安全哈希算法（Secure Hash Algorithm）主要适用于数字签名标准（Digital Signature Standard DSS）里面定义的数字签名算法（Digital Signature Algorithm DSA）。对于长度小于^位的消息，SHA会产生一个位的消息摘要。该算法经过加密专家多年来的发展和改进已日益完善，并被广泛使用。该算法的思想是接收一段明文，然后以一种不可逆的方式将它转换成一段（通常更小）密文，也可以简单的理解为取一串输入码（称为预映射或信息），并把它们转化为长度较短、位数固定的输出序列即散列值（也称为信息摘要或信息认证代码）的过程。散列函数值可以说是对明文的一种“指纹”或是“摘要”所以对散列值的数字签名就可以视为对此明文的数字签名。

SHA-与MD的比较

因为二者均由MD导出，SHA-和MD彼此很相似。相应的，他们的强度和其他特性也是相似，但还有以下几点不同：

对强行攻击的安全性：最显著和最重要的区别是SHA-摘要比MD摘要长位。使用强行技术，产生任何一个报文使其摘要等于给定报摘要的难度对MD是^数量级的操作，而对SHA-则是^数量级的操作。这样，SHA-对强行攻击有更大的强度。

对密码分析的安全性：由于MD的设计，易受密码分析的攻击，SHA-显得不易受这样的攻击。

速度：在相同的硬件上，SHA-的运行速度比MD慢。

第四种.HMAC

java加密的几种方式

基本的单向加密算法：

BASE64 严格地说，属于编码格式，而非加密算法

MD5(Message Digest algorithm 5，信息摘要算法)

SHA(Secure Hash Algorithm，安全散列算法)

HMAC(Hash Message Authentication Code，散列消息鉴别码)

复杂的对称加密（DES、PBE）、非对称加密算法：

DES(Data Encryption Standard，数据加密算法)

PBE(Password-based encryption，基于密码验证)

RSA(算法的名字以发明者的名字命名：Ron Rivest, AdiShamir 和Leonard Adleman)

DH(Diffie-Hellman算法，密钥一致协议)

DSA(Digital Signature Algorithm，数字签名)

ECC(Elliptic Curves Cryptography，椭圆曲线密码编码学)

代码参考：

/**

* BASE64加密

* @param key

* @return

* @throws Exception

public static String encryptBASE64(byte[] key) throws Exception {

return (new BASE64Encoder()).encodeBuffer(key);

}

/**

* MD5加密

* @param data

* @return

* @throws Exception

public static byte[] encryptMD5(byte[] data) throws Exception {

MessageDigest md5 = MessageDigest.getInstance(KEY_MD5);

md5.update(data);

return md5.digest();

}

/**

* SHA加密

* @param data

* @return

* @throws Exception

public static byte[] encryptSHA(byte[] data) throws Exception {

MessageDigest sha = MessageDigest.getInstance(KEY_SHA);

sha.update(data);

return sha.digest();

}

/**

* 初始化HMAC密钥

* @return

* @throws Exception

public static String initMacKey() throws Exception {

KeyGenerator keyGenerator = KeyGenerator.getInstance(KEY_MAC);

SecretKey secretKey = keyGenerator.generateKey();

return encryptBASE64(secretKey.getEncoded());

}

/**

* HMAC加密

* @param data

* @param key

* @return

* @throws Exception

public static byte[] encryptHMAC(byte[] data, String key) throws Exception {

SecretKey secretKey = new SecretKeySpec(decryptBASE64(key), KEY_MAC);

Mac mac = Mac.getInstance(secretKey.getAlgorithm());

mac.init(secretKey);

return mac.doFinal(data);

}

java中使用MD5加密算法进行加密

在各种应用系统的开发中经常需要存储用户信息很多地方都要存储用户密码而将用户密码直接存储在服务器上显然是不安全的本文简要介绍工作中常用的 MD 加密算法希望能抛砖引玉

（一）消息摘要简介

一个消息摘要就是一个数据块的数字指纹即对一个任意长度的一个数据块进行计算产生一个唯一指印（对于SHA 是产生一个字节的二进制数组）消息摘要是一种与消息认证码结合使用以确保消息完整性的技术主要使用单向散列函数算法可用于检验消息的完整性和通过散列密码直接以文本形式保存等目前广泛使用的算法有MD MD SHA

消息摘要有两个基本属性

两个不同的报文难以生成相同的摘要难以对指定的摘要生成一个报文而可以由该报文反推算出该指定的摘要代表美国国家标准技术研究所的SHA 和麻省理工学院Ronald Rivest提出的MD

（二）对字符串进行加密

/** *//**利用MD 进行加密 * @param str 待加密的字符串 * @return 加密后的字符串 * @throws NoSuchAlgorithmException 没有这种产生消息摘要的算法 * @throws UnsupportedEncodingException */ public String EncoderByMd (String str) throws NoSuchAlgorithmException UnsupportedEncodingException { //确定计算方法 MessageDigest md =MessageDigest getInstance( MD ); BASE Encoder base en = new BASE Encoder(); //加密后的字符串 String newstr=base en encode(md digest(str getBytes( utf ))); return newstr; }

调用函数 String str=

System out println（EncoderByMd （str））

输出 eB eJF ptWaXm bijSPyxw==

（三）验证密码是否正确

/** *//**判断用户密码是否正确 * @param newpasswd 用户输入的密码 * @param oldpasswd 数据库中存储的密码－－用户密码的摘要 * @return * @throws NoSuchAlgorithmException * @throws UnsupportedEncodingException */ public boolean checkpassword(String newpasswd String oldpasswd) throws NoSuchAlgorithmException UnsupportedEncodingException { if(EncoderByMd (newpasswd) equals(oldpasswd)) return true; else return false; } lishixinzhi/Article/program/Java/hx/201311/26374

JAVA版MD5加密算法

package sf_md ;

import java io *;

import java security *;

//import java util *;

//import java security interfaces *;

public class MD _算法 {

private String inStr;

private MessageDigest mad ;

public MD _算法(String inStr){

this inStr=inStr;

try{

this mad =MessageDigest getInstance( MD );

}

catch(Exception e){

System out println(e toString());

e printStackTrace();

}

public String pute(){

char[] charArray=this inStr toCharArray();

byte[] byteArray=new byte[charArray length];

for(int i= ;icharArray length;i++)

byteArray[i]=(byte)charArray[i];

byte[] md Bytes=this mad digest(byteArray);

StringBuffer hexValue=new StringBuffer();

for(int i= ;imd Bytes length;i++){

int val=((int)md Bytes[i]) xff;

if(val )

hexValue append( );

hexValue append(Integer toHexString(val));

}

return hexValue toString();

}

public static void main(String[] args) {

String string=null;

try{

System out println( 请输入要加密的数据: );

BufferedReader br=new BufferedReader(new InputStreamReader(System in));

string=br readLine();

}

catch(IOException e){

System out println(e);

}

MD _算法 md =new MD _算法(string);

String postString =pute();

System out println( 加密后的数据: +postString);

}

lishixinzhi/Article/program/Java/hx/201311/25613

可变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( 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 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;

///* 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);

}

/*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 (\ 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

关于加密算法java和加密算法分成常规密码算法和公钥密码算法正确吗的介绍到此就结束了，不知道你从中找到你需要的信息了吗？如果你还想了解更多这方面的信息，记得收藏关注本站。

标签：加密算法java