压缩包大师

很简单的压缩包套娃，密码是压缩包的密码
python脚本whindows,但是解压很慢

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139


import zipfile

import os

import py7zr

import rarfile

#a = py7zr.SevenZipFile(r'e:\test.7z','r')

count=0

  

# now = "D:\\vscodework\\ctf\\2023新生赛\\yasuobao\\10621.7z"

  

while True:

    path="D:\\vscodework\\ctf\\2023新生赛\\yasuobao\\"

    file = os.listdir(path)[0]

    zfilefile = path+file

    s = file.split(".")

  

    #print(zfilefile)

    pwds= s[0]

    #print(file)

    if s[1] == "7z":

        try:

            with py7zr.SevenZipFile(zfilefile, mode='r', password=pwds) as z:

                z.extractall(path='D:\\vscodework\\ctf\\2023新生赛\\yasuobao\\')

                z.close()

                os.remove(zfilefile)

        except:

            pass

        count+=1

        print(count)

    if s[1] == "zip":

        with zipfile.ZipFile(zfilefile,mode="r") as f:

            f.extractall("D:\\vscodework\\ctf\\2023新生赛\\yasuobao\\",pwd=pwds.encode('utf-8'))

            f.close()

        os.remove(zfilefile)

        count+=1

        print(count)

        print(file)

        # zpf= zipfile.ZipFile(zfilefile)

        # list = zpf.namelist()  # 得到压缩包里所有文件

        # for f in list:

        #     zpf.extract(f, "zip", pwd=pwds.encode('utf-8'))  # 循环解压文件到指定目录，密码

        # print("解压成功")

    if s[1]  == "rar":

        def unrar_file_with_password(file_path, output_path, password):

            # 创建RARFile对象

            rar = rarfile.RarFile(file_path)

  

            # 设置密码

            rar.setpassword(password)

  

            # 解压RAR文件

            rar.extractall(output_path)

  

            # 关闭RARFile对象

            rar.close()

        path1 = "D:\\vscodework\\ctf\\2023新生赛\\yasuobao\\"

        # 调用函数解压带密码的RAR文件

        unrar_file_with_password(zfilefile, path1, pwds)

        # print("a")

        os.remove(zfilefile)

        count+=1

        print(count)

    if s[1] != "rar"  and s[1] != "zip" and  s[1] != "7z":

        print("end")

        break

    # rf = rarfile.RarFile(zfilefile)  # 待解压文件

    # path2 ="D:\\vscodework\\ctf\\2023新生赛\\yasuobao\\"

    # print(rf)

    # rf.extractall(path = path2, pwd="39193")  # 解压指定文件路径

    # rf.close()

linux:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

  

import zipfile

import os

import py7zr

import rarfile

#a = py7zr.SevenZipFile(r'e:\test.7z','r')

count=0

  

# now = "/var/www/html/check/10621.7z"

  

while True:

    path="/var/www/html/check/"

    file = os.listdir(path)[0]

    zfilefile = path+file

    s = file.split(".")

  

    #print(zfilefile)

    pwds= s[0]

    #print(file)

    if s[1] == "7z":

        try:

            with py7zr.SevenZipFile(zfilefile, mode='r', password=pwds) as z:

                z.extractall(path='/var/www/html/check/')

                z.close()

                os.remove(zfilefile)

        except:

            pass

        count+=1

        print(count)

    if s[1] == "zip":

        with zipfile.ZipFile(zfilefile,mode="r") as f:

            f.extractall("/var/www/html/check/",pwd=pwds.encode('utf-8'))

            f.close()

        os.remove(zfilefile)

        count+=1

        print(count)

        print(file)

        # zpf= zipfile.ZipFile(zfilefile)

        # list = zpf.namelist()  # 得到压缩包里所有文件

        # for f in list:

        #     zpf.extract(f, "zip", pwd=pwds.encode('utf-8'))  # 循环解压文件到指定目录，密码

        # print("解压成功")

    if s[1]  == "rar":

        def unrar_file_with_password(file_path, output_path, password):

            # 创建RARFile对象

            rar = rarfile.RarFile(file_path)

  

            # 设置密码

            rar.setpassword(password)

  

            # 解压RAR文件

            rar.extractall(output_path)

  

            # 关闭RARFile对象

            rar.close()

        path1 = "/var/www/html/check/"

        # 调用函数解压带密码的RAR文件

        unrar_file_with_password(zfilefile, path1, pwds)

        # print("a")

        os.remove(zfilefile)

        count+=1

        print(count)

    if s[1] != "rar"  and s[1] != "zip" and  s[1] != "7z":

        print("end")

        break

    # rf = rarfile.RarFile(zfilefile)  # 待解压文件

    # path2 ="/var/www/html/check/"

    # print(rf)

    # rf.extractall(path = path2, pwd="39193")  # 解压指定文件路径

    # rf.close()
