MD5的学习与练习,在JSP中如何实现MD5加密的方法
分类:澳门新萄京最大平台

在各类应用系统的支出中,平时索要存款和储蓄用户消息,繁多地点都要存款和储蓄用户密码,而将用户密码直接存款和储蓄在服务器上鲜明是不安全的,本文简单介绍在JSP中什么贯彻MD5加密的主意,希望能一得之见。

MD5加密的Java实现

常用的数字摘要算法有MD5SHA等,上面那对这个数字摘要算法来举办介绍。
将数据(如一段文字)运算变为另一恒定长度值,是散列算法的基础原理。

序言:多数少人以为MD5是一种加密算法,其实严俊来说MD5是为Computer安全领域广阔运用的一种散列函数,用以提供音讯的完整性爱抚;

MD5 和SHA-1 是眼前选用比较常见的散列(Hash)函数,也是在消息证实和数字具名吉林中国广播集团泛利用的二种加密算法。本文基于AVOdyssey

(一)新闻摘要简单介绍
一个音信摘要便是八个数据块的数字指纹。即对三个随意长度的三个数码块实行总结,产生一个唯一指印(对于SHA1是爆发叁个20字节的二进制数组)。音讯摘倘使一种与音讯认证码结合使用以管教音信完整性的技巧。首要选用单向散列函数算法,可用于查验音信的完整性,和经过散列密码直接以文件方式保留等,近来广大利用的算法有MD4、MD5、SHA-1。

    在各样应用种类中,如若急需安装账户,那么就能涉嫌到存款和储蓄用户账户消息的难题,为了确定保证所蕴藏账户音信的安全,平时会动用MD5加密的秘诀来,实行仓库储存。首先,简单得介绍一下,什么是MD5加密。
        MD5的完备是Message-Digest Algorithm 5 (音讯-摘要算法),在90年份初,由MIT Laboratory for 电脑 Scientce 和卡宴SA Data Security Inc 的 罗恩ald L.Rivest开荒出来,经MD2、MD3和MD4前行而来。是让大体量音讯在用数字具名软件签署私人密匙前被"压缩"成一种保密的格式(正是把四个自由长度的字节串调换来自然长的大整数)。不管是MD2、MD4照旧MD5,它们都需求获得二个私行长度的音讯并产生三个129个人的音信摘要。即便那几个算法的组织或多或少有个别相似,但MD2的安插性与MD4和MD5全然两样,那是因为MD2是为8位机器做过设计优化的,而MD4和MD5却是面向叁十二人的微管理器。那多个算法的叙述和C语言源代码在Internet 哈弗FCs 13第21中学有详实的描述,那是一份最华贵的文书档案,由罗恩ald L.Rivest在一九九三年一月向IETF提交。

MD5算法

音讯摘要算法版本5(Message-Digest Algorithm 5)即MD5,由RonRivest(凯雷德SA集团)在1995年提出,近日被普遍应用于数据完整性校验、数据(新闻)摘要、数据加密等。MD2MD5的学习与练习,在JSP中如何实现MD5加密的方法。、MD4MD5都发生16字节(1贰十九个人)的校验值,一般用三十位十六进制数表示。MD2的算法极慢但针锋相对安全,MD4进程高速,但安全性下落,MD5MD4更安全、速度越来越快。

那正是说MD5属不属于加密算法呢?

敏捷嵌入式单片机,完成了MD5和SHA-1

新闻摘要有三个为主品质:

        (一)音信摘要简要介绍
            贰个消息摘要正是三个数据块的数字指纹。即对贰个任意长度的三个数额块进行计算,发生一个唯一指印(对于SHA1是发出叁个20字节的二进制数组)。新闻摘倘使一种与信息认证码结合使用以管教新闻完整性的技巧。重要利用单向散列函数算法,可用以核查新闻的完整性,和透过散列密码直接以文件格局保留等,前段时间周围运用的算法由MD4、MD5、SHA-1.

介绍

MD5 报文章摘要要算法:MD5 报文章摘要要算法将随便长度的消息作为输入值,并将其换算成一个 127人长度的"指纹新闻"或"报文章摘要要"值来表示这一个输入值,并以换算后的值作为结果。MD5 算法首假如为数字具名应用程序而规划的;在那一个数字具名应用程序中,异常的大的文件就要加密(这里的加密进度是经过在一个密码系统下[如:RSA]的公然密钥下设置个人密钥而成功的)从前以一种安全的点子张开压缩。[来自RFC1321]
MD5用途布满,对数据变化音讯摘要放置被篡改,为大文件生成唯一的MD5音信摘要,保险文件未被修改。

以为不属于的人是因为她们以为不能从密文(散列值)反过来获得原来的小说,即未有解密算法,所以这一部分人觉着MD5只可以属于算法,不能够称为加密算法;

三种加密算法的相比较,并对算法进行了汇编语言的优化和立异。依照实验结果,对二种算法的得失实行了比较和解析。

五个不等的报文难以扭转同样的摘要

        音信摘要有七个为主质量:
            1.多个例外的报文难以扭转同样的摘要
            2.不便对点名的摘要生成八个报文,而得以由改报文反推算出该钦定的摘要
        代表:美利坚合作国国标技艺斟酌所的SHA1和南开高校罗恩ald Rivest提议的MD5

贯彻原理:

MD5以5十二个人分组来处理输入的新闻,且每一分组又被分割为拾陆个32席位分组,经过了一类别的拍卖后,算法的输出由八个叁12人分组组成,将这八个三十五位分组级联后将生成二个1贰19个人散列值。

MD5原理参照他事他说加以调查:
MD5算法原理
SHA1和MD5算法详解和源码

认为属于的人是因为她们认为经过MD5管理后看不到原著,即现已将原著加密,所以感到MD5属于加密算法;作者个人扶助前者。

随着音信本事和Internet的敏捷升高,音信安全和可信赖性难点进一步首要。以往新闻安周到临两大主导攻击:被动式攻击(获取新闻的内容、业务流深入分析)和积极向上攻击(假冒、新闻的歪曲、业务拒绝)。前者首要靠加密和解密手艺拓展中用管理,而后面一个将在靠音讯证实来拍卖。在金融交易、电子商务、电子函件、手提式有线电话机用户音信的认同等世界,数据完整性确认和多少来源的真假推断都是很关键的平安服务。达成这么些安全服务的最佳办法就是运用加密函数中的单项散列(Hash)函数。单项散列(Hash)函数是一种单项密码体制,它是三个从公开到密文的不可逆函数,也正是说,是爱莫能助解密的。平时采取在只须要加密、不需要解密的特种应用地方。单项散列(Hash)函数H(M)功效于一率性长度的消息M,它回到一永世长度的散列值h:h=H(M)看作早先音信的不二法门的“数字指纹”,从而能保障数据的完整性和惟一性。

不便对点名的摘要生成一个报文,而得以由该报文反推算出该钦命的摘要。

        (二)对字符串实行加密

SHA算法

安全散列算法(SHA)能计算出三个数字消息所对应到的,长度固定的字符串(又称音讯摘要)的算法。也是一种相比常用的多寡摘要算法,近些日子SHA家族主要有多个算法,对于这二种算法SHA家族中有介绍。

言归正传,上边说说两种加密解密算法吧

出于MD5 与SHA-1均是从MD4 发展而来,它们的布局和强度等特征有那几个相似之处,表(1)是对MD5 与SHA-1的结构比较。SHA-1与MD5 的最大分别在于其摘要比MD5 摘要长 32bit。对于强行攻击,发生其余三个报文使之摘要等于给定报文章摘要要的难度:MD5 是2128 数量级的操作,SHA-1 是2160数据级的操作。发生负有同样摘要的五个报文的难度:MD5是 264 是多少级的操作,SHA-1 是280 数量级的操作。由此,SHA-1对强行攻击的强度越来越大。但由于SHA-1 的轮回步骤比MD5 多(80:64)且要拍卖的缓存大(160 比特:128 比特),SHA-1的周转速度比MD5 慢

