Tupler
[ 分类 ] [ 归档 ] [ 标签 ] [ 关于 ]
Tupler

Contents

[ak赛]EasyDSE

 included in re
   2836 words   14 minutes 

0x00.查壳

https://s2.loli.net/2023/08/27/L83dV6SQtJGXaOs.png 无壳 64位

0x01.IDA看

没加花 直接F5 方便看 https://s2.loli.net/2023/08/27/thuFHazJTGy7C2B.png

 0
 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

int __cdecl main(int argc, const char **argv, const char **envp)
{
  char C[34]; // [rsp+20h] [rbp-60h] BYREF
  int key_pre[64]; // [rsp+50h] [rbp-30h] BYREF
  int m[128]; // [rsp+150h] [rbp+D0h] BYREF
  int dest[16][48]; // [rsp+350h] [rbp+2D0h] BYREF
  int i; // [rsp+F5Ch] [rbp+EDCh]
                                                // m是输入的STR的二进制
                                                // 
  _main();
  while ( 1 )                                  
  {
    while ( getstr(m) )  				 // m=bin(hex(str))
      ;
    getkey(key_pre);                            // key_pre=bin(hex(str))
    exchangeIP(key, key_pre, PC_1, 56);		    //根据表PC_1进行置换 获得key数据
    getroundkey(dest[0], key); 					//根据key进行一系列运算获取dest_KEY
  
    exchangeIP(mint, m, IP_first, 64);          // 根据表将m的前64项置换成mint
    encode(mint, dest);							//加密mint 即为加密前半部分m
    exchangeIP(m, mint, IP_last, 64);			//将加密完的前半部分数据 根据ip_LAST表置换
   
    exchangeIP(mint, &m[64], IP_first, 64);     // 加密后半部分 跟前面类似
    encode(mint, dest);
    exchangeIP(&m[64], mint, IP_last, 64);
      
    for ( i = 0; i <= 127; i += 4 )
      C[i / 4] = hex_re(&m[i]);
    C[32] = 0;
    puts(C);
    if ( !strcmp(flag, C) )
      break;
    puts("flag is incorrect!");
  }
  puts("congratulation!!!");
  getchar();
  return 0;
}
 0
 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

int __cdecl getstr(int *m)
{
  int result; // eax
  char mstr[34]; // [rsp+20h] [rbp-40h]
  int temp; // [rsp+4Ch] [rbp-14h]
  int k; // [rsp+50h] [rbp-10h]
  int t; // [rsp+54h] [rbp-Ch]
  int j; // [rsp+58h] [rbp-8h]
  int i; // [rsp+5Ch] [rbp-4h]

  printf("please input flag: ");
  for ( i = 0; i <= 31 && mstr[i - 1] != '\n'; ++i )
    mstr[i] = getchar();
  if ( i == 32 )
  {
    result = getchar();
    i = 0;
    j = 0;
    while ( i <= 127 )
    {
      result = hex(mstr[j]);
      t = result;
      for ( k = 0; k <= 3; ++k )
      {
        temp = t % 2;
        if ( t % 2 )
          m[i + 3 - k] = 1;
        else
          m[i + 3 - k] = 0;
        result = t / 2;
        t /= 2;
      }
      i += 4;
      ++j;
    }
  }
  else
  {
    puts("the length is incorrect!");
    return 1;
  }
  return result;
}

简单分析发现 getstr为将获取的字符串 直接转换为Hex数据（不是ASCII 而是相当于就是输入的是十六进制的字母 如果不是十六进制的字符直接变为0) 然后将 hex数据转为二进制数据 然后进行置换+加密 +置换 放回m的地方

0
1
2
3
4
5
6

void __cdecl exchangeIP(int *d, int *s, int *IP_0, int n)
{
  int i; // [rsp+Ch] [rbp-4h]

  for ( i = 0; i < n; ++i )
    d[i] = s[IP_0[i] - 1];
}

由上述代码可以得到其逆回置换 

0
1
2
3
4
5
6

void __cdecl exchangeIP(int *d, int *s, int *IP_0, int n)
{
  int i; // [rsp+Ch] [rbp-4h]

  for ( i = 0; i < n; ++i )
    s[IP_0[i] - 1]=d[i] ;
}

