CTF RE中的密码学

printf("\n");

}

int main()
{
printf(“\ncase1:==============================\n”);
// case 1//
const uint8_t key[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};
const uint8_t pt[16] = {0x32, 0x43, 0xf6, 0xa8, 0x88, 0x5a, 0x30, 0x8d, 0x31, 0x31, 0x98, 0xa2, 0xe0, 0x37, 0x07, 0x34};
uint8_t ct[16] = {0}; // 外部申请输出数据内存，用于加密后的数据
uint8_t plain[16] = {0}; // 外部申请输出数据内存，用于解密后的数据

aesEncrypt(key, 16, pt, ct, 16);                                             // 加密
printHex((uint8_t *)pt, 16, "plain data:");                                  // 打印初始明文数据
printf("expect cipher:\n39 25 84 1D 02 DC 09 FB DC 11 85 97 19 6A 0B 32\n"); // 正常解密后的数据内容

printHex(ct, 16, "after encryption:"); // 打印加密后的密文

aesDecrypt(key, 16, ct, plain, 16);       // 解密
printHex(plain, 16, "after decryption:"); // 打印解密后的明文数据

printf("\ncase2:==============================\n");
// case 2 
// 16字节字符串形式秘钥
const uint8_t key2[] = "1234567890123456";
// 32字节长度字符串明文
const uint8_t *data = (uint8_t *)"abcdefghijklmnopqrstuvwxyz123456";
uint8_t ct2[32] = {0};    // 外部申请输出数据内存，用于存放加密后数据
uint8_t plain2[32] = {0}; // 外部申请输出数据内存，用于存放解密后数据

// 加密32字节明文
aesEncrypt(key2, 16, data, ct2, 32);

printf("\nplain text:\n%s\n", data);
printf("expect ciphertext:\nfcad715bd73b5cb0488f840f3bad7889\n");
printHex(ct2, 32, "after encryption:");

// 解密32字节密文
aesDecrypt(key2, 16, ct2, plain2, 32);

// 打印16进制形式的解密后的明文
printHex(plain2, 32, "after decryption:");

// 因为加密前的数据为可见字符的字符串，打印解密后的明文字符，与加密前明文进行对比
printf("output plain text:\n");
for (int i = 0; i < 32; ++i)
{
    printf("%c", plain2[i]);
}

return 0;

}

---


### Tea


明文：2个32位无符号整数，即8字节


密钥：4个32位无符号整数


密文：2个32位无符号整数，即8字节


#### tea\_C++实现

#include <stdio.h>
#include <stdint.h>

// 加密函数
void encrypt(uint32_t *v, uint32_t *k)
{
uint32_t v0 = v[0], v1 = v[1], sum = 0, i;
uint32_t delta = 0x9e3779b9;
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
for (i = 0; i < 32; i++)
{
sum += delta;
v0 += ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
v1 += ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
}
v[0] = v0;
v[1] = v1;
}

// 解密函数
void decrypt(uint32_t *v, uint32_t *k)
{
uint32_t v0 = v[0], v1 = v[1], sum = 0xC6EF3720, i;
uint32_t delta = 0x9e3779b9;
uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];
for (i = 0; i < 32; i++)
{
v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
sum -= delta;
}
v[0] = v0;
v[1] = v1;
}

int main()
{
// v为要加解密的数据，两个32位无符号整数
uint32_t v[2] = {0x0F141297,0x985A36E8};
// k为加解密密钥，4个32位无符号整数，密钥长度为128位
uint32_t k[4] = {0x636c6557,0x5f656d6f,0x48575f32,0x46544355};
/*
s2[0] = 0x7CC261B30BFA9228LL;
s2[1] = 0xA1F3B16FD0860834LL;
s2[2] = 0xA95B1A3E11FB4D32LL;
s2[3] = 0x985A36E80F141297LL;
*/
// c = [0x7CC261B3,0x0BFA9228, 0xA1F3B16F,0xD0860834, 0xA95B1A3E ,0x11FB4D32, 0x985A36E8 ,0x0F141297]
// key = [0x57656C63,0x6F6D655F,0x325F5748,0x55435446]

// encrypt(v7, "Welcome\_2\_WHUCTF");要每四个字母倒过来转换成16进制，然后密文也要符合小端模式。
int n = sizeof(v) / sizeof(uint32\_t);
printf("加密前原始数据：0x%x 0x%x\n", v[0], v[1]);
//encrypt(v, k);
printf("加密后的数据：0x%x 0x%x\n", v[0], v[1]);
decrypt(v, k);
printf("解密后的数据：0x%x 0x%x\n", v[0], v[1]);
for (int i = 0; i < n; i++)
{
    for (int j = 0; j < sizeof(uint32\_t) / sizeof(uint8\_t); j++)
    {
        printf("%c", (v[i] >> (j \* 8)) & 0xFF);
    }
}
printf("\n");
return 0;
//whuctf{You\_Wanna\_Haave\_A\_Drink?}

}

#### tea\_Pathon实现

from ctypes import *

def encrypt(v, k):
v0, v1 = c_uint32(v[0]), c_uint32(v[1])
delta = 0x9e3779b9
k0, k1, k2, k3 = k[0], k[1], k[2], k[3]

total = c_uint32(0)
for i in range(32):
    total.value += delta 
    v0.value += ((v1.value<<4) + k0) ^ (v1.value + total.value) ^ ((v1.value>>5) + k1)  
    v1.value += ((v0.value<<4) + k2) ^ (v0.value + total.value) ^ ((v0.value>>5) + k3)

return v0.value, v1.value 