Java源码

package test;

import java.io.UnsupportedEncodingException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import sun.misc.BASE64Encoder;


/**
 * 对字符串进行加密
 * @param str  待加密的字符串
 * @return  加密后的字符串
 * @throws NoSuchAlgorithmException  没有这种产生消息摘要的算法
 * @throws UnsupportedEncodingException 
 */
public class Demo01 {

    public static String EncoderByMd5(String str) throws NoSuchAlgorithmException, UnsupportedEncodingException{
        //确定算法
        MessageDigest md5 = MessageDigest.getInstance("MD5");
        BASE64Encoder base64en = new BASE64Encoder();
        //加密后的字符串
        String newstr = base64en.encode(md5.digest(str.getBytes("utf-8")));
        return newstr;
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
        String str = "0123456789";
        System.out.println(EncoderByMd5(str));
    }
}

介绍

SHA(Secure Hash Algorithm)是由美利坚同盟友专程拟订密码算法的正规化学工业机械构——United States国标本领商量院(NIST)拟订的,SHA类别算法的摘要长度分别为:SHAMD5的学习与练习,在JSP中如何实现MD5加密的方法。为20字节(160位)、SHA256为32字节(256位)、 SHA384为48字节(384位)、SHA512为64字节(5九人),由于它爆发的多寡摘要的长短更加长,因而更麻烦产生碰撞,由此也进一步安全,它是前景数量摘要算法的升华趋向。由于SHA文山会海算法的多寡摘要长度较长,由此其运算速度与MD5相比,也针锋相对异常的慢。
时下SHA1的应用较为广阔,首要利用于CA和数字证书中,其余在当前网络中盛行的BT软件中,也是行使SHA1来进行理文件件校验的。

安全散列算法SHA

澳门新萄京 1

import java.security.MessageDigest; 
import java.security.NoSuchAlgorithmException; 
public class MD5Digest 
{ 
private MessageDigest __md5 = null; 
private StringBuffer __digestBuffer = null; 
public MD5Digest() 
throws NoSuchAlgorithmException 
{ 
__md5 = MessageDigest.getInstance("MD5"); 
__digestBuffer = new StringBuffer(); 
} 
public String md5crypt(String s) 
{ 
__digestBuffer.setLength(0); 
byte abyte0[] = __md5.digest(s.getBytes()); 
for(int i = 0; i < abyte0.length; i  ) 
__digestBuffer.append(toHex(abyte0[i])); 
return __digestBuffer.toString(); 
} 
public String toHex(byte one){ 
String HEX="0123456789ABCDEF"; 
char[] result=new char[2]; 
result[0]=HEX.charAt((one & 0xf0) >> 4); 
result[1]=HEX.charAt(one & 0x0f); 
String mm=new String(result); 
return mm; 
} 
} 

 

完成原理

给新闻附加填充位使其模512与448同余(MQ2 == 448)。就算知足了准星也要填充511个人(比特)。填充进程是如此的:先补一人1,前边一律补0,直至满意条件。由此至少填充1位,最多填充5九个人。
因为大家存款和储蓄的时候是以字节为单位存款和储蓄的,所以我们的音信的长度(单位:位)一定是8的翻番。而我辈填充的时候也迟早是8位,8位的来填充。也即不大概只填充二个二进制位,至少是8个二进制位(一个字节)。由此至少填充1个字节,最多填充62个字节(64*8=512)。
在叠合填充位完毕以往,还要附加长度,即附加61个人数据来存款和储蓄原始音讯的长度。因为在附加填充位完结未来,新闻长度(单位:位)是512与448同余,而此时再附加62位之后,消息长度就改为了512的大背头倍。
最终大家开首谋算新闻摘要的时候,便是每511个人为一组开始估量的。
其详细的贯彻参见怎么着是安全散列算法SHA256?

参考:多少摘要算法总计

SHA是一种数量加密算法,该算法经过加密大家多年来的前行和校正已日趋完善,未来已成为公认的最安全的散列算法之一,并被广大应用。该算法的思辨是收纳一段明文,然后以一种不可逆的方法将它调换到一段(平常越来越小)密文,也得以省略的精晓为取一串输入码(称为预映射或新闻),并把它们转化为长度异常的短、位数一定的输出种类即散列值(也称之为信息摘要或消息说南陈码)的进程。

MD5 和SHA-1 是单项散列函数的独立代表,它们广泛地运用在音信安全和数字署名等各类领域。从而有效地抵御了新闻的主动式攻击,本文基于AVWrangler单片机完毕了那二种算法,并结成汇编语言尽心了优化,猎取了较好的功效。依照音信安全的渴求的不等档案的次序能够灵活选用那二种算法从而达到实际目标。


        (三)验证密码是或不是科学

散列算法