重点看 encode函数 看样子是先将mint 用dest[i]进行加密 然后再将mint的前半部分和后半部分互换 然后 继续看encode_ground 发现用的是后半部分加密前半部分

 0
 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

void __cdecl encode(int *mint, int (*dest)[48])
{
  int temp; // [rsp+24h] [rbp-Ch]
  int j; // [rsp+28h] [rbp-8h]
  int i; // [rsp+2Ch] [rbp-4h]

  for ( i = 0; i <= 15; ++i )
  {
    encode_ground(mint, &(*dest)[48 * i]);
    for ( j = 0; j <= 31; ++j )
    {
      temp = mint[j];
      mint[j] = mint[j + 32];
      mint[j + 32] = temp;
    }
  }
}

void __cdecl encode_ground(int *m, int *k)
{
  int ec[32]; // [rsp+20h] [rbp-60h] BYREF
  int temp[48]; // [rsp+A0h] [rbp+20h] BYREF
  int i_1; // [rsp+164h] [rbp+E4h]
  int i_0; // [rsp+168h] [rbp+E8h]
  int i; // [rsp+16Ch] [rbp+ECh]

  exchangeIP(temp, m + 32, E, 48);  //根据表E 进行将m后半部分进行置换
  for ( i = 0; i <= 47; ++i )		//将置换后的temp和dest[i]进行异或
    temp[i] ^= k[i];
  for ( i_0 = 0; i_0 <= 47; i_0 += 6 )		//用replaceS 将temp进行 置换加密  
    replaceS(&ec[4 * (i_0 / 6)], &temp[i_0], i_0 / 6);
  exchangeIP(temp, ec, P, 32);		// 将得到的ec再次用P表进行置换
  for ( i_1 = 0; i_1 <= 31; ++i_1 )  //将m的前半部分用temp一一异或
    m[i_1] ^= temp[i_1];
}

void __cdecl replaceS(int *dest, int *source, int n)
{
  int i; // [rsp+8h] [rbp-8h]
  int temp; // [rsp+Ch] [rbp-4h]

  temp = S_Box[n][32 * *source + 16 * source[5] + 8 * source[1] + 4 * source[2] + 2 * source[3] + source[4]];
  for ( i = 3; i >= 0; --i )
  {
    dest[i] = temp % 2;
    temp /= 2;
  }
}
由于内部是异或 所以encode_ground 基本不需要修改 只要再让他运行一次就能解出

分析完后 列一下加密和解密的步骤

程序流程

  1. 将输入的字符串转为16进制再转为2进制储存到一个数组中
  2. 将指定的字符串进行转为16进制转为二进制 放到key数组中
  3. 将key数组进行置换 获得dest
  4. 将上面转换后的输入字符串数组进行 置换 得到mint
  5. 用dest加密mint
  6. 再将mint 置换得到m的前半部分
  7. 后续就是加密后半部分的m

解密流程

  1. 动调获取dest表
  2. 然后一步一步往上进行 先解密后半部分再解密前半部分
  3. encode函数的decode 为 反着来 即为 从最后一项往上

遇到的坑

  • 数据过多 十六进制 替换时 没写 0x

解密脚本 

  0
  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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179

int S_Box[8][65] = { {14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0, 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13, 0}, {15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15, 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 10, 5, 14, 9, 0}, {10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1, 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7, 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12, 0}, {7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4, 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14, 0}, {2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14, 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3, 0}, {12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6, 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13, 0}, {4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2, 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12, 0}, {13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8, 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11, 0} };

