AES加密算法及逆向
Posted megaparsec
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了AES加密算法及逆向相关的知识，希望对你有一定的参考价值。
AES加密算法逆向以及特征识别
1.AES加密算法
关于AES加密算法，网上资料特别特别多，个人认为可以从这几点去学习：
- AES加密算法设计者的相关论文以及其他相关论文（如安全性、性能、硬件/指令实现等）
- 相关书籍、维基百科、国内外他人的优质文章/博客、论坛等
- 标准文件，如：NIST、ISO、ITU-T、RFC等发布的标准文件
- 一些加密库，如Openssl、Crypto++、EverCrypt、Botan等
部分相关资料:
- AES Proposal: Rijndael 链接1
- 现代密码学理论与实践5 ⾼级加密标准AES 链接2
- AES 链接3
- 维基百科-高级加密标准 链接4
- AES加密算法的详细介绍与实现 链接5
- 密码学基础：AES加密算法 链接6
- 密码算法详解——AES 链接7
- William Stallings著；王张宜等译. 密码编码学与网络安全——原理与实践（第五版）[M]. 北京：电子工业出版社，2012.1.
- 二又三大佬的博客 高级加密标准-AES 链接8
- yjp大佬的博客 AES算法详解 链接9
1.1 介绍
AES加密算法就是众多对称加密算法中的一种，它的英文全称是Advanced Encryption Standard，翻译过来是高级加密标准，它是用来替代之前的DES加密算法的。AES加密算法采用分组密码体制，明文分组的长度为128位即16字节，密钥长度可以为16，24或者32字节(128，192，256位)，根据密钥的长度，算法被称为AES-128，AES-192或者AE-256。一共有四种加密模式，我们通常采用需要初始向量IV的CBC模式，初始向量的长度也是128位16个字节。AES的加密模式有以下几种：电码本模式(ECB)、密码分组链接模式(CBC)、计算器模式(CTR)、密码反馈模式(CFB)、输出反馈模式(OFB)
部分术语定义和表示：
状态（State）：密码运算的中间结果称为状态。
State的表示：状态用以字节为基本构成元素的矩阵阵列来表示，该阵列有4行，列数记为Nb。 Nb=分组长度（bits）÷ 32。Nb可以取的值为4，对应的分组长度为128bits。
密码密钥（Cipher Key）的表示： Cipher Key类似地用一个4行的矩阵阵列来表示，列数记为Nk。Nk=密钥长度（bits）÷32。Nk可以取的值为4，6，8，对应的密钥长度为128， 192， 256 bits。
密码学三大原则：扩散原则、混淆原则、雪崩效应
雪崩效应：雪崩效应（avalanche effect）指加密算法（尤其是块密码和加密散列函数）的一种理想属性。雪崩效应是指当输入发生最微小的改变（例如，反转一个二进制位）时，也会导致输出的不可区分性改变（输出中每个二进制位有50%的概率发生反转）。合格块密码中，无论密钥或明文的任何细微变化都必须引起密文的不可区分性改变。 --摘自维基百科 雪崩效应
1.2 加密流程
AES未使用Feistel结构（关于Feistel结构详见 链接10）。其前N-1轮由4个不同的变换组成（即涉及的主要操作有4种）：字节替代(SubByte)、行移位(ShiftRow)、列混淆(MixColumn)和轮密钥加(AddRoundKey)。最后一轮仅包含三个变换。而在第一轮前面有一个起始的单变换（轮密钥加），可以视为0轮。解密过程分别为对应的逆操作。由于每一步操作都是可逆的，按照相反的顺序进行解密即可恢复明文。
- 字节代替（SubBytes）：用一个S盒完成分组的字节到字节的代替。
- 行移位（ShiftRows）：一个简单的置换。
- 列混淆（MixColumns）：利用域GF(2^8)上的算术特性的一个代替。
- 轮密钥加（AddRoundKey）：当前分组和扩展密钥的一部分进行按位异或XOR。
1.2.1 密钥扩展
AES密钥调度
- 密钥bit的总数 = 分组长度 x （轮数Round + 1）
- 当分组长度是128bit且轮数为10时，轮密钥长度为128∗(10+1)=1408bit
- 将初始密钥扩展成扩展密钥
- 轮密钥从扩展密钥中取，第1轮轮密钥取扩展密钥的前Nb个字，第2轮轮密钥取接下来的Nb个字，以此类推。
AES密钥扩展图如下：
函数T由三部分组成：字循环移位、字节代换和轮常量异或。
- 字循环移位：将1个字中的4个字节循环左移1个字节，即将输入字[b0,b1,b2,b3]变换为[b1,b2,b3,b0]。
- 字节代换：对字循环的结果使用S盒进行字节代换。
- 轮常量异或： 将前两步的结果同轮常量Rcon[j]进行异或，其中j表示轮数。
- 轮常量是一个字，使用轮常量是为了防止不同轮中产生的轮密钥的对称性或相似性。
1.2.2 字节替代
字节代换（SubBytes）是对state矩阵中的每一个独立元素于置换盒 （Substitution-box，S盒）中进行查找并以此替换输入状态的操作。字节代换是可逆的非线性变换，也是AES运算组中唯一的非线性变换。字节代换逆操作也是通过逆向置换盒的查找及替换来完成的。
映射方式:把该字节的高4位作为行值，低4位作为列值，以这些行列值作为索引从S盒中对应位置取出元素作为输出，假设输入字节的值为a=a7a6a5a4a3a2a1a0，则输出值为S[a7a6a5a4][a3a2a1a0]。例如，十六进制数23所对应的S盒的行值是2，列值是3，S盒中在此位置的值是26,相应的23被映射为26;字节00000000B替换后的值为（S[0][0]）63H
S盒是事先设计好的16×16的查询表，即256个元素。其设计不是随意的，要根据设计原则严格计算求得，不然无法保证算法的安全性。既然是S盒是计算得来，所以字节代换的操作完全可以通过计算来完成，不过通过S盒查表操作更方便快捷，图中所示就是通过S盒查找对应元素进行的替换操作。
Q:AES加密的S盒与DES加密的S盒有什么区别?
A: from 链接11
- AES的S盒的原理是运用了GF(2^8)的乘法逆和矩阵的可逆运算来保证加密与解密过程的可逆性。DES的S盒设计主要是为了确保非线性关系，并不需要可逆。因而在设计理念上有极大的不同。
- AES的S盒与DES的S盒形式上差别也很大，AES的S盒输入和输出的位数相同，均为128位，大小为16×16的字节矩阵，且只有1组；而DES的S盒输入6位，输出只有4位，大小是4×16的位矩阵，并且有8组。在输入的坐标选择规定上亦有不同。
Q：为什么要用查表法？
A：查表法虽然牺牲了空间，但是效率高，更快捷。
Q：为什么S盒的元素是定值或者说计算而来？怎么计算的？
A(摘自看雪版主看场雪的回答 链接11）：S盒是AES的核心部件，负责提供“非线性变换”的功能。理论上，除了现在AES所使用的“生成S盒的算法”以外，还有很多方法可以生成S盒。但其要求并不是只有“随机”这一点。其重要的安全要求包括但不仅限于：
- 输入与输出的相关性
- 输出的自相关性
- 输入单bit与输出多bit的扩散关系
- 输入多bit与输出单bit的混淆关系
- 可逆
S盒的生成（或者说挑选）是个深奥的学问。
S盒是按照这个公式计算出来的：GF(2^8) = GF(2) [x]/(x^8 + x^4 + x^3 + x + 1)
更为详细具体内容见以下链接;
AES128加密-S盒和逆S盒构造推导及代码实现 链接12
Rijndael S-box 链接13
初识白盒密码 链接14
有限域算术 链接15
1.2.3 行移位
行移位是一个4x4的矩阵内部字节之间的置换，用于提供算法的扩散性。
行移位变换完成基于行的循环移位操作，变换方法为：第0行不变，第1行循环左移1个字节，第2行循环左移两个字节，第3行循环左移3个字节。如下图所示：
逆向行移位即是相反的操作，即：第一行保持不变，第二行循环右移1个字节，第三行循环右移两个字节，第四行循环左移3个字节。
关于扩散性：在密码学中，扩散性是指算法对输入的较小改变产生较大输出变化的能力，也就是就是让明文中的每一位影响密文中的许多位，或者说让密文中的每一位受明文中的许多位的影响．这样可以隐蔽明文的统计特性。比如，在对称加密算法中，如果明文和密文之间的转换具有较小的扩散性，则攻击者可能会使用差分攻击来破解密码。差分攻击就是利用密文的相似性来推断出密钥的技术。因此，扩散性是密码学算法的一个重要特性，通常用来衡量密码学算法的安全性。
扩散原则（Diffusion）就是应将明文的统计规律和结构规律散射到相当长的一段统计中去(Shannon的原话)。
也就是说让明文中的每一位影响密文中的尽可能多的位，或者说让密文中的每一位都受到明文中的尽可能多位的影响。
如果当明文变化一个比特时,密文有某些比特不可能发生变化,则这个明文就与那些密文无关,因而在攻击这个明文比比特时就可不利用那些密文比特。
关于差分攻击：（差分攻击是由Biham和Shamir于1991年提出的选择明文攻击方法。它是针对分组密码攻击最有效的方法之一。差分攻击通过分析特定明文差分对相对应密文差分的影响来提取密钥。差分分析现在被广泛应用于各种分组密码的攻击。
关于差分分析更加详细具体的内容见：
- 搞懂差分密码分析，这篇文章就够了！！链接16
- 差分分析（Differential Cryptandysis）方法 链接17
- Differential Cryptanalysis Tutorial 链接18）
1.2.4 列混淆
列混淆是将状态数组的每一列乘以一个矩阵，其中乘法是在有限域GF(2^8)上进行的，分为正向列混淆和列混淆逆变换两种操作。正向列混淆用于加密操作，列混淆逆变换用于解密操作。
正向列混淆变换过程：
逆向列混淆变换可以再乘以矩阵的逆得到。
列混淆变换中，通过矩阵相乘的运算使得明文中的字节具有很好的混淆效果，而且经过几轮变换之后，列混淆变换和行移位变换使得所有输出位均与所有输入位相关。
关于混淆：在加密算法中，明文、密文、密钥之间的关系要足够复杂，防止统计分析攻击。
混淆原则(Confusion）就是将密文、明文、密钥三者之间的统计关系和代数关系变得尽可能复杂，使得敌手即使获得了密文和明文，也无法求出密钥的任何信息；即使获得了密文和明文的统计规律，也无法求出明文的新的信息。
可进一步理解为：
- 明文不能由已知的明文，密文及少许密钥比特代数地或统计地表示出来。
- 密钥不能由已知的明文，密文及少许密钥比特代数地或统计地表示出来
Q：AES算法最后一轮为什么没有列混淆？
A：详见 aes算法最后一轮为什么没有列混淆？ 链接19
1.2.5 轮密钥加
密钥加是将轮密钥简单地与状态进行逐比特异或。这个操作相对简单，其依据的原理是“任何数和自身的异或结果为0”。加密过程中，每轮的输入与轮子密钥异或一次；因此，解密时再异或上该轮的轮子密钥即可恢复。
轮密钥加过程可以看成是字逐位异或的结果，也可以看成字节级别或者位级别的操作。也就是说，可以看成S0 S1 S2 S3 组成的32位字与W[4i]的异或运算。
1.3 AES加密算法的实现
1.3.1 python
AES256,CBC模式，字符集UTF-8
# 需要安装 pycryptodomex 库
from Cryptodome.Cipher import AES
import base64
# 加密
def aes_encrypt(key, content):
key = key.encode()
# 如果 key 不是 32 位的，则使用 hashlib 库进行 hash
if len(key) != 32:
import hashlib
key = hashlib.sha256(key).hexdigest()
# 如果 content 不是 16 位的倍数，则进行补全
add = 16 - len(content.encode()) % 16
content += '\\0' * add
cipher = AES.new(key, AES.MODE_CBC, b'0123456789012345')
result = base64.b64encode(cipher.encrypt(content.encode()))
return result.decode()
# 解密
def aes_decrypt(key, content):
key = key.encode()
# 如果 key 不是 32 位的，则使用 hashlib 库进行 hash
if len(key) != 32:
import hashlib
key = hashlib.sha256(key).hexdigest()
cipher = AES.new(key, AES.MODE_CBC, b'0123456789012345')
content = base64.b64decode(content.encode())
result = cipher.decrypt(content).decode()
return result.rstrip('\\0')
key = '1234567890abcdefghijklmnopqrstuv'
content = 'hello world'
encrypted = aes_encrypt(key, content)
decrypted = aes_decrypt(key, encrypted)
print(encrypted)
print(decrypted)
#wJFt54fc35P0QQo/ZFHakQ==
#hello world
1.3.2 go
package main
import (
"bytes"
"crypto/aes"
"crypto/cipher"
"encoding/base64"
"fmt"
"log"
"unicode/utf8"
)
func main()
key := []byte("your-aes-256-key-goes-here")
plaintext := "This is the message to be encrypted with AES-256 in CBC mode."
// 加密
block, err := aes.NewCipher(key)
if err != nil
log.Fatal(err)
iv := []byte("initialization-vector")
encrypter := cipher.NewCBCEncrypter(block, iv)
plaintextBytes := []byte(plaintext)
paddedPlaintextBytes := pad(plaintextBytes, block.BlockSize())
ciphertextBytes := make([]byte, len(paddedPlaintextBytes))
encrypter.CryptBlocks(ciphertextBytes, paddedPlaintextBytes)
ciphertext := base64.StdEncoding.EncodeToString(ciphertextBytes)
// 解密
ciphertextBytes, err = base64.StdEncoding.DecodeString(ciphertext)
if err != nil
log.Fatal(err)
decrypter := cipher.NewCBCDecrypter(block, iv)
plaintextBytes = make([]byte, len(ciphertextBytes))
decrypter.CryptBlocks(plaintextBytes, ciphertextBytes)
plaintextBytes = unpad(plaintextBytes)
plaintext = string(plaintextBytes)
fmt.Println(plaintext)
// pad 函数用于填充明文，使它的长度是 blockSize 的倍数。
func pad(src []byte, blockSize int) []byte
padding := blockSize - len(src)%blockSize
padtext := bytes.Repeat([]bytebyte(padding), padding)
return append(src, padtext...)
// unpad 函数用于去除填充的字节。
func unpad(src []byte) []byte
length := len(src)
unpadding := int(src[length-1])
if length < 4
unpadding = length
return src[:(length - unpadding)]
1.3.3 Ruby
require 'openssl'
require 'base64'
def aes256_cbc_encrypt(key, iv, plaintext)
cipher = OpenSSL::Cipher.new('AES-256-CBC')
cipher.encrypt
cipher.key = key
cipher.iv = iv
ciphertext = cipher.update(plaintext) + cipher.final
Base64.strict_encode64(ciphertext)
end
def aes256_cbc_decrypt(key, iv, ciphertext)
ciphertext = Base64.strict_decode64(ciphertext)
cipher = OpenSSL::Cipher.new('AES-256-CBC')
cipher.decrypt
cipher.key = key
cipher.iv = iv
plaintext = cipher.update(ciphertext) + cipher.final
plaintext.force_encoding('UTF-8')
end
key = 'your-aes-256-key-goes-here'
iv = 'initialization-vector'
plaintext = 'This is the message to be encrypted with AES-256 in CBC mode.'
# 加密
ciphertext = aes256_cbc_encrypt(key, iv, plaintext)
# 解密
plaintext = aes256_cbc_decrypt(key, iv, ciphertext)
puts plaintext
1.3.4 C语言
此处链接21的源代码,仅用于学习
AES256 CBC
/* author：sanjeevmishra391
from：https://github.com/sanjeevmishra391/AES256_CBC
仅用于学习
*/
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<stdint.h>
uint32_t word[60];
uint8_t sBox[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;
uint8_t invSBox[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逆向算法之AES算法
AES加密算法是典型的对称加密算法，对称加密算法也就是加密和解密用相同的密钥。
AES加密数组块分组长度必须为128比特，密钥长度可以是128比特、192比特、256比特中的任意一个。AES加密有很多轮的重复和变换，步骤是1、密钥扩展，2、初始轮，3、重复轮，4、最终轮。
1、字节代换
AES的字节代换是一个简单的查表操作，AES定义了一个s盒和一个逆s盒。
状态矩阵中的元素按照将字节的高4位作为行值，低四位作为列值，取出s盒或者逆s盒中对应的行的元素作为输出。例如，加密时，输出的字节s1为0x12，则查s盒的第0x01行和0x02列，得到值0xc9，然后替换s1原有的0x12为0xc9。逆s盒如下。
2、行移位
行移位是一个简单的左循环移位操作。当密钥长度为128比特时，状态矩阵的第0行左移0字节，第1行左移1字节，第2行左移2字节，第3行左移3字节。
3、列混合操作
列混合变换是通过矩阵相乘来实现的，经行移位后的状态矩阵与固定的矩阵相乘，得到混淆后的状态矩阵。
4、轮密钥加
轮密钥加是将128位轮密钥Ki同状态矩阵中的数据进行逐位异或操作。
AES算法实现
1、密钥拓展的实现
//密钥对应的扩展数组
static int w[44];
/**
* 扩展密钥，结果是把w[44]中的每个元素初始化
*/
static void extendKey(char *key) {
for(int i = 0; i < 4; i++)
w[i] = getWordFromStr(key + i * 4);
for(int i = 4, j = 0; i < 44; i++) {
if( i % 4 == 0) {
w[i] = w[i - 4] ^ T(w[i - 1], j);
j++;//下一轮
}else {
w[i] = w[i - 4] ^ w[i - 1];
}
}
}
/**
* 常量轮值表
*/
static const int Rcon[10] = { 0x01000000, 0x02000000,
0x04000000, 0x08000000,
0x10000000, 0x20000000,
0x40000000, 0x80000000,
0x1b000000, 0x36000000 };
/**
* 密钥扩展中的T函数
*/
static int T(int num, int round) {
int numArray[4];
splitIntToArray(num, numArray);
leftLoop4int(numArray, 1);//字循环
//字节代换
for(int i = 0; i < 4; i++)
numArray[i] = getNumFromSBox(numArray[i]);
int result = mergeArrayToInt(numArray);
return result ^ Rcon[round];
}
————————————————
版权声明：本文为CSDN博主「TimeShatter」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_28205153/article/details/55798628
/**
* 常量轮值表
*/
static const int Rcon[10] = { 0x01000000, 0x02000000,
0x04000000, 0x08000000,
0x10000000, 0x20000000,
0x40000000, 0x80000000,
0x1b000000, 0x36000000 };
/**
* 密钥扩展中的T函数
*/
static int T(int num, int round) {
int numArray[4];
splitIntToArray(num, numArray);
leftLoop4int(numArray, 1);//字循环
//字节代换
for(int i = 0; i < 4; i++)
numArray[i] = getNumFromSBox(numArray[i]);
int result = mergeArrayToInt(numArray);
return result ^ Rcon[round];
}
2、字节代换的实现
/**
* 根据索引，从S盒中获得元素
*/
static int getNumFromSBox(int index) {
int row = getLeft4Bit(index);
int col = getRight4Bit(index);
return S[row][col];
}
/**
* 字节代换
*/
static void subBytes(int array[4][4]){
for(int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++)
array[i][j] = getNumFromSBox(array[i][j]);
}
3、行移位的实现
/**
* 将数组中的元素循环左移step位
*/
static void leftLoop4int(int array[4], int step) {
int temp[4];
for(int i = 0; i < 4; i++)
temp[i] = array[i];
int index = step % 4 == 0 ? 0 : step % 4;
for(int i = 0; i < 4; i++){
array[i] = temp[index];
index++;
index = index % 4;
}
}
/**
* 行移位
*/
static void shiftRows(int array[4][4]) {
int rowTwo[4], rowThree[4], rowFour[4];
//复制状态矩阵的第2,3,4行
for(int i = 0; i < 4; i++) {
rowTwo[i] = array[1][i];
rowThree[i] = array[2][i];
rowFour[i] = array[3][i];
}
//循环左移相应的位数
leftLoop4int(rowTwo, 1);
leftLoop4int(rowThree, 2);
leftLoop4int(rowFour, 3);
//把左移后的行复制回状态矩阵中
for(int i = 0; i < 4; i++) {
array[1][i] = rowTwo[i];
array[2][i] = rowThree[i];
array[3][i] = rowFour[i];
}
}
4、列混合的实现
/**
* 列混合要用到的矩阵
*/
static const int colM[4][4] = { 2, 3, 1, 1,
1, 2, 3, 1,
1, 1, 2, 3,
3, 1, 1, 2 };
static int GFMul2(int s) {
int result = s << 1;
int a7 = result & 0x00000100;
if(a7 != 0) {
result = result & 0x000000ff;
result = result ^ 0x1b;
}
return result;
}
static int GFMul3(int s) {
return GFMul2(s) ^ s;
}
/**
* GF上的二元运算
*/
static int GFMul(int n, int s) {
int result;
if(n == 1)
result = s;
else if(n == 2)
result = GFMul2(s);
else if(n == 3)
result = GFMul3(s);
else if(n == 0x9)
result = GFMul9(s);
else if(n == 0xb)//11
result = GFMul11(s);
else if(n == 0xd)//13
result = GFMul13(s);
else if(n == 0xe)//14
result = GFMul14(s);
return result;
}
/**
* 列混合
*/
static void mixColumns(int array[4][4]) {
int tempArray[4][4];
for(int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++)
tempArray[i][j] = array[i][j];
for(int i = 0; i < 4; i++)
for(int j = 0; j < 4; j++){
array[i][j] = GFMul(colM[i][0],tempArray[0][j]) ^ GFMul(colM[i][1],tempArray[1][j])
^ GFMul(colM[i][2],tempArray[2][j]) ^ GFMul(colM[i][3], tempArray[3][j]);
}
}
5、轮密钥加的实现
/**
* 轮密钥加
*/
static void addRoundKey(int array[4][4], int round) {
int warray[4];
for(int i = 0; i < 4; i++) {
splitIntToArray(w[ round * 4 + i], warray);
for(int j = 0; j < 4; j++) {
array[j][i] = array[j][i] ^ warray[j];
}
}
}
总AES解密函数
/**
* 参数 c: 密文的字符串数组。
* 参数 clen: 密文的长度。
* 参数 key: 密钥的字符串数组。
*/
void deAes(char *c, int clen, char *key) {
int keylen = strlen(key);
if(clen == 0 || clen % 16 != 0) {
printf("密文字符长度必须为16的倍数！现在的长度为%d\\n",clen);
exit(0);
}
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16、24和32。当前长度为%d\\n",keylen);
exit(0);
}
extendKey(key);//扩展密钥
int cArray[4][4];
for(int k = 0; k < clen; k += 16) {
convertToIntArray(c + k, cArray);
addRoundKey(cArray, 10);
int wArray[4][4];
for(int i = 9; i >= 1; i--) {
deSubBytes(cArray);
deShiftRows(cArray);
deMixColumns(cArray);
getArrayFrom4W(i, wArray);
deMixColumns(wArray);
addRoundTowArray(cArray, wArray);
}
deSubBytes(cArray);
deShiftRows(cArray);
addRoundKey(cArray, 0);
convertArrayToStr(cArray, c + k);
}
}
以上是关于AES加密算法及逆向的主要内容，如果未能解决你的问题，请参考以下文章