/************************************************ 
  MD5 算法的Java Bean 
  @author:Topcat Tuppin 
  Last Modified:10,Mar,2001 
  *************************************************/ 
  package beartool; 
  import java.lang.reflect.*; 
  /************************************************* 
  md5 类实现了RSA Data Security, Inc.在提交给IETF 
  的RFC1321中的MD5 message-digest 算法。 
  *************************************************/ 
  public class MD5 { 
  /* 下面这些S11-S44实际上是一个4*4的矩阵,在原始的C实现中是用#define 实现的, 
  这里把它们实现成为static final是表示了只读,切能在同一个进程空间内的多个 
  Instance间共享*/ 
  static final int S11 = 7; 
  static final int S12 = 12; 
  static final int S13 = 17; 
  static final int S14 = 22; 
  static final int S21 = 5; 
  static final int S22 = 9; 
  static final int S23 = 14; 
  static final int S24 = 20; 
  static final int S31 = 4; 
  static final int S32 = 11; 
  static final int S33 = 16; 
  static final int S34 = 23; 
  static final int S41 = 6; 
  static final int S42 = 10; 
  static final int S43 = 15; 
  static final int S44 = 21; 
  static final byte[] PADDING = { -128, 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 }; 
  /* 下面的三个成员是MD5计算过程中用到的3个核心数据,在原始的C实现中 
  被定义到MD5_CTX结构中 

  */ 
  private long[] state = new long[4];// state (ABCD) 
  private long[] count = new long[2];// number of bits, modulo 2^64 (lsb first) 
  private byte[] buffer = new byte[64]; // input buffer 

  /* digestHexStr是MD5的唯一一个公共成员,是最新一次计算结果的 
    16进制ASCII表示. 
  */ 
  public String digestHexStr; 

  /* digest,是最新一次计算结果的2进制内部表示,表示128bit的MD5值. 
  */ 
  private byte[] digest = new byte[16]; 

  /* 
  getMD5ofStr是类MD5最主要的公共方法,入口参数是你想要进行MD5变换的字符串 
  返回的是变换完的结果,这个结果是从公共成员digestHexStr取得的. 
  */ 
  public String getMD5ofStr(String inbuf) { 
  md5Init(); 
  md5Update(inbuf.getBytes(), inbuf.length()); 
  md5Final(); 
  digestHexStr = ""; 
  for (int i = 0; i < 16; i  ) { 
  digestHexStr  = byteHEX(digest[i]); 
  } 
  return digestHexStr; 
  } 
  // 这是MD5这个类的标准构造函数,JavaBean要求有一个public的并且没有参数的构造函数 
  public MD5() { 
  md5Init(); 
  return; 
  } 
  /* md5Init是一个初始化函数,初始化核心变量,装入标准的幻数 */ 
  private void md5Init() { 
  count[0] = 0L; 
  count[1] = 0L; 
  ///* Load magic initialization constants. 
  state[0] = 0x67452301L; 
  state[1] = 0xefcdab89L; 
  state[2] = 0x98badcfeL; 
  state[3] = 0x10325476L; 
  return; 
  } 
  /* F, G, H ,I 是4个基本的MD5函数,在原始的MD5的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 1, 2, 3, and 4. 
  Rotation is separate from addition to prevent recomputation. 
  */ 
  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 >>> (32 - 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 >>> (32 - 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 >>> (32 - 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 >>> (32 - s)); 
  a  = b; 
  return a; 
  } 
  /* 
  md5Update是MD5的主计算过程,inbuf是要变换的字节串,inputlen是长度,这个 
  函数由getMD5ofStr调用,调用之前需要调用md5init,因此把它设计成private的 
  */ 
  private void md5Update(byte[] inbuf, int inputLen) { 
  int i, index, partLen; 
  byte[] block = new byte[64]; 
  index = (int)(count[0] >>> 3) & 0x3F; 
  // /* Update number of bits */ 
  if ((count[0]  = (inputLen << 3)) < (inputLen << 3)) 
  count[1]  ; 
  count[1]  = (inputLen >>> 29); 
  partLen = 64 - index; 
  // Transform as many times as possible. 
  if (inputLen >= partLen) { 
  md5Memcpy(buffer, inbuf, index, 0, partLen); 
  md5Transform(buffer); 
  for (i = partLen; i   63 < inputLen; i  = 64) { 
  md5Memcpy(block, inbuf, 0, i, 64); 
  md5Transform (block); 
  } 
  index = 0; 
  } else 
  i = 0; 
  ///* Buffer remaining input */ 
  md5Memcpy(buffer, inbuf, index, i, inputLen - i); 
  } 

  /* 
  md5Final整理和填写输出结果 
  */ 
  private void md5Final () { 
  byte[] bits = new byte[8]; 
  int index, padLen; 
  ///* Save number of bits */ 
  Encode (bits, count, 8); 
  ///* Pad out to 56 mod 64. 
  index = (int)(count[0] >>> 3) & 0x3f; 
  padLen = (index < 56) ? (56 - index) : (120 - index); 
  md5Update (PADDING, padLen); 
  ///* Append length (before padding) */ 
  md5Update(bits, 8); 
  ///* Store state in digest */ 
  Encode (digest, state, 16); 
  } 

  /* md5Memcpy是一个内部使用的byte数组的块拷贝函数,从input的inpos开始把len长度的 
        字节拷贝到output的outpos位置开始 
  */ 
  private void md5Memcpy (byte[] output, byte[] input, 
  int outpos, int inpos, int len) 
  { 
  int i; 
  for (i = 0; i < len; i  ) 
  output[outpos   i] = input[inpos   i]; 
  } 

  /* 
  md5Transform是MD5核心变换程序,有md5Update调用,block是分块的原始字节 
  */ 
  private void md5Transform (byte block[]) { 
  long a = state[0], b = state[1], c = state[2], d = state[3]; 
  long[] x = new long[16]; 
  Decode (x, block, 64); 
  /* Round 1 */ 
  a = FF (a, b, c, d, x[0], S11, 0xd76aa478L); /* 1 */ 
  d = FF (d, a, b, c, x[1], S12, 0xe8c7b756L); /* 2 */ 
  c = FF (c, d, a, b, x[2], S13, 0x242070dbL); /* 3 */ 
  b = FF (b, c, d, a, x[3], S14, 0xc1bdceeeL); /* 4 */ 
  a = FF (a, b, c, d, x[4], S11, 0xf57c0fafL); /* 5 */ 
  d = FF (d, a, b, c, x[5], S12, 0x4787c62aL); /* 6 */ 
  c = FF (c, d, a, b, x[6], S13, 0xa8304613L); /* 7 */ 
  b = FF (b, c, d, a, x[7], S14, 0xfd469501L); /* 8 */ 
  a = FF (a, b, c, d, x[8], S11, 0x698098d8L); /* 9 */ 
  d = FF (d, a, b, c, x[9], S12, 0x8b44f7afL); /* 10 */ 
  c = FF (c, d, a, b, x[10], S13, 0xffff5bb1L); /* 11 */ 
  b = FF (b, c, d, a, x[11], S14, 0x895cd7beL); /* 12 */ 
  a = FF (a, b, c, d, x[12], S11, 0x6b901122L); /* 13 */ 
  d = FF (d, a, b, c, x[13], S12, 0xfd987193L); /* 14 */ 
  c = FF (c, d, a, b, x[14], S13, 0xa679438eL); /* 15 */ 
  b = FF (b, c, d, a, x[15], S14, 0x49b40821L); /* 16 */ 
  /* Round 2 */ 
  a = GG (a, b, c, d, x[1], S21, 0xf61e2562L); /* 17 */ 
  d = GG (d, a, b, c, x[6], S22, 0xc040b340L); /* 18 */ 
  c = GG (c, d, a, b, x[11], S23, 0x265e5a51L); /* 19 */ 
  b = GG (b, c, d, a, x[0], S24, 0xe9b6c7aaL); /* 20 */ 
  a = GG (a, b, c, d, x[5], S21, 0xd62f105dL); /* 21 */ 
  d = GG (d, a, b, c, x[10], S22, 0x2441453L); /* 22 */ 
  c = GG (c, d, a, b, x[15], S23, 0xd8a1e681L); /* 23 */ 
  b = GG (b, c, d, a, x[4], S24, 0xe7d3fbc8L); /* 24 */ 
  a = GG (a, b, c, d, x[9], S21, 0x21e1cde6L); /* 25 */ 
  d = GG (d, a, b, c, x[14], S22, 0xc33707d6L); /* 26 */ 
  c = GG (c, d, a, b, x[3], S23, 0xf4d50d87L); /* 27 */ 
  b = GG (b, c, d, a, x[8], S24, 0x455a14edL); /* 28 */ 
  a = GG (a, b, c, d, x[13], S21, 0xa9e3e905L); /* 29 */ 
  d = GG (d, a, b, c, x[2], S22, 0xfcefa3f8L); /* 30 */ 
  c = GG (c, d, a, b, x[7], S23, 0x676f02d9L); /* 31 */ 
  b = GG (b, c, d, a, x[12], S24, 0x8d2a4c8aL); /* 32 */ 
  /* Round 3 */ 
  a = HH (a, b, c, d, x[5], S31, 0xfffa3942L); /* 33 */ 
  d = HH (d, a, b, c, x[8], S32, 0x8771f681L); /* 34 */ 
  c = HH (c, d, a, b, x[11], S33, 0x6d9d6122L); /* 35 */ 
  b = HH (b, c, d, a, x[14], S34, 0xfde5380cL); /* 36 */ 
  a = HH (a, b, c, d, x[1], S31, 0xa4beea44L); /* 37 */ 
  d = HH (d, a, b, c, x[4], S32, 0x4bdecfa9L); /* 38 */ 
  c = HH (c, d, a, b, x[7], S33, 0xf6bb4b60L); /* 39 */ 
  b = HH (b, c, d, a, x[10], S34, 0xbebfbc70L); /* 40 */ 
  a = HH (a, b, c, d, x[13], S31, 0x289b7ec6L); /* 41 */ 
  d = HH (d, a, b, c, x[0], S32, 0xeaa127faL); /* 42 */ 
  c = HH (c, d, a, b, x[3], S33, 0xd4ef3085L); /* 43 */ 
  b = HH (b, c, d, a, x[6], S34, 0x4881d05L); /* 44 */ 
  a = HH (a, b, c, d, x[9], S31, 0xd9d4d039L); /* 45 */ 
  d = HH (d, a, b, c, x[12], S32, 0xe6db99e5L); /* 46 */ 
  c = HH (c, d, a, b, x[15], S33, 0x1fa27cf8L); /* 47 */ 
  b = HH (b, c, d, a, x[2], S34, 0xc4ac5665L); /* 48 */ 
  /* Round 4 */ 
  a = II (a, b, c, d, x[0], S41, 0xf4292244L); /* 49 */ 
  d = II (d, a, b, c, x[7], S42, 0x432aff97L); /* 50 */ 
  c = II (c, d, a, b, x[14], S43, 0xab9423a7L); /* 51 */ 
  b = II (b, c, d, a, x[5], S44, 0xfc93a039L); /* 52 */ 
  a = II (a, b, c, d, x[12], S41, 0x655b59c3L); /* 53 */ 
  d = II (d, a, b, c, x[3], S42, 0x8f0ccc92L); /* 54 */ 
  c = II (c, d, a, b, x[10], S43, 0xffeff47dL); /* 55 */ 
  b = II (b, c, d, a, x[1], S44, 0x85845dd1L); /* 56 */ 
  a = II (a, b, c, d, x[8], S41, 0x6fa87e4fL); /* 57 */ 
  d = II (d, a, b, c, x[15], S42, 0xfe2ce6e0L); /* 58 */ 
  c = II (c, d, a, b, x[6], S43, 0xa3014314L); /* 59 */ 
  b = II (b, c, d, a, x[13], S44, 0x4e0811a1L); /* 60 */ 
  a = II (a, b, c, d, x[4], S41, 0xf7537e82L); /* 61 */ 
  d = II (d, a, b, c, x[11], S42, 0xbd3af235L); /* 62 */ 
  c = II (c, d, a, b, x[2], S43, 0x2ad7d2bbL); /* 63 */ 
  b = II (b, c, d, a, x[9], S44, 0xeb86d391L); /* 64 */ 
  state[0]  = a; 
  state[1]  = b; 
  state[2]  = c; 
  state[3]  = d; 
  } 

  /*Encode把long数组按顺序拆成byte数组,因为java的long类型是64bit的, 
  只拆低32bit,以适应原始C实现的用途 
  */ 
  private void Encode (byte[] output, long[] input, int len) { 
  int i, j; 
  for (i = 0, j = 0; j < len; i  , j  = 4) { 
  output[j] = (byte)(input[i] & 0xffL); 
  output[j   1] = (byte)((input[i] >>> 8) & 0xffL); 
  output[j   2] = (byte)((input[i] >>> 16) & 0xffL); 
  output[j   3] = (byte)((input[i] >>> 24) & 0xffL); 
  } 
  } 
  /*Decode把byte数组按顺序合成成long数组,因为java的long类型是64bit的, 
  只合成低32bit,高32bit清零,以适应原始C实现的用途 
  */ 
  private void Decode (long[] output, byte[] input, int len) { 
  int i, j; 

  for (i = 0, j = 0; j < len; i  , j  = 4) 
  output[i] = b2iu(input[j]) | 
  (b2iu(input[j   1]) << 8) | 
  (b2iu(input[j   2]) << 16) | 
  (b2iu(input[j   3]) << 24); 
  return; 
  } 

  /* 
  b2iu是我写的一个把byte按照不考虑正负号的原则的"升位"程序,因为java没有unsigned运算 
  */ 
  public static long b2iu(byte b) { 
  return b < 0 ? b & 0x7F   128 : b; 
  } 

  /*byteHEX(),用来把一个byte类型的数转换成十六进制的ASCII表示, 
   因为java中的byte的toString无法实现这一点,我们又没有C语言中的 
  sprintf(outbuf,"X",ib) 
  */ 
  public static String byteHEX(byte ib) { 
  char[] Digit = { '0','1','2','3','4','5','6','7','8','9', 
  'A','B','C','D','E','F' }; 
  char [] ob = new char[2]; 
  ob[0] = Digit[(ib >>> 4) & 0X0F]; 
  ob[1] = Digit[ib & 0X0F]; 
  String s = new String(ob); 
  return s; 
  } 
  public static void main(String args[]) { 

  MD5 m = new MD5(); 
  if (Array.getLength(args) == 0) {//如果没有参数,执行标准的Test Suite 

  System.out.println("MD5 Test suite:"); 
  System.out.println("MD5(""):" m.getMD5ofStr("")); 
  System.out.println("MD5("a"):" m.getMD5ofStr("a")); 
  System.out.println("MD5("abc"):" m.getMD5ofStr("abc")); 
  System.out.println("MD5("message digest"):" m.getMD5ofStr("message digest")); 
  System.out.println("MD5("abcdefghijklmnopqrstuvwxyz"):"  
  m.getMD5ofStr("abcdefghijklmnopqrstuvwxyz")); 
  System.out.println("MD5("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"):"  
  m.getMD5ofStr("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789")); 
  } 
  else  
  System.out.println("MD5("   args[0]   ")="   m.getMD5ofStr(args[0])); 


  } 
  } 
package test;

import java.io.UnsupportedEncodingException;
import java.security.NoSuchAlgorithmException;

/**
 * 判断用户密码是否正确
 * @param newpasswd  用户输入的密码
 * @param oldpasswd  数据库中存储的密码--用户密码的摘要
 * @return
 * @throws NoSuchAlgorithmException
 * @throws UnsupportedEncodingException
 *
 */
public class Demo02 {

    public static boolean checkpassword(String newpasswd, String oldpasswd) throws NoSuchAlgorithmException, UnsupportedEncodingException{
        if (Demo01.EncoderByMd5(newpasswd).equals(oldpasswd)) {
            return true;
        } else {
            return false;
        }
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, UnsupportedEncodingException {
        System.out.println("old:" Demo01.EncoderByMd5("123"));
        System.out.println("new:" Demo01.EncoderByMd5("123"));
        System.out.println(checkpassword("123",Demo01.EncoderByMd5("123")));
    }
}

散列是消息的提炼,平日其尺寸要比消息小得多,且为四个一定长度。加密性强的散列一定是不可逆的,那就象征通过散列结果,不可能推出任何部分的原本消息。任何输入消息的变型,哪怕仅一个人,都将形成散列结果的可想而知变化,那称之为雪崩效应。散列还应当是防冲突的,即找不出具备同等散列结果的两条音信。具备那一个特征的散列结果就足以用来注解音信是或不是被涂改。

JSP中的使用格局

 

单向散列函数一般用于发生消息摘要,密钥加密等,常见的有:


            因为MD5是根据新闻摘要原理的,音信摘要的基本特征就是很难根据摘要推算出音讯报文,因而要表明密码是不是科学,就非得对输入密码(音讯报文)重新总括其摘要,和数据库中贮存的摘要进行自己检查自纠(即数据库中存款和储蓄的实际为用户密码的摘要),若八个摘要同样,则评释密码正确,分化,则申明密码错误。

MD5(Message Digest Algorithm 5):是哈弗SA数据安全公司支付的一种单向散列算法。

 <%@ page language='java' %> 
<jsp:useBean id='oMD5' scope='request' class='beartool.MD5'/> 
<%@ page import='java.util.*'%> 
<%@ page import='java.sql.*'%> 
<html> 
<body> 
<% 
String userid = request.getParameter("UserID");//获取用户输入UserID 
String password = request.getParameter("Password"); //获取用户输入的Password 

String pwdmd5 = oMD5.getMD5ofStr(password);//计算MD5的值 

PrintWriter rp = response.getWriter(); 

Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); 

Connection con = DriverManager.getConnection("jdbc:odbc:community", "", ""); 
Statement stmt = con.createStatement(); 
ResultSet rs = stmt.executeQuery("select * from users where userID ='" userid "' and pwdmd5= '"   pwdmd5 "'" ); 
if (rs.next())  
{ 
rp.print("Login OK"); 

} 
else 
{ 
rp.print("Login Fail"); 
} 
stmt.close(); 
con.close(); 

%> 
</body> 
</html> 

 

SHA(Secure Hash Algorithm):能够对随便长度的数码运算生成贰个161个人的数值。

如上就是本文的全体内容,希望对大家的求学抱有支持,也希望我们多多协助脚本之家。

练习:

SHA-1:该算法输入报文的最大尺寸不超过264人,产生的输出是三个1陆拾一位的报文章摘要要。输入是按512人的分组实行处理的。SHA-1是不可逆的、防冲突,并有所杰出的雪崩效应。

您大概感兴趣的作品:

  • jsp用过滤器消除中文乱码难题的办法
  • Ajax跨域完结代码(后台jsp)
  • 浅谈jsp九大内置对象及五个成效域
  • JSP页面跳转形式小结
  • jsp servlet jdbc实现对数据库的增加和删除改查
  • BootStrap在jsp中的使用
  • 详解java集成支付宝支付接口(JSP 支付宝二零一五0912)
  • JSP达成登陆效能之增添验证码
  • JSP防止网页刷新重复提交数据的两种艺术
  • JSP request.setAttribute()详解及实例

澳门新萄京 2澳门新萄京 3

SHA-1与MD5的比较

package test;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;


/**
 * Java实现MD5加密算法(使用MessageDigest)
 * MD5加密算法,即"Message-Digest Algorithm 5 (信息-摘要算法)",它由MD2、MD3、
 * MD4发展而来的一种单向函数算法(也就是HASH算法),它是国际著名的公钥加密算法标准RSA的第一设计者
 * R.Rivest于上个世纪90年代初开发而来的。MD5的最大作用在于,将不同格式的大容量文件信息在用数字签名
 * 软件来签署私人秘钥前"压缩"成一种保密格式,关键之处在于--这种"压缩"是不可逆的。Java JDK已经自带
 * 了MD5的实现,只要简单调用下就可以。
 * 
 * @author Administrator
 *
 */
public class CreateMD5 {

    //静态方法,便于工具类
    public  static String getMd5(String plainText){
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(plainText.getBytes());
            byte b[] = md.digest();

            int i;

            StringBuffer buf = new StringBuffer("");
            for (int offset = 0; offset < b.length; offset  ) {
                i = b[offset];
                if (i < 0) 
                    i  = 256;
                if (i < 16) 
                    buf.append("0");
                buf.append(Integer.toHexString(i));
            }
            //32位加密
            return buf.toString();
            // 16位的加密
            // return buf.toString().substring(8,24);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
            return null;
        }
    }

    public static void main(String[] args) {
        //测试
        System.out.println(CreateMD5.getMd5("hello"));
    }
}

