工作室招新题write up

张峻铭2022090903016 Crcrcr

Web

1.ClickMe

根据题目应该是点击某个按钮会进行相关反应，而web中唯一的按钮无法点击。使用前缀添加view-source:,查看了网页源代码，发现代码style=”pointer-events:auto，即按钮点击功能被禁用。将网页保存后以记事本形式打开，修改pointr_events的参数为auto，再次打开后点击后即可得到flag为Aegis{We1com3_to_2O23_Ae9is_Recruit!}

2.Get&Post

本题为白盒类型，web前端直接给出了后端文件的源代码。通过观察得知，flag会通过cookie发送给用户，而发送cookie的条件为用户分别通过get和post方法传入a和b两个参数，且参数的值相同。

3.Spider

根据题目字面意思此题应为爬虫类题目，点开后提示向网页添加后缀后进入新的网页获取flag，连续操作几次后仍然在跳转的途中。联想到遇到过需要不断点击的整蛊弹窗，考虑经过大量网页跳转后达到目标网页，编写python爬虫代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import re
import requests

url1 = "http://139.9.212.160:19001/"
while True:
    url = "http://139.9.212.160:19001/"
    # 发送请求并获取网页内容
    response = requests.get(url1)
    html_content = response.text

    # 使用正则表达式匹配以.html结束的字符串
    pattern = r'\b\w+\.html\b'
    matches = re.findall(pattern, html_content)
    list_as_string = ''.join(str(x) for x in matches)
    url1 = url + list_as_string
    print(url1)
    if(url1==url):
        break

该代码不断爬取网页上符合的字符串并不断粘贴在初始网页后面进行访问，以此达到暴力破解的目的，最后程序运行完后进入倒数第二个网址找到flag为Aegis{foll0w_7he_spider&get_f1ag}

4.Upload

页面点击后发现是一个文件提交窗口且仅支持图片类型格式。尝试传入其他格式文件后显示上传失败。上传成功后会给出文件的保存路径。考虑上传一句话木马并修改文件的后缀名为jpg格式以便上传成功。打开burpsuite抓包，将文件名后缀改为.php后放包。将文件保存地址复制后，打开中国蚁剑使用木马中设置的密码进行连接，成功后在/flag目录下找到flag为Aegis{Did’u’_see^some_n!ce_pictures?}

5.Play

打开页面或发现唯一可点击为一个超链接，点开后发现又被骗了（。考虑使用其他方法，在challenge页面提示为git泄露。使用GitHack进行git抓取，成功生成包含在dist文件夹下的网页文档。在cmd中打开此目录，输入git log -p查看git的提交记录，成功找到在Author: root root@LAPTOP-B9A811D6.localdomain
Date: Thu Jul 20 14:33:02 2023 +0800的提交目录下flag = “Aegis{pa1y_f0r_.git!}

Misc

###1.签到题
熟悉提交流程的题目，在readme中即可找到flag为 Aegis{Hello_world!}

2.GFW

根据题目提示，下载telegram后进入指定用户页面，在输入框输入/flag后即可得到一串字符YWVnaXN7T3V0czFkZV90aDNfV2ExbH0=.由后面等号判断这是base64编码，解码后flag为aegis{Outs1de_th3_Wa1l}

3.one more cat?

下载文件后发现未显示后缀名，使用010editor打开后前4个字符为FFD8，判断为jpg文件。修改文件后缀名为jpg文件后顺利打开。观察后发现文件长宽不正确（其实一开始我在文件的十六进制代码随便删着玩，发现刮掉一层后里面还以，误以为是图层重叠什么么的，后面搜了一下才知道是长宽不正确。）查看文件属性得到图片现长宽为1772*723。将两个数据进行十六进制转码得到06EC和02D3，在010editor中找到两个相邻的字串.将图片长度改为04E3后得到flag为Aegis {KGHpnFQM5MfaY9OAV}

Crypto

1.cc的代码1