int PC_2[] = {
	0x0E,0x11,0x0B,0x18,0x1,0x5,0x3,0x1C,0x0F,0x6,0x15,0x0A,
	0x17,0x13,0x0C,0x4,0x1A,0x8,0x10,0x7,0x1B,0x14,0x0D,0x2,
	0x29,0x34,0x1F,0x25,0x2F,0x37,0x1E,0x28,0x33,0x2D,0x21,
	0x30,0x2C,0x31,0x27,0x38,0x22,0x35,0x2E,0x2A,0x32,0x24,
	0x1D,0x20
};
int E[] = { 0x20,0x1,0x2,0x3,0x4,0x5,0x4,0x5,0x6,0x7,0x8,0x9,0x8,0x9,0x0A,0x0B,
0x0C,0x0D,0x0C,0x0D,0x0E,0x0F,0x10,0x11,0x10,0x11,0x12,
0x13,0x14,0x15,0x14,0x15,0x16,0x17,0x18,0x19,0x18,0x19,
0x1A,0x1B,0x1C,0x1D,0x1C,0x1D,0x1E,0x1F,0x20,0x1 };
int P[] = {
	0x10,0x7,0x14,0x15,0x1D,0x0C,0x1C,0x11,0x1,0x0F,0x17,0x1A,
	5,0x12,0x1F,0x0A,0x2,0x8,0x18,0x0E,0x20,0x1B,0x3,0x9,0x13,
	0x0D,0x1E,0x6,0x16,0x0B,0x4,0x19
};
int dest[16][48] = { {0,0,0,1,1,0,0,1,0,1,0,0,1,1,0,0,1,1,0,1,0,0,0,0,0,1,1,1,0,0,1,0,1,1,0,1,1,1,1,0,1,0,0,0,1,1,0,0, },
{0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, },
{0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, },
{1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, },
{0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, },
{1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, },
{0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, },
{0, 0, 1, 1, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, },
{1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, },
{0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, },
{0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, },
{1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1, },
{1, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, },
{0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 0, },
{0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, },
{0, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, }};
void  shiftL(int *dest, int step)
{
	int temp[8]; // [rsp+0h] [rbp-30h]
	int i_1; // [rsp+24h] [rbp-Ch]
	int i_0; // [rsp+28h] [rbp-8h]
	int i; // [rsp+2Ch] [rbp-4h]

	for (i = 0; i < step; ++i)
		temp[i] = dest[i];
	for (i_0 = step; i_0 <= 27; ++i_0)
		dest[i_0 - step] = dest[i_0];
	for (i_1 = 0; i_1 < step; ++i_1)
		dest[28 - step + i_1] = temp[i_1];
}
void replaceS(int *dest, int *source, int n) {
	int i; // [rsp+8h] [rbp-8h]
	int temp; // [rsp+Ch] [rbp-4h]

	temp = S_Box[n][32 * source[0] + 16 * source[5] + 8 * source[1] + 4 * source[2] + 2 * source[3] + source[4]];
	for (i = 3; i >= 0; --i)
	{
		dest[i] = temp % 2;
		temp /= 2;
	}


}
void exchangeIP(int *d, int *s, int *IP_0, int n) {
	int i; // [rsp+Ch] [rbp-4h]

	for (i = 0; i < n; ++i)
		d[i] = s[IP_0[i] - 1];
}
int move_time[16] = { 2,2,1,2,2,3,2,1,3,3,3,2,2 };
void  getroundkey(int dest[16][48], int *k)
{
	int n; // [rsp+3Ch] [rbp-4h]

	for (n = 0; n <= 15; ++n)
	{
		shiftL(k, move_time[n]);
		shiftL(k + 28, move_time[n]);
		exchangeIP(dest[n], k, PC_2, 48);
	}
}

void re_exchangeIP(int *d,int *k,int *IP_0, int n) {
	
	for (int i = 0; i < n;++i)
	{
		k[IP_0[i] - 1] = d[i];
	}
	
}

void encode_ground(int *m, int *k) {
	int ec[32]; // [rsp+20h] [rbp-60h] BYREF
	int temp[48]; // [rsp+A0h] [rbp+20h] BYREF
	int i_1; // [rsp+164h] [rbp+E4h]
	int i_0; // [rsp+168h] [rbp+E8h]
	int i; // [rsp+16Ch] [rbp+ECh]
	exchangeIP(temp, &m[32], E, 48);
	
	for (i = 0; i <= 47; ++i) {
		temp[i] ^= k[i];
		printf("%d,", temp[i]);
	}
	for (i_0 = 0; i_0 <= 47; i_0 += 6)
		replaceS(&ec[4 * (i_0 / 6)], &temp[i_0], i_0 / 6);

	printf("\n");
	exchangeIP(temp, ec, P, 32);
	for (i_1 = 0; i_1 <= 31; ++i_1) {
		
		m[i_1] ^= temp[i_1];
		
	}

}
void decode(int *mint,int dest[16][48]) {
	int temp;
	for (int i = 15; i >-1;--i)
	{
		for (int j = 0; j <= 31; ++j)
		{
			temp = mint[j];
			mint[j] = mint[j + 32];
			mint[j + 32] = temp;
			
		}
		encode_ground(mint, dest[i]);
	}

}


