base64
base64加密的原理：3 8 = 4 6，也就是将原来的3个字节转换成4个6位二进制数，而且一定是3个字节变换成4组的6位二进制数。详细步骤：将字符的ASCII码转换成二进制，接着将二进制串每6个为一组，但有时二进制数的个数不那么恰巧就是6的倍数，所以最后一组后面补0，当一组全部都是0的时候编码是”=”。因为计算机的一个字节是占8位，所以每一组高位再补上两个0。最后将二进制数转成十进制后映射到base64编码表，形成新的字符串。
例如：对字符’34’进行加密，对应的ASCII码分别是51和52，对应的二进制串为001100 110011 0100，转换之后就是00001100 00110011 00010000 00000000，编码之后就是”MzQ=”。
base64解密原理就是加密的逆过程，就不再详细介绍了。
点开附件：
Y3liZXJwZWFjZXtXZWxjb21lX3RvX25ld19Xb3JsZCF9搞个解密脚本，因为python有base64库，所以实现起来并不难：
import base64
Str1 = 'Y3liZXJwZWFjZXtXZWxjb21lX3RvX25ld19Xb3JsZCF9'
print ("flag{" + str(base64.b64decode(Str1)) + "}")根据上面的加密原理，编写一个加密脚本，说不定会在比赛中出现：
import string
Str1 = 'cyberpeace{Welcome_to_new_World!}'
def base(string):
oldstr = ''
newstr = []
base = ''
base64_list = ['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', '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', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/']
#把原始字符串转换为二进制，用bin转换后是0b开头的，所以把b替换了，首位补0补齐8位
for i in string:
oldstr += '{:08}'.format(int(str(bin(ord(i))).replace('0b', '')))
#把转换好的二进制按照6位一组分好，最后一组不足6位的后面补0
for j in range(0, len(oldstr), 6):
newstr.append('{:<06}'.format(oldstr[j:j + 6]))
#在base64_list中找到对应的字符，拼接。int函数的第二个参数是描述第一个参数的进制属性，最后返回的结果是十进制数
for l in range(len(newstr)):
base += base64_list[int(newstr[l], 2)]
#判断base字符结尾补几个‘=’
if len(string) % 3 == 1:
base += '=='
elif len(string) % 3 == 2:
base += '='
return base
print(base(Str1))Caesar
凯撒密码(Caesar Cipher或称恺撒加密、恺撒变换、变换加密、位移加密) 是一种替换加密，明文中的所有字母 都在字母表上向后（或向前）按照一 个固定数目进行偏移后被替换成密文。例，当偏移量是3的时候，所有的字母 A将被替换成D，B变成E，以此类推。
加解密原理可以表示为：E(x) = (x + n) mod 26，D(x) = (x - n) mod 26。(其中n位偏移量)
查找相关资料，还存在若干特定的凯撒密码名称：
偏移量为10：Avocat；偏移量为13：ROT13；偏移量为-5：Cassis(K 6)；偏移量为-6：cassette(K 7)
点击附件，密文为：
oknqdbqmoq{kag_tmhq_xqmdzqp_omqemd_qzodkbfuaz}经过一番试错之后，得到n为12，所以明文为：
cyberpeace{you_have_learned_caesar_encryption}Morse
摩尔斯电码(Morse Code)是由美国人萨缪尔·摩尔斯 在1836年发明的一种时通时断的且通过不同的排列顺序来表达不同英文字母、数字和标点符号的信号代码， 摩尔斯电码主要由以下5种它的代码组成： 1. 点（.） 2. 划（-） 3. 每个字符间短的停顿（通常用空格表示停顿） 4. 每个词之间中等的停顿（通常用 / 划分） 5. 以及句子之间长的停顿
点击附件，密文为：
11 111 010 000 0 1010 111 100 0 00 000 000 111 00 10 1 0 010 0 000 1 00 10 110我们将”1“替换为”-“，”0“替换为”.“，即可得到密文：
-- --- .-. ... . -.-. --- -.. . .. ... ... --- .. -. - . .-. . ... - .. -. --.通过在线解密工具，得到明文：
MORSECODEISSOINTERESTING最后改成题目要求的格式即可提交。
不仅仅是Morse
点开附件，密文为：
--/.-/-.--/..--.-/-..././..--.-/..../.-/...-/./..--.-/.-/-./---/-/...././.-./..--.-/-.././-.-./---/-.././..../..../..../..../.-/.-/.-/.-/.-/-.../.-/.-/-.../-.../-.../.-/.-/-.../-.../.-/.-/.-/.-/.-/.-/.-/.-/-.../.-/.-/-.../.-/-.../.-/.-/.-/.-/.-/.-/.-/-.../-.../.-/-.../.-/.-/.-/-.../-.../.-/.-/.-/-.../-.../.-/.-/-.../.-/.-/.-/.-/-.../.-/-.../.-/.-/-.../.-/.-/.-/-.../-.../.-/-.../.-/.-/.-/-.../.-/.-/.-/-.../.-/.-/-.../.-/-.../-.../.-/.-/-.../-.../-.../.-/-.../.-/.-/.-/-.../.-/-.../.-/-.../-.../.-/.-/.-/-.../-.../.-/-.../.-/.-/.-/-.../.-/.-/-.../.-/.-/-.../.-/.-/.-/.-/-.../-.../.-/-.../-.../.-/.-/-.../-.../.-/.-/-.../.-/.-/-.../.-/.-/.-/-.../.-/.-/-.../.-/.-/-.../.-/.-/-.../.-/-.../.-/.-/-.../-.../.-/-.../.-/.-/.-/.-/-.../-.../.-/-.../.-/.-/-.../-.../.-根据Morse电码的特性，可知”/“是空格，然后我们直接将其解密，明文为：
MAY..--.-BE..--.-HAVE..--.-ANOTHER..--.-DECODEHHHHAAAAABAABBBAABBAAAAAAAABAABABAAAAAAABBABAAABBAAABBAABAAAABABAABAAABBABAAABAAABAABABBAABBBABAAABABABBAAABBABAAABAABAABAAAABBABBAABBAABAABAAABAABAABAABABAABBABAAAABBABAABBA去除干扰项，剩下就是由’A‘和’B‘组成的密文了。根据这个特性，突然联想到最近刚接触到的古典密码：培根密码，剩下的就是对其解密啦。
上脚本：
import re
#明文，并转换成小写
s = 'AAAAABAABBBAABBAAAAAAAABAABABAAAAAAABBABAAABBAAABBAABAAAABABAABAAABBABAAABAAABAABABBAABB' \
'BABAAABABABBAAABBABAAABAABAABAAAABBABBAABBAABAABAAABAABAABAABABAABBABAAAABBABAABBA'
a = s.lower()
#培根密码的编码表
CODE_TABLE = {
'a':'aaaaa','b':'aaaab','c':'aaaba','d':'aaabb','e':'aabaa','f':'aabab','g':'aabba',
'h':'aabbb','i':'abaaa','j':'abaab','k':'ababa','l':'ababb','m':'abbaa','n':'abbab',
'o':'abbba','p':'abbbb','q':'baaaa','r':'baaab','s':'baaba','t':'baabb','u':'babaa',
'v':'babab','w':'babba','x':'babbb','y':'bbaaa','z':'bbaab'
}
#将明文中每5个字符分开，并映射到编码表
def peigendecode(peigen):
msg = ''
codes = re.findall(r'.{5}', a)
for code in codes:
if code =='':
msg +=''
else:
#这句是将键与值进行互换属性，得到另外一个字典
UNCODE = dict(map(lambda t:(t[1], t[0]), CODE_TABLE.items()))
msg += UNCODE[code]
return msg
flag = peigendecode(a)
print("flag = ", flag)
培根密码：培根密码(Baconian Cipher)是一种替换密码，每个明文字母被一个由5字符组成的序列替换，最初的加密方式就是由‘A’和‘B’组成序列替换明文(所以你当然也可以用别的字母)，比如字母‘D’ 替换成“aaabb” 。
easychallenge
附件是一个已经编译过的python文件，通过反编译工具可以看到源码：
import base64
def encode1(ans):
s = ''
for i in ans:
x = ord(i) ^ 36
x = x + 25
s += chr(x)
return s
def encode2(ans):
s = ''
for i in ans:
x = ord(i) + 36
x = x ^ 36
s += chr(x)
return s
def encode3(ans):
return base64.b32encode(ans)
flag = ' '
print 'Please Input your flag:'
flag = raw_input()
final = 'UC7KOWVXWVNKNIC2XCXKHKK2W5NLBKNOUOSK3LNNVWW3E==='
if encode3(encode2(encode1(flag))) == final:
print 'correct'
else:
print 'wrong'相当于是加密脚本了，写个逆向的解密脚本：
import base64
def decode1(ans):
s = ''
for i in ans:
x = ord(i) - 25
x = x ^ 36
s += chr(x)
return s
def decode2(ans):
s = ''
for i in ans:
x = i ^ 36
x = x - 36
s += chr(x)
return s
def decode3(ans):
return base64.b32decode(ans)
cipher = "UC7KOWVXWVNKNIC2XCXKHKK2W5NLBKNOUOSK3LNNVWW3E==="
plainer = decode1(decode2(decode3(cipher)))
print(plainer)转轮机加密
题目如下：
1: < ZWAXJGDLUBVIQHKYPNTCRMOSFE <
2: < KPBELNACZDTRXMJQOYHGVSFUWI <
3: < BDMAIZVRNSJUWFHTEQGYXPLOCK <
4: < RPLNDVHGFCUKTEBSXQYIZMJWAO <
5: < IHFRLABEUOTSGJVDKCPMNZQWXY <
6: < AMKGHIWPNYCJBFZDRUSLOQXVET <
7: < GWTHSPYBXIZULVKMRAFDCEONJQ <
8: < NOZUTWDCVRJLXKISEFAPMYGHBQ <
9: < XPLTDSRFHENYVUBMCQWAOIKZGJ <
10: < UDNAJFBOWTGVRSCZQKELMXYIHP <
11： < MNBVCXZQWERTPOIUYALSKDJFHG <
12： < LVNCMXZPQOWEIURYTASBKJDFHG <
13： < JZQAWSXCDERFVBGTYHNUMKILOP <
密钥为：2,3,7,5,13,12,9,1,8,10,4,11,6
密文为：NFQKSEVOQOFNP按照密钥的顺序进行排序，题目中的第二行是原来的第一行：
2: < KPBELNACZDTRXMJQOYHGVSFUWI <
3: < BDMAIZVRNSJUWFHTEQGYXPLOCK <
7: < GWTHSPYBXIZULVKMRAFDCEONJQ <
5: < IHFRLABEUOTSGJVDKCPMNZQWXY <
13： < JZQAWSXCDERFVBGTYHNUMKILOP <
12： < LVNCMXZPQOWEIURYTASBKJDFHG <
9: < XPLTDSRFHENYVUBMCQWAOIKZGJ <
1: < ZWAXJGDLUBVIQHKYPNTCRMOSFE <
8: < NOZUTWDCVRJLXKISEFAPMYGHBQ <
10: < UDNAJFBOWTGVRSCZQKELMXYIHP <
4: < RPLNDVHGFCUKTEBSXQYIZMJWAO <
11： < MNBVCXZQWERTPOIUYALSKDJFHG <
6: < AMKGHIWPNYCJBFZDRUSLOQXVET <再按照密文中的字母是每行的首字母，且首字母（包含在其后面的字符串）插入到字符串前面，形成新的字符串，例如第一行变为：
NACZDTRXMJQOYHGVSFUWIKPBEL整个的字符串数组变为：
N A C Z D T R X M J Q O Y H G V S F U W I K P B E L
F H T E Q G Y X P L O C K B D M A I Z V R N S J U W
Q G W T H S P Y B X I Z U L V K M R A F D C E O N J
K C P M N Z Q W X Y I H F R L A B E U O T S G J V D
S X C D E R F V B G T Y H N U M K I L O P J Z Q A W
E I U R Y T A S B K J D F H G L V N C M X Z P Q O W
V U B M C Q W A O I K Z G J X P L T D S R F H E N Y
O S F E Z W A X J G D L U B V I Q H K Y P N T C R M
Q N O Z U T W D C V R J L X K I S E F A P M Y G H B
O W T G V R S C Z Q K E L M X Y I H P U D N A J F B
F C U K T E B S X Q Y I Z M J W A O R P L N D V H G
N B V C X Z Q W E R T P O I U Y A L S K D J F H G M
P N Y C J B F Z D R U S L O Q X V E T A M K G H I W发现第17列的字符串是符合逻辑的，所以它就是flag。
幂数加密
题目如下：
8842101220480224404014224202480122其实是以0为间隔，一段内的数字和为某个字母在字母表中的序号。
不过，查了下百度有一个比较接近题目意思的幂数加密
混合编码
题目如下：
JiM3NjsmIzEyMjsmIzY5OyYjMTIwOyYjNzk7JiM4MzsmIzU2OyYjMTIwOyYjNzc7JiM2ODsmIzY5OyYjMTE4OyYjNzc7JiM4NDsmIzY1OyYjNTI7JiM3NjsmIzEyMjsmIzEwNzsmIzUzOyYjNzY7JiMxMjI7JiM2OTsmIzEyMDsmIzc3OyYjODM7JiM1NjsmIzEyMDsmIzc3OyYjNjg7JiMxMDc7JiMxMTg7JiM3NzsmIzg0OyYjNjU7JiMxMjA7JiM3NjsmIzEyMjsmIzY5OyYjMTIwOyYjNzg7JiMxMDU7JiM1NjsmIzEyMDsmIzc3OyYjODQ7JiM2OTsmIzExODsmIzc5OyYjODQ7JiM5OTsmIzExODsmIzc3OyYjODQ7JiM2OTsmIzUwOyYjNzY7JiMxMjI7JiM2OTsmIzEyMDsmIzc4OyYjMTA1OyYjNTY7JiM1MzsmIzc4OyYjMTIxOyYjNTY7JiM1MzsmIzc5OyYjODM7JiM1NjsmIzEyMDsmIzc3OyYjNjg7JiM5OTsmIzExODsmIzc5OyYjODQ7JiM5OTsmIzExODsmIzc3OyYjODQ7JiM2OTsmIzExOTsmIzc2OyYjMTIyOyYjNjk7JiMxMTk7JiM3NzsmIzY3OyYjNTY7JiMxMjA7JiM3NzsmIzY4OyYjNjU7JiMxMTg7JiM3NzsmIzg0OyYjNjU7JiMxMjA7JiM3NjsmIzEyMjsmIzY5OyYjMTE5OyYjNzc7JiMxMDU7JiM1NjsmIzEyMDsmIzc3OyYjNjg7JiM2OTsmIzExODsmIzc3OyYjODQ7JiM2OTsmIzExOTsmIzc2OyYjMTIyOyYjMTA3OyYjNTM7JiM3NjsmIzEyMjsmIzY5OyYjMTE5OyYjNzc7JiM4MzsmIzU2OyYjMTIwOyYjNzc7JiM4NDsmIzEwNzsmIzExODsmIzc3OyYjODQ7JiM2OTsmIzEyMDsmIzc2OyYjMTIyOyYjNjk7JiMxMjA7JiM3ODsmIzY3OyYjNTY7JiMxMjA7JiM3NzsmIzY4OyYjMTAzOyYjMTE4OyYjNzc7JiM4NDsmIzY1OyYjMTE5Ow==看到末尾有两个==，先试一下base64吧：
LzExOS8xMDEvMTA4Lzk5LzExMS8xMDkvMTAxLzExNi8xMTEvOTcvMTE2LzExNi85Ny85OS8xMDcvOTcvMTEwLzEwMC8xMDAvMTAxLzEwMi8xMDEvMTEwLzk5LzEwMS8xMTkvMTExLzExNC8xMDgvMTAw看到里面有”&”和”#”两个符号，这是一种Unicode字符的十进制的写法，进行转换：
LzExOS8xMDEvMTA4Lzk5LzExMS8xMDkvMTAxLzExNi8xMTEvOTcvMTE2LzExNi85Ny85OS8xMDcvOTcvMTEwLzEwMC8xMDAvMTAxLzEwMi8xMDEvMTEwLzk5LzEwMS8xMTkvMTExLzExNC8xMDgvMTAw做到这一步开始有点发闷，要用什么进行解密？看到网上的博客竟然还是使用base64解密，啊这。。
/119/101/108/99/111/109/101/116/111/97/116/116/97/99/107/97/110/100/100/101/102/101/110/99/101/119/111/114/108/100对照ASCII码表就可以解得明文。
Normal_RSA
题目如下是一个flag.enc文件和一个pubkey.pem文件，因为RSA是一个公开密钥加密方式，初步分析是通过公钥求解私钥，在通过私钥求解flag。
enc后缀是通过openssl加密后生成的文件，通过kali的openssl查看pubkey.pem文件：
分解Modulus（即n），先进行进制转换再分解：
在kali上安装rsatool，计算d并生成private.pem文件
python rsatool.py -f PEM -o private.pem -p 275127860351348928173285174381581152299 -q 319576316814478949870590164193048041239 -e 65537对flag.enc进行解密：
openssl rsautl -decrypt -in flag.enc -inkey private.pem
参考：