因为两岸均由MD4导出,SHA-1和MD5互相很一般。相应的,他们的强度和任何特色也是相似,但还会有以下几点不相同:

Java实现MD5加密算法

l 对强行攻击的安全性:最通晓和最要害的分别是SHA-1摘要比MD5摘要长30人。使用强行本领,爆发其余一个报文使其摘要等于给定报纸文摘要的难度对MD5是2^128数额级的操作,而对SHA-1则是2^160多少级的操作。那样,SHA-1对野蛮攻击有越来越大的强度。

澳门新萄京 4澳门新萄京 5

l 对密码深入分析的安全性:由于MD5的规划,易受密码分析的抨击,SHA-1显得不易受这么的口诛笔伐。

package test;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * 使用java获取md5值的两种方法
 * 1.Message Digest Algorithm MD5 (中文名为消息摘要算法第五版)
 * 为计算机安全领域广泛使用的一种散列函数,是一种比较常用的哈希算法。
 * 2.导入包:commons-codec
 * @author Administrator
 *
 */
public class md5_test {
    //MD5的字符串常量
    private final static String[] hexDigits = {"0","1","2","3","4","5","6","7","8","9","a","b","c","d","e","f"};

    public static void main(String[] args) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("MD5");
            System.out.println(byteArrayToHexString(messageDigest.digest("baidu.com".getBytes())));
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
    }

    private static String byteArrayToHexString(byte[] b) {
        StringBuffer resultSb = new StringBuffer();
        for (int i = 0; i < b.length; i  ) {
            resultSb.append(byteToHexString(b[i]));
        }
        return resultSb.toString();
    }

    /**
     * 将一个字节转化成十六进制形式的字符串
     * 
     * @param b
     * @return
     */
    private static String byteToHexString(byte b) {
        int n = b;
        if (n < 0)
            n = 256   n;
            int d1 = n / 16;
            int d2 = n % 16;
            return hexDigits[d1] hexDigits[d2];
    }

}

