zoukankan      html  css  js  c++  java
  • Java关于md5+salt盐加密验证

    1.根据已有的密码字符串去生成一个密码+盐字符串,可以将盐的加密字符串也存放在数据库(看需求),

    2.验证时将提交的密码字符串进行同样的加密再从数据库中取得已有的盐进行组合密码+盐的字符串和已有的进行验证

     1 package com.hjp.exercise.md5test;
     2 
     3 import java.io.UnsupportedEncodingException;
     4 import java.security.NoSuchAlgorithmException;
     5 import java.util.HashMap;
     6 import java.util.Map;
     7 
     8 public class Md5SaltTest {
     9 
    10       private static Map users = new HashMap();   
    11       
    12         public static void main(String[] args){   
    13             String userName = "zyg";   
    14             String password = "123";   
    15             registerUser(userName,password);   
    16                
    17             userName = "changong";   
    18             password = "456";   
    19             registerUser(userName,password);   
    20                
    21             String loginUserId = "zyg";   
    22             String pwd = "1232";   
    23             try {   
    24                 if(loginValid(loginUserId,pwd)){   
    25                     System.out.println("欢迎登陆!!!");   
    26                 }else{   
    27                     System.out.println("口令错误,请重新输入!!!");   
    28                 }   
    29             } catch (NoSuchAlgorithmException e) {   
    30                 // TODO Auto-generated catch block   
    31                 e.printStackTrace();   
    32             } catch (UnsupportedEncodingException e) {   
    33                 // TODO Auto-generated catch block   
    34                 e.printStackTrace();   
    35             }    
    36         }   
    37            
    38         /**  
    39          * 注册用户  
    40          *   
    41          * @param userName  
    42          * @param password  
    43          */  
    44         public static void registerUser(String userName,String password){   
    45             String encryptedPwd = null;   
    46             try {   
    47                 encryptedPwd = Md5SaltTool.getEncryptedPwd(password);   
    48                 users.put(userName, encryptedPwd);   
    49                    
    50             } catch (NoSuchAlgorithmException e) {   
    51                 // TODO Auto-generated catch block   
    52                 e.printStackTrace();   
    53             } catch (UnsupportedEncodingException e) {   
    54                 // TODO Auto-generated catch block   
    55                 e.printStackTrace();   
    56             }   
    57         }   
    58            
    59         /**  
    60          * 验证登陆  
    61          *   
    62          * @param userName  
    63          * @param password  
    64          * @return  
    65          * @throws UnsupportedEncodingException   
    66          * @throws NoSuchAlgorithmException   
    67          */  
    68         public static boolean loginValid(String userName,String password)    
    69                     throws NoSuchAlgorithmException, UnsupportedEncodingException{   
    70              /*String loginUserId = "zyg";   
    71                String pwd = "1232";*/ 
    72             String pwdInDb = (String)users.get(userName);   
    73             if(null!=pwdInDb){ // 该用户存在   
    74                     return Md5SaltTool.validPassword(password, pwdInDb);   
    75             }else{   
    76                 System.out.println("不存在该用户!!!");   
    77                 return false;   
    78             }   
    79         }
    80 }
      1 package com.hjp.exercise.md5test;
      2 
      3 import java.io.UnsupportedEncodingException;
      4 import java.security.MessageDigest;
      5 import java.security.NoSuchAlgorithmException;
      6 import java.security.SecureRandom;
      7 import java.util.Arrays;
      8 
      9 public class Md5SaltTool {
     10 
     11     private static final String HEX_NUMS_STR="0123456789ABCDEF";   
     12     private static final Integer SALT_LENGTH = 12;   
     13        
     14     /**   
     15      * 将16进制字符串转换成字节数组   
     16      * @param hex   
     17      * @return   
     18      */  
     19     public static byte[] hexStringToByte(String hex) {   
     20         int len = (hex.length() / 2);   
     21         byte[] result = new byte[len];   
     22         char[] hexChars = hex.toCharArray();   
     23         for (int i = 0; i < len; i++) {   
     24             int pos = i * 2;   
     25             result[i] = (byte) (HEX_NUMS_STR.indexOf(hexChars[pos]) << 4    
     26                             | HEX_NUMS_STR.indexOf(hexChars[pos + 1]));   
     27         }   
     28         return result;   
     29     }   
     30        
     31     /**  
     32      * 将指定byte数组转换成16进制字符串  
     33      * @param b  
     34      * @return  
     35      */  
     36     public static String byteToHexString(byte[] b) {   
     37         StringBuffer hexString = new StringBuffer();   
     38         for (int i = 0; i < b.length; i++) {   
     39             String hex = Integer.toHexString(b[i] & 0xFF);   
     40             if (hex.length() == 1) {   
     41                 hex = '0' + hex;   
     42             }   
     43             hexString.append(hex.toUpperCase());   
     44         }   
     45         return hexString.toString();   
     46     }   
     47        
     48     /**  
     49      * 验证口令是否合法  
     50      * @param password  
     51      * @param passwordInDb  
     52      * @return  
     53      * @throws NoSuchAlgorithmException  
     54      * @throws UnsupportedEncodingException  
     55      */  
     56     public static boolean validPassword(String password, String passwordInDb)   
     57             throws NoSuchAlgorithmException, UnsupportedEncodingException {   
     58         //将16进制字符串格式口令转换成字节数组   
     59         byte[] pwdInDb = hexStringToByte(passwordInDb);   
     60         //声明盐变量   
     61         byte[] salt = new byte[SALT_LENGTH];   
     62         //将盐从数据库中保存的口令字节数组中提取出来   
     63         System.arraycopy(pwdInDb, 0, salt, 0, SALT_LENGTH);   
     64         //创建消息摘要对象   
     65         MessageDigest md = MessageDigest.getInstance("MD5");   
     66         //将盐数据传入消息摘要对象   
     67         md.update(salt);   
     68         //将口令的数据传给消息摘要对象   
     69         md.update(password.getBytes("UTF-8"));   
     70         //生成输入口令的消息摘要   
     71         byte[] digest = md.digest();   
     72         //声明一个保存数据库中口令消息摘要的变量   
     73         byte[] digestInDb = new byte[pwdInDb.length - SALT_LENGTH];   
     74         //取得数据库中口令的消息摘要   
     75         System.arraycopy(pwdInDb, SALT_LENGTH, digestInDb, 0, digestInDb.length);   
     76         //比较根据输入口令生成的消息摘要和数据库中消息摘要是否相同   
     77         if (Arrays.equals(digest, digestInDb)) {   
     78             //口令正确返回口令匹配消息   
     79             return true;   
     80         } else {   
     81             //口令不正确返回口令不匹配消息   
     82             return false;   
     83         }   
     84     }   
     85   
     86     /**  
     87      * 获得加密后的16进制形式口令  
     88      * @param password  
     89      * @return  
     90      * @throws NoSuchAlgorithmException  
     91      * @throws UnsupportedEncodingException  
     92      */  
     93     public static String getEncryptedPwd(String password)   
     94             throws NoSuchAlgorithmException, UnsupportedEncodingException {   
     95         //声明加密后的口令数组变量   
     96         byte[] pwd = null;   
     97         //随机数生成器   
     98         SecureRandom random = new SecureRandom();   
     99         //声明盐数组变量   12
    100         byte[] salt = new byte[SALT_LENGTH];   
    101         //将随机数放入盐变量中   
    102         random.nextBytes(salt);   
    103   
    104         //声明消息摘要对象   
    105         MessageDigest md = null;   
    106         //创建消息摘要   
    107         md = MessageDigest.getInstance("MD5");   
    108         //将盐数据传入消息摘要对象   
    109         md.update(salt);   
    110         //将口令的数据传给消息摘要对象   
    111         md.update(password.getBytes("UTF-8"));   
    112         //获得消息摘要的字节数组   
    113         byte[] digest = md.digest();   
    114   
    115         //因为要在口令的字节数组中存放盐,所以加上盐的字节长度   
    116         pwd = new byte[digest.length + SALT_LENGTH];   
    117         //将盐的字节拷贝到生成的加密口令字节数组的前12个字节,以便在验证口令时取出盐   
    118         System.arraycopy(salt, 0, pwd, 0, SALT_LENGTH);   
    119         //将消息摘要拷贝到加密口令字节数组从第13个字节开始的字节   
    120         System.arraycopy(digest, 0, pwd, SALT_LENGTH, digest.length);   
    121         for(int i=0;i<pwd.length;i++){
    122             System.out.print(pwd[i]);
    123         }
    124         //将字节数组格式加密后的口令转化为16进制字符串格式的口令   
    125         return byteToHexString(pwd);   
    126     }   
    127 }
  • 相关阅读:
    C#中WinForm程序退出方法技巧(转载)
    webbrowser访问网站禁止弹窗
    (转载)ASP.NET三大核心对象及基础功能解析
    webBrowser调用外部js文件和js函数(转载)
    java IO流
    java线程状态,优先级
    java线程
    Collection接口,Map接口
    序列化和反序列化
    JsonUtil自定义
  • 原文地址:https://www.cnblogs.com/huangjianping/p/8275247.html
Copyright © 2011-2022 走看看