观察后发现这是个同余方程，可以利用辗转相除法求得m的值。代码如下：

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
def extended_gcd(a, b):

    if b == 0:
        return a, 1, 0
    else:
        d, x, y = extended_gcd(b, a % b)
        return d, y, x - (a // b) * y


def solve_equation(a, n, target):

    d, x, y = extended_gcd(a, n)
    if target % d != 0:
        return None  
    x *= target // d
    x %= n
    return x

a = 8885832285076963111586680210364692820709966457672030441334543789536294316276764325084472715660723570686435234128145259842857647663221372060185195892044064

n = 9060969402803629915292267894492786224273473822492111764553997443209807171984324952573563576103685820371134042358293416805659268231981495201044778198872141

target = 114514

solution = solve_equation(a, n, target)
if solution is None:
    print("No solution exists")
else:
    print("The value of m is:", solution)

R什么A

根据题意这是个rsa加密算法，给出了两个用户他们的加密过程。由代码可知两个用户加密时使用了相同的p值。运用同模攻击，即计算n1,n2的最大公倍数可得出p的值，进而计算出q1，q2的值。运用拓展按欧几里得分别计算两用户的私钥，最后解密即可。代码如下

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
  from Crypto.Util.number import  long_to_byte
  e = 0x10001
  n1 = 133168339217550577216589062233437816811151402796223033430088220416336906835669848994634291919170643581348650874065227137073336317617907512053823559235568701518666617297922184334465523573627967988519834913401715758584414421994725070840582274155375718602963660285184191200529505877324844371003066321517039773577
  n2 = 97835755437595943550384485863622347994545081725956858027590612679202717629490020118342555446377038561457615114110440677424494746589149302908259809779710879296073535208650014526412949826891681368091148265929650418740652382792259655790387629193930725722742705798634504994801712862675586856497946091948411904811
  c1 = 79153623056164822940275047499069044582637140703650747599791080674014224831942664718406064442887419006725379874121960823738302298816788211937934636730896427274557688579693244565838177533163514622774701652069473299516660928618067558031889377029541505803032827360621581370094282765008788493519911012912319042922
  c2 = 25367476846913855168742220843431001349944206244063721403515824033435057384220536226996912522239640399134329525506438764500693894800833986724686905563128127624570309841422954176387059594177714614422407030832520985260687376035390006330027872652761934209690803437576392644066370183311540336426081888423843400476

 def gcd(a, b):
    while b != 0:
        a, b = b, a % b
    return a

p=gcd(n1,n2)
q1=n1//p
q2=n2//p
phi1=(p-1)(q1-1)
phi2=(p-1)(q2-1)
def extended_gcd(a, b):
    if b == 0:
        return a, 1, 0
    else:
        d, x, y = extended_gcd(b, a % b)
        return d, y, x - (a // b) * y

def mod_inverse(e, phi):
    d = extended_gcd(e, phi)[1]
    d = (d % phi + phi) % phi
    return d
d1=mod_inverse(e,phi1)
d2=mod_inverse(e,phi2)
m1=pow(c1,d1,n1)
m2=pow(c2,d2,n2)
t1=long_to_byte(m1)
t2=long_to_byte(m2)
s1=t1.decode()
s2=t2.decode()
ans=t1+t2

3.你这对数保熟吗

典型的离散对数问题。经过分解后发现原题中p-1分解后发现由2，3，13的大指数幂相乘得到，考虑使用Pohlig_hellman算法解决。（因为没有研究过群和阶的相关知识所以只好去github找到大佬写的代码））））。以下是解决代码

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
g = 23
p = 335215034881592512312398694238485179340610060759881511231472142277527176340784432381542726029524727833039074808456839870641607412102746854257629226877248337002993023452385472058106944014653401647033456174126976474875859099023703472904735779212010820524934972736276889281087909166017427905825553503050645575935980580803899122224368875197728677516907272452047278523846912786938173456942568602502013001099009776563388736434564541041529106817380347284002060811645842312648498340150736573246893588079033524476111268686138924892091575797329915240849862827621736832883215569687974368499436632617425922744658912248644475097139485785819369867604176912652851123185884810544172785948158330991257118563772736929105360124222843930130347670027236797458715653361366862282591170630650344062377644570729478796795124594909835004189813214758026703689710017334501371279295621820181402191463184275851324378938021156631501330660825566054528793444353


h = 151333891124751042530373058733310229020861747364950371939516479475162992037903347417936196828583151386618599368454072226165444925872870650414551703768232002316254158915083698330990330278130046398088047562784667521913753402515723191873156994035716848303368773750333765220820386506782880732679521051748318241805303190991258449127197189331948934074457050488191283099074865889637545218937526229513889791410777502477696875891082038990413388216830069268272255999388181376286940238370372643791232995202072450723942304527080946432917501351864739416448924582017320060586643735734292637847642023547476853638234949833659591784958385540561237937020927469550605965078493721147809719894402771906021288426916263343205077017375543543255846809902539042307898378549318665401306894386065737984451884222692305472589833388412932383483599881154543926136994191023685493449167048197363831597805973018213602671103739435631408238626910595609595980072843

print("\n\nCalculating prime number decomposition of p-1...")
p_1 = p - 1
d, factors = 2, []
while d*d <= p_1:
    while (p_1 % d) == 0:
        factors.append(d)
        p_1 //= d
    d += 1
if p_1 > 1:
    factors.append(p)

factors = [[x, factors.count(x)] for x in set(factors)]
print("Prime number decomposition of p-1 : \n{}\n\n".format(factors)) 

x = []
for factor in factors:
    print("┌──────────────\n│Searching xi for {}\n└──────────────".format(factor[0]))
    x_i_list = []
    for i in range(factor[1]):
        print("------\nSearching for power {}\n------".format(i))
        if i != 0:
            beta = (beta * pow(g, -(x_i_list[-1] * (factor[0] ** (i - 1))), p)) % p
        else:
            beta = h
        e1 = pow(beta, (p-1) // (factor[0] ** (i + 1)), p)
        e2 = pow(g, (p-1) // factor[0], p)
        print("e1 = {}".format(e1))
        print("e2 = {}".format(e2))
        for k in (range(factor[0])):
            if pow(e2, k, p) == e1:
                print("{}^{} = {} [p]".format(e1, k, e2))
                x_i_list.append(k)
                print("x = {}".format(k))
                break
    x.append(x_i_list)

print("\n\nCreation of congruence system...")
system = []
for i, factor in enumerate(factors):
    y = 0
    for j, x_j in enumerate(x[i]):
        y += x_j * (factor[0] ** j)
    y = y % (factor[0] ** factor[1])
    print("x = {} [p]".format(y))
    system.append(y)
    

result = 0
for i in range(len(factors)):
    p_i, e_i = factors[i]
    p_e = p_i ** e_i
    product = system[i]
    for j in range(len(factors)):
        if j == i:
            continue
        p_e_j = factors[j][0] ** factors[j][1]
        product *= p_e_j * pow(p_e_j, -1, p_e)
        product %= (p - 1)
    result += product
    result %= (p - 1)
    
print("\n\n┌──────────────\n│ x = {}\n└──────────────".format(result))

print("""   _____                                      
  / ___/____ __________ _____  __  __________ 
  \__ \/ __ `/ ___/ __ `/ __ \/ / / / ___/ _ \\
 ___/ / /_/ / /  / /_/ / /_/ / /_/ / /__/  __/
/____/\__,_/_/   \__,_/ .___/\__,_/\___/\___/ 
                     /_/                       (dit le king)
                     """)

###4.cc的代码二
根据题意即求出以center值为中心，radius值为半径的范围内一共有多少素数。因为center值过大，根据文件中的暴力法破解显然跑不出来，考虑优化算法。（一开始我想的是用欧拉筛来找但是center值太大导致python列表容纳不下这么多数据，后面转念一想我铸币了）直接使用Miller_Rabin素性测试判断一个数是否为素数

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
import random
from Crypto.Util.number import  long_to_byte

def is_prime(n, k=5):
    if n <= 1:
        return False
    if n <= 3:
        return True
    if n % 2 == 0:
        return False

    r = 0
    d = n - 1
    while d % 2 == 0:
        r += 1
        d //= 2

    for _ in range(k):
        a = random.randint(2, n - 2)
        x = pow(a, d, n)

        if x == 1 or x == n - 1:
            continue

        for _ in range(r - 1):
            x = pow(x, 2, n)
            if x == n - 1:
                break
        else:
            return False

    return True
center = 865043906 << 64
radius = 1145141
count = 0

for i in range(center - radius, center + radius):
    if is_prime(i):
        count += 1
t=long_to_byte(count)
ans=t.decode()
print(ans)


#markdown
工作室招新题write up
http://example.com/2023/11/03/工作室招新题write-up/
Author
John Doe
Posted on
November 3, 2023
Licensed under