RSA加密算法
rsa基本组成
在RSA加密算法中，以下是常用的符号和对应的含义：
e：公钥指数（exponent），用于加密操作。通常为一个较小的固定值，例如65537。
p和q：两个不同的大素数，用于生成RSA密钥对。它们的乘积n (n = p * q) 是模数（modulus），用于加密和解密操作。
d：私钥指数（exponent），用于解密操作。它通过使用扩展欧几里得算法计算得到，满足 e * d ≡ 1 (mod φ(n))，其中 φ(n) 是欧拉函数值。
n：模数（modulus），也是公钥和私钥共享的一个参数。它是两个素数 p 和 q 的乘积，即 n = p * q。
φ(n)即phi：欧拉函数（Euler’s totient function）的值，表示与 n 互质的正整数的数量。对于两个素数 p 和 q 的乘积 n，φ(n) = (p-1)*(q-1)。
m：明文（plaintext），需要被加密的消息或数据。m=c^d mod n
c: 密文，c=m^e mod n
总结：
e是公钥指数，p和q是素数，d是私钥指数，n是模数，phi是欧拉函数值，m是明文。
已知p,q,e求d（rsa）
我们导入python的gmpy2库，这个库求rsa超好用
1 | from gmpy2 import invert |
成功得到flag
已知p,q,e,c 求明文m [buu rsarsa题]
1 | from libnum import n2s,s2n |
已知p,q,dp,dq,c 求明文m [buu RSA1题]
小记一下：在RSA密码中，dp和dq是私钥的参数，用于加速中国剩余定理（Chinese Remainder Theorem, CRT）解密算法。
dp：是d对p-1的模反元素（modular inverse）。即 dp = d mod (p-1)。
dq：是d对q-1的模反元素。即 dq = d mod (q-1)。
这两个参数在CRT解密算法中起到加速解密过程的作用，通过使用CRT算法可以减少模幂运算的计算量，提高解密效率。具体来说，当进行解密时，先对密文进行两次模幂运算，分别使用dp和dq，并分别取得结果m1和m2。然后根据CRT算法，使用p、q、dp、dq以及模数n计算出明文m。这种方式相比于直接使用d进行模幂运算，能够大大提高解密速度。
m = (m1 + (I * (m2 - m1)) * p) % n
1 | from libnum import n2s,s2n |
逆元
给定整数 𝑎a 和模数 𝑚m，如果存在一个整数 𝑥x，使得：
𝑎⋅𝑥≡1(mod𝑚)a⋅x≡1(modm)
那么这个 𝑥x 就是 𝑎a 的模 𝑚m 下的乘法逆元，记作 𝑎−1(mod 𝑚)a−1(mod m)。
已知e1,e2,c1,c2,n 求明文m(共模攻击）[buu RSA3]
小记一下：
根据给定的参数 e1、e2、c1、c2 和模数 n，下面是求解明文 m 的一般步骤：
使用扩展欧几里得算法计算 e1 和 e2 的最大公约数 gcd(e1, e2)。确保它等于 1，否则无法进行共模攻击。
计算 e1 在模 e2 下的模反元素 s1 = e1^-1 mod e2，以及 e2 在模 e1 下的模反元素 s2 = e2^-1 mod e1。
计算明文 m：
计算 x = (c1^s1 * c2^s2) mod n。
计算 m = x mod n。
需要注意的是，在实际计算过程中，可以使用模幂运算算法和模反元素算法来进行计算。
此外，如果 m 不在 0 到 n-1 的范围内，还需要对结果进行适当的调整，以保证明文 m 在正确的范围内。
1 | from gmpy2 import * |
已知e,n,dp,c 求明文m（dp泄露）[buu RSA2题]
小记一下:
dp=d%(p-1)
dq=d%(q-1)
dp*e = i*(p-1)+1
1 | from gmpy2 import * |
已知p,q,e,n,文件加密密文 求密文m [buu RSA题]
e= 65537
n=86934482296048119190666062003494800588905656017203025617216654058378322103517
p= 285960468890451637935629440372639283459
q= 304008741604601924494328155975272418463
d=81176168860169991027846870170527607562179635470395365333547868786951080991441
enc文件不能直接读，应该用代码读
1 | from Crypto.Util.number import bytes_to_long |
已知p+q，(p+1)*(q+1),c,d求明文m（[GUET-CTF2019]BabyRSA ）
(p+1)(q+1)=pq+1+p+q
n=p*q
m=c^d mod n
写个脚本
1 | from libnum import n2s |
Dangerous RSA（低加密指数攻击）
sa 的加密 为 c = m ^ e mod n
当e 很小，n很大 时，有两种情况
m ^ e 有可能小于 n 。 此时， c = m ^ e 。 密文 m = c 开e次方
当 m ^ e > n 。 此时。 m ^ e = kn + c 。 k 是整数 。对 k 进行爆破，就能找到对应的m
1 | #python3 |
iroot(c+k*n,e)为c+k*n开e次方
mpz用来处理大整数和需要高精度运算
RSAROLL（rsa）
题目信息没看懂，找大佬的wp才知道{920139713,19}，一个是n，一个是e，后面那一大串是拆分的c
我们通过网站分解n得到
p= 18443
q=49891
所以已知信息有
p= 18443
q=49891
n=920139713
e=19
我们写脚本来爆c
1 | import libnum |
得到flag
1 | flag{13212je2ue28fy71w8u87y31r78eu1e2} |
rsa2
源码长这样，我们需要将N分解为p和q
p=9046853915223503351787031888977627106934564043204783593118678181991596316582877057556463152579621699010610569526573031954779520781448550677767565207407183
q=11273732364123571293429600400343309403733952146912318879993851141423284675797325272321856863528776914709992821287788339848962916204774010644058033316303937
然后改一下代码
1 |
|
根据原题处理d值并输出
这里就是按照原题给的计算式去处理d值，这里有个小坑，就是由于Python2和Python3有一点区别，在Python3中，hex(d)得到的值在输出形式上相比Python2少了一个末尾的L，再用这个值去做hash得到的md5值也就不同了。经实验发现，正确的结果可以用Python2直接得到，或在Python3中做hash时给参数末尾加上L。
rsa5（低加密指数广播攻击）
低加密指数广播攻击特点
1 | 加密指数e非常小 |
此题给出的e很小且不变，给出了不同的公钥(e,n)和对应的密文c，也就是用不同的公钥加密相同的明文m
解题思路：
不同的模数n中可能存在相同的p或者说q
求出不同n之间的最大公约数 gcd()
得到p或q 可得d
有私钥d就能得到明文
1 | import gmpy2 |
[NCTF2019]childRSA(费马小定理)
1 | from random import choice |
只在基础的RSA上修改了大素数的生成过程。choice()函数从小于10000的素数中随机挑选一个
1 | 这里primes为前10000个素数的列表 |
p,q的生成方式是一个突破口，分析函数getprime(),p,q就是在前10000个素数列表里面随机找几个素数相乘再加一得到的，所以这10000个素数的乘积x是p-1和q-1的倍数,x=k*(p-1),n=p*q，这里就要从n和x得到p。
费马小定理
1 | 若b为一个素数，则对于任意整数a，有a^(b-1) = 1 (mod b),即a^k*(b-1) = 1 (mod b) |
1 | x=k*(p-1),n=p*q |
1 | import gmpy2 |
总结：当知道某一个数x是p-1,q-1的倍数时，就用gcd(2^x-1,n)=p，进一步gcd(pow(2,x,n)-1,n)=p。
[HDCTF2019]bbbbbbrsa
可以明显的看到c是逆过来的，我们重新把c进行排序，在进行base64解码得到c
1 | from base64 import b64encode as b32encode |
rsa4(低加密指数广播攻击)
另外有两点需要注意：
1、此题中的N、c均是以5进制表示，要先用int(“*****”,5)转换为十进制才能计算(开始运行半天都不出结果，看了其他师傅博客才发现原来是五进制)。
2、题目没有给出加密指数e，但是根据低加密指数广播攻击的特性猜e=3、10、17等
1 | from Crypto.Util.number import * |
primefac.modinv(a, n): 这个部分使用primefac库中的modinv函数，来计算a在模n意义下的逆元素。这意味着找到一个数x，使得 (a * x) % n = 1
[BJDCTF2020]rsa_output
我们审计题目，发现题目给了我们两个一样的m和两个不一样的e和c，我们考虑共模攻击，
c1 = m^e1 mod n =>c1^s1 = m^(e1*s1) mod n
c2 = m^e2 mod n =>c2^s2 = m^(e2*s2) mod n
两者相乘，通过扩展欧几里得定理，我们可知e1与e2互质，必存在s1和s2使e1s1+e2s2=1
由此可求出相对应的s1和s2.
m=（c1*s1+c2*s2）%n
1 | n=21058339337354287847534107544613605305015441090508924094198816691219103399526800112802416383088995253908857460266726925615826895303377801614829364034624475195859997943146305588315939130777450485196290766249612340054354622516207681542973756257677388091926549655162490873849955783768663029138647079874278240867932127196686258800146911620730706734103611833179733264096475286491988063990431085380499075005629807702406676707841324660971173253100956362528346684752959937473852630145893796056675793646430793578265418255919376323796044588559726703858429311784705245069845938316802681575653653770883615525735690306674635167111 |
[BJDCTF2020]RSA
1 | from Crypto.Util.number import getPrime,bytes_to_long |
我们发现第一个n和第二个n共用一个q，因此我们通过gcd可以得到q的值，从而得到p的值，又已知pow(294,e,n)的值，因此我们可以爆破出e的值
1 | from Crypto.Util.number import getPrime, bytes_to_long, long_to_bytes |
[GWCTF 2019]BabyRSA(解方程)
1 | import hashlib |
求得p和q
接着求d
1 | d=gmpy2.invert(e,(p-1)*(q-1)) |
然后可以求c1,c2
1 | c1=pow(m1,d,N) |
然后联立方程，求得F1，F2
1 | F1=Symbol('F1') |
最后转为字节
1 | import gmpy2 |
SameMod（共模攻击）
模攻击
共模是指：就是明文m,相同。用两个公钥e1,e2加密得到两个私钥d1,d2 和两个密文c1,c2
共模攻击，即当m不变的情况下，知道n,e1,e2,c1,c2, 可以在不知道d1,d2的情况下，解出m
利用条件为=> gcd(e1,e2)=1
根据扩展欧几里得 算法得
可以得到该式子的一组解(s1,s2) 假设s1为正数，s2为负数
有整数s1,s2(一正一负)
存在e1s1+e2s2==1
1 | from Crypto.Util.number import long_to_bytes |
我们发现输出是一串乱码，但当我们看到m的值，发现里面有ascii码的影子
我们进行解码
1 | from Crypto.Util.number import long_to_bytes |
得到flag
[AFCTF2018]可怜的RSA（rsa公钥加密）
我们先利用Crypto.PublicKey的RSA模块从key文件中获取公钥信息n,e
1 | from Crypto.PublicKey import RSA |
得到n，e的值后，对n进行分解，得到p和q
1 | p = 3133337 |
利用gmpy2库通过p,q,ep,q,e求d
1 | from gmpy2 import * |
打包密钥对flag.pnc解密（由于是Base64编码后的密文，因此还需解码）
1 | from Crypto.PublicKey import RSA |
[RoarCTF2019]babyRSA(威尔逊定理)
1 | import sympy |
分析
从代码中可以知道：
p=(B1!)%A1p=(B1!)%A1
q=(B2!)%A2q=(B2!)%A2
又由威尔逊定理知道，
(A−1)!≡ −1 mod A(A−1)!≡ −1 mod A
而B=A-random.randint(1e3,1e5)，所以在B的前面补上
(A−1)(A−2)(A−3)…(B+1)(A−1)(A−2)(A−3)…(B+1)
就有
(A−1)(A−2)(A−3)…(B+1)∗(B!)%A=−1%A(A−1)(A−2)(A−3)…(B+1)∗(B!)%A=−1%A
于是再整理一下又有
(A−2)(A−3)…(B+1)∗(B!)%A=1%A(A−2)(A−3)…(B+1)∗(B!)%A=1%A
这就意味这可由(A−2)(A−3)…(B+1)(A−2)(A−3)…(B+1)模A的逆元求得(B!)%A(B!)%A的值。再取nextprime(sympy.ntheory.generate模块里的nextprime不是nextPrime)即可得到p或q的值。
1 | from sympy import nextprime |
RoarCTF{wm-CongrAtu1ation4-1t4-ju4t-A-bAby-R4A}
RSA & what（共模攻击&base64隐写）
我们仔细观察两个文件，发现有两个e和多个c，n是一样的，我们想到共模攻击
1 | from Crypto.Util.number import* |
得到的明文为base64编码，解码后是对base54的介绍，没啥用
我们主要看base64编码是一段一段的
不难想到base64隐写。
我们到网上找一段base64隐写脚本
1 | from Crypto.Util.number import* |
flag吧数字包起来就行了
[NPUCTF2020]EzRSA（最小公倍数(p,q) ∗ 最大公因数(p,q) = p∗q）
根据题设，我们得到以下关系
1 | gift=lcm((p-1)*(q-1)) |
由小学五年级的知识，有
1 | 最小公倍数(p,q) ∗ 最大公因数(p,q) = p∗q |
所以对于gift
有
我们可以求的gift的二进制位数为2045
1 | print(len(bin(gift)[2:])) |
同时我们知道ϕ(n)的位数为2048，因此gcd(p−1,q−1)gcd(p−1,q−1)占3bits，因此最大公因数的范围（十进制）为[4,8]
我们在此范围内遍历最大公因数的值，然后与最小公倍数相乘得到ϕ(n)的值，然后通过逆模运算求得d，然后就可得·明文
但需要注意这里的e不是素数，分解可得e=2*27361
所以在计算时，我们要先将e除以2
值的变化可通过以下表达式体现
所以解出的明文需要开根号再转为字节流
注意：遍历过程中不是所有的值都符合条件，可能会报ZeroDivisionError，因此需要加异常处理
1 | from Crypto.Util.number import * |
[MRCTF2020]babyRSA
由 gen_q()函数我们可以直接得出_Q的值：
1 | Q = sub_Q ** Q_2 % Q_1 |
我们观察gen_p
1 | def gen_p(): |
它通过循环生成了17个素数，并且给了第九个素数的值，我们可以逆推和顺推得到其余16个素数的值
然后n将17个素数乘在一起
有欧拉函数
那我们就可以得到_p的值
既然已知_Q和_P,我们就能得到flag
1 | import gmpy2 |
[MRCTF2020]Easy_RSA
求P：
1 | n=p*q |
已知p+q和p*q，我们就能得到(p+q)和(p-q)的平方，然后开根解方程即可
求Q：
与求P不同：此处无φ(n)，只有Q_E_D，
根据e*d mod φ(n) =1 来求φ(n)
首先：
φ(n)=(p-1)*(q-1)
e*d = kφ(n) +1=k(pq -p -q +1) +1 ==> k = (e * d -1)/(pq - p - q +1)
k值无法确定，上式难以求解。
p,q均为大质数，并且1<< p < q, 那么：
(pq - p - q +1) ≈( p-2)q≈ pq
k = (e * d -1)/(pq - p - q +1) ≈ (Q_E_D -1)/Q_n
由于分母放大，所求k值略小： k = ((Q_E_D-1)//Q_n)+1
则可求解Q
exp
1 | import gmpy2,sympy |
[HDCTF2019]together(base64与unicode之间的转换以及共模攻击)
题目给了四个文件
两个密文，那个公钥
我们先看两个公钥的n和e
我们用kail的openssl进行解码
1 | openssl rsa -pubin -text -modulus -in warmup -in pubkey1.pem |
或者用python脚本进行读取
1 | from Crypto.PublicKey import RSA |
得到两个公钥的n和e
1 | pubkey1.pem |
我们可以发现n相同，但e不同，这里一个考的是共模攻击
然后将my_flag1和my_flag2用随波逐流进行base64转16进制，得到c1和c2
1 | c1=0x52334e6f79367233574c49747974416d6234466d484579676f696c756345455a624f395a595878354a4e3033484e70424c44783766586432666c2b554c352b31315243732f7930716c5447555257574474473636654e4c7a47774e70414b69566a3649375274554a6c3250636d334e764665414677493955735652457968377a4956367349395a50386c2f324756446f724c417a35554c572b66304f494e47684a6d5a6d38464c2f61446e6c6654456c685138374c506963577058596f4d747972365772786a4b364f6e746e384271437430456a51375465585a6878494839565450576a446d46646d4f716171645649542b4c5a656d54674c4e4553774d356e6e346735533361464446776a31596944596c302f2b386574764b664f72666f4b4f7752304378735248616777645555544553384563484c6d4d474378436b445a6e33537a6d6d41364e62336c674c65536747385031413d3d |
然后我们进行rsa解密
1 | from Crypto.Util.number import long_to_bytes |
得到flag
[INSHack2017]rsa16m(低加密指数广播攻击)
通过md文件提示我们可以知道n非常非常非常大
我们推测这题为低密度指数加密攻击，直接将n进行开方
1 | import gmpy2 |
DES
[ACTF新生赛2020]crypto-des
encryptedkey.txt
1 | 72143238992041641000000.000000, |
hint.txt
1 | To solve the key, Maybe you know some interesting data format about C language? |
附件1考的是数据在内存中的存储，我们用struct库中的pack函数打包数据
1 | from libnum import* |
我们得到压缩包密码为
1 | Interestring Idea to encrypt |
得到一个加密文件，密钥都给出来了，直接base64解码后，decrypt()解密就行了。
1 | import pyDes |
AES
1 | ECB模式（电子密码本模式：Electronic codebook） |
AES在python中的加密限制：
1.在python中进行AES加密解密时，所传入的密文，明文，密钥，iv偏移量，都是需要bytes类型的数据。python在构建aes对象时也只能接受bytes类型数据
2.当密钥，iv偏移量，待解密的明文，字节长度不够16字节或者16字节的背书时需要进行补全
3.CBC模式需要重新生成AES对象，为了防止这类错误，我们写代码无论什么模式都要重新生成AES对象
python中bytes类型数据与中文的转换。Tips:utf8一个中文三个字节，gbk一个中文两个字节。
key = "中文数据" #中文数据 key_b = key.encode() #转换成字节型数据 print(key_b) print(key_b.decode()) #字节型数据转换成中文数据1
2
3
4
5
6
7
#### [ACTF新生赛2020]crypto-aes
我们来看题目
from Cryptodome.Cipher import AES
import os
import gmpy2
from flag import FLAG
from Cryptodome.Util.number import *
def main():
key = os.urandom(2) * 16 # 生成一个随机的密钥，长度为32字节（256位） 前16位和后16位相同
iv = os.urandom(16) # 生成一个随机的初始化向量，长度为16字节（128位）
print(bytes_to_long(key) ^ bytes_to_long(iv)) # 将密钥和初始化向量转换为长整数，并执行异或操作，然后打印结果
aes = AES.new(key, AES.MODE_CBC, iv) # 使用密钥、模式（CBC）和初始化向量创建一个新的AES加密对象
enc_flag = aes.encrypt(FLAG) # 使用AES加密对象对FLAG进行加密，并将加密后的结果存储在enc_flag变量中
print(enc_flag) # 打印加密后的FLAG
if name == “main“:
main() # 如果当前模块是主模块，则调用main函数
1 |
|
from Cryptodome.Cipher import AES
import os
from gmpy2 import*
from Cryptodome.Util.number import*
xor = 91144196586662942563895769614300232343026691029427747065707381728622849079757
enc_flag = b’\x8c-\xcd\xde\xa7\xe9\x7f.b\x8aKs\xf1\xba\xc75\xc4d\x13\x07\xac\xa4&\xd6\x91\xfe\xf3\x14\x10|\xf8p’
out = long_to_bytes(xor) #将异或的数值转换为字节型数据
key = out[:16]*2 #取了之前加密key和iv的异或的前16字节，相当于取了高位的128位。
iv = bytes_to_long(key[16:])^bytes_to_long(out[16:]) #此时取了key的后16位与xor的后16位进行xor来还原iv
iv = long_to_bytes(iv)
aes = AES.new(key,AES.MODE_CBC,iv)
flag = aes.decrypt(enc_flag)
print(flag)
1 |
//验证 key = out[:16]*2
from Cryptodome.Cipher import AES
import os
from gmpy2 import *
from Cryptodome.Util.number import *
xor = 91144196586662942563895769614300232343026691029427747065707381728622849079757
out = long_to_bytes(xor) # 将异或的数值转换为字节型数据
key = out[:16] * 2
print(bin(bytes_to_long(key)))
print((bin(bytes_to_long(out[:16]))))
print(“0b11001001100000011100100110000001110010011000000111001001100000011100100110000001110010011000000111001001100000011100100110000001”)
1 |
|
m = 391190709124527428959489662565274039318305952172936859403855079581402770986890308469084735451207885386318986881041563704825943945069343345307381099559075
c = 6665851394203214245856789450723658632520816791621796775909766895233000234023642878786025644953797995373211308485605397024123180085924117610802485972584499
n=2**512
import gmpy2
from Crypto.Util.number import *
import sympy
x=sympy.discrete_log(n,c,m)
print(long_to_bytes(x))
1 |
|
graph=[]
for i in range(27):
graph.append([]) #在一个list中放27个list，索引0-26
for i in range(27):
for j in range(27):
graph[i].append(0xffff) #先将图中各个顶点之间的距离初始化为一个比较大的数
f=open(‘./Downloads/dij.txt’,’r’).readlines() #按行读取，每行内容是list中的一个元素，全部内容组成一个整体的list
#这里需要先手动将txt文件中的最后一行换行去掉否则会多一个’\n’
#print(f)
li=[]
for x in f:
li.append(x.strip().split(‘ ‘)) #strip()删除字符串前后空格，这里是去掉了最后的换行符’\n’，然后再按’ ‘分割每行的每个元素，原本在同一子list中的一行元素也彼此独立出来
#print(li)
for x in li:
graph[int(x[0])][int(x[1])]=int(x[2])
graph[int(x[1])][int(x[0])]=int(x[2])
def try_dijstra():
min_d=[0xffff for i in range(27)] #记录点i到起点1的最短距离
route=[1 for i in range(27)] #记录前驱顶点
isSure=[0 for i in range(27)] #记录各点到起点距离是否已经确定
for i in range(2,27):
min_d[i]=graph[i][1] #初始化一下能直连1的顶点和1的距离
min_d[1]=0
isSure[1]=1
for i in range(26):
min=0xfffff
temp=-1
for j in range(2,27): # 找到当前离顶点1最近的顶点加入已经确定的“顶点阵营”
if isSure[j]==0 and min>min_d[j]:
min=min_d[j]
temp=j
isSure[temp]=1
for j in range(2,27):# 判断从顶点1开始，在经过该顶点后，再到达其邻接顶点的距离，是否比其邻接顶点原本到顶点1的距离更近，如果更近就更新最短距离
if min_d[j]>min_d[temp]+graph[temp][j]:
min_d[j]=min_d[temp]+graph[temp][j]
route[j]=temp
return (route,min_d)
route,min_d=try_dijstra()
print(min_d[26]) #最短距离
print(route) #前驱顶点
passv=[] #存放顶点之间的“内容”（内容最后要组成flag
for i in range(27):
passv.append([]) # 还是在一个list中放27个list
for i in range(27):
for j in range(27):
passv[i].append(0) #需要将内部list中初始化出27个“位置”否则会报错索引越界
for x in li:
passv[int(x[0])][int(x[1])]=x[3]
passv[int(x[1])][int(x[0])]=x[3]
y=26
l=[]
while y!=1:
print(y) #输出终点到起点的最短路径经过的顶点
l.append(passv[y][route[y]]) #y到其前驱顶点route[y]之间的内容
y=route[y]
print()
l=l[::-1]
for i in range(len(l)):
print(l[i],end=’’)
‘’’
339
[1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 5, 5, 5, 4, 4, 4, 6, 6, 6, 25, 9, 11, 12, 6, 18, 22, 25]
26 25 22 12 5 2
FLAG{WEIVKASJVLSJCHFSJVHJSDEV}
‘’’
1 |
|
import hashlib
迭代指定范围内的ASCII字符
for i in range(32, 127):
for j in range(32, 127):
for k in range(32, 127):
# 创建要进行哈希运算的字符串
test_string = ‘TASC’ + chr(i) + ‘O3RJMV’ + chr(j) + ‘WDJKX’ + chr(k) + ‘ZM’
m = hashlib.md5()
# 将字符串编码为字节并更新哈希对象
hashlib 模块中的 update 方法用于将数据传递给哈希对象，以便生成哈希值。在使用 update 方法时，需要传入一个字 节类型的数据。
m.update(test_string.encode(‘utf-8’))
des = m.hexdigest()
# 检查哈希值是否包含指定的子字符串
if ‘e9032’ in des and ‘da’ in des and ‘911513’ in des:
print(des)
//e9032994dabac08080091151380478a2
1 |
|
import hashlib
def prime_factors(n):
“””
分解给定整数n的质因数。
返回一个列表，其中包含n的所有质因数。
“””
# 初始化一个空列表来存储质因数
factors = []
# 从2开始，逐个检查每个数是否是n的因数
for i in range(2, int(n ** 0.5) + 1):
# 如果i是n的因数，将其添加到质因数列表中
if n % i == 0:
factors.append(i)
# 如果i不是质数，则n/i也是一个因数，将其也添加到质因数列表中
if i != n // i:
factors.append(n // i)
# 如果n是偶数且大于2，则它本身不是质数，需要特别处理
if n > 2 and n % 2 == 0:
factors.append(2)
return factors
测试函数
print(prime_factors(98554799767)) # 输出: [101999, 966233]
a=hashlib.md5()
a.update(“101999966233”.encode(‘utf-8’))
print(a.hexdigest().lower())
//d450209323a847c8d01c6be47c81811a
1 |
|
a=[88,90,83,68,77,70,76,90]
b=’’
for i in a:
b+=chr(i)
print(b)
1 |
|
import hashlib
mystery_md5 = “E903???4DAB????08?????51?80??8A?”
for i in range(65, 91):
for j in range(65, 91):
for k in range(65, 91):
# print(f”TASC{chr(i)}O3RJMV{chr(j)}WDJKX{chr(k)}ZMd”, end=”;”)
# 计算候选字符串的MD5哈希值
plaintext = f”TASC{chr(i)}O3RJMV{chr(j)}WDJKX{chr(k)}ZM”
md5_hash = hashlib.md5(plaintext.encode(‘utf8’)).hexdigest().upper() # 注意大小写
# print(md5_hash[:4])
# 比较MD5码的部分
if md5_hash[:4] == mystery_md5[:4]:
print(plaintext)
print(md5_hash)
1 |
|
a = ‘0110000101110011011000010110010001110011011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011000010111001101100100011100010111011101100101011100110111000101100110’
b = ‘0000011100011111000000000000001100001000000001000001001001010101000000110001000001010100010110000100101101011100010110000100101001010110010100110100010001010010000000110100010000000010010110000100011000000110010101000100011100000101010101100100011101010111010001000001001001011101010010100001010000011011’
c = ‘’
for i in range(len(a)):
if a[i] == b[i]:
c += ‘0’
else:
c += ‘1’
print(c)
1 |
|
0110011001101100011000010110011101111011011001010110000100110001011000100110001100110000001110010011100000111000001110010011100100110010001100100011011100110110011000100011011101100110001110010011010101100010001101010011010001100001001101110011010000110011001101010110010100111000001110010110010101111101
1 |
|
flag{ea1bc0988992276b7f95b54a7435e89e}
1 |
|
import base64
a={0: ‘J’, 1: ‘K’, 2: ‘L’, 3: ‘M’, 4: ‘N’, 5: ‘O’, 6: ‘x’, 7: ‘y’, 8: ‘U’, 9: ‘V’, 10: ‘z’, 11: ‘A’, 12: ‘B’, 13: ‘C’, 14: ‘D’, 15: ‘E’, 16: ‘F’, 17: ‘G’, 18: ‘H’, 19: ‘7’, 20: ‘8’, 21: ‘9’, 22: ‘P’, 23: ‘Q’, 24: ‘I’, 25: ‘a’, 26: ‘b’, 27: ‘c’, 28: ‘d’, 29: ‘e’, 30: ‘f’, 31: ‘g’, 32: ‘h’, 33: ‘i’, 34: ‘j’, 35: ‘k’, 36: ‘l’, 37: ‘m’, 38: ‘W’, 39: ‘X’, 40: ‘Y’, 41: ‘Z’, 42: ‘0’, 43: ‘1’, 44: ‘2’, 45: ‘3’, 46: ‘4’, 47: ‘5’, 48: ‘6’, 49: ‘R’, 50: ‘S’, 51: ‘T’, 52: ‘n’, 53: ‘o’, 54: ‘p’, 55: ‘q’, 56: ‘r’, 57: ‘s’, 58: ‘t’, 59: ‘u’, 60: ‘v’, 61: ‘w’, 62: ‘+’, 63: ‘/‘, 64: ‘=’}
b=”FlZNfnF6Qol6e9w17WwQQoGYBQCgIkGTa9w3IQKw”
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’, ‘+’, ‘/‘]
flag=’’
for i in b:
for j in a:
if i == a[j]:
flag+=base64_list[j]
print(base64.b64decode(flag))
//b’BJD{D0_Y0u_kNoW_Th1s_b4se_map}’
1 |
|
def fib_loop_for(n):
a, b = 0, 1
for _ in range(n):
a, b = b, a + b
return a
for i in range(1,33):
print(fib_loop_for(i))
1 |
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309
1 233 3 2584 1346269 144 5 196418 21 1597 610 377 10946 89 514229 987 8 55 6765 2178309 121393 317811 46368 4181 1 832040 2 28657 75025 34 13 17711
c=”36968853882116725547342176952286”
1 |
|
a = “0 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418 317811 514229 832040 1346269 2178309”
b = “0 233 3 2584 1346269 144 5 196418 21 1597 610 377 10946 89 514229 987 8 55 6765 2178309 121393 317811 46368 4181 1 832040 2 28657 75025 34 13 17711”
a = a.split(“ “)
b = b.split(“ “)
flag = []
m = “36968853882116725547342176952286”
for i in range(len(a)):
for j in range(len(a)):
if a[i] == b[j]: #a[i]中的值在b中的索引为j
#print(j)
flag.append(m[j]) #将m[j]中的值添加到flag中
print(len(flag))
print(‘’.join(flag))
#37995588256861228614165223347687
1 |
|
FGCPFLIRTUASYON
1 |
|
flag{CRYPTOFUN}
1 |
|
破解下面的密文：
83 89 78 84 45 86 96 45 115 121 110 116 136 132 132 132 108 128 117 118 134 110 123 111 110 127 108 112 124 122 108 118 128 108 131 114 127 134 108 116 124 124 113 108 76 76 76 76 138 23 90 81 66 71 64 69 114 65 112 64 66 63 69 61 70 114 62 66 61 62 69 67 70 63 61 110 110 112 64 68 62 70 61 112 111 112
flag格式flag{}
1 |
|
ROT5、ROT13、ROT18、ROT47 编码是一种简单的码元位置顺序替换暗码。此类编码具有可逆性，可以自我解密，主要用于应对快速浏览，或者是机器的读取，而不让其理解其意。
ROT5 是 rotate by 5 places 的简写，意思是旋转5个位置，其它皆同。下面分别说说它们的编码方式：
ROT5：只对数字进行编码，用当前数字往前数的第5个数字替换当前数字，例如当前为0，编码后变成5，当前为1，编码后变成6，以此类推顺序循环。
ROT13：只对字母进行编码，用当前字母往前数的第13个字母替换当前字母，例如当前为A，编码后变成N，当前为B，编码后变成O，以此类推顺序循环。
ROT18：这是一个异类，本来没有，它是将ROT5和ROT13组合在一起，为了好称呼，将其命名为ROT18。
ROT47：对数字、字母、常用符号进行编码，按照它们的ASCII值进行位置替换，用当前字符ASCII值往前数的第47位对应字符替换当前字符，例如当前为小写字母z，编码后变成大写字母K，当前为数字0，编码后变成符号_。用于ROT47编码的字符其ASCII值范围是33－126，具体可参考ASCII编码。
1 |
|
s=’83 89 78 84 45 86 96 45 115 121 110 116 136 132 132 132 108 128 117 118 134 110 123 111 110 127 108 112 124 122 108 118 128 108 131 114 127 134 108 116 124 124 113 108 76 76 76 76 138 23 90 81 66 71 64 69 114 65 112 64 66 63 69 61 70 114 62 66 61 62 69 67 70 63 61 110 110 112 64 68 62 70 61 112 111 112’
l = s.split(“ “)
for i in l:
print(chr(int(i) - 13), end=’’)
1 |
FLAG IS flag{www_shiyanbar_com_is_very_good_????}
MD5:38e4c352809e150186920aac37190cbc
1 |
|
得到flag
这是什么(jsfuck)
我们将apk文件修改为txt文件
我们在文件中发现
我们考虑jsfuck解密
我们f12打开控制台，将括号复制进去
得到flag
[MRCTF2020]天干地支+甲子（天干地支）
1 | 六十年甲子（干支表） |
我们对照得到
1 | 11 51 51 40 46 51 38 |
都加一个甲子(60)得到
1 | 71 111 111 100 106 111 98 |
我们对照ascii表得到
1 | Goodjob |
得到flag
1 | flag{Goodjob} |
[NCTF2019]Keyboard(脑洞)
题目提示键盘，我们发现每一个字母都对应上面的一个数字，我们猜测9键盘，而字母个数就是对应的9键盘上的对应的字母
1 | youaresosmartthatthisisjustapieceofcake |
1 | cipher="ooo yyy ii w uuu ee uuuu yyy uuuu y w uuu i i rr w i i rr rrr uuuu rrr uuuu t ii uuuu i w u rrr ee www ee yyy eee www w tt ee" |
[BJDCTF2020]signin
我们观察，密文为16进制，我们将其转换为字符
1 | from Crypto.Util.number import * |
得到flag
1 | BJD{We1c0me_t4_BJDCTF} |
[MRCTF2020]vigenere（维吉尼亚解密）
我们找一个在线网站
https://www.guballa.de/vigenere-solver
把文本放上去，直接破解，flag是最后一行
[ACTF新生赛2020]crypto-rsa0(zip伪加密)
我们把文件下下来后，在hint.txt提示，文件进行了zip伪加密
一个ZIP文件由三个部分组成：
压缩源文件数据区+压缩源文件目录区+压缩源文件目录结束标志。
伪加密原理：zip伪加密是在文件头的加密标志位做修改，进而再打开文件时识被别为加密压缩包。 一般来说，文件各个区域开头就是50 4B，然后后面两个字节是版本，再后面两个就是判断是否有加密的关键了
伪加密：
压缩源文件数据区的全局加密应当为 00 00
且压缩文件目录区的全局方式标记应当为 09 00
原理
ZIP伪加密是在文件头的加密标志位做修改，进而再打开文件时识别为加密压缩包。
在参考了网上多数文章无果后，在西普的一个小题找到了可以复现的方法。
给出西普的某个示例：
1 | 压缩源文件数据区 |
保存之后打开压缩包，发发现就可以顺利打开rsa.py文件了
然后就是个rsa解密了
1 | import binascii |
传感器（曼彻斯特编码）
Wiki
曼彻斯特编码（Manchester Encoding），也叫做相位编码（ Phase Encode，简写PE），是一个同步时钟编码技术，被物理层使用来编码一个同步位流的时钟和数据。它在以太网媒介系统中的应用属于数据通信中的两种位同步方法里的自同步法（另一种是外同步法），即接收方利用包含有同步信号的特殊编码从信号自身提取同步信号来锁定自己的时钟脉冲频率，达到同步目的。
Encode and Decode
IEEE 802.4（令牌总线）和低速版的IEEE 802.3（以太网）中规定, 按照这样的说法, 01电平跳变表示1, 10的电平跳变表示0。
Ideas
1 | 5555555595555A65556AA696AA6666666955`转为二进制，根据01->1,10->0。可得到 |
1 | cipher='5555555595555A65556AA696AA6666666955' |
[NPUCTF2020]这是什么觅🐎（观察）
用记事本打开是个乱码·
但我们看到开头那个pk，我们想到zip文件，我们将后缀改为zip，成功打开文件
看到有一个字条和日历，猜测是类似矩阵的原理,
1 | F1 W1 S22 S21 T12 S11 W1 S13 |
两个s应该是s1对应周六，s2对应周日
字母最后的数字对应所在的行数
例如F1，第一行的星期五
1 | 3 1 12 5 14 4 1 18 |
对照字母表 calendar，flag{calendar}
浪里淘沙（脑洞）
打开txt文档发现大量的单词，再结合题目给到的一串数字4、8、11、15、16可以考虑到是跟字频有关
我们打开万能的wps进行查询
然后放到excel进行排序
标注起题目要求的编号组合起字符串即可得到flag
flag{weshouldlearnthecrypto}
[WUSTCTF2020]B@se（base64变表&排列组合）
题目附件内容：
首先通过观察题目字符特征很明显是base64编码，第一行的密文是通过下面给的base64的变表，但是仔细观察缺少了四个字符，因此我们需要写脚本把缺少的字符给还原出来
爆破脚本：
1 | import string |
很明显图中框出来的地方就是最后的flag值
总结：此题考察了缺损的base64变表，需要使用爆破脚本破解出明文。
[AFCTF2018]Single（爆破）
我们下载附件，发现里面有个c语言程序和一个文件
通过代码分析，我们发现Cipher.txt是一个加密后的文件，仔细观察，很明显示是一个无规律替换加密，我们使用词频分析
得到flag
或者我们逆向输出
1 | #include <bits/stdc++.h> |
得到加密前的文件，找到flag
鸡藕椒盐味（海明校验码）
1.分析校验位数
从题目可知验证码为110010100000共12位，校验位一般都是在2^n的位置，所以共有4位校验码在1，2，4，8位置
拓展：海明验证码公式：2^r≥k+r+1 （r为校验位 ，k为信息位），如本验证码本来有8位信息码，带入公式可得r=4，所以在1，2，4，8位置添加相应校验码
2.画表
题目中提到打印的时候倒了一下，所以将信息位倒着填入表中
| 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 位数 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 0 | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 信息位（D） | ||||
| R1 | R2 | R3 | R4 | 校验位（R） |
3.求校验位的值
例如：1由第一位R1来校验；2由第二位R2来校验；由于3=1+2（1和2指的是位数，都是2的n次方）所以3由第一位R1和第二位R2校验，4由第四位R3校验，5和3道理是一样的，5=1+4（2^0+2^2）;6=2+4;7=1+2+4，依次类推。得出下表：
| 海明码位号 | 占用的校验位号 | 校验位 |
|---|---|---|
| 1 | 1 | R1 |
| 2 | 2 | R2 |
| 3 | 1、2 | R1、R2 |
| 4 | 4 | R3 |
| 5 | 1、4 | R1、R3 |
| 6 | 2、4 | R2、R3 |
| 7 | 1、2、4 | R1、R2、R3 |
| 8 | 8 | R4 |
| 9 | 1、8 | R1、R4 |
| 10 | 2、8 | R2、R4 |
| 11 | 1、2、8 | R1、R2、R4 |
| 12 | 4、8 | R3、R4 |
进行汇总，看每个校验位都确定了哪一位。
R1：1、3、5、7、9、11
R2：2、3、6、7、10、11
R3：4、5、6、7、12
R4：9、10、11、12
最后用异或运算求出R1、R2、R3、R4、R5的值（以R1为例）：
R1=D1⊕D3⊕D5⊕D7⊕D9⊕D11=1
以此类推：R1=1,R2=0,R3=0,R4=0
可以看到P1P2P3P4=0001,R1R2R3R4=1000
可以求得监督位（异或）：
| 0 | 0 | 0 | 1 | 验证码中的校验码 |
|---|---|---|---|---|
| 1 | 0 | 0 | 0 | 求得的校验码 |
| 1 | 0 | 0 | 1 | 监督位 |
监督位不为0000，说明接收方生成的校验位和收到的校验位不同，错误的位数是监督位的十进制即9，所以把D9就是题目中提到的错误，得到正确验证码110110100000，然后根据提示MD5hash一下就出来了。
1 | 1 import hashlib |
套入flag{}即可得到答案flag{d14084c7ceca6359eaac6df3c234dd3b}
[AFCTF2018]BASE(base16,32,64解密)
我们随便截取文件的一段内容，发现能进行多段base64解密
我们找个脚本
1 | import re |
[BJDCTF2020]Polybius(波利比奥斯方阵密码)
由题目我们知道这个题目的考点是波利比奥斯方阵
Polybius校验表如下
(2,4)这个坐标既可以表示i 也可以表示 j因此破解的时候这里又会多两种情况
我们来康个例子
假设明文序列为attack at once，使用一套秘密混杂的字母表填满波利比奥斯方阵
如下
- i 和 j视为同一格
- 选择这五个字母，是因为它们译成摩斯密码时不容易混淆，可以降低传输错误的机率
根据上面的Polybius方阵将对应的明文进行加密。其中，A,D,F,G,X也可以用数字1,2,3,4,5来代替，这样密文就成了：
| 明文 | A | T | T | A | C | K | A | T | O | N | C | E |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 密文 | AF | AD | AD | AF | GF | DX | AF | AD | DF | FX | GF | XF |
| 13 | 12 | 12 | 13 | 43 | 25 | 13 | 12 | 23 | 35 | 43 | 53 |
我们来分析题目
密文：ouauuuoooeeaaiaeauieuooeeiea
hint: VGhlIGxlbmd0aCBvZiB0aGlzIHBsYWludGV4dDogMTQ=
基本的解题方阵如下
base64解密后信息为The length of this plaintext: 14，提示长度为14，但是a,e,o,i,u这五个字符的代表顺序却不知道,因此可能有54321种情况,在结合刚才所说的i,j同时占一个位置,所以情况数要再乘上2,将这些情况全部都打印出来,然后去找有真实语义的句子就可以了.所以密文为14×2位，可以推测为波利比奥斯方阵密码
1 | import itertools |
https://www.cnblogs.com/labster/p/13842837.html
四面八方（四方密码）
根据题目提示，该题考的是四方密码
四方密码用4个5×5的矩阵来加密。每个矩阵都有25个字母（通常会取消Q或将I,J视作同一样，或改进为6×6的矩阵，加入10个数字）。
加密原理：
首先选择两个英文字作密匙，例如example和keyword。对于每一个密匙，将重复出现的字母去除，即example要转成exampl，然后将每个字母顺序放入矩阵，再将余下的字母顺序放入矩阵，便得出加密矩阵。
将这两个加密矩阵放在右上角和左下角，余下的两个角放a到z顺序的矩阵： [1]
加密的步骤：
两个字母一组地分开讯息：（例如hello world变成he ll ow or ld）；
找出第一个字母在左上角矩阵的位置；
同样道理，找第二个字母在右下角矩阵的位置；
找右上角矩阵中，和第一个字母同行，第二个字母同列的字母；
找左下角矩阵中，和第一个字母同列，第二个字母同行的字母；
得到的这两个字母就是加密过的讯息。
he lp me ob iw an ke no bi的加密结果：FY NF NE HW BX AF FO KH MD
引用大佬博客中的一张图片：
再回到本题
由key1:security和 key2:information可以确认阵图
abcde SECUR
fghij ITYAB
klmno DFGHJ
prstu KLMNO
vwxyz PVWXZ
INFOR abcde
MATBC fghij
DEGHJ klmno
KLPSU prstu
VWXYZ vwxyz
要解密的密文为zh nj in ho op cf cu kt lj
按照刚才的方法解密为：yo un ga nd su cc es sf ul
flag{youngandsuccessful}
也可以用脚本
我们引用大佬脚本
1 | import collections |
[ACTF新生赛2020]crypto-classic1(键盘包围密码&维吉尼亚)
首先是个26键键盘包围密码解密，得到压缩包密码circle
解压，得到维吉尼亚密码
1 | SRLU{LZPL_S_UASHKXUPD_NXYTFTJT} |
再利用脚本
1 | # coding=utf-8 |
EasyProgram（伪代码）
看了下，没看懂啥语言，应该是伪代码吧，这道题的flag的加密其实就一句话
1 | set flag[m]:flag[m]^s[x] |
要逆向很简单
1 | #读文件方法一： |