l 速度:在同一的硬件上,SHA-1的运维速度比MD5慢。

选用java获取md5值的二种方法

RSA算法

澳门新萄京 6澳门新萄京 7

奥迪Q5SA算法是第三个能同期用于加密和数字签字的算法,也易于精晓和操作。牧马人SA是眼前最有影响力的公钥加密算法,它能够抵抗到近期甘休已知的有所密码攻击,已被ISO推荐为公钥数据加密标准。PAJEROSA算法基于一个相当归纳的数论事实:将七个大素数相乘十三分便于,但当场想要对其乘积进行因式分解却非常困难,因而可以将乘积公开作为加密密钥。

package test;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * MD5加密
 * @author Administrator
 *
 */
public class MD5 {
    public static void main(String[] args) {
        System.out.println(MD5.getMD5("123456"));
    }

    /**
     * 用md5 编码后的码值
     * 
     * @param sInput
     * 明码
     * @return md5加密后的密码
     */
    private static String getMD5(String sInput) {

        String algorithm ="";
        if (sInput == null) {
            return "null";
        }

        try {
            algorithm = System.getProperty("MD5.algorithm","MD5");
        } catch (SecurityException se) {
        }
        MessageDigest md = null;
        try {
            md = MessageDigest.getInstance(algorithm);
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        byte buffer[] = sInput.getBytes();

        for (int count = 0; count < sInput.length(); count  ) {
            md.update(buffer,0,count);
        }
        byte bDigest[] = md.digest();
        BigInteger bi = new BigInteger(bDigest);
        return (bi.toString(16));
    }
}

WranglerSA的瑕疵首要有:A)产生密钥很困苦,受到素数产生手艺的限量,因此难以成功二次一密。B)分经理度太大,为保证安全性,n 至少也要 600bits以上,使运算代价很高,特别是速度相当慢,C)PAJEROSA密钥长度随着保密等级升高,扩充比比较快。

MD5加密

数量加密规范DES

澳门新萄京 8澳门新萄京 9

DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位,产生最大 63人的分组大小。那是多少个迭代的分组密码,使用称为 Feistel 的本领,其元帅加密的文本块分成两半。使用子密钥对里面十分之五使用循环成效,然后将出口与另50%拓展“异或”运算;接着交流这两半,这一进程会继续下去,但结尾三个循环不交流。DES 使用 16 个循环,使用异或,置换,代换,移位操作两种为主运算。

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.security.Provider;
import java.security.Security;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.apache.commons.codec.digest.DigestUtils;

import sun.applet.Main;
import sun.awt.image.BytePackedRaster;

/**
 * java计算过G文件md5 值计算
 * 
 * @author Administrator
 *
 */
public class Md5CaculateUtil {

    private Md5CaculateUtil(){

    }

    private static char[] hexChar = {
        '0','1','2','3','4','5','6','7','8','9',
        'a','b','c','d','e','f'
    };

    public static String getHash(String fileName,String hashType)
    throws IOException, NoSuchAlgorithmException{

        File f = new File(fileName);
        System.out.println("---------------------------------");
        System.out.println("|当前文件名称:" f.getName());
        System.out.println("|当前文件大小:" f.length()/1024/1024 "MB");
        System.out.println("|当前文件路径[绝对]:" f.getAbsolutePath());
        System.out.println("|当前文件路径[---]:" f.getCanonicalPath());
        System.out.println("---------------------------------");

        InputStream ins = new FileInputStream(f);

        byte[] buffer = new byte[8192];
        MessageDigest md5 = MessageDigest.getInstance(hashType);

        int len;
        while ((len = ins.read(buffer)) != -1) {
            md5.update(buffer, 0, len);
        }

        ins.close();
        // 也可以用apache自带的计算MD5方法
        return DigestUtils.md5Hex(md5.digest());
        // 自己写的转计算MD5方法
        // return toHexString(md5.digest());
    }

