逆向工程实验_pre1（密码学算法破解）_sha1反编译

一、Base64编码算法

一、搜索Base64算法资料，详细解释该算法。用Python实现它，把自己的学号（字母大写）用Base64编码输出。并且把上面的源代码文件编译成pyc文件。

Base64算法实现转换原理
它是用64个可打印字符表示二进制所有数据方法。由于2的6次方等于64，所以可以用每6个位元为一个单元，对应某个可打印字符。我们知道三个字节有24个位元，就可以刚好对应于4个Base64单元，即3个字节需要用4个Base64的可打印字符来表示。在Base64中的可打印字符包括字母A-Z、a-z、数字0-9 ，这样共有62个字符，此外两个可打印符号在不同的系统中一般有所不同。但是，我们经常所说的Base64另外2个字符是：“+/”。这64个字符，所对应表如下。

转换的时候，将三个byte的数据，先后放入一个24bit的缓冲区中，先来的byte占高位。数据不足3byte的话，于缓冲区中剩下的bit用0补足。然后，每次取出6个bit，按照其值选择ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/中的字符作为编码后的输出。不断进行，直到全部输入数据转换完成。
这是恰好三个字节转为base64：

如果最后剩下两个输入数据，在编码结果后加1个“=”；如果最后剩下一个输入数据，编码结果后加2个“=”：
如果没有剩下任何数据，就什么都不要加，这样才可以保证资料还原的正确性。无论什么样的字符都会全部被编码，编码后的数据比原始数据略长，为原来的4/3。
源代码：

import string
# Base64的64个可打印字符
#letters = list( string . ascii_letters) + list(string.digits) + ['+', '/']
#print(letters)

letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
#print(letters)

#定义base64加密函数
def encryption(inputString):
    # 对每一个字节取ascii数值或unicode数值，然后转换为2进制
    ascii = ['{:0>8}'.format(str(bin(ord(i))).replace('0b', ''))
             for i in inputString]
    #返回的加密文本
    outputString = ''
    # 不够3字节的整数倍，需要补齐“=”的个数
    equalNumber = 0
    #对每个字符的转换
    while ascii:
        #三个asciiw为一组
        AsciiList = ascii[:3]
        if len(AsciiList) != 3:
            #不满三个的，在后面加“=”
            while len(AsciiList) < 3:
                equalNumber += 1
                AsciiList += ['0'*8]
        #join方法连接成三个8字节的字符串
        tempString = ''.join(AsciiList)
        # 三个8字节的二进制，转换为4个6字节的二进制
        tempStringList = [tempString[x:x+6] for x in [0, 6, 12, 18]]
        # 二进制转为10进制
        tempStringList = [int(x, 2) for x in tempStringList]
        # 判断是否需要补“=”,只要equakNumber大于0即需要
        if equalNumber:
            tempStringList = tempStringList[0:4-equalNumber]
        #装换成那64个字符
        outputString += ''.join([letters[x] for x in tempStringList])
        ascii = ascii[3:]
    #在最后加上“=”
    outputString = outputString + '=' * equalNumber
    #返回加密后的文本
    return outputString

#定义base64解密函数
def decryption(inputString):
    # 对前面不是“=”的字节取索引，然后转换为2进制
    asciiList = ['{:0>6}'.format(str(bin(letters.index(i))).replace('0b', ''))
                      for i in inputString if i != '=']
    outputString = ''
    #补齐“=”的个数
    equalNumber = inputString.count('=')
    while asciiList:
        tempList = asciiList[:4]
        #转换成2进制字符串
        tempString = ''.join(tempList)
        # 对没有8位2进制的字符串补够8位2进制
        if len(tempString) % 8 != 0:
            tempString = tempString[0:-1*equalNumber*2]
        # 4个6字节的二进制  转换  为三个8字节的二进制
        tempStringList = [tempString[x:x+8] for x in [0, 8, 16]]
        # 二进制转为10进制
        tempStringList = [int(x, 2) for x in tempStringList if x]
        #连接成字符串
        outputString += ''.join([chr(x) for x in tempStringList])
        asciiList = asciiList[4:]
    #print(output_str)
    return outputString

studentNumber = 'A12345678'
#加密
encryptedText = encryption(studentNumber)
print("加密文本为："+encryptedText)
#解密
decryptedText = decryption(encryptedText)
print("解密文本为："+decryptedText)