bd
1
2
3
https://www.cnblogs.com/mumuhhh/p/17789591.html
https://blog.csdn.net/Ahi0upsec/article/details/132717024

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

from Crypto.Util.number import *
from secret import flag

p = getPrime(512)
q = getPrime(512)
n = p * q
d = getPrime(299)
e = inverse(d,(p-1)*(q-1))
m = bytes_to_long(flag)
c = pow(m,e,n)
hint1 = p >> (512-70)
hint2 = q >> (512-70)

print(f"n = {n}")
print(f"e = {e}")
print(f"c = {c}")
print(f"hint1 = {hint1}")
print(f"hint2 = {hint2}")
# n = 64421669931279763032337930351371074312763623230334264672272991963587968145469789623226631192910548697947848779021944177739911084383786634595255436873350170397825307930618697902052402139072111389681839113510986333829074390665317265603346122882832568330112945567680656219994967593371244275156478322204419261819
# e = 31010691142874094705557092175690153458422282630834301371323563655985170293061551914791533335820551677589839843761852199680128997193432075880230502409814741638209947794142932041357373199521605405986705517942961028228255066560857365694517578822510622110740926010357756915595155038827023753366174321207668419113
# c = 44228757856694834445202355486356318880471120936109992694489050154150768403667631244534149277159399976972028214341072460353357561691320731420869678207365539080035139895735181119706727564445399237943178679966032596522818504363414526390960660239215638736706163678206959509331192083842100728618312517781111784803
# hint1 = 597218086872775768003
# hint2 = 836339982627318976124

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
import time
time.clock = time.time
 
debug = True
 
strict = False
 
helpful_only = True
dimension_min = 7 # 如果晶格达到该尺寸，则停止移除
# 显示有用矢量的统计数据
def helpful_vectors(BB, modulus):
    nothelpful = 0
    for ii in range(BB.dimensions()[0]):
        if BB[ii,ii] >= modulus:
            nothelpful += 1
 
	#print (nothelpful, "/", BB.dimensions()[0], " vectors are not helpful")
# 显示带有 0 和 X 的矩阵
def matrix_overview(BB, bound):
    for ii in range(BB.dimensions()[0]):
        a = ('%02d ' % ii)
        for jj in range(BB.dimensions()[1]):
            a += '0' if BB[ii,jj] == 0 else 'X'
            if BB.dimensions()[0] < 60: 
                a += ' '
        if BB[ii, ii] >= bound:
            a += '~'
        #print (a)

# 尝试删除无用的向量
# 从当前 = n-1（最后一个向量）开始
def remove_unhelpful(BB, monomials, bound, current):
    # 我们从当前 = n-1（最后一个向量）开始
    if current == -1 or BB.dimensions()[0] <= dimension_min:
        return BB
 
    # 开始从后面检查
    for ii in range(current, -1, -1):
        #  如果它没有用
        if BB[ii, ii] >= bound:
            affected_vectors = 0
            affected_vector_index = 0
             # 让我们检查它是否影响其他向量
            for jj in range(ii + 1, BB.dimensions()[0]):
                # 如果另一个向量受到影响：
                # 我们增加计数
                if BB[jj, ii] != 0:
                    affected_vectors += 1
                    affected_vector_index = jj
 
            # 等级：0
            # 如果没有其他载体最终受到影响
            # 我们删除它
            if affected_vectors == 0:
                #print ("* removing unhelpful vector", ii)
                BB = BB.delete_columns([ii])
                BB = BB.delete_rows([ii])
                monomials.pop(ii)
                BB = remove_unhelpful(BB, monomials, bound, ii-1)
                return BB
 
           # 等级：1
            #如果只有一个受到影响，我们会检查
            # 如果它正在影响别的向量
            elif affected_vectors == 1:
                affected_deeper = True
                for kk in range(affected_vector_index + 1, BB.dimensions()[0]):
                    # 如果它影响哪怕一个向量
                    # 我们放弃这个
                    if BB[kk, affected_vector_index] != 0:
                        affected_deeper = False
                # 如果没有其他向量受到影响，则将其删除，并且
                # 这个有用的向量不够有用
                #与我们无用的相比
                if affected_deeper and abs(bound - BB[affected_vector_index, affected_vector_index]) < abs(bound - BB[ii, ii]):
                    #print ("* removing unhelpful vectors", ii, "and", affected_vector_index)
                    BB = BB.delete_columns([affected_vector_index, ii])
                    BB = BB.delete_rows([affected_vector_index, ii])
                    monomials.pop(affected_vector_index)
                    monomials.pop(ii)
                    BB = remove_unhelpful(BB, monomials, bound, ii-1)
                    return BB
    # nothing happened
    return BB
 