    public static String getHash2(String fileName){
        File f = new File(fileName);
        return String.valueOf(f.lastModified());
    }

    protected static String toHexString(byte[] b){
        StringBuilder sb = new StringBuilder(b.length*2);
        for (int i = 0; i < b.length; i  ) {
            sb.append(hexChar[(b[i] & 0xf0) >>> 4]);
            sb.append(hexChar[b[i] & 0x0f]);
        }
        return sb.toString();
    }

    /**
     * 获取MessageDigest支持几种加密算法
     */
    @SuppressWarnings({"rawtypes","unchecked"})
    private static String[] getCryptolmpls(String serviceType){

        Set result = new HashSet();
        // all prividers
        Provider[] providers = Security.getProviders();
        for (int i = 0; i < providers.length; i  ) {
            // get services provided by each provider
            Set keys = providers[i].keySet();
            for (Iterator it = keys.iterator(); it.hasNext();) {
                String key = it.next().toString();
                key = key.split(" ")[0];

                if (key.startsWith(serviceType ".")) {
                    result.add(key.substring(serviceType.length() 1));
                } else if (key.startsWith("Alg.Alias." serviceType ".")) {
                        result.add(key.substring(serviceType.length(), 11));
                    }
                }
            }
        return (String[]) result.toArray(new String[result.size()]);
    }

    public static void main(String[] args) throws NoSuchAlgorithmException, IOException {
        // 调用方法
        // String[] names = getCryptolmpls("MessageDigest");
        // for(String name : names){
        //   System.out.println(name);
    //        }
        long start = System.currentTimeMillis();
        System.out.println("开始计算文件MD5值,请稍后...");
        String fileName = "E:\Office_2010_Tookit_2.2.3XiaZaiBa.zip";
        // String fileName = "E:\SoTowerStudio-3.1.0.exe";
        String hashType = "MD5";
        String hash = getHash(fileName, hashType);
        System.out.println("MD5" hash);
        long end = System.currentTimeMillis();
        System.out.println("一共耗时:" (end-start) "毫秒");
    }
}

攻击 DES 的主要格局被称呼蛮力的或根本密钥寻找,即重复尝试种种密钥直到有三个合乎甘休。借使DES 使用 56 位的密钥,则恐怕的密钥数量是 2 的 伍18回方个。随着Computer系列本领的无休止升华,DES 的安全性比它刚面世时会弱得多,可是从非关键性质的实在出发,仍可以够以为它是十足的。不过,DES 今后仅用于旧类其他决断,而更加多地挑选新的加密标准 — 高等加密规范(Advanced Encryption Standard,AES)。

java计算过G文件md5 值计算

BASE64

澳门新萄京 10澳门新萄京 11

Base64是互联网上最分布的用于传输8Bit字节代码的编码方式之一,大家能够查看OdysseyFC2045~TucsonFC2049,下边有MIME的详细标准。Base64编码可用来在HTTP景况下传递较长的标记新闻。在一些应用程序中时时要求把二进制数据编码为符合放在U奔驰G级L(包蕴隐藏表单域)中的方式。此时,选用Base64编码不只有比较简便,同一时间也颇具不可读性,即所编码的数量不会被人用肉眼所一向看到。

package test;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import exception.SpeedException;

/**
 * Java三行代码搞定MD5加密
 * 
 * 对字符串md5加密
 * 
 * @param str
 * @return
 *
 */
public class MD5Demo {
    public static String getMD5(String str) throws SpeedException{
        try {
            // 生成一个MD5加密计算摘要
            MessageDigest md = MessageDigest.getInstance("MD5");
            // 计算md5函数
            md.update(str.getBytes());
            // digest()最后确定返回md5 hash值,返回值为字符串。因为md5 hash值是16位的hex值,实际上就是8位的字符
            // BigInteger函数则将8位的字符串转换成16位hex值,用字符串来表示,得到字符串形式的hash值
            return new BigInteger(1,md.digest()).toString(16);
        } catch (Exception e) {
            throw new SpeedException("MD5加密出现错误");
        }
    }

    public static void main(String[] args) throws SpeedException {
        System.out.println(getMD5("123"));;
    }
}

Java三行代码解决MD5加密

澳门新萄京 12澳门新萄京 13

package test;

import java.security.MessageDigest;

/**
 * 利用Java自带的MD5加密
 * 
 * @author Administrator
 *
 */
public class MD5Util {
    public final static String MD5(String s){
        char hexDigits[]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

        try {
            byte[] btInput = s.getBytes();
            //获得MD5摘要算法的 MessageDigest 对象
            MessageDigest mdInst = MessageDigest.getInstance("MD5");
            //使用指定的字节更新摘要
            mdInst.update(btInput);
            //获得密文
            byte[] md = mdInst.digest();
            //把密文转换成十六进制的字符串形式
            int j = md.length;
            char str[] = new char[j * 2];
            int k = 0;
            for (int i = 0; i < j; i  ) {
                byte byte0 = md[i];
                str[k  ] = hexDigits[byte0 >>> 4 & 0xf];
                str[k  ] = hexDigits[byte0 & 0xf];
            }
            return new String(str);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }
    public static void main(String[] args) {
        System.out.println(MD5Util.MD5("20121221"));
        System.out.println("加密");
    }
}

利用Java自带的MD5加密

澳门新萄京 14澳门新萄京 15

package test;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.math.BigInteger;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.security.MessageDigest;

import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.io.IOUtils;


/**
 * Java读取文件MD5的两种方案
 * 1.MessageDigest实现
 * 2.org.apache.commons.codec.digest实现
 * 
 * @author Administrator
 *
 */
public class testMD5 {