int main(int argc,char **argv)
{
	int s[56] = { 1,1,0,0,0,0,1,1,1,1,0,0,0,0,0,0,0,0,1,1,0,0,1,1,1,0,1,0,0,0,1,1,0,0,1,1,1,1,1,1,0,0,0,0,1,1,0,0,1,1,1,1,1,0,1,0 };
	int PC_1[] = { 0x39, 0x31, 0x29, 0x21, 0x19, 0x11, 9, 1, 0x3A, 0x32, 0x2A, 0x22,
		0x1A, 0x12, 0x0A, 0x2, 0x3B, 0x33, 0x2B, 0x23, 0x1B, 0x13, 0x0B,
		3, 0x3C, 0x34, 0x2C, 0x24, 0x3F, 0x37, 0x2F, 0x27, 0x1F, 0x21,
		0x0F, 0x7, 0x3E, 0x36, 0x2E, 0x26, 0x1E, 0x16, 0x0E, 0x6, 0x3D, 0x35,
		0x2D, 0x25, 0x1D, 0x15, 0x0D, 0x5, 0x1C, 0x14, 0x0C, 0x4 };
	int mint[64];// = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1 };
	int ip_First[] = { 0x3A,0x32,0x2A,0x22,0x1A,0x12,0x0A,0x2,0x3C,0x34,0x2C,
0x24,0x1C,0x14,0x0C,0x4,0x3E,0x36,0x2E,0x26,0x1E,0x16,
0x0E,0x6,0x40,0x38,0x30,0x28,0x20,0x18,0x10,0x8,0x39,0x31,
0x29,0x21,0x19,0x11,0x9,0x1,0x3B,0x33,0x2B,0x23,0x1B,0x13,
0x0B,0x3,0x3D,0x35,0x2D,0x25,0x1D,0x15,0x0D,0x5,0x3F,0x37,
0x2F,0x27,0x1F,0x17,0x0F, 7 };
	int IP_last[] = {
0x28,0x8,0x30,0x10,0x38,0x18,0x40,0x20,0x27,0x7,0x2F,0x0F,
0x37,0x17,0x3F,0x1F,0x26,0x6,0x2E,0x0E,0x36,0x16,0x3E,
0x1E,0x25,0x5,0x2D,0x0D,0x35,0x15,0x3D,0x1D,0x24,0x4,0x2C,
0x0C,0x34,0x14,0x3C,0x1C,0x23,0x3,0x2B,0x0B,0x33,0x13,
0x3B,0x1B,0x22,0x2,0x2A,0x0A,0x32,0x12,0x3A,0x1A,0x21,
0x1,0x29,0x9,0x31,0x11,0x39,0x19
	};
	int key1[64];
	int key2[64];
	int m[] = { 1,1,0,0,0,0,1,1,0,1,0,1,1,0,0,0,1,0,1,0,1,0,1,1,0,0,1,1,1,1,0,0,1,0,1,0,0,1,0,1,1,1,1,1,1,1,0,1,0,1,1,0,0,1,1,1,0,1,0,1,0,1,1,1,1,0,1,1,0,0,1,1,1,0,0,1,1,1,0,0,0,0,0,1,0,0,1,0,1,0,1,0,1,0,0,0,0,0,1,0,1,1,0,0,1,0,1,0,1,0,1,1,1,0,0,0,1,0,1,1,1,0,0,0,1,1,0,1 };
	//getroundkey(dest, s);
	int m1[64];
	int m2[64];
	int temp_mint[64];
	re_exchangeIP(m, temp_mint, IP_last, 64);
	decode(temp_mint, dest);
	re_exchangeIP(temp_mint, m1, ip_First, 64);


	re_exchangeIP(&m[64], key1, IP_last, 64);
	decode(key1, dest);
	re_exchangeIP(key1, m2,ip_First, 64);

	for (int i = 0; i < 64; i++)
	{
		printf("%d", m1[i]);
	}
	for (int i = 0; i < 64; i++)
	{
		printf("%d", m2[i]);
	}
	return 0;

}

Updated on 2023-03-04
 re
Back | Home