import base64
#Python2中可直接编码打印
#Python3中的因为3.x中字符都为unicode编码，而b64encode函数的参数为byte类型，所以必须先转码utf-8。
encodestr = base64.b64encode('A12345678'.encode('utf-8'))
print("Python库中的base64编码："+str(encodestr,'utf-8'))
decodestr = base64.b64decode(encodestr.decode('utf-8'))
print("Python库中的base64解码："+str(decodestr,'utf-8'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
'
运行
运行

代码结果截图：

自己实现的Base64算法编码和解码的结果，与导入Python库中的Base64算法编码和解码的结果相同，编码结果为：PTQxNjEOMDAx，解码结果为：A12345678。
转换成pyc文件：
源代码：

import py_compile
#文件路径下不要有中文，否则py_compile会编译报错
py_compile.compile('D:\pyc\Base64.py')
1
2
3

直接用Python自带的IDLE命令行编译

注意文件路径下不要有中文，否则py_compile会编译报错

二、pyc文件反编译

二、找班上学号和你相邻的一位同学要一下上面的pyc文件（不是源代码文件），然后搜索相关反编译工具把pyc反编译成Python源代码，最好能多找几种工具或者途径达到反编译的目的。

我找的是另一位同学的pyc文件
1、在线反编译

2、Easy Python Decompiler反编译工具

但是他的代码可能用的是最新的python环境，Easy Python Decompiler目前只支持带python3.4。但我反编译其他文件没有问题。
3、使用uncompyle6代码反编译

import os
import sys


def displayFile(file):
    unPath = sys.executable
    unPath = unPath[0: unPath.rfind(os.sep)]
    newname = file[0:file.rfind('.')] + '.py'
    command = "python -u " + unPath + "\scripts\uncompyle2 " + file + ">" + newname
    try:
        os.system(command)
    except :
        print
        file


if __name__ == '__main__':
    # print unPath
    print("init")
    displayFile('D:\\hh.pyc')
    print("finished")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

反编译出来的源代码为：

import string
base64_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
a1 = 'A12345678'
a2 = ''
a3 = ''
n1 = len(a1) % 3
n2 = len(a1) // 3
for i in range(1, n1):
    a1 += '\x00'

# WARNING: Decompyle incomplete
import string
base64_charset = string.ascii_uppercase + string.ascii_lowercase + string.digits + '+/'
a1 = 'A12345678'
a2 = ''
a3 = ''
n1 = len(a1) % 3
n2 = len(a1) // 3
for i in range(1, n1):
    a1 += '\x00'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
'
运行
运行

三、sha1算法破解

三、去https://www.mysterytwisterc3.org/注册一个账号（字母大写），i注册的时候有个Captcha可能要FQ才能显示，账号密码记住以后要用到。
完成关卡Cracking SHA1-Hashed Passwords
https://www.mysterytwisterc3.org/en/challenges/level-ii/cracking-sha1-hashed-passwords

pdf中键盘上的指纹，它提示我们密码中可能出现的字符有“QWINqwin%(*=2468”，且密码经过sha1算法加密后的密文为：67ae1a64661ac8b4494666f58c4822408dd0a3e4，要求我们解出密。

代码的原理和第五题相似，都是sha1算法暴力破解。因为是先写的第五题，这题团里就不多说了。
源代码：

package sha1;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.concurrent.Callable;
import java.lang.Math;
/**
 * 文件注释：
 *
 * @Auther: Legends
 * @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 = ("QWINqwin%(*=2468").toCharArray();
        //char [] encryptedText = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890~!@#$%^&*()[]|;',<>.?".toCharArray();
        /*长度为5的密文字符串*/
        String data = null;
        /*根据输入的线程编号threadNumber，分配相应的任务*/
        int [] temp = new int[8];
        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;
        /*8个字符的组合*/
        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++){
                            for(int f = (length * temp[5]); f < (length * (temp[5]+1)); f++){
                                for(int g = (length * temp[6]); g < (length * (temp[6]+1)); g++){
                                    for(int h = (length * temp[7]); h < (length * (temp[7]+1)); h++){
                                        /*获取不同的键盘字符组合*/
                                        data = ""+ encryptedText[a] + encryptedText[b] + encryptedText[c] + encryptedText[d] + encryptedText[e] + encryptedText[f]+ encryptedText[g]+ encryptedText[h];
                                        /*将字符加密*/
                                        String result = sha1(data);
                                        String decrypted = "67ae1a64661ac8b4494666f58c4822408dd0a3e4";
                                        //String decrypted = "4b58475789e60dbf1a28d638b556a938134644c8";
                                        /*如果字符加密后的sha1哈希值和所给的相等，即为找到了答案*/
                                        if(decrypted.equals(result)){
                                            //System.out.println("4b58475789e60dbf1a28d638b556a938134644c8的sha1算法解密结果为： "+data);
                                            System.out.println("67ae1a64661ac8b4494666f58c4822408dd0a3e4的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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

package sha1;

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

/**
 * 文件注释：逆向工程pre1，第五题
 *
 * @Auther: Legends
 * @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<256; i++){
          Sha1 sha1 = new Sha1(i);
            /*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();
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

在线解密：

密文67ae1a64661ac8b4494666f58c4822408dd0a3e4最后的sha1算法解密结果为：（Q=win*5。提交通过。

四、数据库的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: Legends
 * @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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

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: Legends
 * @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();
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

实验结果截图：

4B58475789E60DBF1A28D638B556A93813 4644C8经过解密后的结果就是BSWAP。上面输出出现的是中文乱码，由于编译器的原因，原本只是想输出一个中文提示而已。

后面抛出的异常是由于输出结果之后，我立即终止了所有还在运行的线程以免浪费时间，捕捉到的系统抛出的异常提示。但这些都无伤大雅，并不影响结果。

验证：

BSWAP经过sha1算法加密后的结果就是4B58475789E60DBF1A28D638B556A938134644C8。