21、我喜欢培根
key: CTF{}
解题链接： http://ctf5.shiyanbar.com/crypto/enc1.txt
打开链接后：
-- --- .-. ... . ..--.- .. ... ..--.- -.-. --- --- .-.. ..--.- -... ..- - ..--.- -... .- -.-. --- -. ..--.- .. ... ..--.- -.-. --- --- .-.. . .-. ..--.- -.. -.-. -.-. -.. -.-. -.-. -.-. -.. -.. -.. -.-. -.. -.-. -.-. -.-. -.. -.. -.-. -.-. -.-. -.-. -.-. -.-. -.-. -.-. -.-. -.. -.. -.-. -.. -.-. -.-. -.-. -.-. -.. -.-. -.-. -.-. -.-. -.-. / -.-. -.. -.-. -.-. -.-. -.. -.-. -.-. -.. -.-. / -.-. -.-. -.-. -.. -.-. -.-. -.. -.. -.. -.-. -.-. -.. -.. -.. -.-. -.-. -.. -.-. -.. -..
很明显是摩斯密码，用摩斯密码在线解密得到：
http://www.jb51.net/tools/morse.htm（在线解密平台）
MORSE..--.-IS..--.-COOL..--.-BUT..--.-BACON..--.-IS..--.-COOLER..--.-DCCDCCCDDDCDCCCDDCCCCCCCCCDDCDCCCCDCCCCC/CDCCCDCCDC/CCCDCCDDDCCDDDCCDCDD
将后面DCC…..进行转换，培根所用的密码是一种本质上用二进制数设计的，
没有用通常的0和1来表示，而是采用a和b，如大写字母和小写字母，英文和数字，斜体和正体，D代表1，C代表0.在这里D为b,C为a.
分析：从字面意义以及培根密码特点得知密文，那么二进制得知替换（标准对应方便）
密文：DCCDCCCDDDCDCCCDDCCCCCCCCCDDCDCCCCDCCCCC/CDCCCDCCDC/CCCDCCDDDCCDDDCCDCDD
替换：baabaaabbbabaaabbaaaaaaaaabbabaaaabaaaaa/abaaabaaba/aaabaabbbaabbbaababb
将/去掉，得到下面的字符串，采用py脚本进行解密将转换后的输入既可以得到明文。baabaaabbbabaaabbaaaaaaaaabbabaaaabaaaaaabaaabaabaaaabaabbbaabbbaababb
培根加解密的代码：
#!/usr/bin/python
# -*- coding: utf-8 -*-
#输入均为小写字母
import re
alphabet =
[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘,‘g‘,‘h‘,‘i‘,‘j‘,‘k‘,‘l‘,‘m‘,‘n‘,‘o‘,‘p‘,‘q‘,‘r‘,‘s‘,‘t‘,‘u‘,‘v‘,‘w‘,‘x‘,‘y‘,‘z‘]
first_cipher = ["aaaaa","aaaab","aaaba","aaabb","aabaa","aabab","aabba","aabbb","abaaa","abaab","ababa","ababb","abbaa","abbab","abbba","abbbb","baaaa","baaab","baaba","baabb","babaa","babab","babba","babbb","bbaaa","bbaab"]
second_cipher =
["aaaaa","aaaab","aaaba","aaabb","aabaa","aabab","aabba","aabbb","abaaa","abaaa","abaab","ababa","ababb","abbaa","abbab","abbba","abbbb","baaaa","baaab","baaba","baabb","baabb","babaa","babab","babba","babbb"]
def encode():
string = raw_input("please input string to encode:\n")
e_string1 = ""
e_string2 = ""
for index in string:
for i in range(0,26):
if index == alphabet[i]:
e_string1 += first_cipher[i]
e_string2 += second_cipher[i]
break
print "first encode method result is:\n"+e_string1
print "second encode method result is:\n"+e_string2
return
def decode():
e_string = raw_input("please input string to decode:\n")
e_array = re.findall(".{5}",e_string)
d_string1 = ""
d_string2 = ""
for index in e_array:
for i in range(0,26):
if index == first_cipher[i]:
d_string1 += alphabet[i]
if index == second_cipher[i]:
d_string2 += alphabet[i]
print "first decode method result is:\n"+d_string1
print "second decode method result is:\n"+d_string2
return
if __name__ == ‘__main__‘:
while True:
print "\t*******Bacon Encode_Decode System*******"
print "input should be lowercase,cipher just include a b"
print( ‘1.encode\n2.decode\n3.exit‘)
s_number = raw_input("please input number to choose\n")
if s_number == "1":
encode()
raw_input()
elif s_number == "2":
decode()
raw_input()
elif s_number == "3":
break
else:
continue
解密后的明文为：
Shiyanba/is/colol,提交的里面不应该有/,故换成空格，同时将小写变成大写。
答案：CTF{SHIYANBA IS COOL}
22、奇怪的字符串
信息保密的需求和实际操作自古有之，与之相应的信息加密与解密也是历史悠久，现有一段经过古典密码理论（不止一种）加密的密文，内容如下：
89 51 82 109 89 50 86 122 97 71 107 61请找出这段密文隐藏的消息明文
解题链接： http://ctf5.shiyanbar.com/423/crypto/2.html
古典密码编码方法归根结底主要有两种，即置换和代换。
1.古典密码解码ASCII码对于字母：Y3RmY2VzaGk=
2.已经提示有等号用base64解：ctfceshi
所以最后flag:ctfceshi
古典密码置换成字母的代码：
#从数字转换到字母 按照ASCII编码
L=[89,51,82,109,89,50,86,122,97,71,107,61]
for x
in L:
print chr(x),
运行的结果：Y 3 R m Y 2 V z a G k =
由等号知可能为base64编码，
采用如下的py代码进行解码：
#-*-
coding: utf-8
import
base64
str=b‘Y3RmY2VzaGk=‘
str=base64.b64decode(str)
print(str)
str=str.decode(‘ascii‘)#bytes解码会得到str
print(str)
运行的结果为：ctfceshi
答案：ctfceshi
23、古典密码
密文内容如下{79 67 85 123 67 70 84 69 76 88 79 85 89 68 69 67 84 78 71 65 72 79 72 82 78 70 73 69 78 77 125 73 79 84 65}
请对其进行解密
提示：1.加解密方法就在谜面中
2.利用key值的固定结构
格式：CTF{ }
解题思路：将ASCII码转换为字母，得到OCU{CFTELXOUYDECTNGAHOHRNFIENM}IOTA
古典密码中最基础的加密法：列置换，加密：将明文按固定长m分组，即每行m个字母，在密钥控制下按某一顺序交换列，最后按列优先的顺序依次读出，即产生了密文。
原来字符串为35位。35=7*5
得到如下结果：
1 234567
OCU{CFT
ELXOUYD
ECTNGAH
OHRNFIE
NM}IOTA
根据第2条提示，可知，第2列打头或者第5列打头，第7列为第二列，{是第四列，
}是最后一列，
1234567置换成2764513
结果变为：
2764513
CTF{COU
LDYOUEX
CHANGET
HEINFOR
MATION}
CTF{COULDYOUEXCHANGETHEINFORMATION}刚好是一句完整的话，猜想应该是答案。
答案：CTF{COULDYOUEXCHANGETHEINFORMATION}
24、困在栅栏里的凯撒
小白发现了一段很6的字符：NlEyQd{seft}
解题思路：
首先是栅栏密码解密，由题意知，每组字数为6，栅栏密码在线解密得：NEQ{etlydsf}
栅栏密码在线加解密平台：http://www.qqxiuzi.cn/bianma/zhalanmima.php
凯撒解密的代码：（python2.7）
#实现97-122小写ASCII字母(默认)
def change(c,i):
c=c.lower()
num=ord(c)
if(num>=97 and num<=122):
num=97+(num+i-97)%(26)
return chr(num)
def kaisa_jiAmi(string,i):
string_new=‘‘
for s in string:
string_new+=change(s,i)
print(string_new)
return string_new
#本题有种暴力解密感觉
def kaisa_jiEmi(string):
for i in range(0,26):
print(‘第‘+str(i+1)+‘种可能:‘)
#区别在于 string 是该对象原本就是字符串类型, 而 str()则是将该对象转换成字符串类型。
kaisa_jiAmi(string,i)
#你要知道input输入的数据类型都是string
def main():
print(‘请输入操作，注意默认小写，大写同理:‘)
choice=raw_input(‘1:恺撒加密,2:凯撒穷举解密.请输入1或2：‘)
if choice==‘1‘:
string=raw_input(‘请输入需要加密字符串： ‘)
num=int(raw_input(‘请输入需要加密的KEY： ‘))
kaisa_jiAmi(string,num)
elif choice==‘2‘:
string=raw_input(‘请输入需要解密字符串： ‘) #python2.7输入用这种形式
kaisa_jiEmi(string)
else:
print(‘输入错误，请重试‘)
main()
if __name__==‘__main__‘:
main()
运行之后的结果：
请输入操作，注意默认小写，大写同理:
1:恺撒加密,2:凯撒穷举解密.请输入1或2：2
请输入需要解密字符串： NEQ{etlydsf}
第1种可能:
neq{etlydsf}
第2种可能:
ofr{fumzetg}
第3种可能:
pgs{gvnafuh}
第4种可能:
qht{hwobgvi}
第5种可能:
riu{ixpchwj}
第6种可能:
sjv{jyqdixk}
第7种可能:
tkw{kzrejyl}
第8种可能:
ulx{lasfkzm}
第9种可能:
vmy{mbtglan}
第10种可能:
wnz{ncuhmbo}
第11种可能:
xoa{odvincp}
第12种可能:
ypb{pewjodq}
第13种可能:
zqc{qfxkper}
第14种可能:
ard{rgylqfs}
第15种可能:
bse{shzmrgt}
第16种可能:
ctf{tianshu}
第17种可能:
dug{ujbotiv}
第18种可能:
evh{vkcpujw}
第19种可能:
fwi{wldqvkx}
第20种可能:
gxj{xmerwly}
第21种可能:
hyk{ynfsxmz}
第22种可能:
izl{zogtyna}
第23种可能:
jam{aphuzob}
第24种可能:
kbn{bqivapc}
第25种可能:
lco{crjwbqd}
第26种可能:
mdp{dskxcre}
>>>
明显这个ctf{tianshu}最像答案，带入提交。
然后通过凯撒解密：CTF{tianshu}
答案：CTF{tianshu}
25、数码管
flag已给出，请以十六进制表示
解题链接： http://ctf5.shiyanbar.com/DUTCTF/1.png
点进链接得到如下的图：
由题意知，我们要得到的的是DUTCTF{XX}，XX部分
题目给出的图片是八段数码管，并且颜色有红蓝之分，提示我们应该联想到共阳极、共阴极。
于是百度寻找字母的相应编码（题目给出的字母是HELLO） 红色为阳极，蓝色为阴极。
阴极对照表：
注：前面是16进制编码，后面是显示。
对照可得：8979C738C0
答案：DUTCTF{8979C738C0}
26、Decode
flag格式:ctf{}
解题链接： http://ctf5.shiyanbar.com/crypto/Readme.txt
点进链接后是这个：
0x253464253534253435253335253433253661253435253737253464253531253666253738253464253434253637253462253466253534253662253462253464253534253435253738253433253661253435253737253466253531253666253738253464253434253435253462253464253534253435253332253433253661253435253738253464253531253666253738253464253534253535253462253464253534253431253330253433253661253435253737253465253531253666253738253464253661253435253462253466253534253633253462253464253534253435253737253433253661253662253334253433253661253662253333253433253661253435253738253465253431253364253364
解题思路：
1.Decode，肯定是运用各种解码
ox表示十六进制，从网上了解到十六进制编码是把整个数字4个一分求一个字符这样会超出ascii码范围，
网上的数据都是以ox开头比如网上数据ox12ox96ox48....
而本题数据就开头是ox唯一一个,那么我们就两个一分。
十六进制解码转化字符代码如下：（python2.7）
#coding=utf-8
#十六进制解码转化字符代码如下
str="253464253534253435253335253433253661253435253737253464253531253666253738253464253434253637253462253466253534253662253462253464253534253435253738253433253661253435253737253466253531253666253738253464253434253435253462253464253534253435253332253433253661253435253738253464253531253666253738253464253534253535253462253464253534253431253330253433253661253435253737253465253531253666253738253464253661253435253462253466253534253633253462253464253534253435253737253433253661253662253334253433253661253662253333253433253661253435253738253465253431253364253364"
def HexDe(str):
decstr=""
for i in range(0,len(str),2):
decstr +=chr(int(str[i:i +
2],16))#unichr()跟chr()一样，只不过返回的是Unicode字符
# print decstr
# return decstr
if i==len(str)-2:
print decstr
HexDe(str)
2.这就得到结果，很显然这是url编码
%4d%54%45%35%43%6a%45%77%4d%51%6f%78%4d%44%67%4b%4f%54%6b%4b%4d%54%45%78%43%6a%45%77%4f%51%6f%78%4d%44
%45%4b%4d%54%45%32%43%6a%45%78%4d%51%6f%78%4d%54%55%4b%4d%54%41%30%43%6a%45%77%4e%51%6f%78%4d%6a%45%4b
%4f%54%63%4b%4d%54%45%77%43%6a%6b%34%43%6a%6b%33%43%6a%45%78%4e%41%3d%3d
提供一个网址解它http://tool.chinaz.com/Tools/Unicode.aspx
解码：
URL解码后的具体如下：
MTE5CjEwMQoxMDgKOTkKMTExCjEwOQoxMD
EKMTE2CjExMQoxMTUKMTA0CjEwNQoxMjEK
OTcKMTEwCjk4Cjk3CjExNA==
4.利用Base64代码得到：
-----------------------------------------------------------------------------------------------------------------------------------------------------
#-*- coding:
utf-8
import base64
str=b‘MTE5CjEwMQoxMDgKOTkKMTExCjEwOQoxMDEKMTE2CjExMQoxMTUKMTA0CjEwNQoxMjEKOTcKMTEwCjk4Cjk3CjExNA==‘
str=base64.b64decode(str)
str=str.decode(‘ascii‘)#bytes解码会得到str
print(str)
-----------------------------------------------------------------------------------------------------------------------------------------------------
119
101
108
99
111
109
101
116
111
115
104
105
121
97
110
98
97
114
5.利用Ascii代码得到
-----------------------------------------------------------------------------------------------------------------------
#从数字转换到字母 按照ASCII编码
L=[119,101,108,99,111,109,101,116,111,115,104,105,121,97,110,98,97,114]
for x in L:
print chr(x),
运行后得到结果：w e l c o m e t o s h i y a n b a r
得到flag:welcometoshiyanbar当然这不是最终答案，看题目格式要求
答案：ctf{welcometoshiyanbar}
27、黑客叔叔（雨袭团）内部交流题（第一季1.0.1）
解题链接： http://ctf5.shiyanbar.com/crypto/p0tt1 .html
点进链接出现如下图所示：
最简单的加密方式 ：by:p0tt1
dW1mcGJsamhhd3Jmcm14aHoxOXptZjltZWducm13NDV4M2RvbmhxfDAxfDAzfDA3fCt8KzF8KzN8Kzd8MisxfDIrMnwyKzZ8Mis3fDIrOXwzKzB8MyszfDMrN3wzKzh8Mys5fD98
解题思路：
Base64在线加解密网站：
http://tool.oschina.net/encrypt?type=3
题目是一串字符串，猜想是base64编码的，在网站在线解密，得到：
umfpbljhawrfrmxhz19zmf9megnrmw45x3donhq|01|03|07|+|+1|+3|+7|2+1|2+2|2+6|2+7|2+9|3+0|3+3|3+7|3+8|3+9|?|
分析：后面的数字指示了前面的字母大小写变化的规则，
|01|03|07|表示1,3,7个变为大写，
|2+1|2+2|2+6|2+7|2+9|3+0|3+3|3+7|3+8|3+9|表示21个,22个、26、27、29、30、33、37、38、39变为大写
最后看|+|+1|+3|+7|的意思是|1+0|1+1|1+3|1+7|，表示10个，11个，13个、17个依次改过来得到:
UmFpblJhaWRfRmxhZ19zMF9meGNrMW45X3doNHQ
得到的结果再经过base64解密可得到如下：
RainRaid_Flag_s0_fxck1n9_wh4t
答案：RainRaid_Flag_s0_fxck1n9_wh4t
28、warmup
描述见文件
解题链接： http://ctf5.shiyanbar.com/crypto/warmup.zip
点开链接下载到一个warmup.zip的文件，里面是
Warmup.pub文件和c.txt的密文
猜想这是用“openssl”加密过的一段密码，下载openssl可以打开它。
下载地址：http://download.csdn.net/download/king152004/320857
下载后至直接运行程序即可。
将Warmup.pub放在该程序的同一目录下，输入：
OpenSSL> rsa -pubin -inform PEM -text -noout -in warmup.pub
运行后出现如下结果：
OpenSSL> rsa -pubin -inform PEM -text -noout -in warmup.pub
Modulus (2050 bit):
03:67:19:8d:6b:56:14:e9:58:13:ad:d8:f2:2a:47:
17:bc:72:be:1e:ab:d9:33:d1:b8:69:44:fd:b7:5b:
8e:d2:30:be:62:d7:d1:b6:9d:22:20:95:c1:28:c8:
6f:82:01:2e:cb:11:61:91:fd:9d:01:8a:6d:02:f8:
4d:b2:7b:c5:1a:21:30:7d:c8:6f:4b:f7:71:c6:91:
c1:43:e5:ab:e5:49:b5:bd:2d:6e:b1:a2:1f:d6:27:
0e:7e:1b:48:fe:06:11:fb:b2:e1:b0:b3:52:4e:6f:
4d:e8:b4:e4:a3:45:da:44:a1:3d:e8:25:b7:26:08:
db:6c:7c:4a:40:b7:82:66:e6:c8:7b:bf:de:f6:b4:
83:81:d4:9c:45:07:a5:8b:cd:47:b7:6d:64:b4:59:
08:b1:58:bd:7e:bc:4d:ac:b0:b1:cf:d6:c2:c1:95:
74:f4:0e:b2:ef:d0:e9:e1:0d:c7:00:5c:ad:39:bc:
af:52:b9:ea:c3:87:33:68:d6:90:31:c5:e7:24:68:
4a:44:f0:68:ef:d1:d3:dc:09:6d:9b:5d:64:11:e5:
8b:de:e4:3e:46:b9:9a:0d:04:94:b9:db:28:19:5a:
f9:01:af:f1:30:d4:a6:e2:03:da:d0:8d:a5:7f:a7:
e4:02:62:a5:ba:db:2a:32:3e:da:28:b4:46:96:ab:
30:5d
Exponent:
00:f3:95:9d:97:8e:02:eb:9f:06:de:f3:f3:35:d8:
f8:af:d7:60:99:51:dd:ac:60:b7:14:b6:c2:2a:f0:
fa:91:2f:21:0b:34:20:6b:d2:4a:96:01:c7:8d:f4:
a0:27:5f:10:7f:d3:ab:55:2d:95:05:7e:b9:34:e7:
1b:dd:cd:70:45:c2:4b:18:58:7b:8c:8f:cf:5a:dd:
4c:5d:83:f0:c7:7c:94:dc:9c:50:cb:e4:38:e2:b6:
7b:af:d3:16:33:b6:aa:f1:78:1d:90:c3:ad:6f:03:
d0:37:b3:32:18:01:b2:35:46:d4:83:e6:7e:26:06:
7f:7b:22:34:7d:db:c0:c2:d5:92:ce:81:4c:bf:5d:
fc:cc:14:14:37:f1:4e:0b:39:90:f8:80:61:e5:f0:
ba:e5:f0:1e:3f:a7:0d:b0:e9:60:5e:7c:fd:57:5e:
9c:81:ef:ee:c5:29:c3:3f:d9:03:7a:20:fd:8a:cd:
51:3a:c9:63:77:68:31:3e:63:f9:83:8a:e3:51:1c:
dd:0a:9a:2b:51:6f:21:48:c8:d4:75:a3:60:a0:63:
59:44:97:39:ee:cd:25:1a:bb:42:b0:14:57:3e:43:
9f:2f:a4:57:35:57:b2:56:99:ff:c1:1e:63:1c:e8:
ee:97:5a:86:e7:e2:72:bc:f5:f7:6a:93:45:03:48:
fe:3f
在rsa中公钥长度不是越大越好，通常在65537左右被认为是比较安全的，
太小或太大都回减弱密码安全体系，我们要充分利用这一点。
公钥长度太大太小会导致Wiener’s attack:
https://en.wikipedia.org/wiki/Wiener%27s_attack
解释rsa-wiener-attack：
A Python implementation of the Wiener attack on
RSA public-key encryption scheme.
It uses some results about continued fractions
approximations to infer the private
key from public key in the cases the encryption
exponent is too small or too large.
利用这种攻击我们将可以通过e,n求出私钥d，尝试的d有限（
可以事先设置一个阈值N，即尝试的次数，本测试案例设置N为10，
实际上这远不够，可根据自己的需要适当增大N）
OpenSSL>
rsa -in warmup.pub -pubin -modulus -text
Modulus (2050 bit):
03:67:19:8d:6b:56:14:e9:58:13:ad:d8:f2:2a:47:
17:bc:72:be:1e:ab:d9:33:d1:b8:69:44:fd:b7:5b:
8e:d2:30:be:62:d7:d1:b6:9d:22:20:95:c1:28:c8:
6f:82:01:2e:cb:11:61:91:fd:9d:01:8a:6d:02:f8:
4d:b2:7b:c5:1a:21:30:7d:c8:6f:4b:f7:71:c6:91:
c1:43:e5:ab:e5:49:b5:bd:2d:6e:b1:a2:1f:d6:27:
0e:7e:1b:48:fe:06:11:fb:b2:e1:b0:b3:52:4e:6f:
4d:e8:b4:e4:a3:45:da:44:a1:3d:e8:25:b7:26:08:
db:6c:7c:4a:40:b7:82:66:e6:c8:7b:bf:de:f6:b4:
83:81:d4:9c:45:07:a5:8b:cd:47:b7:6d:64:b4:59:
08:b1:58:bd:7e:bc:4d:ac:b0:b1:cf:d6:c2:c1:95:
74:f4:0e:b2:ef:d0:e9:e1:0d:c7:00:5c:ad:39:bc:
af:52:b9:ea:c3:87:33:68:d6:90:31:c5:e7:24:68:
4a:44:f0:68:ef:d1:d3:dc:09:6d:9b:5d:64:11:e5:
8b:de:e4:3e:46:b9:9a:0d:04:94:b9:db:28:19:5a:
f9:01:af:f1:30:d4:a6:e2:03:da:d0:8d:a5:7f:a7:
e4:02:62:a5:ba:db:2a:32:3e:da:28:b4:46:96:ab:
30:5d
Exponent:
00:f3:95:9d:97:8e:02:eb:9f:06:de:f3:f3:35:d8:
f8:af:d7:60:99:51:dd:ac:60:b7:14:b6:c2:2a:f0:
fa:91:2f:21:0b:34:20:6b:d2:4a:96:01:c7:8d:f4:
a0:27:5f:10:7f:d3:ab:55:2d:95:05:7e:b9:34:e7:
1b:dd:cd:70:45:c2:4b:18:58:7b:8c:8f:cf:5a:dd:
4c:5d:83:f0:c7:7c:94:dc:9c:50:cb:e4:38:e2:b6:
7b:af:d3:16:33:b6:aa:f1:78:1d:90:c3:ad:6f:03:
d0:37:b3:32:18:01:b2:35:46:d4:83:e6:7e:26:06:
7f:7b:22:34:7d:db:c0:c2:d5:92:ce:81:4c:bf:5d:
fc:cc:14:14:37:f1:4e:0b:39:90:f8:80:61:e5:f0:
ba:e5:f0:1e:3f:a7:0d:b0:e9:60:5e:7c:fd:57:5e:
9c:81:ef:ee:c5:29:c3:3f:d9:03:7a:20:fd:8a:cd:
51:3a:c9:63:77:68:31:3e:63:f9:83:8a:e3:51:1c:
dd:0a:9a:2b:51:6f:21:48:c8:d4:75:a3:60:a0:63:
59:44:97:39:ee:cd:25:1a:bb:42:b0:14:57:3e:43:
9f:2f:a4:57:35:57:b2:56:99:ff:c1:1e:63:1c:e8:
ee:97:5a:86:e7:e2:72:bc:f5:f7:6a:93:45:03:48:
fe:3f
Modulus=367198D6B5614E95813ADD8F22A4717BC72BE1EABD933D1B86944FDB75B8ED230BE62D7D1B69D222095C128C86F82012ECB116191FD9D018A6D02F84DB27BC51A21307DC86F4BF771C691C143E5ABE549B5BD2D6EB1A21FD6270E7E1B48FE0611FBB2E1B0B3524E6F4DE8B4E4A345DA44A13DE825B72608DB6C7C4A40B78266E6C87BBFDEF6B48381D49C4507A58BCD47B76D64B45908B158BD7EBC4DACB0B1CFD6C2C19574F40EB2EFD0E9E10DC7005CAD39BCAF52B9EAC3873368D69031C5E724684A44F068EFD1D3DC096D9B5D6411E58BDEE43E46B99A0D0494B9DB28195AF901AFF130D4A6E203DAD08DA57FA7E40262A5BADB2A323EDA28B44696AB305D
writing RSA key
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAQEDZxmNa1YU6VgTrdjyKkcX
vHK+HqvZM9G4aUT9t1uO0jC+YtfRtp0iIJXBKMhvggEuyxFhkf2dAYptAvhNsnvF
GiEwfchvS/dxxpHBQ+Wr5Um1vS1usaIf1icOfhtI/gYR+7LhsLNSTm9N6LTko0Xa
RKE96CW3JgjbbHxKQLeCZubIe7/e9rSDgdScRQeli81Ht21ktFkIsVi9frxNrLCx
z9bCwZV09A6y79Dp4Q3HAFytObyvUrnqw4czaNaQMcXnJGhKRPBo79HT3Altm11k
EeWL3uQ+RrmaDQSUudsoGVr5Aa/xMNSm4gPa0I2lf6fkAmKlutsqMj7aKLRGlqsw
XQKCAQEA85Wdl44C658G3vPzNdj4r9dgmVHdrGC3FLbCKvD6kS8hCzQga9JKlgHH
jfSgJ18Qf9OrVS2VBX65NOcb3c1wRcJLGFh7jI/PWt1MXYPwx3yU3JxQy+Q44rZ7
r9MWM7aq8XgdkMOtbwPQN7MyGAGyNUbUg+Z+JgZ/eyI0fdvAwtWSzoFMv138zBQU
N/FOCzmQ+IBh5fC65fAeP6cNsOlgXnz9V16cge/uxSnDP9kDeiD9is1ROsljd2gx
PmP5g4rjURzdCporUW8hSMjUdaNgoGNZRJc57s0lGrtCsBRXPkOfL6RXNVeyVpn/
wR5jHOjul1qG5+JyvPX3apNFA0j+Pw==
-----END PUBLIC KEY-----
上面的图片是公钥的 既然是RSA 那么就离不开 n d e 三个数值
猜想上面就是编码格式：(这个解题编码要配置)
- # coding=utf-8
- import ContinuedFractions, Arithmetic
- import binascii
- def hack_RSA(e,n):
- ‘‘‘‘‘
- Finds d knowing (e,n)
- applying the Wiener continued fraction attack
- ‘‘‘
- frac = ContinuedFractions.rational_to_contfrac(e, n)
- convergents = ContinuedFractions.convergents_from_contfrac(frac)
- for (k,d) in convergents:
- #check if d is actually the key
- if k!=0 and (e*d-1)%k == 0:
- phi = (e*d-1)//k
- s = n - phi + 1
- # check if the equation x^2 - s*x + n = 0
- # has integer roots
- discr = s*s - 4*n
- if(discr>=0):
- t = Arithmetic.is_perfect_square(discr)
- if t!=-1 and (s+t)%2==0:
- #print("Hacked!")
- return d
- if __name__ == "__main__":
- print("-------------------------")
- n=0x367198D6B5614E95813ADD8F22A4717BC72BE1EABD933D1B86944FDB75B8ED230BE62D7D1B69D222095C128C86F82012ECB116191FD9D018A6D02F84DB27BC51A21307DC86F4BF771C691C143E5ABE549B5BD2D6EB1A21FD6270E7E1B48FE0611FBB2E1B0B3524E6F4DE8B4E4A345DA44A13DE825B72608DB6C7C4A40B78266E6C87BBFDEF6B48381D49C4507A58BCD47B76D64B45908B158BD7EBC4DACB0B1CFD6C2C19574F40EB2EFD0E9E10DC7005CAD39BCAF52B9EAC3873368D69031C5E724684A44F068EFD1D3DC096D9B5D6411E58BDEE43E46B99A0D0494B9DB28195AF901AFF130D4A6E203DAD08DA57FA7E40262A5BADB2A323EDA28B44696AB305D
- e=0xF3959D978E02EB9F06DEF3F335D8F8AFD7609951DDAC60B714B6C22AF0FA912F210B34206BD24A9601C78DF4A0275F107FD3AB552D95057EB934E71BDDCD7045C24B18587B8C8FCF5ADD4C5D83F0C77C94DC9C50CBE438E2B67BAFD31633B6AAF1781D90C3AD6F03D037B3321801B23546D483E67E26067F7B22347DDBC0C2D592CE814CBF5DFCCC141437F14E0B3990F88061E5F0BAE5F01E3FA70DB0E9605E7CFD575E9C81EFEEC529C33FD9037A20FD8ACD513AC9637768313E63F9838AE3511CDD0A9A2B516F2148C8D475A360A06359449739EECD251ABB42B014573E439F2FA4573557B25699FFC11E631CE8EE975A86E7E272BCF5F76A93450348FE3F
- d=hack_RSA(e,n)
- #print(hack_RSA(e,n))打印不了hack_RSA(e,n)不是字符串
- print(‘d= ‘+str(d))
- c=0x1e04304936215de8e21965cfca9c245b1a8f38339875d36779c0f123c475bc24d5eef50e7d9ff5830e80c62e8083ec55f27456c80b0ab26546b9aeb8af30e82b650690a2ed7ea407dcd094ab9c9d3d25a93b2140dcebae1814610302896e67f3ae37d108cd029fae6362ea7ac1168974c1a747ec9173799e1107e7a56d783660418ebdf6898d7037cea25867093216c2c702ef3eef71f694a6063f5f0f1179c8a2afe9898ae8dec5bb393cdffa3a52a297cd96d1ea602309ecf47cd009829b44ed3100cf6194510c53c25ca7435f60ce5f4f614cdd2c63756093b848a70aade002d6bc8f316c9e5503f32d39a56193d1d92b697b48f5aa43417631846824b5e86
- m=hex(pow(c,d,n))
- print(str(m))
- print(binascii.unhexlify(m[2:]))#unhexlify和a2b_hex实际是一个函数，建议使用unhexlify。作用是16转换产生的字串
- print("-------------------------")
求出d=422190901650907812920180123687944676069788522092850669615064693823744099274668340988114145183193919060
9743447676525325543963362353923989076199470515758399
得到D的值之后：用python进行解题（python2.7）
import binascii
n = 0x367198D6B5614E95813ADD8F22A4717BC72BE1EABD933D1B86944FDB75B8ED230BE62D7D1B69D222095C128C86F82012ECB116191FD9D018A6D02F84DB27BC51A21307DC86F4BF771C691C143E5ABE549B5BD2D6EB1A21FD6270E7E1B48FE0611FBB2E1B0B3524E6F4DE8B4E4A345DA44A13DE825B72608DB6C7C4A40B78266E6C87BBFDEF6B48381D49C4507A58BCD47B76D64B45908B158BD7EBC4DACB0B1CFD6C2C19574F40EB2EFD0E9E10DC7005CAD39BCAF52B9EAC3873368D69031C5E724684A44F068EFD1D3DC096D9B5D6411E58BDEE43E46B99A0D0494B9DB28195AF901AFF130D4A6E203DAD08DA57FA7E40262A5BADB2A323EDA28B44696AB305D
d = 4221909016509078129201801236879446760697885220928506696150646938237440992746683409881141451831939190609743447676525325543963362353923989076199470515758399L
c = 0x1e04304936215de8e21965cfca9c245b1a8f38339875d36779c0f123c475bc24d5eef50e7d9ff5830e80c62e8083ec55f27456c80b0ab26546b9aeb8af30e82b650690a2ed7ea407dcd094ab9c9d3d25a93b2140dcebae1814610302896e67f3ae37d108cd029fae6362ea7ac1168974c1a747ec9173799e1107e7a56d783660418ebdf6898d7037cea25867093216c2c702ef3eef71f694a6063f5f0f1179c8a2afe9898ae8dec5bb393cdffa3a52a297cd96d1ea602309ecf47cd009829b44ed3100cf6194510c53c25ca7435f60ce5f4f614cdd2c63756093b848a70aade002d6bc8f316c9e5503f32d39a56193d1d92b697b48f5aa43417631846824b5e86
m = hex(pow(c, d, n)).rstrip("L")
print m
print binascii.unhexlify(m[2:])
程序运行后：
0x424354467b3965745265613479217d
BCTF{9etRea4y!}
答案：BCTF{9etRea4y!}
29、古典密码的安全性不高，但仍然十分美妙，请破译下面的密文
本题 flag 并非 flag{可见字符} 的形式
解题链接： http://ctf5.shiyanbar.com/qwctf/1.html
打开链接后出现如下的代码：
Os drnuzearyuwn, y jtkjzoztzoes douwlr oj y ilzwex eq lsdexosa kn pwodw tsozj eq ufyoszlbz yrl rlufydlx pozw douwlrzlbz, ydderxosa ze y rlatfyr jnjzli; mjy gfbmw vla xy wbfnsy symmyew (mjy vrwm qrvvrf), hlbew rd symmyew, mebhsymw rd symmyew, vbomgeyw rd mjy lxrzy, lfk wr dremj. Mjy eyqybzye kyqbhjyew mjy myom xa hyedrevbfn lf bfzyewy wgxwmbmgmbrf. Wr mjy dsln bw f1_2jyf-k3_jg1-vb-vl_l
解题思路：看到这一长串的字符串，可以猜想可能是字符串，在
https://quipqiup.com/（在线解密平台）
可以看到So the flag is后面的就是答案，输入提交果然是答案。
答案：n1_2hen-d3_hu1-mi-ma_a
30、杯酒人生
使用古典密码
一喵星人要想喵星发送一段不知道干什么用的密码“BLOCKCIPHERDESIGNPRINCIPLE”，
但是它忘记了密钥是什么， 手头（爪头）只有它自己加密过的密钥“HTRUZYJW”，
而且它
还知道原密钥是一个单词， 你可以帮助它传递信息， 早日攻克蓝星， 征服人类吗？
解题思路：根据题目提示原密钥是一个单词，猜想这个密钥是使用最常使用的凯撒移位，根据凯撒密码的加密方式，写出如下的py脚本.(注：输入的解密字符串为小写时，输出也是，输入为大写时输出也是大写。
#实现大小写字母并行平移
def
change1(c,i):
num=ord(c)
if(num>=97 and num<=122):
num=97+(num+i-97)%(26)
return chr(num)
def
change2(c,i):
num=ord(c)
if(num>=65 and num<=90):
num=65+(num+i-65)%(26)
return chr(num)
def
kaisa_jiAmi(string,i):
string_new=‘‘
for s in string:
num=ord(s)
if(num>=97 and num<=122 ):
string_new+=change1(s,i)
elif(num>=65 and num<=90 ):
string_new+=change2(s,i)
print(string_new)
return string_new
#本题有种暴力解密感觉
def
kaisa_jiEmi(string):
for i in range(0,26):
print(‘第‘+str(i+1)+‘种可能:‘)
#区别在于 string 是该对象原本就是字符串类型, 而 str()则是将该对象转换成字符串类型。
kaisa_jiAmi(string,i)
#你要知道input输入的数据类型都是string
def
main():
print(‘请输入操作，注意默认小写，大写同理:‘)
choice=raw_input(‘1:恺撒加密,2:凯撒穷举解密.请输入1或2：‘)
if choice==‘1‘:
string=raw_input(‘请输入需要加密字符串： ‘)
num=int(raw_input(‘请输入需要加密的KEY： ‘))
kaisa_jiAmi(string,num)
elif choice==‘2‘:
string=raw_input(‘请输入需要解密字符串： ‘)
kaisa_jiEmi(string)
else:
print(‘输入错误，请重试‘)
main()
if
__name__==‘__main__‘:
main()
程序运行后的输出：
请输入操作，注意默认小写，大写同理:
1:恺撒加密,2:凯撒穷举解密.请输入1或2：2
请输入需要解密字符串： htruzyjw
第1种可能:
htruzyjw
第2种可能:
iusvazkx
第3种可能:
jvtwbaly
第4种可能:
kwuxcbmz
第5种可能:
lxvydcna
第6种可能:
mywzedob
第7种可能:
nzxafepc
第8种可能:
oaybgfqd
第9种可能:
pbzchgre
第10种可能:
qcadihsf
第11种可能:
rdbejitg
第12种可能:
secfkjuh
第13种可能:
tfdglkvi
第14种可能:
ugehmlwj
第15种可能:
vhfinmxk
第16种可能:
wigjonyl
第17种可能:
xjhkpozm
第18种可能:
ykilqpan
第19种可能:
zljmrqbo
第20种可能:
amknsrcp
第21种可能:
bnlotsdq
第22种可能:
computer
第23种可能:
dpnqvufs
第24种可能:
eqorwvgt
第25种可能:
frpsxwhu
第26种可能:
Gsqtyxiv
根据提示：原密钥是一个单词，查看输出的结果知，密钥为：COMPUTER
看到题目中全部出现大写字母：密钥和密文都是，因此猜想可能是特殊的特殊凯撒密码---维吉尼亚密码。
本题中：明文：BLOCKCIPHERDESIGNPRINCIPLE
密钥：COMPUTER
维尼吉亚加密代码如下：
#——*coding:utf-8*-
# 维吉尼亚密码
def
VigenereEncryto(min,key):
MinLen=len(min)#明文长度
KeyLen=len(key)#密钥长度
(q,r)=divmod(MinLen,KeyLen)#q商 r余数
out=""
#完整映射密钥的加密
for i in range(0,q):
for j in range(0,KeyLen):
#谈谈核心代码理解结合实例
#密钥:R
#明文:T
#密文:K：
#(R-A)%26+A和（T-A）%26+A得到K===>（T-A+R-A）%26+A
#（T-A）%26+A就是以A开头第T个元素，A与R列对齐意思即是，(R-A)%26+A就是以R头字母表，R之后的第T-A元素
c=int((ord(min[i*KeyLen+j])-ord(‘A‘)+ord(key[j])-ord(‘A‘))%26+ord(‘A‘))
out+=chr(c)
#残余映射密钥加密
for i in range(0,r):
c=int((ord(min[q*KeyLen+i])-ord(‘A‘)+ord(key[i])-ord(‘A‘))%26+ord(‘A‘))
out+=chr(c)
return out
def
VigenereDecryto(anwen,key):
AnLen=len(anwen)#明文长度
KeyLen=len(key)#密钥长度
(q,r)=divmod(AnLen,KeyLen)#q商 r余数
out=""
#完整映射密钥的加密
for i in range(0,q):
for j in range(0,KeyLen):
#已知暗文位置减去A,加上Z减去key的位置就是，A到明文长度
#K-A+1
+ Z-R===〉T-A
c=int((ord(anwen[i*KeyLen+j])-ord(‘A‘)+1+ord(‘Z‘)-ord(key[j]))%26+ord(‘A‘))
out+=chr(c)
#残余映射密钥加密
for i in range(0,r):
c=int((ord(anwen[q*KeyLen+i])-ord(‘A‘)+1+ord(‘Z‘)-ord(key[i]))%26+ord(‘A‘))
out+=chr(c)
return out
def
Lower(str):
u=""
for i in str:
u+=i.lower()
return u
if
__name__==‘__main__‘:
num=raw_input(‘选择维吉尼亚模式：1加密，2解密： ‘)
if(num==‘1‘):
str=raw_input(‘请输入明文: ‘)
key=raw_input(‘请输入密钥: ‘)
print(‘加密后的密文： ‘+VigenereEncryto(str,key))
print(‘密文转化成小写：
‘+Lower(VigenereEncryto(str,key)))
elif(num==‘2‘):
str=raw_input(‘ 请输入密文: ‘)
key=raw_input(‘ 请输入密钥: ‘)
print(‘解密后的明文： ‘+VigenereDecryto(str,key))
print(‘明文转化成小写：
‘+Lower(VigenereDecryto(str,key)))
else:
print(‘Error‘)
运行结果：
答案：DZAREVMGJSDSYLMXPDDXHVMGNS