数据库的sha1密码激活成功教程[亲测有效]

从前有一个熊孩子入侵了一个网站的数据库，找到了管理员密码，手一抖在数据库中修改了
一下，现在的密码变成了 4B58475789E60DBF1A28GD638B556A938134644C8。
（41位）那个熊孩子其实就是我！肿么办求解原始密码！在线等，挺急的。。
hint：密码长度为5

现在的密码是40位16进制数加上“G”这个多余的非16进制数，可能是题目中说的手抖修改了一下加上了这个，上次预习作业pre0中出现的sha1加密算法，加密后的密文是160位2进制数即40位16进制，所以上面的密码应该是sha1加密过的密文4B58475789E60DBF1A28D638B556A938134644C8。
在线sha1解密得到结果为：BSWAP。符合题目要求的密码长度为5。

它这个在线解密应该也就是匹配它的数据库中的密文，如果是新的明文经常会解密失败。
代码算法原理：
我自己写的一个暴力激活成功教程sha1算法的代码，原理就是通过对键盘输入的所有符号进行对比：abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQ RSTUVWXYZ1234567890~!@# $%^&*()[]|;’,<>.?。因为题目中提示了代码长度为5，通过比较5位数字不同的组合，计算他们的sha1算法的哈希值，当出现题目中的4B58475789E60DBF1A28D638B556A938134644C8是，即为找到解。这种暴力激活成功教程的方法虽然计算量比较大，但是只要密码中的字符在abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@#$ %^&*()[]|;’,<>.?中，还是能求出解的。
因为计算量比较大，所以我采用了多线程编程的方式，新建了一个最多可以跑32条线程的线程池。将任务分成32部分，一旦有一条线程找到了正确答案，就立即退出，终止线程池中的所有线程。
源代码：Sha1.java

package sha1;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.Callable;
import java.lang.Math;
/** * 文件注释： * * @Auther: * @Date: 2018/2/27 18:30 * @Description: */
public  class Sha1 implements Callable { 
   

    private int threadNumber;
    Sha1(int threadNumber){ 
   
        this.threadNumber = threadNumber ;
    }

    /** * 重写call方法，分配每个线程的任务 * @return 0或10 * @throws Exception */
    @Override
    public Object call() throws Exception { 
   
        char [] encryptedText = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@#$%^&*()[]|;',<>.?".toCharArray();
        /*长度为5的密文字符串*/
        String data = null;
        /*根据输入的线程编号threadNumber，分配相应的任务*/
        int [] temp = new int[5];
        for (int i = 0; i<temp.length ; i++) { 
   
            int n = (int) Math.pow(2,i);
            if((threadNumber & n) > 0){ 
   
                temp[i] = 1;
            }
            else { 
   
                temp[i] = 0;
            }
        }

        int length = encryptedText.length / 2;
        for(int a = (length * temp[0]) ; a < (length * (temp[0]+1)); a++){ 
   
            for(int b = (length * temp[1]); b < (length * (temp[1]+1)); b++){ 
   
                for(int c = (length * temp[2]); c < (length * (temp[2]+1)); c++){ 
   
                    for(int d = (length * temp[3]); d < (length * (temp[3]+1)); d++){ 
   
                        for(int e = (length * temp[4]); e < (length * (temp[4]+1)); e++){ 
   
                            /*获取不同的键盘字符组合*/
                            data = ""+ encryptedText[a] + encryptedText[b] + encryptedText[c] + encryptedText[d] + encryptedText[e] ;
                            /*将字符加密*/
                            String result = sha1(data);
                            String decrypted = "4b58475789e60dbf1a28d638b556a938134644c8";
                            /*如果字符加密后的sha1哈希值和所给的相等，即为找到了答案*/
                            if(decrypted.equals(result)){ 
   
                                System.out.println("4b58475789e60dbf1a28d638b556a938134644c8的sha1算法解密结果为： "+data);
                                return 10;
                            }
                        }
                    }
                }
            }
        }
        return 0;
    }
    /** * sha1算法加密 * @param data * @return * @throws NoSuchAlgorithmException */
    public static String sha1(String data) throws NoSuchAlgorithmException { 
   
        //信息摘要器 算法名称
        MessageDigest md = MessageDigest.getInstance("SHA1");
        //把字符串转为字节数组
        byte[] b = data.getBytes();
        //使用指定的字节来更新我们的摘要
        md.update(b);
        //获取密文 （完成摘要计算）
        byte[] b2 = md.digest();
        //获取计算的长度
        int len = b2.length;
        //16进制字符串
        String str = "0123456789abcdef";
        //把字符串转为字符串数组
        char[] ch = str.toCharArray();

        //创建一个40位长度的字节数组
        char[] chs = new char[len*2];
        //循环20次
        for(int i=0,k=0;i<len;i++) { 
   
            //获取摘要计算后的字节数组中的每个字节
            byte b3 = b2[i];
            // >>>:无符号右移
            // &:按位与
            //0xf:0-15的数字
            chs[k++] = ch[b3 >>> 4 & 0xf];
            chs[k++] = ch[b3 & 0xf];
        }
        //字符数组转为字符串
        return new String(chs);
    }
}

Sha1Test.java

package sha1;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.ThreadPoolExecutor;
/*Future类包含线程池执行完毕之后存储的结果*/

/** * @Auther: * @Date: 2018/2/27 18:33 * @Description: */
public class Sha1Test { 
   
   public static void main(String[] args) { 
   
      // 执行线程池
      ThreadPoolExecutor executor=(ThreadPoolExecutor)Executors.newFixedThreadPool(32);

      //分成32个任务计算，提交任务
      for (int i=0; i<32; i++){ 
   
          Sha1 sha1 = new Sha1(i);
            executor.submit(sha1);
            /*Future类获取线程的返回值*/
            Future<Integer> result = executor.submit(sha1);
            try { 
   
                /*将返回值转换成Interger对象*/
                Integer test = result.get();
                /*比较结果后终止线程池*/
                if(test.equals((Integer)10)){ 
   
                    // 关闭线程池
                    executor.shutdown();
                }
            } catch (InterruptedException | ExecutionException e) { 
   
                e.printStackTrace();
            }
      }
      // 关闭线程池
      executor.shutdown();
   }
}