def decrypt(v, k):
v0, v1 = c_uint32(v[0]), c_uint32(v[1])
delta = 0x9e3779b9
k0, k1, k2, k3 = k[0], k[1], k[2], k[3]

total = c_uint32(delta \* 32)
for i in range(32):                       
    v1.value -= ((v0.value<<4) + k2) ^ (v0.value + total.value) ^ ((v0.value>>5) + k3) 
    v0.value -= ((v1.value<<4) + k0) ^ (v1.value + total.value) ^ ((v1.value>>5) + k1)  
    total.value -= delta

return v0.value, v1.value   

test

if name == “__main__”:

# 待加密的明文，两个32位整型，即64bit的明文数据
value = [0x12345678, 0x78563412]
# 四个key，每个是32bit，即密钥长度为128bit
key = [0x1, 0x2, 0x3, 0x4]
print("Data is : ", hex(value[0]), hex(value[1]))  
res = encrypt(value, key)
print("Encrypted data is : ", hex(res[0]), hex(res[1]))
res = decrypt(res, key)
print("Decrypted data is : ", hex(res[0]), hex(res[1]))

“”"
Data is : 0x12345678 0x78563412
Encrypted data is : 0x9a65a69a 0x67ed00f6
Decrypted data is : 0x12345678 0x78563412
“”"

#### xtea

from ctypes import *

def encrypt(v, key):
v0, v1 = c_uint32(v[0]), c_uint32(v[1])
delta = 0x9E3779B9

total = c_uint32(0)
for i in range(32):  
    v0.value += (((v1.value << 4) ^ (v1.value >> 5)) + v1.value) ^ (total.value + key[total.value & 3])
    total.value += delta 
    v1.value += (((v0.value << 4) ^ (v0.value >> 5)) + v0.value) ^ (total.value + key[(total.value>>11) & 3])

return v0.value, v1.value 

def decrypt(v, key):
v0, v1 = c_uint32(v[0]), c_uint32(v[1])
delta = 0x9E3779B9

total = c_uint32(delta \* 32)
for i in range(32):
    v1.value -= (((v0.value << 4) ^ (v0.value >> 5)) + v0.value) ^ (total.value + key[(total.value>>11) & 3])
    total.value -= delta 
    v0.value -= (((v1.value << 4) ^ (v1.value >> 5)) + v1.value) ^ (total.value + key[total.value & 3])

return v0.value, v1.value 

test

if name == “__main__”:
# 待加密的明文，两个32位整型，即64bit的明文数据
value = [0x12345678, 0x78563412]
# 四个key，每个是32bit，即密钥长度为128bit
key = [0x1, 0x2, 0x3, 0x4]

print("Data is : ", hex(value[0]), hex(value[1]))
res = encrypt(value, key)
print("Encrypted data is : ", hex(res[0]), hex(res[1]))
res = decrypt(res, key)
print("Decrypted data is : ", hex(res[0]), hex(res[1]))

“”"
Data is : 0x12345678 0x78563412
Encrypted data is : 0xae685ec7 0x59af4238
Decrypted data is : 0x12345678 0x78563412
“”"

#### xxtea

from ctypes import *

def MX(z, y, total, key, p, e):
temp1 = (z.value>>5 ^ y.value<<2) + (y.value>>3 ^ z.value<<4)
temp2 = (total.value ^ y.value) + (key[(p&3) ^ e.value] ^ z.value)

return c_uint32(temp1 ^ temp2)

def encrypt(n, v, key):
delta = 0x9e3779b9
rounds = 6 + 52//n

total = c_uint32(0)
z = c_uint32(v[n-1])
e = c_uint32(0)

while rounds > 0:
    total.value += delta  
    e.value = (total.value >> 2) & 3
    for p in range(n-1):
        y = c_uint32(v[p+1])
        v[p] = c_uint32(v[p] + MX(z,y,total,key,p,e).value).value
        z.value = v[p]
    y = c_uint32(v[0])
    v[n-1] = c_uint32(v[n-1] + MX(z,y,total,key,n-1,e).value).value
    z.value = v[n-1]
    rounds -= 1 

return v

def decrypt(n, v, key):
delta = 0x9e3779b9
rounds = 6 + 52//n

total = c_uint32(rounds \* delta)
y = c_uint32(v[0])
e = c_uint32(0)

while rounds > 0:
    e.value = (total.value >> 2) & 3
    for p in range(n-1, 0, -1):
        z = c_uint32(v[p-1])
        v[p] = c_uint32((v[p] - MX(z,y,total,key,p,e).value)).value
        y.value = v[p]
    z = c_uint32(v[n-1])  
    v[0] = c_uint32(v[0] - MX(z,y,total,key,0,e).value).value
    y.value = v[0]  
    total.value -= delta
    rounds -= 1

return v 

test

if name == “__main__”:
# 该算法中每次可加密不只64bit的数据，并且加密的轮数由加密数据长度决定
v = [0x12345678, 0x78563412]
k = [0x1, 0x2, 0x3, 0x4]
n = 2

print("Data is : ", hex(v[0]), hex(v[1]))
res = encrypt(n, v, k)
print("Encrypted data is : ", hex(res[0]), hex(res[1]))
res = decrypt(n, res, k)
print("Decrypted data is : ", hex(res[0]), hex(res[1]))

“”"
Data is : 0x12345678 0x78563412
Encrypted data is : 0xef86c2bb 0x25f31b5e
Decrypted data is : 0x12345678 0x78563412
“”"

---


### RSA

import rsa

生成RSA密钥对

public_key, private_key = rsa.newkeys(2048)

要加密的数据

message = b"Hello, RSA!"

使