MD5

MD5对明文的处理

C实现MD5算法的使用

MD5.h

#pragma once
//
// Created by Administrator on 2021-07-28.
//
//在一些情况下，反斜杠 \ 可以用作行连接符，用于将代码行连接在一起。换句话说，如果你想在一行代码上换行而不终止该行，可以在行末添加一个反斜杠。
#ifndef HOOKDEMO_MD5_H
#define HOOKDEMO_MD5_H

typedef struct {
    unsigned int count[2];
    unsigned int state[4];
    unsigned char buffer[64];
} MD5_CTX;

#define F(x,y,z) ((x & y) | (~x & z))
#define G(x,y,z) ((x & z) | (y & ~z))
#define H(x,y,z) (x^y^z)
#define I(x,y,z) (y ^ (x | ~z))
#define ROTATE_LEFT(x,n) ((x << n) | (x >> (32-n)))
#define FF(a,b,c,d,x,s,ac) \
          { \
          a += F(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define GG(a,b,c,d,x,s,ac) \
          { \
          a += G(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define HH(a,b,c,d,x,s,ac) \
          { \
          a += H(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
#define II(a,b,c,d,x,s,ac) \
          { \
          a += I(b,c,d) + x + ac; \
          a = ROTATE_LEFT(a,s); \
          a += b; \
          }
void MD5Init(MD5_CTX* context);
void MD5Update(MD5_CTX* context, unsigned char* input, unsigned int inputlen);
void MD5Final(MD5_CTX* context, unsigned char digest[16]);
void MD5Transform(unsigned int state[4], unsigned char block[64]);
void MD5Encode(unsigned char* output, unsigned int* input, unsigned int len);
void MD5Decode(unsigned int* output, unsigned char* input, unsigned int len);

#endif //HOOKDEMO_MD5_H

MD5.cpp

#include <iostream>
#include <memory.h>
#include <string.h>
#include "MD5.h"

using namespace std;

unsigned char PADDING[] = { 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                           0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };

void MD5Init(MD5_CTX* context) {
    context->count[0] = 0;
    context->count[1] = 0;
    context->state[0] = 0x67452301;
    context->state[1] = 0xEFCDAB89;
    context->state[2] = 0x98BADCFE;
    context->state[3] = 0x10325476;
}

void MD5Update(MD5_CTX* context, unsigned char* input, unsigned int inputlen) {
    unsigned int i = 0, index = 0, partlen = 0;
    index = (context->count[0] >> 3) & 0x3F;
    partlen = 64 - index;
    context->count[0] += inputlen << 3;
    if (context->count[0] < (inputlen << 3))
        context->count[1]++;
    context->count[1] += inputlen >> 29;

    if (inputlen >= partlen) {
        memcpy(&context->buffer[index], input, partlen);
        MD5Transform(context->state, context->buffer);
        for (i = partlen; i + 64 <= inputlen; i += 64)
            MD5Transform(context->state, &input[i]);
        index = 0;
    }
    else {
        i = 0;
    }
    memcpy(&context->buffer[index], &input[i], inputlen - i);
}

void MD5Final(MD5_CTX* context, unsigned char digest[16]) {
    unsigned int index = 0, padlen = 0;
    unsigned char bits[8];
    index = (context->count[0] >> 3) & 0x3F;
    padlen = (index < 56) ? (56 - index) : (120 - index);
    MD5Encode(bits, context->count, 8);
    MD5Update(context, PADDING, padlen);
    MD5Update(context, bits, 8);
    MD5Encode(digest, context->state, 16);
}

void MD5Encode(unsigned char* output, unsigned int* input, unsigned int len) {
    unsigned int i = 0, j = 0;
    while (j < len) {
        output[j] = input[i] & 0xFF;
        output[j + 1] = (input[i] >> 8) & 0xFF;
        output[j + 2] = (input[i] >> 16) & 0xFF;
        output[j + 3] = (input[i] >> 24) & 0xFF;
        i++;
        j += 4;
    }
}

void MD5Decode(unsigned int* output, unsigned char* input, unsigned int len) {
    unsigned int i = 0, j = 0;
    while (j < len) {
        output[i] = (input[j]) |
            (input[j + 1] << 8) |
            (input[j + 2] << 16) |
            (input[j + 3] << 24);
        i++;
        j += 4;
    }
}

void MD5Transform(unsigned int state[4], unsigned char block[64]) {
    unsigned int a = state[0];
    unsigned int b = state[1];
    unsigned int c = state[2];
    unsigned int d = state[3];
    unsigned int x[64];
    MD5Decode(x, block, 64);
    FF(a, b, c, d, x[0], 7, 0xd76aa478); /* 1 */
    // ... 省略其余部分，保持原代码中的内容
    II(b, c, d, a, x[9], 21, 0xeb86d391); /* 64 */
    state[0] += a;
    state[1] += b;
    state[2] += c;
    state[3] += d;
}

int main() {
    MD5_CTX context;
    MD5Init(&context);
    unsigned char* plainText = (unsigned char*)"xiaojianbang";
    MD5Update(&context, plainText, strlen(reinterpret_cast<const char*>(plainText)));
    unsigned char result[16];
    MD5Final(&context, result);

    char temp[3] = { 0 }; // 修改为 3，2 + 1 结束符
    char finalResult[33] = { 0 }; // 32 + 1 结束符
    for (int i = 0; i < 16; i++) {
        sprintf_s(temp, sizeof(temp), "%.2x", result[i]);
        strcat_s(finalResult, sizeof(finalResult), temp);
    }

    cout << finalResult << endl;

    return 0;
}

对明文进行Hex编码

对于字符串 "xiaojianbang"，每个字符对应的 ASCII 值及其十六进制表示如下：
x -> 120 -> 78
i -> 105 -> 69
a -> 97 -> 61
o -> 111 -> 6f
j -> 106 -> 6a
i -> 105 -> 69
a -> 97 -> 61
n -> 110 -> 6e
b -> 98 -> 62
a -> 97 -> 61
n -> 110 -> 6e
g -> 103 -> 67

填充

把明文填充到448bit(56byte),先填一个1，后面跟对应个数的0
结果：78 69 61 6f 6a 69 61 6e 62 61 6e 67 80(80 -> 1000 0000)
附加消息长度，用64bit表示消息长度，xiaojianbang的长度为96bit，对应16进制为0x60，所以表示为:

60 00 00 00 00 00 00 00 转小端序60 00 00 00 00 00 00 00
如果内容过长，64比特位放不下，就取低64bit位。所以MD5输入长度考研无限大，SHA3算法也是无限大，其他哈希算法不是。

大端序（Big-endian）
在大端序中，数据的高位字节存储在内存的低地址处，低位字节存储在高地址处。换句话说，字节序列的第一个字节是最高有效字节（Most Significant Byte，MSB）。

示例： 对于一个 32 位的整数 0x12345678，在大端序中，它在内存中的存储顺序是：

复制代码
地址    数据
0x00    0x12
0x01    0x34
0x02    0x56
0x03    0x78
小端序（Little-endian）
在小端序中，数据的低位字节存储在内存的低地址处，高位字节存储在高地址处。也就是说，字节序列的第一个字节是最低有效字节（Least Significant Byte，LSB）。

示例： 对于同一个 32 位整数 0x12345678，在小端序中，它在内存中的存储顺序是：

复制代码
地址    数据
0x00    0x78
0x01    0x56
0x02    0x34
0x03    0x12
区别和应用
平台差异：不同的计算机架构可能使用不同的字节序。例如，Intel x86 和 x86-64 架构通常使用小端序，而某些网络协议和其他处理器（如某些 ARM 和 PowerPC 处理器）使用大端序。
网络传输：在网络协议中，通常使用大端序（也称为网络字节序），这意味着在网络上传输多字节数据时需要转换为大端序。

- MD5的分组长度为512bit，数据需要处理到512的倍数，因此需要填充 

- 把处理后的明文分成16块M1-M6

### MD5的初始化常量

```cpp
在内存中:d    
A: 01 23 45 67
B: 89 ab cd ef
C: fe dc ba 98
D: 76 54 32 10
    
context->state[0] = 0x67452301;
context->state[1] = 0xEFCDAB89;
context->state[2] = 0x98BADCFE;
context->state[3] = 0x10325476;

MD5Transform

MD5总共64轮，每一轮都会把旧的D直接给新的A，旧的B直接给新的C，旧的C直接给新的D，也就是每一轮只计算一个新的B
图中的田代表相加
图中的F函数并不是一个函数，而是由四个函数组成
K表里面的值是由公式计算的，但体现在代码中一般都是常量
<<<s代表循环左移
最后把四个初始化常量不断变化后的值，拼接得到最终的摘要结果

IDA中的数据类型

DCB、DCW、DCD、DCQ

ARM和THUMB模式

ARM 和 THUMB 模式简介：

ARM 处理器有两种主要的指令编码模式：ARM 模式和THUMB 模式。这两种模式的主要区别是指令的大小：

ARM 模式：指令通常为 32 位长。
THUMB 模式：指令通常为 16 位长，目的是提高代码密度，减少内存占用。

这两种模式可以在执行时动态切换，允许程序根据需要在这两种模式之间切换，以达到性能和内存的平衡。

SHA1

算法细节

SHA1算法对于明文的处理与MD5相同，区别是最后的消息长度是大端字节序，SHA1算法的初始化常量有5个，其中前四个与MD5是一致的
SHA1的分组长度也是512bit，明文也要分段，类似Mi，区别是有80段，后64段是扩展出来的，遵循大端字节序
SHA1与SHA0的区别就是在扩展这64段的时候，增加了循环左移1位

W[t] = SHACircularShift(1,w[t-3]^w[t-8]^w[t-14]^w[t-16]);
SHA1的核心计算过程与MD5差不多，区别是K值只有4个，每20轮用一个，总共80轮

哈希算法的识别

MD5

初始化常量4个

A = 0x67452301

B = 0xEFCDAB89

C = 0x98BADCFE

D = 0x10325476
K表64个，每轮用一个，总共64轮

K1 = 0xd76aa478

K2 = 0xe8c7b756

K3 = 0x242070db
输出长度16个字节，或者或32个十六进制数，有时候输出16个十六进制数

SHA1

初始化常量是5个

A = 0x67452301

B = 0xEFCDAB89

C = 0x98BADCFE

D = 0x10325476

E = 0xC3D2E1F0

和MD5相比，有五个初始化链接变量，而且前四个链接变量是完全相同的
K表4个

只有4个K值，每20轮用同一个K作变换，而且前四个链接变量完全相同

K1 = 0x5a837999

K2 = 0x6ed9eba1

K3 = 0x8f1bbcdc

K4 = 0xca62c1d6
输出长度20个字节，或者或40个十六进制数

SHA256算法

初始化常量8个

A = 0x6A09E667

B = 0xBB67AE85

C = 0x3C6EF372

D = 0xA54FF53A

E = 0x510E527F

F = 0x9B05688C

G = 0x1F83D9AB

H = 0x5BE0CD19

K表64个，每轮一个K值
输出长度位32个字节，或者说64个十六进制数

SHA512

初始化常量8个，IDA反编译有时显示位16个
K表80个，每轮一个K值
输出长度为64字节，或者说128个十六进制数
MD5、SHA1、SHA256都是512bit分组，SHA512是1024bit分组

HmacMD5

密钥扩展

密钥a12345678转Hex编码：61 31 32 33 34 35 36 37 38
然后填充0，让密钥长度达到算法的分组长度，MD5的话就是512bit
如果密钥太长，就县进行MD5，再填充0

16字节 + 一堆0

扩展后的密钥与0x36异或

57 07、、、、0e、、、36、、、

异或后的数据与明文级联

级联（Concatenate）指的是将两个或多个数据元素（通常是字符串、数组、或其他数据结构）连接在一起，形成一个新的、更长的序列

级联后的数据进行Hass(MD5)算法

扩展后的密钥与0x5c异或

异或的结果与Hash的结果级联

再次进行Hash算法

MAC算法的简单识别

找0x36和0x5c、54和92来分辨是不是HMAC算法

也可以靠猜，比如MD5、魔改的MD5、HmacMD5最后输出结果都是16字节

DES

不考虑填充方式
不考虑加密模式
不考虑iv向量
输入明文为8个字节，密钥为8个字节，输出结果也为8个字节

明文：0123456789ABCDEF

密钥：133457799BBCDFF1

第1步：子密钥的生成

把密钥转二进制

00010011 00110100 01010111 01111001 10011011 10111100 11011111 11110001

根据PC1表，对密钥进行重新排列

int PC1_Table[56] = {

57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,

10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,

63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,

14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4};

密钥编排后的结果

1111000 0110011 0010101 0101111 0101010 1011001 1001111 0001111

接下来将这56比特长的密钥分成左右两部分，命名为C0，D0

C0 = 1111000 0110011 0010101 0101111

D0 = 0101010 1011001 1001111 0001111

循环左移规定的位数，得到C1，D1到C16，D16的十六个数据

key_shift = [1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1];

C1 = 1110000 1100110 0101010 1011111

D1 = 1010101 0110011 0011110 0011110

C2D2可以对C1D1分别左移1位来得到

C2D2也可以对C0D0分别左移2位来得到

将C1D1拼接起来，继续后续的处理

C1D1 = 1110000 1100110 0101010 1011111 1010101 0110011 0011110 0011110

根据PC2表进行重排，56bit长的CnDn只留下48比特

int PC2_Table[48] = {

14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,

23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,

41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,

44, 49, 39, 56, 34, 53, 46, 42, 50, 36, 29, 32};

重排后CnDn就是子密钥，命名为Kn

后续DES的十六轮运算中，第n轮就是用Kn，16个子密钥为

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

K2 = 011110 011010 111011 011001 110110 111100 100111 100101

K3 = 010101 011111 110010 001010 010000 101100 111110 011001

K4 = 011100 101010 110111 010110 110110 110011 010100 011101

K5 = 011111 001110 110000 000111 111010 110101 001110 101000

K6 = 011000 111010 010100 111110 010100 000111 101100 101111

K7 = 111011 001000 010010 110111 111101 100001 100010 111100

K8 = 111101 111000 101000 111010 110000 010011 101111 111011

K9 = 111000 001101 101111 101011 111011 011110 011110 000001

K10 = 101100 011111 001101 000111 101110 100100 011001 001111

K11 = 001000 010101 111111 010011 110111 101101 001110 000110

K12 = 011101 010111 000111 110101 100101 000110 011111 101001

K13 = 100101 111100 010111 010001 111110 101011 101001 000001

K14 = 010111 110100 001110 110111 111100 101110 011100 111010

K15 = 101111 111001 000110 001101 001111 010011 111100 001010

K16 = 110010 110011 110110 001011 000011 100001 011111 110101

第2步：明文的编排

把明文转二进制

00000001 00100011 01000101 01100111 10001001 10101011 11001101 11101111

根据IP表，对明文进行初始置换

int IP_Table[64] = {

58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,

62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,

57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,

61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7};

明文重新排列后的结果

11001100 00000000 11001100 11111111 11110000 10101010 11110000 10101010

第3步：明文的运算

首先将明文分成左右两半，像上面的密钥一样

L0 和 R0

L0：11001100 00000000 11001100 11111111

R0：11110000 10101010 11110000 10101010

16轮迭代的基本套路

Ln = Rn-1

Rn = Ln-1 + f(Rn-1, Kn)

以n = 1为例:

L1 = R0 = 11110000 10101010 11110000 10101010

R1 = L0 xor f(R0, K1)

f函数传入了R0与K1，即第1个子密钥

R0 = 11110000 10101010 11110000 10101010

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

R0为32bit，K1为48bit，长度不同，没法按位异或

将32bit的R0扩展成48bit，使用到E表

E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101

int E_Table[48] = {

32, 1, 2, 3, 4, 5, 4, 5, 6, 7, 8, 9,

8, 9, 10, 11, 12, 13, 12, 13, 14, 15, 16, 17,

16, 17, 18, 19, 20, 21, 20, 21, 22, 23, 24, 25,

24, 25, 26, 27, 28, 29, 28, 29, 30, 31, 32, 1};

进行密钥混合 E(R0) ^ K1

E(R0) = 011110 100001 010101 010101 011110 100001 010101 010101

K1 = 000110 110000 001011 101111 111111 000111 000001 110010

K1+E(R0)= 011000 010001 011110 111010 100001 100110 010100 100111

DES算法核心

将上一步的结果分成8块6bit

B1 = 011000

B2 = 010001

B3 = 011110

B4 = 111010

B5 = 100001

B6 = 100110

B7 = 010100

B8 = 100111

把B1-B8的值当成索引，在S1-S8盒中取值，规则如下：

以B1为例，值为011000，将它分成0 1100 0，得到

i = 00 即 0

j = 1100 即 12

在S1中查找第0行第12列的值(这里从0开始算)

int S_Box[8][4][16] = {

// S1

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,

// S2

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, 0, 5, 14, 9,

// S3

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,

// S4

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,

// S5

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,

// S6

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,

// S7

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,

// S8

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行第12列的值为5

B1 = 5 = 0101

再以B2为例

B2 = 0 1000 1

i = 01 = 1

j = 1000 = 8

B2 = 12 = 1100

B1在S1中找，B2在S2中找，以此类推

最后8个6比特的值在S盒作用下变成8个4比特的值

S(K1+E(R0)) = 0101 1100 1000 0010 1011 0101 1001 0111

得到的结果进行P表的重排

int P_Table[32] = {

16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,

2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25};

P(S(K1+E(R0))) = 0010 0011 0100 1010 1010 1001 1011 1011

F函数完事，即F = P(S(K1+E(R0)))

F的结果与L0异或

L1 = R0 = 11110000 10101010 11110000 10101010

R1 = Ln-1 xor f(Rn-1,Kn) = 11101111 01001010 01100101 01000100

一轮运算完毕，16轮运算的操作完全一致

L1: 11110000 10101010 11110000 10101010

R1: 11101111 01001010 01100101 01000100

L2: 11101111 01001010 01100101 01000100

R2: 11001100 00000001 01110111 00001001

L3: 11001100 00000001 01110111 00001001

R3: 10100010 01011100 00001011 11110100

L4: 10100010 01011100 00001011 11110100

R4: 01110111 00100010 00000000 01000101

L5: 01110111 00100010 00000000 01000101

R5: 10001010 01001111 10100110 00110111

L6: 10001010 01001111 10100110 00110111

R6: 11101001 01100111 11001101 01101001

L7: 11101001 01100111 11001101 01101001

R7: 00000110 01001010 10111010 00010000

L8: 00000110 01001010 10111010 00010000

R8: 11010101 01101001 01001011 10010000

L9: 11010101 01101001 01001011 10010000

R9: 00100100 01111100 11000110 01111010

L10:00100100 01111100 11000110 01111010

R10:10110111 11010101 11010111 10110010

L11:10110111 11010101 11010111 10110010

R11:11000101 01111000 00111100 01111000

L12:11000101 01111000 00111100 01111000

R12:01110101 10111101 00011000 01011000

L13:01110101 10111101 00011000 01011000

R13:00011000 11000011 00010101 01011010

L14:00011000 11000011 00010101 01011010

R14:11000010 10001100 10010110 00001101

L15:11000010 10001100 10010110 00001101

R15:01000011 01000010 00110010 00110100

L16:01000011 01000010 00110010 00110100

R16:00001010 01001100 11011001 10010101

L16和R16倒换，左右调一下顺序，结果为R16L16

R16L16 = 00001010 01001100 11011001 10010101 01000011 01000010 00110010 00110100

最后一步，根据FP表进行末置换

10000101 11101000 00010011 01010100 00001111 00001010 10110100 00000101

int FP_Table[64] = {

40, 8, 48, 16, 56, 24, 64, 32, 39, 7, 47, 15, 55, 23, 63, 31,

38, 6, 46, 14, 54, 22, 62, 30, 37, 5, 45, 13, 53, 21, 61, 29,

36, 4, 44, 12, 52, 20, 60, 28, 35, 3, 43, 11, 51, 19, 59, 27,

34, 2, 42, 10, 50, 18, 58, 26, 33, 1, 41, 9, 49, 17, 57, 25};

上述数据的十六进制形式为

85 e8 13 54 0f 0a b4 05

末置换就是初始置换的逆运算

明文经过初始置换，不做任何处理再进行末置换，值等于它自身

AES

AES特点

在一个分组长度内，明文长度变化，AES的加密结果长度都一样
密钥长度128、192、256三种，如果少一个十六进制数，会在前面补0
分组长度只有128一种
密文长度与填充后的明文长度有关，一般是16字节的倍数
DES是针对bit进行操作，AES是针对字节进行操作

AES和DES的区别与联系

DES和AES都是对称加密算法，加解密都是用同一个密钥
DES和AES都是分组加密算法，DES的分组长度是64比特，AES的分组长度是128比特
DES的密钥64比特，AES的密钥128比特、192比特、256比特
DES运算的基本单元是比特，AES运算的基本单元是字节
DES和AES都可以分成密钥的编排和明文的运算
DES中有非常多的置换，AES没有
DES有16轮运算，在密钥编排中生成了16组子密钥
AES有10、12、14轮运算，也生成了10、12、14组轮密钥，都是每轮用一个