""" 
Returns:
* 0,0   if it fails
* -1，-1 如果 "strict=true"，并且行列式不受约束
* x0,y0 the solutions of `pol`
"""
def boneh_durfee(pol, modulus, mm, tt, XX, YY):
    """
    Boneh and Durfee revisited by Herrmann and May
 
 在以下情况下找到解决方案：
* d < N^delta
* |x|< e^delta
* |y|< e^0.5
每当 delta < 1 - sqrt（2）/2 ~ 0.292
    """
 
    # substitution (Herrman and May)
    PR.<u, x, y> = PolynomialRing(ZZ)   #多项式环
    Q = PR.quotient(x*y + 1 - u)        #  u = xy + 1
    polZ = Q(pol).lift()
 
    UU = XX*YY + 1
 
    # x-移位
    gg = []
    for kk in range(mm + 1):
        for ii in range(mm - kk + 1):
            xshift = x^ii * modulus^(mm - kk) * polZ(u, x, y)^kk
            gg.append(xshift)
    gg.sort()
 
    # 单项式 x 移位列表
    monomials = []
    for polynomial in gg:
        for monomial in polynomial.monomials(): #对于多项式中的单项式。单项式（）：
            if monomial not in monomials:  # 如果单项不在单项中
                monomials.append(monomial)
    monomials.sort()
 
    # y-移位
    for jj in range(1, tt + 1):
        for kk in range(floor(mm/tt) * jj, mm + 1):
            yshift = y^jj * polZ(u, x, y)^kk * modulus^(mm - kk)
            yshift = Q(yshift).lift()
            gg.append(yshift) # substitution
 
    # 单项式 y 移位列表
    for jj in range(1, tt + 1):
        for kk in range(floor(mm/tt) * jj, mm + 1):
            monomials.append(u^kk * y^jj)
 
    # 构造格 B
    nn = len(monomials)
    BB = Matrix(ZZ, nn)
    for ii in range(nn):
        BB[ii, 0] = gg[ii](0, 0, 0)
        for jj in range(1, ii + 1):
            if monomials[jj] in gg[ii].monomials():
                BB(UU,XX,YY)
 
    #约化格的原型
    if helpful_only:
        #  #自动删除
        BB = remove_unhelpful(BB, monomials, modulus^mm, nn-1)
        # 重置维度
        nn = BB.dimensions()[0]
        if nn == 0:
            print ("failure")
            return 0,0
 
    # 检查向量是否有帮助
    if debug:
        helpful_vectors(BB, modulus^mm)
 
    # 检查行列式是否正确界定
    det = BB.det()
    bound = modulus^(mm*nn)
    if det >= bound:
        print ("We do not have det < bound. Solutions might not be found.")
        print ("Try with highers m and t.")
        if debug:
            diff = (log(det) - log(bound)) / log(2)
            print ("size det(L) - size e^(m*n) = ", floor(diff))
        if strict:
            return -1, -1
    else:
        print ("det(L) < e^(m*n) (good! If a solution exists < N^delta, it will be found)")
 
    # display the lattice basis
    if debug:
        matrix_overview(BB, modulus^mm)
 
    # LLL
    if debug:
        print ("optimizing basis of the lattice via LLL, this can take a long time")
 
    #BB = BB.BKZ(block_size=25)
    BB = BB.LLL()
 
    if debug:
        print ("LLL is done!")
 
    # 替换向量 i 和 j ->多项式 1 和 2
    if debug:
        print ("在格中寻找线性无关向量")
    found_polynomials = False
 
    for pol1_idx in range(nn - 1):
        for pol2_idx in range(pol1_idx + 1, nn):
 
            # 对于i and j, 构造两个多项式
 
            PR.<w,z> = PolynomialRing(ZZ)
            pol1 = pol2 = 0
            for jj in range(nn):
                pol1 += monomials[jj](w*z+1,w,z) * BB[pol1_idx, jj] / monomials[jj](UU,XX,YY)
                pol2 += monomials[jj](w*z+1,w,z) * BB[pol2_idx, jj] / monomials[jj](UU,XX,YY)
 
            # 结果
            PR.<q> = PolynomialRing(ZZ)
            rr = pol1.resultant(pol2)
 
 
            if rr.is_zero() or rr.monomials() == :
                continue
            else:
                print ("found them, using vectors", pol1_idx, "and", pol2_idx)
                found_polynomials = True
                break
        if found_polynomials:
            break
 
    if not found_polynomials:
        print ("no independant vectors could be found. This should very rarely happen...")
        return 0, 0
 
    rr = rr(q, q)
 
    # solutions
    soly = rr.roots()
 
    if len(soly) == 0:
        print ("Your prediction (delta) is too small")
        return 0, 0
 
    soly = soly[0][0]
    ss = pol1(q, soly)
    solx = ss.roots()[0][0]
    return solx, soly
 