    public static String getMd5ByFile(File file) throws FileNotFoundException{
        String value = null;
        FileInputStream in = new FileInputStream(file);

        try {
            MappedByteBuffer byteBuffer = in.getChannel().map(FileChannel.MapMode.READ_ONLY, 0, file.length());
            MessageDigest md5 = MessageDigest.getInstance("MD5");
            md5.update(byteBuffer);
            BigInteger bi = new BigInteger(1,md5.digest());
            value = bi.toString(16);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (null != in) {
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return value;
    }

    public static void main(String[] args) throws IOException {

        String path ="E:\commons-codec-1.10-bin.zip";

        String v = getMd5ByFile(new File(path));
        System.out.println("MD5:" v.toUpperCase());

        FileInputStream fis = new FileInputStream(path);
        String md5 = DigestUtils.md5Hex(IOUtils.toByteArray(fis));
        IOUtils.closeQuietly(fis);
        System.out.println("MD5:" md5);

//        System.out.println("MD5" DigestUtils.md5Hex("WANGQIUYUN"));
    }
}

Java读取文件MD5的二种方案

澳门新萄京 16澳门新萄京 17

package test;

import org.apache.commons.codec.digest.DigestUtils;

public class ToMain {
    public static void main(String[] args) {
        System.out.println(DigestUtils.md5Hex("baidu.com"));
    }
}

ToMain

澳门新萄京 18澳门新萄京 19

package exception;

public class SpeedException extends Exception {
    public SpeedException(String msg)  
    {  
        super(msg);  
    }  
}

SpeedException

 

主干的java加密算法MD5等等

简言之的java加密算法有:
BASE64    严刻地说,属于编码格式,而非加密算法
MD5     (Message Digest algorithm 5,音讯摘要算法)
SHA        (Secure Hash Algorithm,安全散列算法)
HMAC    (Hash Message Authentication Code, 散列新闻鉴定识别码)

Java中4大亚湾原子核能发电站心加密算法深入分析

1.BASE64
Base64是互连网上最广大的用来传输8Bit字节代码的编码格局之一,大家能够查阅揽胜极光FC2045~TiguanFC2049,上边有MIME的详尽标准。Base64编码可用来在HTTP意况下传递较长的标志消息。举例,在Java Persistence系统Hibernate中,就使用了Base64来将壹个较长的唯一标记符(一般为128-bit的UUID)编码为一个字符串,用作HTTP表单和HTTP GET U宝马X5L中的参数。在其它应用程序中,也经常必要把二进制数据编码为符合放在U大切诺基L(包含隐藏表单域)中的情势。此时,选取Base64编码具有不可读性,即所编码的数码不会被人用眼睛所平素看到。

代码完毕:

package com.cn.单向加密;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

/**
 * BASE64的加密解密是双向的,可以求反解。
 * BASE64Encoder和BASE64Decoder是非官方JDK实现类。虽然可以在JDK里能找到
 * 并使用,但是在API里查不到。
 * JRE中sun和com.sun 开头包的类都是未被文档化的,他们属于java,javax类库的基础,
 * 其中的实现大多数与底层平台有关,一般来说是不推荐使用的。
 * BASE64严格地说,属于编码格式,而非加密算法
 * 主要就是BASE64Encoder、BASE64Decoder两个类,我们只需要直到使用对应的方法即可。
 * 另外,BASE加密后产生的字节位数是8的倍数,如果不够位数以=符号填充。
 * BASE64
 * 按照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加密的。
 * 
 * @author Administrator
 *
 */
public class BASE64 {
    /**
     * BASE64解密
     * 
     * @param key
     * @return
     * @throws Exception
     */
    public static byte[] decryptBASE64(String key) throws Exception{
        return (new BASE64Decoder()).decodeBuffer(key);
    }

    /**
     * BASE64加密
     * 
     * @param key
     * @return
     * @throws Exception
     */
    public static String encryptBASE64(byte[] key)throws Exception{
        return (new BASE64Encoder()).encodeBuffer(key);
    }

    public static void main(String[] args) {

        String str = "12345678";

        try {
            String result1 = BASE64.encryptBASE64(str.getBytes());
            System.out.println("result1=====加密数据=====>> " result1);

            byte result2[] = BASE64.decryptBASE64(result1);
            String str2 = new String(result2);
            System.out.println("str2=====解密数据=====>> " str2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

2.MD5
MD5即Message-Digest Algorithm 5(新闻-摘要算法5),用于确定保证音信传输完整
一样。是Computer遍布采纳的杂凑算法之一(又译摘要算法、哈希算法),主流编制程序
语言广泛已有MD5完成。将数据(如汉字)运算为另一恒久长度值,是杂凑算法的基础原理,MD5的前身有MD2、MD3和MD4.广阔用于加密和平消除密技术,常用于文书校验。
校验?不管文件多大,经过MD5后都能生成唯一的MD5值。好比明日的ISO校验,都是
MD5校验。怎么用?当然是把ISO经过MD5后发出MD5的值。一般下载linux-ISO的仇敌
都见过相爱在三翻五次叛变放着的MD5的串。就是用来注解是不是一样的。

代码达成:

package com.cn.单向加密;

import java.math.BigInteger;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

/**
 * MD5(Message Digest algorithm 5,信息摘要算法)
 * 通常我们不直接使用上述MD5加密。
 * 通常将MD5产生的字节数组交给BASE64再加密一把,得到相应的字符串
 * 
 * Digest:汇编
 *
 */
public class MD5 {
    public static final String KEY_MD5 = "MD5";

    public static String getResult(String inputStr){
        System.out.println("=======加密前的数据:" inputStr);
        BigInteger bigInteger = null;

        try {
            MessageDigest md = MessageDigest.getInstance(KEY_MD5);
            byte[] inputData = inputStr.getBytes();
            md.update(inputData);
            bigInteger = new BigInteger(md.digest());
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("MD5加密后:" bigInteger.toString(16));
        return bigInteger.toString(16);
    }

    public static void main(String[] args) {
        try {
            String inputStr = "简单加密8888888888888888888";
            getResult(inputStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

MD5算法具有以下特征:

1.压缩性:猖獗长度的数码,算出的MD5值长度都以稳固的。
2.轻巧计算:从原数据总计出MD5值很轻巧。
3.抗修改性:对原数据实行别的变动,哪怕只修改1个字节,所获得的MD5值都有极大差别。
4.弱抗冲击:已知原数据和其MD5值,想到贰个具备一样MD5值的数码(即伪造数据)是那么些艰辛的。
5.强抗碰撞:想找到三个例外的数据,使它们具有同等的MD5值,是特别困难的。
MD5的效应是让大体积音讯在用数字具名软件签署私人秘钥前被"压缩"成一种保密格式(正是把自由长度的字节串转换来自然长的十六进制数字串)。除了MD5以外,当中比较有名的还恐怕有sha-1、ExigeIPEMD以及R等。

3.SHA
安然哈希算法(Secure Hash Algorithm)主要适用于数字具名规范(Digital Signature Standard DSS)里面定义的数字具名算法(Digital Signature Algorithm DSA)。对于长度小于2~60位的新闻,SHA1会发生四个1陆拾三个人的信息摘要。该算法经过加密学者多年来的向上和改正已日益完善,并被广泛利用。该算法的思想是接到一段明文,然后以一种不可逆的主意将它调换来一段(平日越来越小)密文,也足以省略的知晓为取一串输入码(称为预映射或新闻),并把它们转化为长度十分的短、位数一定的出口系列即散列值(也堪当音信摘要或音信验证代码)的进程。散列函数值能够说是对公开的一种"指纹"或是"摘要"所以对散列值的数字签名就足以算得对此公开的数字签字。

java实现:

package com.cn.单向加密;

import java.math.BigInteger;
import java.security.MessageDigest;

/**
 * 
 * SHA(Secure Hash Algorithm,安全散列算法),数字签名等密码学应用中重要的工具,
 * 被广泛地应用与电子商务等信息安全领域。虽然,SHA与MD5通过碰撞法都被破解了,
 * 但是SHA仍然是公认的安全加密算法,较之MD5更为安全
 * 
 * @author Administrator
 *
 */
public class SHA {
    public static final String KEY_SHA = "SHA";

    public static String getResult(String inputStr){
        BigInteger sha = null;
        System.out.println("=======加密前的数据:" inputStr);
        byte[] inputData = inputStr.getBytes();

        try {
            MessageDigest messageDigest = MessageDigest.getInstance(KEY_SHA);
            messageDigest.update(inputData);
            sha = new BigInteger(messageDigest.digest());
            System.out.println("SHA加密后:" sha.toString(32));
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sha.toString(32);
    }

    public static void main(String[] args) {
        try {
            String inputStr = "简单加密";
            getResult(inputStr);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

 

SHA-1与MD5的比较
因为两个均由MD4导出,SHA-1和MD5互相很相似。相应的,他们的强度和别的特色也是形似,但还会有以下几点分歧:
| 对野蛮攻击的安全性:最显眼和最首要的区分是SHA-1摘要比MD5摘要长三十个人。使用强行才能,产生别的八个报文使其摘要等于给定报纸文摘要的难度对MD5是2^128数据级的操作,而对SHA-1则是2^160数量级的操作。那样,SHA-1对无情攻击有越来越大的强度。
| 对密码分析的安全性:由于MD5的统一希图,易受密码分析的攻击,SHA-1显得不易受这么的抨击。
| 速度:在平等的硬件上,SHA-1的运作速度比MD5慢。

4.HMAC(Hash Message Authentication Code),散列音讯鉴定区别码,基于秘钥的Hash算法的辨证协议。消息鉴定识别完成鉴定识别的规律是,用公开函数和秘钥产生贰个恒定长度的值作为验证标志,用这么些标记鉴定区别新闻的完整性。使用贰个秘钥生成多个一定大小的小数据块,即MAC,并将其进入到消息中,然后传输。接收方利用与发送方分享的秘钥实行辨认认证等。
粤语名"散列音信鉴定分别码",首若是使用哈希算法,以一个秘钥和二个音讯为输入,生成多个音讯照耀作为出口。一般的,新闻鉴定区别码用于评释传输于八个联合想有壹个秘钥的单位之间的信息。HMAC能够与其余迭代散列函数捆绑使用。MD5和SHA-1就是这种散列函数。HMAC还足以使用二个用于计算和认同新闻鉴定区别值的秘钥。

HMAC,散列消息鉴定区别码,是依附秘钥的Hash算法的申明协议。它的达成原理是,用公开函数和秘钥发生二个固定长度的值作为注脚标记,用这几个标记鉴定识别音讯的完整性。使用一个秘钥生成三个恒久大小的小数据块,即MAC,并将其加盟到音讯中,然后传输。接收方利用与发送方分享的秘钥进行分辨认证等。

这种布局的首要职能是:
    不用修改不仅能够行使符合的散列函数,而且散列函数在软件方面展现的很好,并且源码是开诚相见的通用的。
    能够保证散列函数原有的属性而不致其向下。
    能够使得基于合理的关于底层散列函数假若的消息鉴定区别机制的加密强度解析,便于明白。
    当开掘或索要运算速度更加快或更安全的散列函数时,能够很轻松的达成底层散列函数的替换。

定义HMAC要求三个加密用散列函数(表示H)和三个秘钥K。大家如若H是贰个将数据块用多少个主干的迭代压缩函数来加密的散列函数。大家用B来表示数据块的字长。(以上关联的散列函数的划分数据块字长B=64),用L来表示散列函数的输出数据字长(MD5中L=16,SHA-第11中学L=20)。鉴定识别秘钥的长度能够是低于等于多少块字长的别的正整数值。应用程序中央银行使的秘钥长度要是比B大,则第一利用散列函数H功效与它,然后用H输出的L长度字符串作为在HMAC中实际应用的秘钥。一般情形下,推荐的小小秘钥K长度是L个字长。(与H的出口数据长度相等)。

笔者们将定义五个定位且差别的字符串ipad,opad:('i','o'表示当中与外表)
    ipad = the byte 0x36 repeated B times
    opad = the byte 0x5C repeated B times

计算'text' 的HMAC;
    H(K XOR opad,H(K XOR ipad, text))

估测计算步骤:
澳门新萄京,    在秘钥K后边增添0创设三个字长为B的字符串。(例如,即使K的字长是20字节,则K后会进入45个零字节0x00)
    将上一步生成的B字长的字符串与ipad作困惑运算
    将数据流text填充至第二步的结果字符串中
    用H作用于第三步生成的数据流
    将率先步生成的B字长字符串与opad作异或运算
    再将第四步的结果填充进第五步的结果中
    用H功能于第六步生成的数据流,输出最后结出

秘钥
    用于HMAC的秘钥能够是随意长度(比B长的秘钥将率先被H管理)。但当秘钥长度小于L时,会稳中有降函数的巴中强度。长度大于L的秘钥也是能够的,但附加的长度并无法明显的拉长函数的平安强度。

    秘钥必须自由接纳(或利用强劲的依照随机种子的伪随机生成方法),并且要周期性的立异。前段时间的抨击没有建议贰个卓有成效的转移秘钥的作用,因为这个攻击实际上并不管事。然则,周期性更新秘钥时三个应付函数和秘钥所存在的机密缺陷的主干安全措施,并能够减低败露秘钥带来的妨害。

java达成代码:

package com.cn.单向加密;


import java.security.NoSuchAlgorithmException;

import javax.crypto.KeyGenerator;
import javax.crypto.Mac;
import javax.crypto.SecretKey;
import javax.crypto.spec.SecretKeySpec;

import com.google.common.base.Strings;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

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

/** 
 * 定义加密方式 
 * MAC算法可选以下多种算法 
 * HmacMD5 
 * HmacSHA1 
 * HmacSHA256 
 * HmacSHA384 
 * HmacSHA512 
 */  
public class HMAC {
    private final static String KEY_MAC = "HmacMD5";  

    /** 
     * 全局数组 
     */  
    private final static String[] hexDigits = { "0", "1", "2", "3", "4", "5",  
            "6", "7", "8", "9", "a", "b", "c", "d", "e", "f" };  

    /** 
     * 构造函数 
     */  
    public HMAC() {  

    }  

    /** 
     * BASE64 加密 
     * @param key 需要加密的字节数组 
     * @return 字符串 
     * @throws Exception 
     */  
    public static String encryptBase64(byte[] key) throws Exception {  
        return (new BASE64Encoder()).encodeBuffer(key);  
    }  

    /** 
     * BASE64 解密 
     * @param key 需要解密的字符串 
     * @return 字节数组 
     * @throws Exception 
     */  
    public static byte[] decryptBase64(String key) throws Exception {  
        return (new BASE64Decoder()).decodeBuffer(key);  
    }  

    /** 
     * 初始化HMAC密钥 
     * @return 
     */  
    public static String init() {  
        SecretKey key;  
        String str = "";  
        try {  
            KeyGenerator generator = KeyGenerator.getInstance(KEY_MAC);  
            key = generator.generateKey();  
            str = encryptBase64(key.getEncoded());  
        } catch (NoSuchAlgorithmException e) {  
            e.printStackTrace();  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return str;  
    }  

    /** 
     * HMAC加密 
     * @param data 需要加密的字节数组 
     * @param key 密钥 
     * @return 字节数组 
     */  
    public static byte[] encryptHMAC(byte[] data, String key) {  
        SecretKey secretKey;  
        byte[] bytes = null;  
        try {  
            secretKey = new SecretKeySpec(decryptBase64(key), KEY_MAC);  
            Mac mac = Mac.getInstance(secretKey.getAlgorithm());  
            mac.init(secretKey);  
            bytes = mac.doFinal(data);  
        } catch (Exception e) {  
            e.printStackTrace();  
        }  
        return bytes;  
    }  

    /** 
     * HMAC加密 
     * @param data 需要加密的字符串 
     * @param key 密钥 
     * @return 字符串 
     */  
    public static String encryptHMAC(String data, String key) {  
        if (Strings.isNullOrEmpty(data)) {  
            return null;  
        }  
        byte[] bytes = encryptHMAC(data.getBytes(), key);  
        return byteArrayToHexString(bytes);  
    }  


    /** 
     * 将一个字节转化成十六进制形式的字符串 
     * @param b 字节数组 
     * @return 字符串 
     */  
    private static String byteToHexString(byte b) {  
        int ret = b;  
        //System.out.println("ret = "   ret);  
        if (ret < 0) {  
            ret  = 256;  
        }  
        int m = ret / 16;  
        int n = ret % 16;  
        return hexDigits[m]   hexDigits[n];  
    }  

    /** 
     * 转换字节数组为十六进制字符串 
     * @param bytes 字节数组 
     * @return 十六进制字符串 
     */  
    private static String byteArrayToHexString(byte[] bytes) {  
        StringBuffer sb = new StringBuffer();  
        for (int i = 0; i < bytes.length; i  ) {  
            sb.append(byteToHexString(bytes[i]));  
        }  
        return sb.toString();  
    }  

    /** 
     * 测试方法 
     * @param args 
     */  
    public static void main(String[] args) throws Exception {  
        String key = HMAC.init();  
        System.out.println("Mac密钥:n"   key);  
        String word = "123";  
        System.out.println(encryptHMAC(word, key));  
    }  
}

 

本文由澳门新萄京发布于澳门新萄京最大平台,转载请注明出处:MD5的学习与练习,在JSP中如何实现MD5加密的方法

上一篇:澳门新萄京jQuery选择器之子元素选择器详解,j 下一篇:没有了
猜你喜欢
热门排行
精彩图文