admin管理员组文章数量:1026989
各种密码算法记录
TEA
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; /* set up */ uint32_t delta=0x9e3779b9; /* a key schedule constant */ uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */ for (i=0; i < 32; i++) { /* basic cycle start */ sum += delta; v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1); v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3); } /* end cycle */ 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; /* set up */ uint32_t delta=0x9e3779b9; /* a key schedule constant */ uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */ for (i=0; i<32; i++) { /* basic cycle start */ v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3); v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1); sum -= delta; } /* end cycle */ v[0]=v0; v[1]=v1;
} int main()
{ uint32_t v[2]={1,2},k[4]={2,2,3,4}; // v为要加密的数据是两个32位无符号整数 // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位 printf("加密前原始数据：%u %u\n",v[0],v[1]); encrypt(v, k); printf("加密后的数据：%u %u\n",v[0],v[1]); decrypt(v, k); printf("解密后的数据：%u %u\n",v[0],v[1]); return 0;
}
//加密前原始数据：1 2
//加密后的数据：1347371722 925494771
//解密后的数据：1 2 XTea
XTEA是TEA的升级版，增加了更多的密钥表，移位和异或操作等等，设计者是Roger Needham, David Wheeler
XTEA是TEA的扩展，也称做TEAN，它使用与TEA相同的简单运算，同样是一个64位块的Feistel密码，使用128位密钥，建议32轮, 但四个子密钥采取不正规的方式进行混合以阻止密钥表攻击。
c实现：
#include <stdio.h>
#include <stdint.h> /* take 64 bits of data in v[0] and v[1] and 128 bits of key[0] - key[3] */ void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) { unsigned int i; uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9; for (i=0; i < num_rounds; i++) { v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]); sum += delta; v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]); } v[0]=v0; v[1]=v1;
} void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) { unsigned int i; uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds; for (i=0; i < num_rounds; i++) { v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]); sum -= delta; v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]); } v[0]=v0; v[1]=v1;
} int main()
{ uint32_t v[2]={1,2}; uint32_t const k[4]={2,2,3,4}; unsigned int r=32;//num_rounds建议取值为32 // v为要加密的数据是两个32位无符号整数 // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位 printf("加密前原始数据：%u %u\n",v[0],v[1]); encipher(r, v, k); printf("加密后的数据：%u %u\n",v[0],v[1]); decipher(r, v, k); printf("解密后的数据：%u %u\n",v[0],v[1]); return 0;
}
XXTea
c实现：
#include <stdio.h>
#include <stdint.h>
#define DELTA 0x9e3779b9
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z))) void btea(uint32_t *v, int n, uint32_t const key[4])
{ uint32_t y, z, sum; unsigned p, rounds, e; if (n > 1) /* Coding Part */ { rounds = 6 + 52/n; sum = 0; z = v[n-1]; do { sum += DELTA; e = (sum >> 2) & 3; for (p=0; p<n-1; p++) { y = v[p+1]; z = v[p] += MX; } y = v[0]; z = v[n-1] += MX; } while (--rounds); } else if (n < -1) /* Decoding Part */ { n = -n; rounds = 6 + 52/n; sum = rounds*DELTA; y = v[0]; do { e = (sum >> 2) & 3; for (p=n-1; p>0; p--) { z = v[p-1]; y = v[p] -= MX; } z = v[n-1]; y = v[0] -= MX; sum -= DELTA; } while (--rounds); }
} int main()
{ uint32_t v[2]= {1,2}; uint32_t const k[4]= {2,2,3,4}; int n= 2; //n的绝对值表示v的长度，取正表示加密，取负表示解密 // v为要加密的数据是两个32位无符号整数 // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位 printf("加密前原始数据：%u %u\n",v[0],v[1]); btea(v, n, k); printf("加密后的数据：%u %u\n",v[0],v[1]); btea(v, -n, k); printf("解密后的数据：%u %u\n",v[0],v[1]); return 0;
}
python实现
RC4
附上原理图片：
C++实现：
#include <iostream>
#include <Windows.h>
#include <time.h>
#include "rc4.h"
#define WIN32_LEAN_AND_MEANvoid rc4_setup(struct rc4_state* s, unsigned char* key, int length)
{int i, j, k, * m, a;s->x = 0;s->y = 0;m = s->m;for (i = 0; i < 256; i++){m[i] = i;}j = k = 0;for (i = 0; i < 256; i++){a = m[i];j = (unsigned char)(j + a + key[k]);m[i] = m[j]; m[j] = a;if (++k >= length) k = 0;}
}void rc4_crypt(struct rc4_state* s, unsigned char* data, int length)
{int i, x, y, * m, a, b;x = s->x;y = s->y;m = s->m;for (i = 0; i < length; i++){x = (unsigned char)(x + 1); a = m[x];y = (unsigned char)(y + a);m[x] = b = m[y];m[y] = a;data[i] ^= m[(unsigned char)(a + b)];}s->x = x;s->y = y;
}int main() {// real executionchar mykey[128] = { "12345678\0" };//char data[512] = { "vrvfvfvfvfvfv\0" };char data[512] = { "vfvdvdsfsfsfssff\0" };struct rc4_state* s;s = (struct rc4_state*)malloc(sizeof(struct rc4_state));rc4_setup(s, (unsigned char*)mykey, strlen(mykey));rc4_crypt(s, (unsigned char*)data, strlen(data));for (int i = 0; i < strlen(data); i++) {printf("0x%x, ", (UINT8*)(data[i] & 0xff));}printf("\n");printf("encrypt : %s\n", data);printf("%d\n", strcmp(data, ans));rc4_setup(s, (unsigned char*)mykey, strlen(mykey));rc4_crypt(s, (unsigned char*)data, strlen(data));printf("decrypt : %s\n", data);return (0);
}
python 实现：
# -*- coding: utf-8 -*-
# Author:0verWatchimport base64def get_message():print("输入你的信息：")s = input()return sdef get_key():print("输入你的秘钥：")key = input()if key == '':key = 'none_public_key'return keydef init_box(key):"""S盒"""s_box = list(range(256)) #我这里没管秘钥小于256的情况，小于256应该不断重复填充即可j = 0for i in range(256):j = (j + s_box[i] + ord(key[i % len(key)])) % 256s_box[i], s_box[j] = s_box[j], s_box[i]#print(type(s_box)) #for_testreturn s_boxdef ex_encrypt(plain,box,mode):"""利用PRGA生成秘钥流并与密文字节异或，加解密同一个算法"""if mode == '2':while True:c_mode = input("输入你的解密模式:Base64 or ordinary\n")if c_mode == 'Base64':plain = base64.b64decode(plain)plain = bytes.decode(plain)breakelif c_mode == 'ordinary':plain = plainbreakelse:print("Something Wrong,请重新新输入")continueres = []i = j =0for s in plain:i = (i + 1) %256j = (j + box[i]) %256box[i], box[j] = box[j], box[i]t = (box[i] + box[j])% 256k = box[t]print(hex(ord(s)^k),end=' ')res.append(chr(ord(s)^k))cipher = "".join(res)#print(cipher)if mode == '1':# 化成可视字符需要编码print("加密后的输出(没经过任何编码):")print(cipher)# base64的目的也是为了变成可见字符print("base64后的编码:")print(str(base64.b64encode(cipher.encode('utf-8')),'utf-8'))if mode == '2':print("解密后的密文：")print(cipher)def get_mode():print("请选择加密或者解密")print("1. Encrypt")print("2. Decode")mode = input()if mode == '1':message = get_message()key = get_key()box = init_box(key)ex_encrypt(message,box,mode)elif mode == '2':message = get_message()key = get_key()box = init_box(key)ex_encrypt(message, box, mode)else:print("输入有误！")if __name__ == '__main__':while True:get_mode()AES
AES ECB
原理：
- –>
- –>
- –>
C++：
/************************************************************************* > File Name: AES.cpp > Author: SongLee > E-mail: lisong.shine@qq > Created Time: 2014年12月12日 星期五 20时15分50秒 > Personal Blog: ************************************************************************/
#include <iostream>
#include <bitset>
#include <string>
using namespace std;
typedef bitset<8> byte;
typedef bitset<32> word;const int Nr = 10; // AES-128需要 10 轮加密
const int Nk = 4; // Nk 表示输入密钥的 word 个数byte S_Box[16][16] = {{0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76},{0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0},{0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15},{0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75},{0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84},{0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF},{0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8},{0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2},{0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73},{0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB},{0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79},{0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08},{0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A},{0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E},{0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF},{0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16}
};byte Inv_S_Box[16][16] = {{0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB},{0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB},{0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E},{0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25},{0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92},{0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84},{0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06},{0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B},{0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73},{0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E},{0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B},{0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4},{0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F},{0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF},{0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61},{0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D}
};// 轮常数，密钥扩展中用到。（AES-128只需要10轮）
word Rcon[10] = {0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000};/**********************************************************************/
/* */
/* AES算法实现 */
/* */
/**********************************************************************/ /******************************下面是加密的变换函数**********************/
/*** S盒变换 - 前4位为行号，后4位为列号*/
void SubBytes(byte mtx[4*4])
{for(int i=0; i<16; ++i){int row = mtx[i][7]*8 + mtx[i][6]*4 + mtx[i][5]*2 + mtx[i][4];int col = mtx[i][3]*8 + mtx[i][2]*4 + mtx[i][1]*2 + mtx[i][0];mtx[i] = S_Box[row][col];}
}/*** 行变换 - 按字节循环移位*/
void ShiftRows(byte mtx[4*4])
{// 第二行循环左移一位byte temp = mtx[4];for(int i=0; i<3; ++i)mtx[i+4] = mtx[i+5];mtx[7] = temp;// 第三行循环左移两位for(int i=0; i<2; ++i){temp = mtx[i+8];mtx[i+8] = mtx[i+10];mtx[i+10] = temp;}// 第四行循环左移三位temp = mtx[15];for(int i=3; i>0; --i)mtx[i+12] = mtx[i+11];mtx[12] = temp;
}/*** 有限域上的乘法 GF(2^8)*/
byte GFMul(byte a, byte b) { byte p = 0;byte hi_bit_set;for (int counter = 0; counter < 8; counter++) {if ((b & byte(1)) != 0) {p ^= a;}hi_bit_set = (byte) (a & byte(0x80));a <<= 1;if (hi_bit_set != 0) {a ^= 0x1b; /* x^8 + x^4 + x^3 + x + 1 */}b >>= 1;}return p;
}/*** 列变换*/
void MixColumns(byte mtx[4*4])
{byte arr[4];for(int i=0; i<4; ++i){for(int j=0; j<4; ++j)arr[j] = mtx[i+j*4];mtx[i] = GFMul(0x02, arr[0]) ^ GFMul(0x03, arr[1]) ^ arr[2] ^ arr[3];mtx[i+4] = arr[0] ^ GFMul(0x02, arr[1]) ^ GFMul(0x03, arr[2]) ^ arr[3];mtx[i+8] = arr[0] ^ arr[1] ^ GFMul(0x02, arr[2]) ^ GFMul(0x03, arr[3]);mtx[i+12] = GFMul(0x03, arr[0]) ^ arr[1] ^ arr[2] ^ GFMul(0x02, arr[3]);}
}/*** 轮密钥加变换 - 将每一列与扩展密钥进行异或*/
void AddRoundKey(byte mtx[4*4], word k[4])
{for(int i=0; i<4; ++i){word k1 = k[i] >> 24;word k2 = (k[i] << 8) >> 24;word k3 = (k[i] << 16) >> 24;word k4 = (k[i] << 24) >> 24;mtx[i] = mtx[i] ^ byte(k1.to_ulong());mtx[i+4] = mtx[i+4] ^ byte(k2.to_ulong());mtx[i+8] = mtx[i+8] ^ byte(k3.to_ulong());mtx[i+12] = mtx[i+12] ^ byte(k4.to_ulong());}
}/**************************下面是解密的逆变换函数***********************/
/*** 逆S盒变换*/
void InvSubBytes(byte mtx[4*4])
{for(int i=0; i<16; ++i){int row = mtx[i][7]*8 + mtx[i][6]*4 + mtx[i][5]*2 + mtx[i][4];int col = mtx[i][3]*8 + mtx[i][2]*4 + mtx[i][1]*2 + mtx[i][0];mtx[i] = Inv_S_Box[row][col];}
}/*** 逆行变换 - 以字节为单位循环右移*/
void InvShiftRows(byte mtx[4*4])
{// 第二行循环右移一位byte temp = mtx[7];for(int i=3; i>0; --i)mtx[i+4] = mtx[i+3];mtx[4] = temp;// 第三行循环右移两位for(int i=0; i<2; ++i){temp = mtx[i+8];mtx[i+8] = mtx[i+10];mtx[i+10] = temp;}// 第四行循环右移三位temp = mtx[12];for(int i=0; i<3; ++i)mtx[i+12] = mtx[i+13];mtx[15] = temp;
}void InvMixColumns(byte mtx[4*4])
{byte arr[4];for(int i=0; i<4; ++i){for(int j=0; j<4; ++j)arr[j] = mtx[i+j*4];mtx[i] = GFMul(0x0e, arr[0]) ^ GFMul(0x0b, arr[1]) ^ GFMul(0x0d, arr[2]) ^ GFMul(0x09, arr[3]);mtx[i+4] = GFMul(0x09, arr[0]) ^ GFMul(0x0e, arr[1]) ^ GFMul(0x0b, arr[2]) ^ GFMul(0x0d, arr[3]);mtx[i+8] = GFMul(0x0d, arr[0]) ^ GFMul(0x09, arr[1]) ^ GFMul(0x0e, arr[2]) ^ GFMul(0x0b, arr[3]);mtx[i+12] = GFMul(0x0b, arr[0]) ^ GFMul(0x0d, arr[1]) ^ GFMul(0x09, arr[2]) ^ GFMul(0x0e, arr[3]);}
}/******************************下面是密钥扩展部分***********************/
/*** 将4个 byte 转换为一个 word.*/
word Word(byte& k1, byte& k2, byte& k3, byte& k4)
{word result(0x00000000);word temp;temp = k1.to_ulong(); // K1temp <<= 24;result |= temp;temp = k2.to_ulong(); // K2temp <<= 16;result |= temp;temp = k3.to_ulong(); // K3temp <<= 8;result |= temp;temp = k4.to_ulong(); // K4result |= temp;return result;
}/*** 按字节 循环左移一位* 即把[a0, a1, a2, a3]变成[a1, a2, a3, a0]*/
word RotWord(word& rw)
{word high = rw << 8;word low = rw >> 24;return high | low;
}/*** 对输入word中的每一个字节进行S-盒变换*/
word SubWord(word& sw)
{word temp;for(int i=0; i<32; i+=8){int row = sw[i+7]*8 + sw[i+6]*4 + sw[i+5]*2 + sw[i+4];int col = sw[i+3]*8 + sw[i+2]*4 + sw[i+1]*2 + sw[i];byte val = S_Box[row][col];for(int j=0; j<8; ++j)temp[i+j] = val[j];}return temp;
}/*** 密钥扩展函数 - 对128位密钥进行扩展得到 w[4*(Nr+1)]*/
void KeyExpansion(byte key[4*Nk], word w[4*(Nr+1)])
{word temp;int i = 0;// w[]的前4个就是输入的keywhile(i < Nk) {w[i] = Word(key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]);++i;}i = Nk;while(i < 4*(Nr+1)){temp = w[i-1]; // 记录前一个wordif(i % Nk == 0)w[i] = w[i-Nk] ^ SubWord(RotWord(temp)) ^ Rcon[i/Nk-1];else w[i] = w[i-Nk] ^ temp;++i;}
}/******************************下面是加密和解密函数**************************/
/*** 加密*/
void encrypt(byte in[4*4], word w[4*(Nr+1)])
{word key[4];for(int i=0; i<4; ++i)key[i] = w[i];AddRoundKey(in, key);for(int round=1; round<Nr; ++round){SubBytes(in);ShiftRows(in);MixColumns(in);for(int i=0; i<4; ++i)key[i] = w[4*round+i];AddRoundKey(in, key);}SubBytes(in);ShiftRows(in);for(int i=0; i<4; ++i)key[i] = w[4*Nr+i];AddRoundKey(in, key);
}/*** 解密*/
void decrypt(byte in[4*4], word w[4*(Nr+1)])
{word key[4];for(int i=0; i<4; ++i)key[i] = w[4*Nr+i];AddRoundKey(in, key);for(int round=Nr-1; round>0; --round){InvShiftRows(in);InvSubBytes(in);for(int i=0; i<4; ++i)key[i] = w[4*round+i];AddRoundKey(in, key);InvMixColumns(in);}InvShiftRows(in);InvSubBytes(in);for(int i=0; i<4; ++i)key[i] = w[i];AddRoundKey(in, key);
}/**********************************************************************/
/* */
/* 测试 */
/* */
/**********************************************************************/
int main()
{byte key[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};byte plain[16] = {0x32, 0x88, 0x31, 0xe0, 0x43, 0x5a, 0x31, 0x37,0xf6, 0x30, 0x98, 0x07,0xa8, 0x8d, 0xa2, 0x34}; // 输出密钥cout << "密钥是：";for(int i=0; i<16; ++i)cout << hex << key[i].to_ulong() << " ";cout << endl;word w[4*(Nr+1)];KeyExpansion(key, w);// 输出待加密的明文cout << endl << "待加密的明文："<<endl;for(int i=0; i<16; ++i){cout << hex << plain[i].to_ulong() << " ";if((i+1)%4 == 0)cout << endl;}cout << endl;// 加密，输出密文encrypt(plain, w);cout << "加密后的密文："<<endl;for(int i=0; i<16; ++i){cout << hex << plain[i].to_ulong() << " ";if((i+1)%4 == 0)cout << endl;}cout << endl;// 解密，输出明文decrypt(plain, w);cout << "解密后的明文："<<endl;for(int i=0; i<16; ++i){cout << hex << plain[i].to_ulong() << " ";if((i+1)%4 == 0)cout << endl;}cout << endl;return 0;
}
python：
from Crypto.Cipher import AES
from Crypto.Util.number import long_to_bytes, bytes_to_long
import sys
show = NONEdef aes_enc(m, key):H = AES.new(key, AES.MODE_ECB)return H.encrypt(m)def aes_dec(c, key):H = AES.new(key, AES.MODE_ECB)return H.decrypt(c)def check_encrypt():c = "5658a9ced4f5415d3e85e2e879d464405658a9ced4f5415d3e85e2e879d46440"key = long_to_bytes(0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)#print aes_enc(c, key).encode('hex')print aes_dec(c.strip().decode("hex"), key).encode('hex')c = "2020202020202020202020202020202020202020202020202020202020202020"key = long_to_bytes(0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)print aes_enc(c.strip().decode("hex"), key).encode('hex')#print aes_dec(c.strip().decode("hex"), key).encode('hex')check_encrypt()
C实现：
#include <stdint.h>
#include <stdio.h>
#include <string.h>typedef struct {uint32_t eK[44], dK[44]; // encKey, decKeyint Nr; // 10 rounds
}AesKey;#define BLOCKSIZE 16 //AES-128分组长度为16字节// uint8_t y[4] -> uint32_t x
#define LOAD32H(x, y) \do { (x) = ((uint32_t)((y)[0] & 0xff)<<24) | ((uint32_t)((y)[1] & 0xff)<<16) | \((uint32_t)((y)[2] & 0xff)<<8) | ((uint32_t)((y)[3] & 0xff));} while(0)// uint32_t x -> uint8_t y[4]
#define STORE32H(x, y) \do { (y)[0] = (uint8_t)(((x)>>24) & 0xff); (y)[1] = (uint8_t)(((x)>>16) & 0xff); \(y)[2] = (uint8_t)(((x)>>8) & 0xff); (y)[3] = (uint8_t)((x) & 0xff); } while(0)// 从uint32_t x中提取从低位开始的第n个字节
#define BYTE(x, n) (((x) >> (8 * (n))) & 0xff)/* used for keyExpansion */
// 字节替换然后循环左移1位
#define MIX(x) (((S[BYTE(x, 2)] << 24) & 0xff000000) ^ ((S[BYTE(x, 1)] << 16) & 0xff0000) ^ \((S[BYTE(x, 0)] << 8) & 0xff00) ^ (S[BYTE(x, 3)] & 0xff))// uint32_t x循环左移n位
#define ROF32(x, n) (((x) << (n)) | ((x) >> (32-(n))))
// uint32_t x循环右移n位
#define ROR32(x, n) (((x) >> (n)) | ((x) << (32-(n))))/* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
// AES-128轮常量
static const uint32_t rcon[10] = {0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
};
// S盒
unsigned char S[256] = {0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
};//逆S盒
unsigned char inv_S[256] = {0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};/* copy in[16] to state[4][4] */
int loadStateArray(uint8_t(*state)[4], const uint8_t* in) {for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[j][i] = *in++;}}return 0;
}/* copy state[4][4] to out[16] */
int storeStateArray(uint8_t(*state)[4], uint8_t* out) {for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {*out++ = state[j][i];}}return 0;
}
//秘钥扩展
int keyExpansion(const uint8_t* key, uint32_t keyLen, AesKey* aesKey) {if (NULL == key || NULL == aesKey) {printf("keyExpansion param is NULL\n");return -1;}if (keyLen != 16) {printf("keyExpansion keyLen = %d, Not support.\n", keyLen);return -1;}uint32_t* w = aesKey->eK; //加密秘钥uint32_t* v = aesKey->dK; //解密秘钥/* keyLen is 16 Bytes, generate uint32_t W[44]. *//* W[0-3] */for (int i = 0; i < 4; ++i) {LOAD32H(w[i], key + 4 * i);}/* W[4-43] */for (int i = 0; i < 10; ++i) {w[4] = w[0] ^ MIX(w[3]) ^ rcon[i];w[5] = w[1] ^ w[4];w[6] = w[2] ^ w[5];w[7] = w[3] ^ w[6];w += 4;}w = aesKey->eK + 44 - 4;//解密秘钥矩阵为加密秘钥矩阵的倒序，方便使用，把ek的11个矩阵倒序排列分配给dk作为解密秘钥//即dk[0-3]=ek[41-44], dk[4-7]=ek[37-40]... dk[41-44]=ek[0-3]for (int j = 0; j < 11; ++j) {for (int i = 0; i < 4; ++i) {v[i] = w[i];}w -= 4;v += 4;}return 0;
}// 轮秘钥加
int addRoundKey(uint8_t(*state)[4], const uint32_t* key) {uint8_t k[4][4];/* i: row, j: col */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {k[i][j] = (uint8_t)BYTE(key[j], 3 - i); /* 把 uint32 key[4] 先转换为矩阵 uint8 k[4][4] */state[i][j] ^= k[i][j];}}return 0;
}//字节替换
int subBytes(uint8_t(*state)[4]) {/* i: row, j: col */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[i][j] = S[state[i][j]]; //直接使用原始字节作为S盒数据下标}}return 0;
}//逆字节替换
int invSubBytes(uint8_t(*state)[4]) {/* i: row, j: col */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[i][j] = inv_S[state[i][j]];}}return 0;
}//行移位
int shiftRows(uint8_t(*state)[4]) {uint32_t block[4] = { 0 };/* i: row */for (int i = 0; i < 4; ++i) {//便于行循环移位，先把一行4字节拼成uint_32结构，移位后再转成独立的4个字节uint8_tLOAD32H(block[i], state[i]);block[i] = ROF32(block[i], 8 * i);STORE32H(block[i], state[i]);}return 0;
}//逆行移位
int invShiftRows(uint8_t(*state)[4]) {uint32_t block[4] = { 0 };/* i: row */for (int i = 0; i < 4; ++i) {LOAD32H(block[i], state[i]);block[i] = ROR32(block[i], 8 * i);STORE32H(block[i], state[i]);}return 0;
}/* Galois Field (256) Multiplication of two Bytes */
// 两字节的伽罗华域乘法运算
uint8_t GMul(uint8_t u, uint8_t v) {uint8_t p = 0;for (int i = 0; i < 8; ++i) {if (u & 0x01) { //p ^= v;}int flag = (v & 0x80);v <<= 1;if (flag) {v ^= 0x1B; /* x^8 + x^4 + x^3 + x + 1 */}u >>= 1;}return p;
}// 列混合
int mixColumns(uint8_t(*state)[4]) {uint8_t tmp[4][4];uint8_t M[4][4] = { {0x02, 0x03, 0x01, 0x01},{0x01, 0x02, 0x03, 0x01},{0x01, 0x01, 0x02, 0x03},{0x03, 0x01, 0x01, 0x02} };/* copy state[4][4] to tmp[4][4] */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {tmp[i][j] = state[i][j];}}for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) { //伽罗华域加法和乘法state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j])^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j]);}}return 0;
}// 逆列混合
int invMixColumns(uint8_t(*state)[4]) {uint8_t tmp[4][4];uint8_t M[4][4] = { {0x0E, 0x0B, 0x0D, 0x09},{0x09, 0x0E, 0x0B, 0x0D},{0x0D, 0x09, 0x0E, 0x0B},{0x0B, 0x0D, 0x09, 0x0E} }; //使用列混合矩阵的逆矩阵/* copy state[4][4] to tmp[4][4] */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {tmp[i][j] = state[i][j];}}for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j])^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j]);}}return 0;
}// AES-128加密接口，输入key应为16字节长度，输入长度应该是16字节整倍数，
// 这样输出长度与输入长度相同，函数调用外部为输出数据分配内存
int aesEncrypt(const uint8_t* key, uint32_t keyLen, const uint8_t* pt, uint8_t* ct, uint32_t len) {AesKey aesKey;uint8_t* pos = ct;const uint32_t* rk = aesKey.eK; //解密秘钥指针uint8_t out[BLOCKSIZE] = { 0 };uint8_t actualKey[16] = { 0 };uint8_t state[4][4] = { 0 };if (NULL == key || NULL == pt || NULL == ct) {printf("param err.\n");return -1;}if (keyLen > 16) {printf("keyLen must be 16.\n");return -1;}if (len % BLOCKSIZE) {printf("inLen is invalid.\n");return -1;}memcpy(actualKey, key, keyLen);keyExpansion(actualKey, 16, &aesKey); // 秘钥扩展// 使用ECB模式循环加密多个分组长度的数据for (int i = 0; i < len; i += BLOCKSIZE) {// 把16字节的明文转换为4x4状态矩阵来进行处理loadStateArray(state, pt);// 轮秘钥加addRoundKey(state, rk);for (int j = 1; j < 10; ++j) {rk += 4;subBytes(state); // 字节替换shiftRows(state); // 行移位mixColumns(state); // 列混合addRoundKey(state, rk); // 轮秘钥加}subBytes(state); // 字节替换shiftRows(state); // 行移位// 此处不进行列混合addRoundKey(state, rk + 4); // 轮秘钥加// 把4x4状态矩阵转换为uint8_t一维数组输出保存storeStateArray(state, pos);pos += BLOCKSIZE; // 加密数据内存指针移动到下一个分组pt += BLOCKSIZE; // 明文数据指针移动到下一个分组rk = aesKey.eK; // 恢复rk指针到秘钥初始位置}return 0;
}// AES128解密， 参数要求同加密
int aesDecrypt(const uint8_t* key, uint32_t keyLen, const uint8_t* ct, uint8_t* pt, uint32_t len) {AesKey aesKey;uint8_t* pos = pt;const uint32_t* rk = aesKey.dK; //解密秘钥指针uint8_t out[BLOCKSIZE] = { 0 };uint8_t actualKey[16] = { 0 };uint8_t state[4][4] = { 0 };if (NULL == key || NULL == ct || NULL == pt) {printf("param err.\n");return -1;}if (keyLen > 16) {printf("keyLen must be 16.\n");return -1;}if (len % BLOCKSIZE) {printf("inLen is invalid.\n");return -1;}memcpy(actualKey, key, keyLen);keyExpansion(actualKey, 16, &aesKey); //秘钥扩展，同加密for (int i = 0; i < len; i += BLOCKSIZE) {// 把16字节的密文转换为4x4状态矩阵来进行处理loadStateArray(state, ct);// 轮秘钥加，同加密addRoundKey(state, rk);for (int j = 1; j < 10; ++j) {rk += 4;invShiftRows(state); // 逆行移位invSubBytes(state); // 逆字节替换，这两步顺序可以颠倒addRoundKey(state, rk); // 轮秘钥加，同加密invMixColumns(state); // 逆列混合}invSubBytes(state); // 逆字节替换invShiftRows(state); // 逆行移位// 此处没有逆列混合addRoundKey(state, rk + 4); // 轮秘钥加，同加密storeStateArray(state, pos); // 保存明文数据pos += BLOCKSIZE; // 输出数据内存指针移位分组长度ct += BLOCKSIZE; // 输入数据内存指针移位分组长度rk = aesKey.dK; // 恢复rk指针到秘钥初始位置}return 0;
}
// 方便输出16进制数据
void printHex(uint8_t* ptr, int len, char* tag) {printf("%s\ndata[%d]: ", tag, len);for (int i = 0; i < len; ++i) {printf("%.2X ", *ptr++);}printf("\n");
}int main() {// case 1const 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(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:"); // 打印解密后的明文数据// 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;
}RSA
RSA常用攻击方式 –>
python：
import primefac
from Crypto.Util.number import long_to_bytes, bytes_to_longp = 0xf22ac0b157f14abe6fd077b9e10aaf44e1a9fcbe5275a1188672a05baaf6e49599af0b2c8a51d2c9d7f3ecbbc388bbdd0d8ddca52254f551d02ee258e0c30505c5bcd281726a6084c342bb1a61d37b627ef3501a95a80ec432cc7f05a864302c159991373568926dd62d6ea310c8768289d8d1ee1afc94f9ef8654ca63f3498dLq = 0xb60a50ac3362a7a75acef9a78e4a009bf5e106a5928ba259050d6cc37b91549b2be76c163792fdcdf9c517bd05d4db6dfc10db599887a1c990d6bef3e9bf41a111bee23d72b64c15e5066ba5cc3c7782ebd9aca20a17be7980947e977a20f9c0af347f4cab4c249f8c39cff1849a7eac5e9a56612735072f58e801b5fd679dc1Ln = 0xac3426f9dcffb48c184f40c7e99bbf8cea568de21ae9a752d6a45ce75f67c1c3b199399979d2ed45acde9155d46c043826b0c8cfb3be97d5154ad3eb4467d3e6b6df3455eb480ed02a318cfd88415a56732029d323c574bd1198793175197ac5076440624f23281d64a7cf42f3ccf9257bbf10fefd60e4263c4a01935f0f6a1ce64c5041cbd81d32fbf71545df8a39e0625825fd331028431318cb562211a890ac60c47eae623932ebea5452d77f2d05047fea9d47f6699707527772b0d8dfd53de355a67277fe0e820d29d8a341ba27046b9ee292b987b0a2d10eeab6318167eaafdd577a6df6be135c633c85bc69bf52816b563204084dd69040257f40ec4dLe = 0x10001d = primefac.modinv(e, (p - 1) * (q - 1)) % ((p - 1) * (q - 1))print "q4"m = pow(c, d, n)key = long_to_bytes(m)
各种密码算法记录
TEA
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; /* set up */ uint32_t delta=0x9e3779b9; /* a key schedule constant */ uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */ for (i=0; i < 32; i++) { /* basic cycle start */ sum += delta; v0 += ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1); v1 += ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3); } /* end cycle */ 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; /* set up */ uint32_t delta=0x9e3779b9; /* a key schedule constant */ uint32_t k0=k[0], k1=k[1], k2=k[2], k3=k[3]; /* cache key */ for (i=0; i<32; i++) { /* basic cycle start */ v1 -= ((v0<<4) + k2) ^ (v0 + sum) ^ ((v0>>5) + k3); v0 -= ((v1<<4) + k0) ^ (v1 + sum) ^ ((v1>>5) + k1); sum -= delta; } /* end cycle */ v[0]=v0; v[1]=v1;
} int main()
{ uint32_t v[2]={1,2},k[4]={2,2,3,4}; // v为要加密的数据是两个32位无符号整数 // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位 printf("加密前原始数据：%u %u\n",v[0],v[1]); encrypt(v, k); printf("加密后的数据：%u %u\n",v[0],v[1]); decrypt(v, k); printf("解密后的数据：%u %u\n",v[0],v[1]); return 0;
}
//加密前原始数据：1 2
//加密后的数据：1347371722 925494771
//解密后的数据：1 2 XTea
XTEA是TEA的升级版，增加了更多的密钥表，移位和异或操作等等，设计者是Roger Needham, David Wheeler
XTEA是TEA的扩展，也称做TEAN，它使用与TEA相同的简单运算，同样是一个64位块的Feistel密码，使用128位密钥，建议32轮, 但四个子密钥采取不正规的方式进行混合以阻止密钥表攻击。
c实现：
#include <stdio.h>
#include <stdint.h> /* take 64 bits of data in v[0] and v[1] and 128 bits of key[0] - key[3] */ void encipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) { unsigned int i; uint32_t v0=v[0], v1=v[1], sum=0, delta=0x9E3779B9; for (i=0; i < num_rounds; i++) { v0 += (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]); sum += delta; v1 += (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]); } v[0]=v0; v[1]=v1;
} void decipher(unsigned int num_rounds, uint32_t v[2], uint32_t const key[4]) { unsigned int i; uint32_t v0=v[0], v1=v[1], delta=0x9E3779B9, sum=delta*num_rounds; for (i=0; i < num_rounds; i++) { v1 -= (((v0 << 4) ^ (v0 >> 5)) + v0) ^ (sum + key[(sum>>11) & 3]); sum -= delta; v0 -= (((v1 << 4) ^ (v1 >> 5)) + v1) ^ (sum + key[sum & 3]); } v[0]=v0; v[1]=v1;
} int main()
{ uint32_t v[2]={1,2}; uint32_t const k[4]={2,2,3,4}; unsigned int r=32;//num_rounds建议取值为32 // v为要加密的数据是两个32位无符号整数 // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位 printf("加密前原始数据：%u %u\n",v[0],v[1]); encipher(r, v, k); printf("加密后的数据：%u %u\n",v[0],v[1]); decipher(r, v, k); printf("解密后的数据：%u %u\n",v[0],v[1]); return 0;
}
XXTea
c实现：
#include <stdio.h>
#include <stdint.h>
#define DELTA 0x9e3779b9
#define MX (((z>>5^y<<2) + (y>>3^z<<4)) ^ ((sum^y) + (key[(p&3)^e] ^ z))) void btea(uint32_t *v, int n, uint32_t const key[4])
{ uint32_t y, z, sum; unsigned p, rounds, e; if (n > 1) /* Coding Part */ { rounds = 6 + 52/n; sum = 0; z = v[n-1]; do { sum += DELTA; e = (sum >> 2) & 3; for (p=0; p<n-1; p++) { y = v[p+1]; z = v[p] += MX; } y = v[0]; z = v[n-1] += MX; } while (--rounds); } else if (n < -1) /* Decoding Part */ { n = -n; rounds = 6 + 52/n; sum = rounds*DELTA; y = v[0]; do { e = (sum >> 2) & 3; for (p=n-1; p>0; p--) { z = v[p-1]; y = v[p] -= MX; } z = v[n-1]; y = v[0] -= MX; sum -= DELTA; } while (--rounds); }
} int main()
{ uint32_t v[2]= {1,2}; uint32_t const k[4]= {2,2,3,4}; int n= 2; //n的绝对值表示v的长度，取正表示加密，取负表示解密 // v为要加密的数据是两个32位无符号整数 // k为加密解密密钥，为4个32位无符号整数，即密钥长度为128位 printf("加密前原始数据：%u %u\n",v[0],v[1]); btea(v, n, k); printf("加密后的数据：%u %u\n",v[0],v[1]); btea(v, -n, k); printf("解密后的数据：%u %u\n",v[0],v[1]); return 0;
}
python实现
RC4
附上原理图片：
C++实现：
#include <iostream>
#include <Windows.h>
#include <time.h>
#include "rc4.h"
#define WIN32_LEAN_AND_MEANvoid rc4_setup(struct rc4_state* s, unsigned char* key, int length)
{int i, j, k, * m, a;s->x = 0;s->y = 0;m = s->m;for (i = 0; i < 256; i++){m[i] = i;}j = k = 0;for (i = 0; i < 256; i++){a = m[i];j = (unsigned char)(j + a + key[k]);m[i] = m[j]; m[j] = a;if (++k >= length) k = 0;}
}void rc4_crypt(struct rc4_state* s, unsigned char* data, int length)
{int i, x, y, * m, a, b;x = s->x;y = s->y;m = s->m;for (i = 0; i < length; i++){x = (unsigned char)(x + 1); a = m[x];y = (unsigned char)(y + a);m[x] = b = m[y];m[y] = a;data[i] ^= m[(unsigned char)(a + b)];}s->x = x;s->y = y;
}int main() {// real executionchar mykey[128] = { "12345678\0" };//char data[512] = { "vrvfvfvfvfvfv\0" };char data[512] = { "vfvdvdsfsfsfssff\0" };struct rc4_state* s;s = (struct rc4_state*)malloc(sizeof(struct rc4_state));rc4_setup(s, (unsigned char*)mykey, strlen(mykey));rc4_crypt(s, (unsigned char*)data, strlen(data));for (int i = 0; i < strlen(data); i++) {printf("0x%x, ", (UINT8*)(data[i] & 0xff));}printf("\n");printf("encrypt : %s\n", data);printf("%d\n", strcmp(data, ans));rc4_setup(s, (unsigned char*)mykey, strlen(mykey));rc4_crypt(s, (unsigned char*)data, strlen(data));printf("decrypt : %s\n", data);return (0);
}
python 实现：
# -*- coding: utf-8 -*-
# Author:0verWatchimport base64def get_message():print("输入你的信息：")s = input()return sdef get_key():print("输入你的秘钥：")key = input()if key == '':key = 'none_public_key'return keydef init_box(key):"""S盒"""s_box = list(range(256)) #我这里没管秘钥小于256的情况，小于256应该不断重复填充即可j = 0for i in range(256):j = (j + s_box[i] + ord(key[i % len(key)])) % 256s_box[i], s_box[j] = s_box[j], s_box[i]#print(type(s_box)) #for_testreturn s_boxdef ex_encrypt(plain,box,mode):"""利用PRGA生成秘钥流并与密文字节异或，加解密同一个算法"""if mode == '2':while True:c_mode = input("输入你的解密模式:Base64 or ordinary\n")if c_mode == 'Base64':plain = base64.b64decode(plain)plain = bytes.decode(plain)breakelif c_mode == 'ordinary':plain = plainbreakelse:print("Something Wrong,请重新新输入")continueres = []i = j =0for s in plain:i = (i + 1) %256j = (j + box[i]) %256box[i], box[j] = box[j], box[i]t = (box[i] + box[j])% 256k = box[t]print(hex(ord(s)^k),end=' ')res.append(chr(ord(s)^k))cipher = "".join(res)#print(cipher)if mode == '1':# 化成可视字符需要编码print("加密后的输出(没经过任何编码):")print(cipher)# base64的目的也是为了变成可见字符print("base64后的编码:")print(str(base64.b64encode(cipher.encode('utf-8')),'utf-8'))if mode == '2':print("解密后的密文：")print(cipher)def get_mode():print("请选择加密或者解密")print("1. Encrypt")print("2. Decode")mode = input()if mode == '1':message = get_message()key = get_key()box = init_box(key)ex_encrypt(message,box,mode)elif mode == '2':message = get_message()key = get_key()box = init_box(key)ex_encrypt(message, box, mode)else:print("输入有误！")if __name__ == '__main__':while True:get_mode()AES
AES ECB
原理：
- –>
- –>
- –>
C++：
/************************************************************************* > File Name: AES.cpp > Author: SongLee > E-mail: lisong.shine@qq > Created Time: 2014年12月12日 星期五 20时15分50秒 > Personal Blog: ************************************************************************/
#include <iostream>
#include <bitset>
#include <string>
using namespace std;
typedef bitset<8> byte;
typedef bitset<32> word;const int Nr = 10; // AES-128需要 10 轮加密
const int Nk = 4; // Nk 表示输入密钥的 word 个数byte S_Box[16][16] = {{0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76},{0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0},{0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15},{0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75},{0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84},{0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF},{0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8},{0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2},{0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73},{0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB},{0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79},{0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08},{0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A},{0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E},{0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF},{0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16}
};byte Inv_S_Box[16][16] = {{0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB},{0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB},{0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E},{0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25},{0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92},{0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84},{0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06},{0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B},{0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73},{0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E},{0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B},{0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4},{0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F},{0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF},{0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61},{0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D}
};// 轮常数，密钥扩展中用到。（AES-128只需要10轮）
word Rcon[10] = {0x01000000, 0x02000000, 0x04000000, 0x08000000, 0x10000000, 0x20000000, 0x40000000, 0x80000000, 0x1b000000, 0x36000000};/**********************************************************************/
/* */
/* AES算法实现 */
/* */
/**********************************************************************/ /******************************下面是加密的变换函数**********************/
/*** S盒变换 - 前4位为行号，后4位为列号*/
void SubBytes(byte mtx[4*4])
{for(int i=0; i<16; ++i){int row = mtx[i][7]*8 + mtx[i][6]*4 + mtx[i][5]*2 + mtx[i][4];int col = mtx[i][3]*8 + mtx[i][2]*4 + mtx[i][1]*2 + mtx[i][0];mtx[i] = S_Box[row][col];}
}/*** 行变换 - 按字节循环移位*/
void ShiftRows(byte mtx[4*4])
{// 第二行循环左移一位byte temp = mtx[4];for(int i=0; i<3; ++i)mtx[i+4] = mtx[i+5];mtx[7] = temp;// 第三行循环左移两位for(int i=0; i<2; ++i){temp = mtx[i+8];mtx[i+8] = mtx[i+10];mtx[i+10] = temp;}// 第四行循环左移三位temp = mtx[15];for(int i=3; i>0; --i)mtx[i+12] = mtx[i+11];mtx[12] = temp;
}/*** 有限域上的乘法 GF(2^8)*/
byte GFMul(byte a, byte b) { byte p = 0;byte hi_bit_set;for (int counter = 0; counter < 8; counter++) {if ((b & byte(1)) != 0) {p ^= a;}hi_bit_set = (byte) (a & byte(0x80));a <<= 1;if (hi_bit_set != 0) {a ^= 0x1b; /* x^8 + x^4 + x^3 + x + 1 */}b >>= 1;}return p;
}/*** 列变换*/
void MixColumns(byte mtx[4*4])
{byte arr[4];for(int i=0; i<4; ++i){for(int j=0; j<4; ++j)arr[j] = mtx[i+j*4];mtx[i] = GFMul(0x02, arr[0]) ^ GFMul(0x03, arr[1]) ^ arr[2] ^ arr[3];mtx[i+4] = arr[0] ^ GFMul(0x02, arr[1]) ^ GFMul(0x03, arr[2]) ^ arr[3];mtx[i+8] = arr[0] ^ arr[1] ^ GFMul(0x02, arr[2]) ^ GFMul(0x03, arr[3]);mtx[i+12] = GFMul(0x03, arr[0]) ^ arr[1] ^ arr[2] ^ GFMul(0x02, arr[3]);}
}/*** 轮密钥加变换 - 将每一列与扩展密钥进行异或*/
void AddRoundKey(byte mtx[4*4], word k[4])
{for(int i=0; i<4; ++i){word k1 = k[i] >> 24;word k2 = (k[i] << 8) >> 24;word k3 = (k[i] << 16) >> 24;word k4 = (k[i] << 24) >> 24;mtx[i] = mtx[i] ^ byte(k1.to_ulong());mtx[i+4] = mtx[i+4] ^ byte(k2.to_ulong());mtx[i+8] = mtx[i+8] ^ byte(k3.to_ulong());mtx[i+12] = mtx[i+12] ^ byte(k4.to_ulong());}
}/**************************下面是解密的逆变换函数***********************/
/*** 逆S盒变换*/
void InvSubBytes(byte mtx[4*4])
{for(int i=0; i<16; ++i){int row = mtx[i][7]*8 + mtx[i][6]*4 + mtx[i][5]*2 + mtx[i][4];int col = mtx[i][3]*8 + mtx[i][2]*4 + mtx[i][1]*2 + mtx[i][0];mtx[i] = Inv_S_Box[row][col];}
}/*** 逆行变换 - 以字节为单位循环右移*/
void InvShiftRows(byte mtx[4*4])
{// 第二行循环右移一位byte temp = mtx[7];for(int i=3; i>0; --i)mtx[i+4] = mtx[i+3];mtx[4] = temp;// 第三行循环右移两位for(int i=0; i<2; ++i){temp = mtx[i+8];mtx[i+8] = mtx[i+10];mtx[i+10] = temp;}// 第四行循环右移三位temp = mtx[12];for(int i=0; i<3; ++i)mtx[i+12] = mtx[i+13];mtx[15] = temp;
}void InvMixColumns(byte mtx[4*4])
{byte arr[4];for(int i=0; i<4; ++i){for(int j=0; j<4; ++j)arr[j] = mtx[i+j*4];mtx[i] = GFMul(0x0e, arr[0]) ^ GFMul(0x0b, arr[1]) ^ GFMul(0x0d, arr[2]) ^ GFMul(0x09, arr[3]);mtx[i+4] = GFMul(0x09, arr[0]) ^ GFMul(0x0e, arr[1]) ^ GFMul(0x0b, arr[2]) ^ GFMul(0x0d, arr[3]);mtx[i+8] = GFMul(0x0d, arr[0]) ^ GFMul(0x09, arr[1]) ^ GFMul(0x0e, arr[2]) ^ GFMul(0x0b, arr[3]);mtx[i+12] = GFMul(0x0b, arr[0]) ^ GFMul(0x0d, arr[1]) ^ GFMul(0x09, arr[2]) ^ GFMul(0x0e, arr[3]);}
}/******************************下面是密钥扩展部分***********************/
/*** 将4个 byte 转换为一个 word.*/
word Word(byte& k1, byte& k2, byte& k3, byte& k4)
{word result(0x00000000);word temp;temp = k1.to_ulong(); // K1temp <<= 24;result |= temp;temp = k2.to_ulong(); // K2temp <<= 16;result |= temp;temp = k3.to_ulong(); // K3temp <<= 8;result |= temp;temp = k4.to_ulong(); // K4result |= temp;return result;
}/*** 按字节 循环左移一位* 即把[a0, a1, a2, a3]变成[a1, a2, a3, a0]*/
word RotWord(word& rw)
{word high = rw << 8;word low = rw >> 24;return high | low;
}/*** 对输入word中的每一个字节进行S-盒变换*/
word SubWord(word& sw)
{word temp;for(int i=0; i<32; i+=8){int row = sw[i+7]*8 + sw[i+6]*4 + sw[i+5]*2 + sw[i+4];int col = sw[i+3]*8 + sw[i+2]*4 + sw[i+1]*2 + sw[i];byte val = S_Box[row][col];for(int j=0; j<8; ++j)temp[i+j] = val[j];}return temp;
}/*** 密钥扩展函数 - 对128位密钥进行扩展得到 w[4*(Nr+1)]*/
void KeyExpansion(byte key[4*Nk], word w[4*(Nr+1)])
{word temp;int i = 0;// w[]的前4个就是输入的keywhile(i < Nk) {w[i] = Word(key[4*i], key[4*i+1], key[4*i+2], key[4*i+3]);++i;}i = Nk;while(i < 4*(Nr+1)){temp = w[i-1]; // 记录前一个wordif(i % Nk == 0)w[i] = w[i-Nk] ^ SubWord(RotWord(temp)) ^ Rcon[i/Nk-1];else w[i] = w[i-Nk] ^ temp;++i;}
}/******************************下面是加密和解密函数**************************/
/*** 加密*/
void encrypt(byte in[4*4], word w[4*(Nr+1)])
{word key[4];for(int i=0; i<4; ++i)key[i] = w[i];AddRoundKey(in, key);for(int round=1; round<Nr; ++round){SubBytes(in);ShiftRows(in);MixColumns(in);for(int i=0; i<4; ++i)key[i] = w[4*round+i];AddRoundKey(in, key);}SubBytes(in);ShiftRows(in);for(int i=0; i<4; ++i)key[i] = w[4*Nr+i];AddRoundKey(in, key);
}/*** 解密*/
void decrypt(byte in[4*4], word w[4*(Nr+1)])
{word key[4];for(int i=0; i<4; ++i)key[i] = w[4*Nr+i];AddRoundKey(in, key);for(int round=Nr-1; round>0; --round){InvShiftRows(in);InvSubBytes(in);for(int i=0; i<4; ++i)key[i] = w[4*round+i];AddRoundKey(in, key);InvMixColumns(in);}InvShiftRows(in);InvSubBytes(in);for(int i=0; i<4; ++i)key[i] = w[i];AddRoundKey(in, key);
}/**********************************************************************/
/* */
/* 测试 */
/* */
/**********************************************************************/
int main()
{byte key[16] = {0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6, 0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c};byte plain[16] = {0x32, 0x88, 0x31, 0xe0, 0x43, 0x5a, 0x31, 0x37,0xf6, 0x30, 0x98, 0x07,0xa8, 0x8d, 0xa2, 0x34}; // 输出密钥cout << "密钥是：";for(int i=0; i<16; ++i)cout << hex << key[i].to_ulong() << " ";cout << endl;word w[4*(Nr+1)];KeyExpansion(key, w);// 输出待加密的明文cout << endl << "待加密的明文："<<endl;for(int i=0; i<16; ++i){cout << hex << plain[i].to_ulong() << " ";if((i+1)%4 == 0)cout << endl;}cout << endl;// 加密，输出密文encrypt(plain, w);cout << "加密后的密文："<<endl;for(int i=0; i<16; ++i){cout << hex << plain[i].to_ulong() << " ";if((i+1)%4 == 0)cout << endl;}cout << endl;// 解密，输出明文decrypt(plain, w);cout << "解密后的明文："<<endl;for(int i=0; i<16; ++i){cout << hex << plain[i].to_ulong() << " ";if((i+1)%4 == 0)cout << endl;}cout << endl;return 0;
}
python：
from Crypto.Cipher import AES
from Crypto.Util.number import long_to_bytes, bytes_to_long
import sys
show = NONEdef aes_enc(m, key):H = AES.new(key, AES.MODE_ECB)return H.encrypt(m)def aes_dec(c, key):H = AES.new(key, AES.MODE_ECB)return H.decrypt(c)def check_encrypt():c = "5658a9ced4f5415d3e85e2e879d464405658a9ced4f5415d3e85e2e879d46440"key = long_to_bytes(0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)#print aes_enc(c, key).encode('hex')print aes_dec(c.strip().decode("hex"), key).encode('hex')c = "2020202020202020202020202020202020202020202020202020202020202020"key = long_to_bytes(0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb)print aes_enc(c.strip().decode("hex"), key).encode('hex')#print aes_dec(c.strip().decode("hex"), key).encode('hex')check_encrypt()
C实现：
#include <stdint.h>
#include <stdio.h>
#include <string.h>typedef struct {uint32_t eK[44], dK[44]; // encKey, decKeyint Nr; // 10 rounds
}AesKey;#define BLOCKSIZE 16 //AES-128分组长度为16字节// uint8_t y[4] -> uint32_t x
#define LOAD32H(x, y) \do { (x) = ((uint32_t)((y)[0] & 0xff)<<24) | ((uint32_t)((y)[1] & 0xff)<<16) | \((uint32_t)((y)[2] & 0xff)<<8) | ((uint32_t)((y)[3] & 0xff));} while(0)// uint32_t x -> uint8_t y[4]
#define STORE32H(x, y) \do { (y)[0] = (uint8_t)(((x)>>24) & 0xff); (y)[1] = (uint8_t)(((x)>>16) & 0xff); \(y)[2] = (uint8_t)(((x)>>8) & 0xff); (y)[3] = (uint8_t)((x) & 0xff); } while(0)// 从uint32_t x中提取从低位开始的第n个字节
#define BYTE(x, n) (((x) >> (8 * (n))) & 0xff)/* used for keyExpansion */
// 字节替换然后循环左移1位
#define MIX(x) (((S[BYTE(x, 2)] << 24) & 0xff000000) ^ ((S[BYTE(x, 1)] << 16) & 0xff0000) ^ \((S[BYTE(x, 0)] << 8) & 0xff00) ^ (S[BYTE(x, 3)] & 0xff))// uint32_t x循环左移n位
#define ROF32(x, n) (((x) << (n)) | ((x) >> (32-(n))))
// uint32_t x循环右移n位
#define ROR32(x, n) (((x) >> (n)) | ((x) << (32-(n))))/* for 128-bit blocks, Rijndael never uses more than 10 rcon values */
// AES-128轮常量
static const uint32_t rcon[10] = {0x01000000UL, 0x02000000UL, 0x04000000UL, 0x08000000UL, 0x10000000UL,0x20000000UL, 0x40000000UL, 0x80000000UL, 0x1B000000UL, 0x36000000UL
};
// S盒
unsigned char S[256] = {0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
};//逆S盒
unsigned char inv_S[256] = {0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};/* copy in[16] to state[4][4] */
int loadStateArray(uint8_t(*state)[4], const uint8_t* in) {for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[j][i] = *in++;}}return 0;
}/* copy state[4][4] to out[16] */
int storeStateArray(uint8_t(*state)[4], uint8_t* out) {for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {*out++ = state[j][i];}}return 0;
}
//秘钥扩展
int keyExpansion(const uint8_t* key, uint32_t keyLen, AesKey* aesKey) {if (NULL == key || NULL == aesKey) {printf("keyExpansion param is NULL\n");return -1;}if (keyLen != 16) {printf("keyExpansion keyLen = %d, Not support.\n", keyLen);return -1;}uint32_t* w = aesKey->eK; //加密秘钥uint32_t* v = aesKey->dK; //解密秘钥/* keyLen is 16 Bytes, generate uint32_t W[44]. *//* W[0-3] */for (int i = 0; i < 4; ++i) {LOAD32H(w[i], key + 4 * i);}/* W[4-43] */for (int i = 0; i < 10; ++i) {w[4] = w[0] ^ MIX(w[3]) ^ rcon[i];w[5] = w[1] ^ w[4];w[6] = w[2] ^ w[5];w[7] = w[3] ^ w[6];w += 4;}w = aesKey->eK + 44 - 4;//解密秘钥矩阵为加密秘钥矩阵的倒序，方便使用，把ek的11个矩阵倒序排列分配给dk作为解密秘钥//即dk[0-3]=ek[41-44], dk[4-7]=ek[37-40]... dk[41-44]=ek[0-3]for (int j = 0; j < 11; ++j) {for (int i = 0; i < 4; ++i) {v[i] = w[i];}w -= 4;v += 4;}return 0;
}// 轮秘钥加
int addRoundKey(uint8_t(*state)[4], const uint32_t* key) {uint8_t k[4][4];/* i: row, j: col */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {k[i][j] = (uint8_t)BYTE(key[j], 3 - i); /* 把 uint32 key[4] 先转换为矩阵 uint8 k[4][4] */state[i][j] ^= k[i][j];}}return 0;
}//字节替换
int subBytes(uint8_t(*state)[4]) {/* i: row, j: col */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[i][j] = S[state[i][j]]; //直接使用原始字节作为S盒数据下标}}return 0;
}//逆字节替换
int invSubBytes(uint8_t(*state)[4]) {/* i: row, j: col */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[i][j] = inv_S[state[i][j]];}}return 0;
}//行移位
int shiftRows(uint8_t(*state)[4]) {uint32_t block[4] = { 0 };/* i: row */for (int i = 0; i < 4; ++i) {//便于行循环移位，先把一行4字节拼成uint_32结构，移位后再转成独立的4个字节uint8_tLOAD32H(block[i], state[i]);block[i] = ROF32(block[i], 8 * i);STORE32H(block[i], state[i]);}return 0;
}//逆行移位
int invShiftRows(uint8_t(*state)[4]) {uint32_t block[4] = { 0 };/* i: row */for (int i = 0; i < 4; ++i) {LOAD32H(block[i], state[i]);block[i] = ROR32(block[i], 8 * i);STORE32H(block[i], state[i]);}return 0;
}/* Galois Field (256) Multiplication of two Bytes */
// 两字节的伽罗华域乘法运算
uint8_t GMul(uint8_t u, uint8_t v) {uint8_t p = 0;for (int i = 0; i < 8; ++i) {if (u & 0x01) { //p ^= v;}int flag = (v & 0x80);v <<= 1;if (flag) {v ^= 0x1B; /* x^8 + x^4 + x^3 + x + 1 */}u >>= 1;}return p;
}// 列混合
int mixColumns(uint8_t(*state)[4]) {uint8_t tmp[4][4];uint8_t M[4][4] = { {0x02, 0x03, 0x01, 0x01},{0x01, 0x02, 0x03, 0x01},{0x01, 0x01, 0x02, 0x03},{0x03, 0x01, 0x01, 0x02} };/* copy state[4][4] to tmp[4][4] */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {tmp[i][j] = state[i][j];}}for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) { //伽罗华域加法和乘法state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j])^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j]);}}return 0;
}// 逆列混合
int invMixColumns(uint8_t(*state)[4]) {uint8_t tmp[4][4];uint8_t M[4][4] = { {0x0E, 0x0B, 0x0D, 0x09},{0x09, 0x0E, 0x0B, 0x0D},{0x0D, 0x09, 0x0E, 0x0B},{0x0B, 0x0D, 0x09, 0x0E} }; //使用列混合矩阵的逆矩阵/* copy state[4][4] to tmp[4][4] */for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {tmp[i][j] = state[i][j];}}for (int i = 0; i < 4; ++i) {for (int j = 0; j < 4; ++j) {state[i][j] = GMul(M[i][0], tmp[0][j]) ^ GMul(M[i][1], tmp[1][j])^ GMul(M[i][2], tmp[2][j]) ^ GMul(M[i][3], tmp[3][j]);}}return 0;
}// AES-128加密接口，输入key应为16字节长度，输入长度应该是16字节整倍数，
// 这样输出长度与输入长度相同，函数调用外部为输出数据分配内存
int aesEncrypt(const uint8_t* key, uint32_t keyLen, const uint8_t* pt, uint8_t* ct, uint32_t len) {AesKey aesKey;uint8_t* pos = ct;const uint32_t* rk = aesKey.eK; //解密秘钥指针uint8_t out[BLOCKSIZE] = { 0 };uint8_t actualKey[16] = { 0 };uint8_t state[4][4] = { 0 };if (NULL == key || NULL == pt || NULL == ct) {printf("param err.\n");return -1;}if (keyLen > 16) {printf("keyLen must be 16.\n");return -1;}if (len % BLOCKSIZE) {printf("inLen is invalid.\n");return -1;}memcpy(actualKey, key, keyLen);keyExpansion(actualKey, 16, &aesKey); // 秘钥扩展// 使用ECB模式循环加密多个分组长度的数据for (int i = 0; i < len; i += BLOCKSIZE) {// 把16字节的明文转换为4x4状态矩阵来进行处理loadStateArray(state, pt);// 轮秘钥加addRoundKey(state, rk);for (int j = 1; j < 10; ++j) {rk += 4;subBytes(state); // 字节替换shiftRows(state); // 行移位mixColumns(state); // 列混合addRoundKey(state, rk); // 轮秘钥加}subBytes(state); // 字节替换shiftRows(state); // 行移位// 此处不进行列混合addRoundKey(state, rk + 4); // 轮秘钥加// 把4x4状态矩阵转换为uint8_t一维数组输出保存storeStateArray(state, pos);pos += BLOCKSIZE; // 加密数据内存指针移动到下一个分组pt += BLOCKSIZE; // 明文数据指针移动到下一个分组rk = aesKey.eK; // 恢复rk指针到秘钥初始位置}return 0;
}// AES128解密， 参数要求同加密
int aesDecrypt(const uint8_t* key, uint32_t keyLen, const uint8_t* ct, uint8_t* pt, uint32_t len) {AesKey aesKey;uint8_t* pos = pt;const uint32_t* rk = aesKey.dK; //解密秘钥指针uint8_t out[BLOCKSIZE] = { 0 };uint8_t actualKey[16] = { 0 };uint8_t state[4][4] = { 0 };if (NULL == key || NULL == ct || NULL == pt) {printf("param err.\n");return -1;}if (keyLen > 16) {printf("keyLen must be 16.\n");return -1;}if (len % BLOCKSIZE) {printf("inLen is invalid.\n");return -1;}memcpy(actualKey, key, keyLen);keyExpansion(actualKey, 16, &aesKey); //秘钥扩展，同加密for (int i = 0; i < len; i += BLOCKSIZE) {// 把16字节的密文转换为4x4状态矩阵来进行处理loadStateArray(state, ct);// 轮秘钥加，同加密addRoundKey(state, rk);for (int j = 1; j < 10; ++j) {rk += 4;invShiftRows(state); // 逆行移位invSubBytes(state); // 逆字节替换，这两步顺序可以颠倒addRoundKey(state, rk); // 轮秘钥加，同加密invMixColumns(state); // 逆列混合}invSubBytes(state); // 逆字节替换invShiftRows(state); // 逆行移位// 此处没有逆列混合addRoundKey(state, rk + 4); // 轮秘钥加，同加密storeStateArray(state, pos); // 保存明文数据pos += BLOCKSIZE; // 输出数据内存指针移位分组长度ct += BLOCKSIZE; // 输入数据内存指针移位分组长度rk = aesKey.dK; // 恢复rk指针到秘钥初始位置}return 0;
}
// 方便输出16进制数据
void printHex(uint8_t* ptr, int len, char* tag) {printf("%s\ndata[%d]: ", tag, len);for (int i = 0; i < len; ++i) {printf("%.2X ", *ptr++);}printf("\n");
}int main() {// case 1const 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(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:"); // 打印解密后的明文数据// 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;
}RSA
RSA常用攻击方式 –>
python：
import primefac
from Crypto.Util.number import long_to_bytes, bytes_to_longp = 0xf22ac0b157f14abe6fd077b9e10aaf44e1a9fcbe5275a1188672a05baaf6e49599af0b2c8a51d2c9d7f3ecbbc388bbdd0d8ddca52254f551d02ee258e0c30505c5bcd281726a6084c342bb1a61d37b627ef3501a95a80ec432cc7f05a864302c159991373568926dd62d6ea310c8768289d8d1ee1afc94f9ef8654ca63f3498dLq = 0xb60a50ac3362a7a75acef9a78e4a009bf5e106a5928ba259050d6cc37b91549b2be76c163792fdcdf9c517bd05d4db6dfc10db599887a1c990d6bef3e9bf41a111bee23d72b64c15e5066ba5cc3c7782ebd9aca20a17be7980947e977a20f9c0af347f4cab4c249f8c39cff1849a7eac5e9a56612735072f58e801b5fd679dc1Ln = 0xac3426f9dcffb48c184f40c7e99bbf8cea568de21ae9a752d6a45ce75f67c1c3b199399979d2ed45acde9155d46c043826b0c8cfb3be97d5154ad3eb4467d3e6b6df3455eb480ed02a318cfd88415a56732029d323c574bd1198793175197ac5076440624f23281d64a7cf42f3ccf9257bbf10fefd60e4263c4a01935f0f6a1ce64c5041cbd81d32fbf71545df8a39e0625825fd331028431318cb562211a890ac60c47eae623932ebea5452d77f2d05047fea9d47f6699707527772b0d8dfd53de355a67277fe0e820d29d8a341ba27046b9ee292b987b0a2d10eeab6318167eaafdd577a6df6be135c633c85bc69bf52816b563204084dd69040257f40ec4dLe = 0x10001d = primefac.modinv(e, (p - 1) * (q - 1)) % ((p - 1) * (q - 1))print "q4"m = pow(c, d, n)key = long_to_bytes(m)
本文标签： 各种密码算法记录
版权声明：本文标题：各种密码算法记录 内容由热心网友自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://it.en369.cn/IT/1694640908a254399.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论