def example():
    ############################################
    # 随机生成数据
    ##########################################
    #start_time =time.perf_counter
    start =time.clock()
    size=512
    length_N = 2*size;
    ss=0
    s=70;
    M=1   # the number of experiments
    delta = 299/1024
    # p =  random_prime(2^512,2^511)
    for i in range(M):
#         p =  random_prime(2^size,None,2^(size-1))
#         q =  random_prime(2^size,None,2^(size-1))
#         if(p<q):
#             temp=p
#             p=q
#             q=temp
        N = 64421669931279763032337930351371074312763623230334264672272991963587968145469789623226631192910548697947848779021944177739911084383786634595255436873350170397825307930618697902052402139072111389681839113510986333829074390665317265603346122882832568330112945567680656219994967593371244275156478322204419261819
        e = 31010691142874094705557092175690153458422282630834301371323563655985170293061551914791533335820551677589839843761852199680128997193432075880230502409814741638209947794142932041357373199521605405986705517942961028228255066560857365694517578822510622110740926010357756915595155038827023753366174321207668419113
        c = 44228757856694834445202355486356318880471120936109992694489050154150768403667631244534149277159399976972028214341072460353357561691320731420869678207365539080035139895735181119706727564445399237943178679966032596522818504363414526390960660239215638736706163678206959509331192083842100728618312517781111784803
        hint1 =  597218086872775768003
        hint2 =  836339982627318976124
#         print ("p真实高",s,"比特：", int(p/2^(512-s)))
#         print ("q真实高",s,"比特：", int(q/2^(512-s)))
 
#         N = p*q;
 
 
    # 解密指数d的指数( 最大0.292)
 
 
 
        m = 7   # 格大小（越大越好/越慢）
        t = round(((1-2*delta) * m))  # 来自 Herrmann 和 May 的优化
        X = floor(N^delta)  # 
        Y = floor(N^(1/2)/2^s)    # 如果 p、 q 大小相同，则正确
        for l in range(int(hint1),int(hint1)+1):
            print('\n\n\n l=',l)
            pM=l;
            p0=pM*2^(size-s)+2^(size-s)-1;
            q0=N/p0;
            qM=int(q0/2^(size-s))
            A = N + 1-pM*2^(size-s)-qM*2^(size-s);
        #A = N+1
            P.<x,y> = PolynomialRing(ZZ)
            pol = 1 + x * (A + y)  #构建的方程
 
            # Checking bounds
            #if debug:
                #print ("=== 核对数据 ===")
                #print ("* delta:", delta)
                #print ("* delta < 0.292", delta < 0.292)
                #print ("* size of e:", ceil(log(e)/log(2)))  # e的bit数
                # print ("* size of N:", len(bin(N)))          # N的bit数
                #print ("* size of N:", ceil(log(N)/log(2)))  # N的bit数
                #print ("* m:", m, ", t:", t)
 
            # boneh_durfee
            if debug:
                ##print ("=== running algorithm ===")
                start_time = time.time()
 
 
            solx, soly = boneh_durfee(pol, e, m, t, X, Y)
 
 
            if solx > 0:
                #print ("=== solution found ===")
                if False:
                    print ("x:", solx)
                    print ("y:", soly)
 
                d_sol = int(pol(solx, soly) / e)
                ss=ss+1

                print ("=== solution found ===")
                print ("p的高比特为：",l)
                print ("q的高比特为：",qM)
                print ("d=",d_sol) 
 
            if debug:
                print("=== %s seconds ===" % (time.time() - start_time))
            #break
        print("ss=",ss)
                            #end=time.process_time
        end=time.clock()
        print('Running time: %s Seconds'%(end-start))
if __name__ == "__main__":
    example()

image-20220124192143500

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
n = 64421669931279763032337930351371074312763623230334264672272991963587968145469789623226631192910548697947848779021944177739911084383786634595255436873350170397825307930618697902052402139072111389681839113510986333829074390665317265603346122882832568330112945567680656219994967593371244275156478322204419261819

e = 31010691142874094705557092175690153458422282630834301371323563655985170293061551914791533335820551677589839843761852199680128997193432075880230502409814741638209947794142932041357373199521605405986705517942961028228255066560857365694517578822510622110740926010357756915595155038827023753366174321207668419113

c = 44228757856694834445202355486356318880471120936109992694489050154150768403667631244534149277159399976972028214341072460353357561691320731420869678207365539080035139895735181119706727564445399237943178679966032596522818504363414526390960660239215638736706163678206959509331192083842100728618312517781111784803

hint1 = 597218086872775768003

hint2 = 836339982627318976124

d= 723139209811695466615412520251642069457719866228119412426018806563095539525831453648719201

m = pow(c,d,n)

print(long_to_bytes(m))