NotionNext BLOG

祥云杯misc/re

Mon, 31 Oct 2022 00:00:00 GMT

MISC

strange_forensics

首先，是一个linux取证，需要得到这个镜像的版本号

使用命令这边只用vol3有这个命令，如果是对于linux取证的话


#vol3
vol -f 1.mem banners

得到版本


Linux version 5.4.0-84-generic (buildd@lcy01-amd64-007) (gcc version 7.5.0 (Ubuntu 7.5.0-3ubuntu1~18.04)) #94~18.04.1-Ubuntu SMP Thu Aug 26 23:17:46 UTC 2021 (Ubuntu 5.4.0-84.94~18.04.1-generic 5.4.133)

然后我们要构建一个跟这个内核一样，记住是一模一样的内核。

ps:踩坑

这边就不能使用上面学习链接中的做法使用vol3去拉出内核，我具体原因也不知道是为什么，最后会导致本来好好的，amd64-007变成amd64-046

就使用字符表+dwarf的方式制作内核调试信息的文件

学习链接2

安装部分就不讲解了，我们需要去安装一个18.04的ubuntu，在装完之后需要uname -a 查看一下自己内核版本能不能对上，然后需要在这个ubuntu上下一个volatility2，进行dwarf的编译

1.创建vtypes


cd volatility/tools/linux
make

2.获取符号表

一般我们可以在/boot目录下找到该System.map文件。该文件包含系统的符号信息。

这个就是我们所需要的符号表了

3.制作用户配置文件

将moudle.dwarf以及system.map文件打包成一个zip文件


sudo zip ./volatility/plugins/overlays/linux/Ubuntu.zip ./tools/linux/module.dwarf /boot/System.map-`uname -r`

这样我们一个可以调试的内核就制作好了

4.开始做题

然后我们回到自己的kali虚拟机,使用vol2，将Ubuntu.zip放到自己的//volatility-master/volatility/plugins/linux/目录下

查看info


python2 vol.py --info

第一个就是，我们选用这个作为我们的profiles

LinuxUbuntux64

分享一个师傅的blog，里面有几篇关于linux 取证的分析大佬博客

以及linux取证下的命令官网

密码在/etc/shadow 下


python2 vol.py -f 1.mem --profile=LinuxUbuntux64 linux_enumerate_files | grep 'shadow'

然后将这个文件dump下来


python2 vol.py -f 1.mem --profile=LinuxUbuntux64 linux_find_file -i 0xffff97ce7444b448 -O shadow

拿到了

直接somd5解

拿到密码

然后查看文件

恢复文件的元数据：包括文件大小，MACtimes，权限，所有者，等等

为了获取完整的数据，命令必须以root权限运行


python2 vol.py -f 1.mem --profile=LinuxUbuntux64 linux_recover_filesystem -D dum

可以在/home/bob/Desktop目录下找到一个secret.zip文件

是一个伪无密，把两个加密数据块的0000改成0900就可以爆破了

爆破密码得到第二部分flag


_y0u_Ar3_tHe_LIn

第三部分flag，应该是非预期，直接在010里面搜索，flag3，就可以得到第三部分flag

最后得到完整的flag


flag{890topico_y0u_Ar3_tHe_LInUx_forEnsIcS_MASTER}

从而可以引出更多的非预期

在010直接搜索gdm-password，稍微翻一下，只有110个搜索

可以直接得到密码，gdm-password是root密码

然后binwalk -e可以直接将zip分离出来，就是小心内存炸了，所以从理论上来说，这道题甚至不用配profile。

总结

这题主要是考察linux镜像取证，主要难点就是配linux镜像，后面就没有什么难得了。

REVERSE

rocket

装一个ubuntu22.04，以及8.2的racket。官网的rocket是8.6版本的，所以要去历史里面下载

racket8.2

下载下来是一个.sh文件，直接./运行即可

output是一串值，估计是flag，我们先不去管它

装好之后运行./chall 会让你输入一个值，然后输出到output（这边有一个坑，因为output不能被覆盖，不知道是不是我虚拟机的问题，需要每次都去删掉output）

这边输入一个1跟一个b，因为1跟b的ascii码正好是2倍，也好找规律。看到输入一个字符之后得到了一个值，我们可以猜测是经过了某种运算，又因为我们设定了1跟b，所以将这两个值相除一下，正好是8倍，我们就猜测，中间的运算是将字符的ASCII值进行了3次方


import base64
import string
import math
from Crypto.Util.number import *
import gmpy2

print(ord('b'))
print(ord('1'),117649,941192)
print(941192/117649)
print(chr(ord('1')*2))

我们就将output中的值开三次方根，然后直接转字符，就可以得到flag


import base64
import string
import math
from Crypto.Util.number import *
import gmpy2

print(ord('b'))
print(ord('1'),117649,941192)
print(941192/117649)
print(chr(ord('1')*2))
print(long_to_bytes(gmpy2.iroot(7212272804013543391008421832457418223544765489764042171135982569211377620290274828526744558976950004052088838419495093523281490171119109149692343753662521483209758621522737222024221994157092624427343057143179489608942837157528031299236230089474932932551406181,3)[0]))

engtom

又是一个需要搭建环境的题，这次比赛搭建环境的题是真的多，尝试了20.04跟22.04的ubuntu不能搭建，然后尝试用18.04成功

首先拿到一个chall.snapshot文件，不知道是什么，打开010，发现文件头是JRRYF，想到了之前做的某个比赛中也有类似的文件，是使用的jerryscript,可惜环境早就删了，重新搭一个

上官网，直接使用他给的命令，一键部署


sudo apt-get install gcc gcc-arm-none-eabi cmake cppcheck clang-format-10 python
python3 tools/build.py  #不能使用python，因为Ubuntu默认python是2.7，会导致编译失败

ps：踩坑

在直接运行的时候，会有报错

在查询了多方文档之后（真的坑，基本找不到文档），文档，发现要将几个接口给ON起来，否则会不能用

至于怎么找到这几个命令，可以使用-h来查询命令

然后执行


./jerry --show-opcodes --exec-snapshot chall.snapshot

然后就可以分析字节码了

得到


Byte code dump:

  Maximum stack depth: 38
  Flags: [small_lit_enc]
  Argument range end: 0
  Register range end: 5
  Identifier range end: 30
  Const literal range end: 91
  Literal range end: 101

   0 : CBC_CHECK_VAR ident:5->string(SboxTable)
   2 : CBC_CHECK_VAR ident:6->string(CK)
   4 : CBC_CHECK_VAR ident:7->string(FK)
   6 : CBC_CHECK_VAR ident:8->string(bigxor)
   8 : CBC_CHECK_VAR ident:9->string(leftshift)
  10 : CBC_CHECK_VAR ident:10->string(prefixInteger)
  12 : CBC_CHECK_VAR ident:11->string(sm4Sbox)
  14 : CBC_CHECK_VAR ident:12->string(GET_ULONG_BE)
  16 : CBC_CHECK_VAR ident:13->string(PUT_ULONG_BE)
  18 : CBC_CHECK_VAR ident:14->string(sm4_getkey)
  20 : CBC_CHECK_VAR ident:15->string(encrypt)
  22 : CBC_CHECK_VAR ident:16->string(decrypt_sm4)
  24 : CBC_CHECK_VAR ident:17->string(compare_array)
  26 : CBC_CHECK_VAR ident:18->string(input)
  28 : CBC_CHECK_VAR ident:19->string(num)
  30 : CBC_CHECK_VAR ident:20->string(message)
  32 : CBC_CHECK_VAR ident:21->string(count)
  34 : CBC_CHECK_VAR ident:22->string(pad_len)
  36 : CBC_CREATE_VAR_EVAL ident:5->string(SboxTable)
  38 : CBC_CREATE_VAR_EVAL ident:6->string(CK)
  40 : CBC_CREATE_VAR_EVAL ident:7->string(FK)
  42 : CBC_CREATE_VAR_FUNC_EVAL lit:91 ident:8->string(bigxor)
  45 : CBC_CREATE_VAR_FUNC_EVAL lit:92 ident:9->string(leftshift)
  48 : CBC_CREATE_VAR_FUNC_EVAL lit:93 ident:10->string(prefixInteger)
  51 : CBC_CREATE_VAR_FUNC_EVAL lit:94 ident:11->string(sm4Sbox)
  54 : CBC_CREATE_VAR_FUNC_EVAL lit:95 ident:12->string(GET_ULONG_BE)
  57 : CBC_CREATE_VAR_FUNC_EVAL lit:96 ident:13->string(PUT_ULONG_BE)
  60 : CBC_CREATE_VAR_FUNC_EVAL lit:97 ident:14->string(sm4_getkey)
  63 : CBC_CREATE_VAR_FUNC_EVAL lit:98 ident:15->string(encrypt)
  66 : CBC_CREATE_VAR_FUNC_EVAL lit:99 ident:16->string(decrypt_sm4)
  69 : CBC_CREATE_VAR_FUNC_EVAL lit:100 ident:17->string(compare_array)
  72 : CBC_CREATE_VAR_EVAL ident:18->string(input)
  74 : CBC_CREATE_VAR_EVAL ident:19->string(num)
  76 : CBC_CREATE_VAR_EVAL ident:20->string(message)
  78 : CBC_CREATE_VAR_EVAL ident:21->string(count)
  80 : CBC_CREATE_VAR_EVAL ident:22->string(pad_len)
  82 : CBC_PUSH_LITERAL ident:23->string(Array)
  84 : CBC_NEW0
  85 : CBC_ASSIGN_SET_IDENT ident:5->string(SboxTable)
  87 : CBC_PUSH_LITERAL_PUSH_NUMBER_0 ident:5->string(SboxTable)
  89 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:214
  92 : CBC_PUSH_NUMBER_POS_BYTE number:144
  94 : CBC_PUSH_NUMBER_POS_BYTE number:233
  96 : CBC_PUSH_NUMBER_POS_BYTE number:254
  98 : CBC_PUSH_NUMBER_POS_BYTE number:204
 100 : CBC_PUSH_NUMBER_POS_BYTE number:225
 102 : CBC_PUSH_NUMBER_POS_BYTE number:61
 104 : CBC_PUSH_NUMBER_POS_BYTE number:183
 106 : CBC_PUSH_NUMBER_POS_BYTE number:22
 108 : CBC_PUSH_NUMBER_POS_BYTE number:182
 110 : CBC_PUSH_NUMBER_POS_BYTE number:20
 112 : CBC_PUSH_NUMBER_POS_BYTE number:194
 114 : CBC_PUSH_NUMBER_POS_BYTE number:40
 116 : CBC_PUSH_NUMBER_POS_BYTE number:251
 118 : CBC_PUSH_NUMBER_POS_BYTE number:44
 120 : CBC_PUSH_NUMBER_POS_BYTE number:5
 122 : CBC_NEW byte_arg:16
 124 : CBC_ASSIGN_BLOCK
 125 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:1
 128 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:43
 131 : CBC_PUSH_NUMBER_POS_BYTE number:103
 133 : CBC_PUSH_NUMBER_POS_BYTE number:154
 135 : CBC_PUSH_NUMBER_POS_BYTE number:118
 137 : CBC_PUSH_NUMBER_POS_BYTE number:42
 139 : CBC_PUSH_NUMBER_POS_BYTE number:190
 141 : CBC_PUSH_NUMBER_POS_BYTE number:4
 143 : CBC_PUSH_NUMBER_POS_BYTE number:195
 145 : CBC_PUSH_NUMBER_POS_BYTE number:170
 147 : CBC_PUSH_NUMBER_POS_BYTE number:68
 149 : CBC_PUSH_NUMBER_POS_BYTE number:19
 151 : CBC_PUSH_NUMBER_POS_BYTE number:38
 153 : CBC_PUSH_NUMBER_POS_BYTE number:73
 155 : CBC_PUSH_NUMBER_POS_BYTE number:134
 157 : CBC_PUSH_NUMBER_POS_BYTE number:6
 159 : CBC_PUSH_NUMBER_POS_BYTE number:153
 161 : CBC_NEW byte_arg:16
 163 : CBC_ASSIGN_BLOCK
 164 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:2
 167 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:156
 170 : CBC_PUSH_NUMBER_POS_BYTE number:66
 172 : CBC_PUSH_NUMBER_POS_BYTE number:80
 174 : CBC_PUSH_NUMBER_POS_BYTE number:244
 176 : CBC_PUSH_NUMBER_POS_BYTE number:145
 178 : CBC_PUSH_NUMBER_POS_BYTE number:239
 180 : CBC_PUSH_NUMBER_POS_BYTE number:152
 182 : CBC_PUSH_NUMBER_POS_BYTE number:122
 184 : CBC_PUSH_NUMBER_POS_BYTE number:51
 186 : CBC_PUSH_NUMBER_POS_BYTE number:84
 188 : CBC_PUSH_NUMBER_POS_BYTE number:11
 190 : CBC_PUSH_NUMBER_POS_BYTE number:67
 192 : CBC_PUSH_NUMBER_POS_BYTE number:237
 194 : CBC_PUSH_NUMBER_POS_BYTE number:207
 196 : CBC_PUSH_NUMBER_POS_BYTE number:172
 198 : CBC_PUSH_NUMBER_POS_BYTE number:98
 200 : CBC_NEW byte_arg:16
 202 : CBC_ASSIGN_BLOCK
 203 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:3
 206 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:228
 209 : CBC_PUSH_NUMBER_POS_BYTE number:179
 211 : CBC_PUSH_NUMBER_POS_BYTE number:28
 213 : CBC_PUSH_NUMBER_POS_BYTE number:169
 215 : CBC_PUSH_NUMBER_POS_BYTE number:201
 217 : CBC_PUSH_NUMBER_POS_BYTE number:8
 219 : CBC_PUSH_NUMBER_POS_BYTE number:232
 221 : CBC_PUSH_NUMBER_POS_BYTE number:149
 223 : CBC_PUSH_NUMBER_POS_BYTE number:128
 225 : CBC_PUSH_NUMBER_POS_BYTE number:223
 227 : CBC_PUSH_NUMBER_POS_BYTE number:148
 229 : CBC_PUSH_NUMBER_POS_BYTE number:250
 231 : CBC_PUSH_NUMBER_POS_BYTE number:117
 233 : CBC_PUSH_NUMBER_POS_BYTE number:143
 235 : CBC_PUSH_NUMBER_POS_BYTE number:63
 237 : CBC_PUSH_NUMBER_POS_BYTE number:166
 239 : CBC_NEW byte_arg:16
 241 : CBC_ASSIGN_BLOCK
 242 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:4
 245 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:71
 248 : CBC_PUSH_NUMBER_POS_BYTE number:7
 250 : CBC_PUSH_NUMBER_POS_BYTE number:167
 252 : CBC_PUSH_NUMBER_POS_BYTE number:252
 254 : CBC_PUSH_NUMBER_POS_BYTE number:243
 256 : CBC_PUSH_NUMBER_POS_BYTE number:115
 258 : CBC_PUSH_NUMBER_POS_BYTE number:23
 260 : CBC_PUSH_NUMBER_POS_BYTE number:186
 262 : CBC_PUSH_NUMBER_POS_BYTE number:131
 264 : CBC_PUSH_NUMBER_POS_BYTE number:89
 266 : CBC_PUSH_NUMBER_POS_BYTE number:60
 268 : CBC_PUSH_NUMBER_POS_BYTE number:25
 270 : CBC_PUSH_NUMBER_POS_BYTE number:230
 272 : CBC_PUSH_NUMBER_POS_BYTE number:133
 274 : CBC_PUSH_NUMBER_POS_BYTE number:79
 276 : CBC_PUSH_NUMBER_POS_BYTE number:168
 278 : CBC_NEW byte_arg:16
 280 : CBC_ASSIGN_BLOCK
 281 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:5
 284 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:104
 287 : CBC_PUSH_NUMBER_POS_BYTE number:107
 289 : CBC_PUSH_NUMBER_POS_BYTE number:129
 291 : CBC_PUSH_NUMBER_POS_BYTE number:178
 293 : CBC_PUSH_NUMBER_POS_BYTE number:113
 295 : CBC_PUSH_NUMBER_POS_BYTE number:100
 297 : CBC_PUSH_NUMBER_POS_BYTE number:218
 299 : CBC_PUSH_NUMBER_POS_BYTE number:139
 301 : CBC_PUSH_NUMBER_POS_BYTE number:248
 303 : CBC_PUSH_NUMBER_POS_BYTE number:235
 305 : CBC_PUSH_NUMBER_POS_BYTE number:15
 307 : CBC_PUSH_NUMBER_POS_BYTE number:75
 309 : CBC_PUSH_NUMBER_POS_BYTE number:112
 311 : CBC_PUSH_NUMBER_POS_BYTE number:86
 313 : CBC_PUSH_NUMBER_POS_BYTE number:157
 315 : CBC_PUSH_NUMBER_POS_BYTE number:53
 317 : CBC_NEW byte_arg:16
 319 : CBC_ASSIGN_BLOCK
 320 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:6
 323 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:30
 326 : CBC_PUSH_NUMBER_POS_BYTE number:36
 328 : CBC_PUSH_NUMBER_POS_BYTE number:14
 330 : CBC_PUSH_NUMBER_POS_BYTE number:94
 332 : CBC_PUSH_NUMBER_POS_BYTE number:99
 334 : CBC_PUSH_NUMBER_POS_BYTE number:88
 336 : CBC_PUSH_NUMBER_POS_BYTE number:209
 338 : CBC_PUSH_NUMBER_POS_BYTE number:162
 340 : CBC_PUSH_NUMBER_POS_BYTE number:37
 342 : CBC_PUSH_NUMBER_POS_BYTE number:34
 344 : CBC_PUSH_NUMBER_POS_BYTE number:124
 346 : CBC_PUSH_NUMBER_POS_BYTE number:59
 348 : CBC_PUSH_NUMBER_POS_BYTE number:1
 350 : CBC_PUSH_NUMBER_POS_BYTE number:33
 352 : CBC_PUSH_NUMBER_POS_BYTE number:120
 354 : CBC_PUSH_NUMBER_POS_BYTE number:135
 356 : CBC_NEW byte_arg:16
 358 : CBC_ASSIGN_BLOCK
 359 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:7
 362 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:212
 365 : CBC_PUSH_NUMBER_0
 366 : CBC_PUSH_NUMBER_POS_BYTE number:70
 368 : CBC_PUSH_NUMBER_POS_BYTE number:87
 370 : CBC_PUSH_NUMBER_POS_BYTE number:159
 372 : CBC_PUSH_NUMBER_POS_BYTE number:211
 374 : CBC_PUSH_NUMBER_POS_BYTE number:39
 376 : CBC_PUSH_NUMBER_POS_BYTE number:82
 378 : CBC_PUSH_NUMBER_POS_BYTE number:76
 380 : CBC_PUSH_NUMBER_POS_BYTE number:54
 382 : CBC_PUSH_NUMBER_POS_BYTE number:2
 384 : CBC_PUSH_NUMBER_POS_BYTE number:231
 386 : CBC_PUSH_NUMBER_POS_BYTE number:160
 388 : CBC_PUSH_NUMBER_POS_BYTE number:196
 390 : CBC_PUSH_NUMBER_POS_BYTE number:200
 392 : CBC_PUSH_NUMBER_POS_BYTE number:158
 394 : CBC_NEW byte_arg:16
 396 : CBC_ASSIGN_BLOCK
 397 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:8
 400 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:234
 403 : CBC_PUSH_NUMBER_POS_BYTE number:191
 405 : CBC_PUSH_NUMBER_POS_BYTE number:138
 407 : CBC_PUSH_NUMBER_POS_BYTE number:210
 409 : CBC_PUSH_NUMBER_POS_BYTE number:64
 411 : CBC_PUSH_NUMBER_POS_BYTE number:199
 413 : CBC_PUSH_NUMBER_POS_BYTE number:56
 415 : CBC_PUSH_NUMBER_POS_BYTE number:181
 417 : CBC_PUSH_NUMBER_POS_BYTE number:163
 419 : CBC_PUSH_NUMBER_POS_BYTE number:247
 421 : CBC_PUSH_NUMBER_POS_BYTE number:242
 423 : CBC_PUSH_NUMBER_POS_BYTE number:206
 425 : CBC_PUSH_NUMBER_POS_BYTE number:249
 427 : CBC_PUSH_NUMBER_POS_BYTE number:97
 429 : CBC_PUSH_NUMBER_POS_BYTE number:21
 431 : CBC_PUSH_NUMBER_POS_BYTE number:161
 433 : CBC_NEW byte_arg:16
 435 : CBC_ASSIGN_BLOCK
 436 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:9
 439 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:224
 442 : CBC_PUSH_NUMBER_POS_BYTE number:174
 444 : CBC_PUSH_NUMBER_POS_BYTE number:93
 446 : CBC_PUSH_NUMBER_POS_BYTE number:164
 448 : CBC_PUSH_NUMBER_POS_BYTE number:155
 450 : CBC_PUSH_NUMBER_POS_BYTE number:52
 452 : CBC_PUSH_NUMBER_POS_BYTE number:26
 454 : CBC_PUSH_NUMBER_POS_BYTE number:85
 456 : CBC_PUSH_NUMBER_POS_BYTE number:173
 458 : CBC_PUSH_NUMBER_POS_BYTE number:147
 460 : CBC_PUSH_NUMBER_POS_BYTE number:50
 462 : CBC_PUSH_NUMBER_POS_BYTE number:48
 464 : CBC_PUSH_NUMBER_POS_BYTE number:245
 466 : CBC_PUSH_NUMBER_POS_BYTE number:140
 468 : CBC_PUSH_NUMBER_POS_BYTE number:177
 470 : CBC_PUSH_NUMBER_POS_BYTE number:227
 472 : CBC_NEW byte_arg:16
 474 : CBC_ASSIGN_BLOCK
 475 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:10
 478 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:29
 481 : CBC_PUSH_NUMBER_POS_BYTE number:246
 483 : CBC_PUSH_NUMBER_POS_BYTE number:226
 485 : CBC_PUSH_NUMBER_POS_BYTE number:46
 487 : CBC_PUSH_NUMBER_POS_BYTE number:130
 489 : CBC_PUSH_NUMBER_POS_BYTE number:102
 491 : CBC_PUSH_NUMBER_POS_BYTE number:202
 493 : CBC_PUSH_NUMBER_POS_BYTE number:96
 495 : CBC_PUSH_NUMBER_POS_BYTE number:192
 497 : CBC_PUSH_NUMBER_POS_BYTE number:41
 499 : CBC_PUSH_NUMBER_POS_BYTE number:35
 501 : CBC_PUSH_NUMBER_POS_BYTE number:171
 503 : CBC_PUSH_NUMBER_POS_BYTE number:13
 505 : CBC_PUSH_NUMBER_POS_BYTE number:83
 507 : CBC_PUSH_NUMBER_POS_BYTE number:78
 509 : CBC_PUSH_NUMBER_POS_BYTE number:111
 511 : CBC_NEW byte_arg:16
 513 : CBC_ASSIGN_BLOCK
 514 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:11
 517 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:213
 520 : CBC_PUSH_NUMBER_POS_BYTE number:219
 522 : CBC_PUSH_NUMBER_POS_BYTE number:55
 524 : CBC_PUSH_NUMBER_POS_BYTE number:69
 526 : CBC_PUSH_NUMBER_POS_BYTE number:222
 528 : CBC_PUSH_NUMBER_POS_BYTE number:253
 530 : CBC_PUSH_NUMBER_POS_BYTE number:142
 532 : CBC_PUSH_NUMBER_POS_BYTE number:47
 534 : CBC_PUSH_NUMBER_POS_BYTE number:3
 536 : CBC_PUSH_NUMBER_POS_BYTE number:255
 538 : CBC_PUSH_NUMBER_POS_BYTE number:106
 540 : CBC_PUSH_NUMBER_POS_BYTE number:114
 542 : CBC_PUSH_NUMBER_POS_BYTE number:109
 544 : CBC_PUSH_NUMBER_POS_BYTE number:108
 546 : CBC_PUSH_NUMBER_POS_BYTE number:91
 548 : CBC_PUSH_NUMBER_POS_BYTE number:81
 550 : CBC_NEW byte_arg:16
 552 : CBC_ASSIGN_BLOCK
 553 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:12
 556 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:141
 559 : CBC_PUSH_NUMBER_POS_BYTE number:27
 561 : CBC_PUSH_NUMBER_POS_BYTE number:175
 563 : CBC_PUSH_NUMBER_POS_BYTE number:146
 565 : CBC_PUSH_NUMBER_POS_BYTE number:187
 567 : CBC_PUSH_NUMBER_POS_BYTE number:221
 569 : CBC_PUSH_NUMBER_POS_BYTE number:188
 571 : CBC_PUSH_NUMBER_POS_BYTE number:127
 573 : CBC_PUSH_NUMBER_POS_BYTE number:17
 575 : CBC_PUSH_NUMBER_POS_BYTE number:217
 577 : CBC_PUSH_NUMBER_POS_BYTE number:92
 579 : CBC_PUSH_NUMBER_POS_BYTE number:65
 581 : CBC_PUSH_NUMBER_POS_BYTE number:31
 583 : CBC_PUSH_NUMBER_POS_BYTE number:16
 585 : CBC_PUSH_NUMBER_POS_BYTE number:90
 587 : CBC_PUSH_NUMBER_POS_BYTE number:216
 589 : CBC_NEW byte_arg:16
 591 : CBC_ASSIGN_BLOCK
 592 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:13
 595 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:10
 598 : CBC_PUSH_NUMBER_POS_BYTE number:193
 600 : CBC_PUSH_NUMBER_POS_BYTE number:49
 602 : CBC_PUSH_NUMBER_POS_BYTE number:136
 604 : CBC_PUSH_NUMBER_POS_BYTE number:165
 606 : CBC_PUSH_NUMBER_POS_BYTE number:205
 608 : CBC_PUSH_NUMBER_POS_BYTE number:123
 610 : CBC_PUSH_NUMBER_POS_BYTE number:189
 612 : CBC_PUSH_NUMBER_POS_BYTE number:45
 614 : CBC_PUSH_NUMBER_POS_BYTE number:116
 616 : CBC_PUSH_NUMBER_POS_BYTE number:208
 618 : CBC_PUSH_NUMBER_POS_BYTE number:18
 620 : CBC_PUSH_NUMBER_POS_BYTE number:184
 622 : CBC_PUSH_NUMBER_POS_BYTE number:229
 624 : CBC_PUSH_NUMBER_POS_BYTE number:180
 626 : CBC_PUSH_NUMBER_POS_BYTE number:176
 628 : CBC_NEW byte_arg:16
 630 : CBC_ASSIGN_BLOCK
 631 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:14
 634 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:137
 637 : CBC_PUSH_NUMBER_POS_BYTE number:105
 639 : CBC_PUSH_NUMBER_POS_BYTE number:151
 641 : CBC_PUSH_NUMBER_POS_BYTE number:74
 643 : CBC_PUSH_NUMBER_POS_BYTE number:12
 645 : CBC_PUSH_NUMBER_POS_BYTE number:150
 647 : CBC_PUSH_NUMBER_POS_BYTE number:119
 649 : CBC_PUSH_NUMBER_POS_BYTE number:126
 651 : CBC_PUSH_NUMBER_POS_BYTE number:101
 653 : CBC_PUSH_NUMBER_POS_BYTE number:185
 655 : CBC_PUSH_NUMBER_POS_BYTE number:241
 657 : CBC_PUSH_NUMBER_POS_BYTE number:9
 659 : CBC_PUSH_NUMBER_POS_BYTE number:197
 661 : CBC_PUSH_NUMBER_POS_BYTE number:110
 663 : CBC_PUSH_NUMBER_POS_BYTE number:198
 665 : CBC_PUSH_NUMBER_POS_BYTE number:132
 667 : CBC_NEW byte_arg:16
 669 : CBC_ASSIGN_BLOCK
 670 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:5->string(SboxTable) number:15
 673 : CBC_PUSH_LITERAL_PUSH_NUMBER_POS_BYTE ident:23->string(Array) number:24
 676 : CBC_PUSH_NUMBER_POS_BYTE number:240
 678 : CBC_PUSH_NUMBER_POS_BYTE number:125
 680 : CBC_PUSH_NUMBER_POS_BYTE number:236
 682 : CBC_PUSH_NUMBER_POS_BYTE number:58
 684 : CBC_PUSH_NUMBER_POS_BYTE number:220
 686 : CBC_PUSH_NUMBER_POS_BYTE number:77
 688 : CBC_PUSH_NUMBER_POS_BYTE number:32
 690 : CBC_PUSH_NUMBER_POS_BYTE number:121
 692 : CBC_PUSH_NUMBER_POS_BYTE number:238
 694 : CBC_PUSH_NUMBER_POS_BYTE number:95
 696 : CBC_PUSH_NUMBER_POS_BYTE number:62
 698 : CBC_PUSH_NUMBER_POS_BYTE number:215
 700 : CBC_PUSH_NUMBER_POS_BYTE number:203
 702 : CBC_PUSH_NUMBER_POS_BYTE number:57
 704 : CBC_PUSH_NUMBER_POS_BYTE number:72
 706 : CBC_NEW byte_arg:16
 708 : CBC_ASSIGN_BLOCK
 709 : CBC_PUSH_THREE_LITERALS ident:23->string(Array) const:30->number(462357) const:31->number(472066609)
 713 : CBC_PUSH_THREE_LITERALS const:32->number(943670861) const:33->number(1415275113) const:34->number(1886879365)
 717 : CBC_PUSH_THREE_LITERALS const:35->number(2358483617) const:36->number(2830087869) const:37->number(3301692121)
 721 : CBC_PUSH_THREE_LITERALS const:38->number(3773296373) const:39->number(4228057617) const:40->number(404694573)
 725 : CBC_PUSH_THREE_LITERALS const:41->number(876298825) const:42->number(1347903077) const:43->number(1819507329)
 729 : CBC_PUSH_THREE_LITERALS const:44->number(2291111581) const:45->number(2762715833) const:46->number(3234320085)
 733 : CBC_PUSH_THREE_LITERALS const:47->number(3705924337) const:48->number(4177462797) const:49->number(337322537)
 737 : CBC_PUSH_THREE_LITERALS const:50->number(808926789) const:51->number(1280531041) const:52->number(1752135293)
 741 : CBC_PUSH_THREE_LITERALS const:53->number(2223739545) const:54->number(2695343797) const:55->number(3166948049)
 745 : CBC_PUSH_THREE_LITERALS const:56->number(3638552301) const:57->number(4110090761) const:58->number(269950501)
 749 : CBC_PUSH_THREE_LITERALS const:59->number(741554753) const:60->number(1213159005) const:61->number(1684763257)
 753 : CBC_NEW byte_arg:32
 755 : CBC_ASSIGN_SET_IDENT ident:6->string(CK)
 757 : CBC_PUSH_THREE_LITERALS ident:23->string(Array) const:62->number(2746333894) const:63->number(1453994832)
 761 : CBC_PUSH_TWO_LITERALS const:64->number(1736282519) const:65->number(2993693404)
 764 : CBC_NEW byte_arg:4
 766 : CBC_ASSIGN_SET_IDENT ident:7->string(FK)
 768 : CBC_PUSH_LITERAL const:66->string(ctf{this_is_an_example})
 770 : CBC_ASSIGN_SET_IDENT ident:18->string(input)
 772 : CBC_PUSH_NUMBER_0
 773 : CBC_ASSIGN_SET_IDENT ident:19->string(num)
 775 : CBC_PUSH_LITERAL ident:23->string(Array)
 777 : CBC_NEW0
 778 : CBC_ASSIGN_SET_IDENT ident:20->string(message)
 780 : CBC_PUSH_NUMBER_0
 781 : CBC_MOV_IDENT reg:1
 783 : CBC_JUMP_FORWARD offset:32(->815)
 785 : CBC_MULTIPLY_TWO_LITERALS ident:19->string(num) const:67->number(256)
 788 : CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE ident:18->string(input) const:68->string(charCodeAt)
 791 : CBC_PUSH_LITERAL reg:1
 793 : CBC_CALL1_PROP_PUSH_RESULT
 794 : CBC_ADD
 795 : CBC_ASSIGN_SET_IDENT_BLOCK ident:19->string(num)
 797 : CBC_MODULO_TWO_LITERALS reg:1 const:69->number(4)
 800 : CBC_EQUAL_RIGHT_LITERAL const:70->number(3)
 802 : CBC_BRANCH_IF_FALSE_FORWARD offset:11(->813)
 804 : CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE ident:20->string(message) const:71->string(push)
 807 : CBC_PUSH_LITERAL ident:19->string(num)
 809 : CBC_CALL1_PROP_BLOCK
 810 : CBC_PUSH_NUMBER_0
 811 : CBC_ASSIGN_SET_IDENT_BLOCK ident:19->string(num)
 813 : CBC_PRE_INCR_IDENT reg:1
 815 : CBC_PUSH_TWO_LITERALS reg:1 ident:18->string(input)
 818 : CBC_PUSH_PROP_LITERAL const:72->string(length)
 820 : CBC_LESS
 821 : CBC_BRANCH_IF_TRUE_BACKWARD offset:36(->785)
 823 : CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE ident:24->string(Math) const:73->string(ceil)
 826 : CBC_PUSH_PROP_LITERAL_LITERAL ident:20->string(message) const:72->string(length)
 829 : CBC_DIVIDE_RIGHT_LITERAL const:69->number(4)
 831 : CBC_CALL1_PROP_PUSH_RESULT
 832 : CBC_ASSIGN_SET_IDENT ident:21->string(count)
 834 : CBC_MULTIPLY_TWO_LITERALS ident:21->string(count) const:69->number(4)
 837 : CBC_ASSIGN_SET_IDENT ident:22->string(pad_len)
 839 : CBC_JUMP_FORWARD offset:7(->846)
 841 : CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE ident:20->string(message) const:71->string(push)
 844 : CBC_PUSH_NUMBER_0
 845 : CBC_CALL1_PROP_BLOCK
 846 : CBC_PUSH_PROP_LITERAL_LITERAL ident:20->string(message) const:72->string(length)
 849 : CBC_LESS_RIGHT_LITERAL ident:22->string(pad_len)
 851 : CBC_BRANCH_IF_TRUE_BACKWARD offset:10(->841)
 853 : CBC_PUSH_THREE_LITERALS ident:23->string(Array) const:74->number(19088743) const:75->number(2309737967)
 857 : CBC_PUSH_TWO_LITERALS const:76->number(4275878552) const:77->number(1985229328)
 860 : CBC_NEW byte_arg:4
 862 : CBC_ASSIGN_SET_IDENT_BLOCK ident:25->string(key)
 864 : CBC_PUSH_THREE_LITERALS ident:23->string(Array) const:78->number(1605062385) const:79->number(-642825121)
 868 : CBC_PUSH_THREE_LITERALS const:80->number(2061445208) const:81->number(1405610911) const:82->number(1713399267)
 872 : CBC_PUSH_THREE_LITERALS const:83->number(1396669315) const:84->number(1081797168) const:85->number(605181189)
 876 : CBC_PUSH_THREE_LITERALS const:86->number(1824766525) const:87->number(1196148725) const:88->number(763423307)
 880 : CBC_PUSH_LITERAL const:89->number(1125925868)
 882 : CBC_NEW byte_arg:12
 884 : CBC_ASSIGN_SET_IDENT_BLOCK ident:26->string(ans)
 886 : CBC_PUSH_LITERAL ident:23->string(Array)
 888 : CBC_NEW0
 889 : CBC_ASSIGN_SET_IDENT_BLOCK ident:27->string(message_c)
 891 : CBC_PUSH_NUMBER_0
 892 : CBC_MOV_IDENT reg:1
 894 : CBC_JUMP_FORWARD offset:47(->941)
 896 : CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE ident:20->string(message) const:90->string(splice)
 899 : CBC_PUSH_NUMBER_0
 900 : CBC_PUSH_NUMBER_POS_BYTE number:4
 902 : CBC_CALL2_PROP_PUSH_RESULT
 903 : CBC_MOV_IDENT reg:2
 905 : CBC_PUSH_THREE_LITERALS ident:15->string(encrypt) reg:2 ident:25->string(key)
 909 : CBC_CALL2_PUSH_RESULT
 910 : CBC_MOV_IDENT reg:3
 912 : CBC_PUSH_NUMBER_0
 913 : CBC_MOV_IDENT reg:4
 915 : CBC_JUMP_FORWARD offset:16(->931)
 917 : CBC_PUSH_PROP_LITERAL_LITERAL_REFERENCE ident:27->string(message_c) const:71->string(push)
 920 : CBC_PUSH_THREE_LITERALS ident:28->string(parseInt) reg:3 reg:4
 924 : CBC_PUSH_PROP
 925 : CBC_PUSH_NUMBER_POS_BYTE number:16
 927 : CBC_CALL2_PUSH_RESULT
 928 : CBC_CALL1_PROP_BLOCK
 929 : CBC_PRE_INCR_IDENT reg:4
 931 : CBC_PUSH_TWO_LITERALS reg:4 reg:3
 934 : CBC_PUSH_PROP_LITERAL const:72->string(length)
 936 : CBC_LESS
 937 : CBC_BRANCH_IF_TRUE_BACKWARD offset:20(->917)
 939 : CBC_PRE_INCR_IDENT reg:1
 941 : CBC_LESS_TWO_LITERALS reg:1 ident:21->string(count)
 944 : CBC_BRANCH_IF_TRUE_BACKWARD offset:48(->896)
 946 : CBC_PUSH_LITERAL ident:27->string(message_c)
 948 : CBC_BRANCH_IF_FALSE_FORWARD offset:10(->958)
 950 : CBC_PUSH_THREE_LITERALS ident:29->string(print) ident:17->string(compare_array) ident:27->string(message_c)
 954 : CBC_PUSH_LITERAL ident:26->string(ans)
 956 : CBC_CALL2_PUSH_RESULT
 957 : CBC_CALL1_BLOCK
 958 : CBC_RETURN_FUNCTION_END

可以看出是SM4加密

找到key和ans


key = [19088743,2309737967,4275878552,1985229328]
ans = [1605062385,-642825121,2061445208,1405610911,1713399267,1396669315,1081797168,605181189,1824766525,1196148725,763423307,1125925868]

转成hex
key='0x123456789abcdeffedcba9876543210'
ans='0x5fab4ef1d9af445f7adf285853c7eb9f662065e3533f7b83407aea30241255056cc3ba3d474bc7f52d80ea4b431c43ec'

直接使用在线解码，得到flag


ctf{w3_f0und_1t_112ug31vjhe121f21fas}

第四届杭州师范大学校赛出题人miscwp

Wed, 05 Apr 2023 00:00:00 GMT

把学弟的wp拿来用，自己懒得写了总的来说出题想法是想让做题人多动动手，主动查查一些资料，不过，最后一败涂地

致我那逝去的青春

参考资料

这题是抄的去年NCTF2022的原题，当做签到题，要是没人做出来其他题就把这个放出来

下面直接放出脚本，注释都在上面了


import string

# 读取卡组代码
# AAECAZoFKNAFhAeMBtIGngXIBrwFzgnmBpIJpgnSBrYH5gaSCaYJ0ga2B4IGugm2B9AF/gOIBPQIiAnQBb4GiAngA8wI8ge2B+oDvga2B6gFmgjyB+IJAAA=
with open('hearthstone.txt','r') as f:
    tes = f.readline()

# 生成base64索引表
box = list(string.ascii_uppercase+string.ascii_lowercase+string.digits+"+/")

bin_arr = []
# 将代码四四分组
grouped_string = [tes[i:i+4] for i in range(0, len(tes), 4)]
for line in grouped_string:
    # 将每组的每一位转为6位的二进制值
    chres = ''
    for i in range(0,4):
        # =用000000填充
        if line[i] == '=':
            chres += '000000'
        else:
            chres += format(box.index(line[i]), "06b")
    # 将4个6位的二进制值转为3个8位的二进制值
    for i in range(0, len(chres), 8):
        # 省略最后一组8位都是0的情况
        if chres[i:i+8] == '00000000' and line == grouped_string[-1]:
            continue
        else:
            bin_arr.append(chres[i:i+8])

# 将前面与卡牌内容无关的二进制值去除
bin_arr = bin_arr[7:]
# 以两个为一组，去除一组中第一个值的第一位，去除一组中第二个值中前面无意义的0
for n in range(0,len(bin_arr),2):
    # bin(int(bin_arr[n+1], 2))[2:] 去除无意义的0
    tmp = bin(int(bin_arr[n+1], 2))[2:] + bin_arr[n][1:]
    # 如果其ascii值大于255，则需要除10再转为字符，否则直接转为字符
    if int(tmp,2) > 255:
        print(chr(int(tmp,2)//10),end='')
    else:
        print(chr(int(tmp,2)),end='')

# HZNUCTF{WuwU_WuwU_My_H34rtHSt0ne_1S_Die}

另一种解法

python居然有一个库是hearthstone，可以一把梭


from hearthstone.deckstrings import Deck

deck = Deck.from_deckstring('AAEDAZoFKIwGngXIBrwFzgnQBfIHygf0CIgJkAi+BogJ1gjMCPIHtgeeBeAD6AfyB7YHvgbgA+AD4AO2B7wFkgnMCMwI+ga2B/QImgi6BJAIiAn2BOIJAAA=')

for card in deck.cards:
    flag_part = int(card[0] / 10)
    print(chr(flag_part), end='')

snake

misc选手怎么能不会逆向呢？

下载后是一个python编程的exe文件，先将其反编译，使用pyinstxtractor工具


python .\pyinstxtractor.py D:\Security\CTF\杂\HZNUCTF校赛决赛\MISC\snake\snake.exe

得到的文件夹中有snake.pyc文件，我们再将其反编译为py文件，使用在线网站

打开得到的py文件，发现上面有flag的提示

将其格式转换一下


s = b"import hashlib \nimport string \nsalt_1 = 'xxxxxxxxxxx' \nsalt_2 = 'xxxxxxxxxxx' \nsalt_3 = 'xxxxxxxxxxx' \nsalt = salt_1 + salt_2 + salt_3 \ndata = 'HZNUCTF{xxxxx}'  #5%e4%bd%8d ascii+digits+_ \nsalt_data = salt + data \ndata_sha = hashlib.sha256(salt_data.encode('utf-8')).hexdigest() \nprint(data_sha)  #c08521f3c380906d05ee8afbc7fa2943afb3788d9cec94c1b86771ee35ca4738"
print(s.decode())

得到


import hashlib
import string
salt_1 = 'xxxxxxxxxxx'
salt_2 = 'xxxxxxxxxxx'
salt_3 = 'xxxxxxxxxxx'
salt = salt_1 + salt_2 + salt_3
data = 'HZNUCTF{xxxxx}'  #5%e4%bd%8d ascii+digits+_
salt_data = salt + data
data_sha = hashlib.sha256(salt_data.encode('utf-8')).hexdigest()
print(data_sha)  #c08521f3c380906d05ee8afbc7fa2943afb3788d9cec94c1b86771ee35ca4738

这里salt值还不知道，再去文件中找一下

发现salt_1和salt_2都是已知的，salt_3需要逆运算一下


print(''.join([chr(ord(c)-i) for i, c in enumerate('mhigexn|irlt')]))
# mggdashuaibi

得到三个salt后再看代码，就是一个哈希爆破，一共有5位需要爆破，这里直接给出爆破脚本


import hashlib
import string
salt_1 = 'mxx307shuai'
salt_2 = 'mxx407shuai'
salt_3 = 'mggdashuaibi'
salt = salt_1 + salt_2 + salt_3
box = list(string.ascii_letters+string.digits+"_")
for a in box:
    for b in box:
        for c in box:
            for d in box:
                for e in box:
                    data = "HZNUCTF{"+a+b+c+d+e+"}"
                    salt_data = salt + data
                    data_sha = hashlib.sha256(salt_data.encode('utf-8')).hexdigest()
                    if data_sha == 'c08521f3c380906d05ee8afbc7fa2943afb3788d9cec94c1b86771ee35ca4738':
                        print(data)
                        exit(0)

babyLSB

一个小小魔改的LSB


hint：

写脚本，两个像素点一组，注意文件名

解压得到R0G2R1G2A2B3.png，这里根据提示的两个像素点为一组，可以猜测文件名中的R0G2R1对应第一个像素点，G2A2B3对应第二个像素点，而其中的字母表示通道，数字代表8位二进制的哪一位是插入点

因此这里编写解密脚本


import numpy as np
from PIL import Image

# 读取png图片
img = Image.open("R0G2R1G2A2B3.png")

# 获取图像尺寸
width, height = img.size

# 将图像转换为NumPy数组
img_arr = np.array(img)

res = ''
# 创建一个文本文件并写入RGBA通道值
for i in range(height):
    for j in range(0,width,2):
        # 两个为一组
        rgb_1 = img_arr[i, j, :]
        rgb_2 = img_arr[i, j+1, :]
        # 根据文件名 R0G2R1G2A2B3 ，R0G2R1 是第一个的值，表示r通道的0位，g通道的2位，r通道的1位；G2A2B3 是第二个的值，表示g通道的2位，alpha通道的2位，b通道的3位
        res += format(rgb_1[0],'08b')[-1] + format(rgb_1[1],'08b')[-3] + format(rgb_1[0],'08b')[-2] + format(rgb_2[1],'08b')[-3] + format(rgb_2[3],'08b')[-3] + format(rgb_2[2],'08b')[-4]

#print(res)
# 通过二进制转十六进制发现504b开头，猜测为zip文件，因此将二进制转为zip文件
int_list = [int(res[i:i+8],2) for i in range(0,len(res),8)]
bytes_data = bytes(int_list)
with open("output.zip", "wb") as f:
    f.write(bytes_data)

得到output.zip，解压后得到FLAG.txt，其中就是flag

蹦蹦炸弹


题目描述：

解压密码：5ff0762eeabcd275c75c4b6e943097c518604493323a52488e67a5d595d108ce79c6d1539a3740f026c4d10d55085c9ec6b0b52a9b5892e1fbd85b671ed16d7a
大坏蛋mxx307入侵了我的系统，最后还想ssh将我的PPT偷走，不过聪明的可莉可是加密了PPT，诶，我忘记我的PPT的密码是啥了，好像是5位小写字母呢。
ssh为弱密码
flag有三部分，第一部分为用户密码

hint：
1. Linux取证
2. Ubuntu符号表(附件)

解压是一个dmp后缀的内存文件，直接用vol2跑会卡住，应该是没有对应镜像的内核

用vol3看一下文件的版本号


python vol.py -f /root/temp/flag.dmp banners

得到结果


Linux version 4.15.0-20-generic (buildd@lgw01-amd64-039) (gcc version 7.3.0 (Ubuntu 7.3.0-16ubuntu3))
#21-Ubuntu SMP Tue Apr 24 06:16:15 UTC 2018 (Ubuntu 4.15.0-20.21-generic 4.15.17)

题目中是直接提供符号表的，我也不想去自己去搞了，放一篇文章可以参考一下

(看我的祥云杯捏)

将下载的Ubuntu.zip放在kali的volatility的/volatility/plugins/overlays/linux/目录下

切换到vol2，通过以下命令查看是否成功载入


python2 vol.py --info | grep Ubuntu

然后就可以开始使用vol2做题了，以下链接中有vol2常用linux取证命令的解释

part1

根据题目描述中，第一部分为用户密码，一般用户密码存放在/etc/shadow中，通过以下命令找到该文件的地址


python2 vol.py -f /root/temp/flag.dmp --profile=LinuxUbuntux64 linux_enumerate_files | grep 'shadow'

找到地址后，通过以下命令将文件提取出来


python2 vol.py -f /root/temp/flag.dmp --profile=LinuxUbuntux64 linux_find_file -i 0xffff8b7ad779f3a8 -O shadow

打印提取出来的文件shadow，下面flag处是一个sha512crypt $6$, SHA512 (Unix)加密的哈希值

如何判断该类型哈希值呢？这里是通过hashcat攻击模式索引网站找到的

https://hashcat.net/wiki/doku.php?id=example_hashes

复制哈希值的特征 $6$ ，去网页中ctrl+f搜索即可找到

找到对应的攻击值1800，我们采用hashcat来攻击（一般来说短时间的题目爆破结果都不会很复杂，这里直接使用kali自带的rockyou.txt字典爆破比较快）


hashcat -m 1800 -a 0 /root/temp/burte.txt /usr/share/wordlists/rockyou.txt

得到第一部分flag：admin

part2

然后我们再通过以下命令，查看linux内存文件的bash记录（类似于windows取证的cmd命令行，都是需要关注的敏感部分）


python2 vol.py -f /root/temp/flag.dmp --profile=LinuxUbuntux64 linux_bash

在bash记录中我们能找到一个连接ssh的记录

结合题目描述中的ssh为弱密码，尝试去爆破登陆，这里使用metasploit中的ssh爆破模块来爆破（这个工具一般来说，kali自带的）

在比赛前给toto做了一遍，然后他说123456是可以找到的，我忘记了，那就找找呗


# 启动msfconsole
msfconsole

# 查找爆破ssh登陆模块
search ssh_login

# 利用模块
use auxiliary/scanner/ssh/ssh_login

# 这里设置中ip，用户名，爆破密码字典是必须设置的
# 设置目标主机ip
set RHOSTS 1.14.49.218

# 设置登陆用户名
set USERNAME ctfer

# 设置密码爆破字典（因为是弱口令，还是用rockyou字典）
set PASS_FILE /usr/share/wordlists/rockyou.txt

# 设置线程
set THREADS 50

# 设置找到密码即停止
set STOP_ON_SUCCESS true

最后通过show options查看模块设置

再输入run开启爆破，最后找到结果为123456

然后获得第二部分flag有两种方式

方式一（非预期）

使用ssh直连bash


ssh -p 22 ctfer@1.14.49.218
# 输入密码123456（这里是无回显的）

进去后发现很多命令都不能使用了，只有ls可以使用，通过ls /可以看到根目录下有一个part2的文件

然后我问了mgg后才知道，是被删命令了，但是bash有两个自带命令是删不掉的，一个是for，一个是echo（这边不是删命令，也差不多，只给了ls的使用权限）

这里通过echo $(可以读取到part2的内容

通过提示$FLAG，我们再去通过echo $FLAG读取环境变量的内容，得到第二部分的flag：_L1nux_f0r3nsics_is_34sy_4nd_

这边听zysgmzb说，跟picoctf2023撞思路了

方式二

通过xftp连接ssh，可以直接跨越目录去读取part2文件

使用xftp连接后，到达根目录，右键用记事本打开即可得知flag在环境变量中，然后再使用echo $FLAG去打印flag（预期解是一样的，找环境变量那个文件，然后右键打开编辑就读取就好了）

`part3（明文攻击可能是以后常考的一个考点了，freebuf那篇文章yyds）`

我们通过查找桌面上的文件，找到存在一个flag.zip


python2 vol.py -f /root/temp/flag.dmp --profile=LinuxUbuntux64 linux_enumerate_files | grep 'Desktop'

还是将其提取出来先


python2 vol.py -f /root/temp/flag.dmp --profile=LinuxUbuntux64 linux_find_file -i 0xffff8b7b753b5e68 -O flag.zip

提取出来的flag.zip发现其中两个文件都被加密了，但是使用7-zip打开，发现他们的加密算法都是ZipCrypto，这里可以尝试明文爆破


zip明文攻击条件：

1. 至少已知明文的12个字节及偏移，其中至少8字节需要连续。
2. 明文对应的文件加密方式为ZipCrypto Store

知识扩展：

ZIP的加密算法大致分为两种ZipCrypto和AES-256,各自又分Deflate和Store。
- ZipCrypto Deflate
- ZipCrypto Store
- AES-256 Deflate
- AES-256 Store

只有使用ZipCrypto Deflate /Store才可以使用 ZIP已知明文攻击进行破解。

先创建已知明文hznuctf.pptx


echo -n "hznuctf.pptx" > ~/temp/flag.txt

进行明文攻击


./bkcrack -C ~/temp/flag.zip -c hznuctf.zip -p ~/temp/flag.txt -o 30 -x 0 504B0304

c 提取的密文部分p 提取的明文部分x 压缩包内目标文件的偏移地址部分已知明文值C 加密压缩包o offset -p参数指定的明文在压缩包内目标文件的偏移量

得到密钥为9f08aab0 c1cab858 f800fdf2

通过密钥提取文件


./bkcrack -C ~/temp/flag.zip -c hznuctf.zip -k 9f08aab0 c1cab858 f800fdf2 -d ~/temp/hznuctf.zip

k 压缩包的密钥

d 提取文件的名称

提取出来的文件其中是一个加密的pptx文件，我们继续使用hashcat去爆破其密码

先要提取hznuctf.pptx的哈希值


office2john hznuctf.pptx >> office.txt

得到的office.txt中需要将其中的hznuctf.pptx:删掉

然后找到其在hashcat中哈希对应的值9600

这里wp中采用的是掩码爆破，因为在题目描述中提示了5位小写字母，但是我爆破半天没出来，后来发现其密码也是弱口令，通过rockyou字典可以找到

掩码爆破


hashcat -m 9600 -a 3 /root/temp/office.txt ?l?l?l?l?l --self-test-disable

字典爆破


hashcat -m 9600 -a 0 ~/temp/office.txt /usr/share/wordlists/rockyou.txt

得到密码为：fools

使用密码能打开pptx文件，flag有点难找，mgg给了一个trick，通过文件-信息-检查问题-检查文档可以发现pptx的注释中存在额外内容

最后在第一张ppt的注释中找到最后一部分flag：w3_n33d_bl4sting

最后完整的flag为

HZNUCTF{admin_L1nux_f0r3nsics_is_34sy_4nd_w3_n33d_bl4sting}

参考文章

https://byxs20.github.io/posts/41220.html#7-F-LINUX

https://blog.csdn.net/weixin_46081055/article/details/121897319

https://zhuanlan.zhihu.com/p/375352843

https://blog.csdn.net/weixin_39934520/article/details/108042194

https://blog.csdn.net/weixin_30538029/article/details/98886434



Linux内存取证出题记录
Wed, 05 Apr 2023 00:00:00 GMT
为了准备校赛，准备了一个内存取证的题目，既然是校赛的，肯定不能搞简单的win7了，试了下win10，如果要原汁取证好像没什么能搞的（指不上那些cs马之类的，cmd好像也读不到，搞了也麻烦，这种不如拿去投题），就简单尝试linux。就简单记录一下。
1、确定版本
先后尝试了22.04,20.04的ubuntu，他们的版本好像太高了，测了几种之后，好像是5.14版本以上的内核，vol2就分析不出来了，得用vol3才行，嫌麻烦就不用了，最后敲定了18.0.4.4版本的ubuntu，内核版本是
Linux version 4.15.0-20-generic (buildd@lgw01-amd64-039) (gcc version 7.3.0 (Ubuntu 7.3.0-16ubuntu3)) 
#21-Ubuntu SMP Tue Apr 24 06:16:15 UTC 2018 (Ubuntu 4.15.0-20.21-generic 4.15.17)
这边可以直接用下镜像，然后装vol2，make的方法搞内核，也可以用apt的方法搞，这边就不再赘述，具体祥云杯的那篇wp，贴一下vol3方法截图吧，是别的师傅那里的
2、开始出题
首先需要了解什么是内存镜像
内存为易失性储存设备，电子设备在断电后的短时间内，内存中就会丢失数据，从而失去分析价值；但是随着技术的进步，只要在设备断电后快速将内存卸下，并接入专用设备，也可以从残留的数据中提取证据。更何况大部分情况下，取证人员可以直接在现场，保持设备通电开机的情况下，直接对目标设备的内存进行取证工作，从而给完整提取目标设备的内存数据提供了机会。                                             不同于直接对硬盘、手机、储存卡等设备进行取证，内存取证由于其为设备的内存数据，其天生就为电子取证的重要一点：因为设备在运行中，凡是涉及到数据的解析，在内存中大多都是以中间态或最后的明文态而存在；而在硬盘等设备中，数据可以进行加密，进行混淆，就大大增加了分析难度。故在电子取证中，内存取证往往为最为重要的一环。                                               对于比赛中所接触到的内存取证，选手大多拿到的都是已经提取好的内存镜像文件，也就是内存数据的原始完整拷贝，这已经从开局就大大简化了内存取证的难度。而选手接下来所要面对的，就是对内存数据进行解析。对于内存数据，最为常用的工具便是 Volatility Framework ，其为 Volatility Foundation 所开发的一款对内存取证分析提供支持的框架，对多平台电子设备的内存数据均提供了支持，并且也支持加载第三方模块来增加功能
就跟普通的出题，往里面丢就好，不过会碰到一个小问题，就是碰到大文件，可能会dmp不下来，可以在里面装一个010editor，然后打开，稍微编辑保存改回来就可以，然后就可以dump下来了。因为内存取证，终归还是残留数据。
然后就用avml dump就行
./avml xxx.dmp
出题其实很简单，主要是做题比较难。


Windows7内存取证出题记录
Mon, 07 Nov 2022 00:00:00 GMT
写在开头：
最近为了准备ISCTF的套娃题，想起来可以外层套一个取证的皮，但是本来的环境因为电脑重装就无了，所以重新用虚拟机搭了一个Win7的环境，然后遇到了几个之前遇到过的问题，那个时候没有记录，导致配环境浪费了很多时间，这边就小小的记录一下吧。         win7取证的话，硬盘容量建议开大一点，给25g，他自身好像是占了13g，然后一些补丁后续要加，我尝试了20G，容量不够，25G就足够的空间了
 
Step1:环境镜像
 我使用的是VMware搭的虚拟机，去官网下的镜像，这边就直接放一篇博客了，参考博客，镜像版本选取什么应该大抵是没什么问题的，实在要参考的话，我这边选择的是这款，怎么有两款，忘了是哪款了，自己试试吧，应该是64位的那款。
 
Step2:SP1问题
 出题最主要的就是问个SP1问题了，为什么捏，因为我想安装vmtools，否则我的附件以及dump出来的内存镜像无法从虚拟机中导出来，看了网上几篇《很老》的教程，都是千篇一律的从微软官网下载补丁，然后移进去，然后安装补丁就好了，很简单，但是他们好像忽略了一个问题，没有vmtools，我根本移不进去啊（不知道是不是我虚拟机的问题）。凭借一个misc手的直觉，我最后发现了一个很好地方法，就是使用UltraISO。
我们可以把自己想要传入到虚拟机中的东西，用Ultra打包成iso镜像，然后直接丢进去。
ps:试过插U盘，但是报错U盘无法解析
Step3:具体解决方法
1、创建ISO镜像
我们将自己想要移到虚拟机中的文件移动到右上方的地方，就直接点住图标拖过去就行，然后点左上角直接保存即可
2、导入镜像
然后我们打开VMware win7的虚拟机，导入ISO镜像即可
然后就打开虚拟机就可以啦
3、打开文件
打开驱动
将里面的内容移到桌面上就好了
Step4:打补丁
这边有两个补丁要打，一个是更新程序？还有一个就是sp1
可以自己去官网下，链接自己找，用IDM下很快，或者用我的百度网盘（没会员就不怪我了奥，大小1.4G，体验30s应该也可以下一大部分），顺便把dump.exe也给啦，一个32位的，一个64位的，自己对应版本使用即可
链接：https://pan.baidu.com/s/1r5AcV9z7UxV3-SdjdFNaYA?pwd=yv4m 提取码：yv4m
然后我记得好像是先装exe那个？无所谓，自己都试一试，两个装完之后就可以快乐地安装vmtools了。
Step5:开始出题
我这边是设置了两个考点，一个是开机密码是flag123456，他是以hash存储的，是可以解出来的。还有一个就是桌面上的文件
把你想要的东西放在桌面上，进阶一点，你可以在你的命令行里打一些命令，或者在你的剪切板，ie浏览器里访问一些网站，这些就靠你自己去尝试啦。最后运行dumpit.exe就好了，直接拖到终端运行即可
然后按下y，一个题目就出好咯，可以去欺负小新生了，下班！
 
 
 
 


《套神看了都摇头》出题记录
Wed, 02 Nov 2022 00:00:00 GMT
写在开头：想把misc的一些简单的知识点串在一起，更考核选手的综合能力，但是胡乱的套会导致其中解码过程中出现很多的错误，所以需要给选手一些明确的hint，比如用什么网站进行的加密，比如一个简单的例子，千千秀字的栅栏，用bugku是解不出来的（反正我枚举解不出，就当他解不出了），这些知识点都是我学习misc刚开始一个月里面刷的题，所以就选用了过来。
flag
首先拿到了一个flag
ISCTF{W0_b8_4_t4O_sH3n_!!!_Sh31_4_t40_sheN}
千千秀字栅栏
给出了一个千千秀字的hint，先留档
IW4s!10}S0_H!__C_t3_4sTb4nS_hF8O_hte{__!34N
与佛论禅
佛曰有好几种，新佛曰跟佛曰，我这边出了一个问题就是与佛论禅也有两种，一种是佛曰，一种是佛又曰，这两个的网址是不一样的
虽然说问题不大，但是谨记
佛又曰：楞苏喝帝婆醯伽婆夜婆数遮钵娑孕度利伽咩唵钵呼度曳婆写曳尼迦卢罚数菩伽嚧阇耶俱钵阿地怛度卢咩阇萨钵俱数帝舍伽呼写阇遮墀楞室提豆哆咩数输咩谨皤俱吉怛驮伊伽埵漫漫
base64
然后就是简单的套了一个base
5L2b5Y+I5puw77ya5qWe6IuP5Zad5bid5amG6Yav5Ly95amG5aSc5amG5pWw6YGu6ZK15aiR5a2V5bqm5Yip5Ly95ZKp5ZS16ZK15ZG85bqm5puz5amG5YaZ5puz5bC86L+m5Y2i572a5pWw6I+p5Ly95Zqn6ZiH6IC25L+x6ZK16Zi/5Zyw5oCb5bqm5Y2i5ZKp6ZiH6JCo6ZK15L+x5pWw5bid6IiN5Ly95ZG85YaZ6ZiH6YGu5aKA5qWe5a6k5o+Q6LGG5ZOG5ZKp5pWw6L6T5ZKp6LCo55qk5L+x5ZCJ5oCb6amu5LyK5Ly95Z+15ryr5ryr
AES(https://www.sojson.com/encrypt_aes.html)
简单套一个AES，也是选用了最简单的无脑的没有偏移的AES，但是我不是很清楚他的key是怎么处理的，我使用相同的key去别的网站加密得到的不是一个密文（日后有空去看看，估计是没空的），所以这边也给出了hint，加密网站，按下不表*2
U2FsdGVkX19fGDp6HBRwc0ot+XQFmWrHPBhG0F2Y4JyJhRomofwFXBnUZUPnQc9V
hviHIwagGUMvhlGtnHOjWUN/69h1eku4YWeTL2bswkotj1GImP36TzV3G+z1yYqy
LGez1wUKbtuNpVfSU2/u79oAubWN8mVtMUalmNoYjtP3adjM5p/zXL6kul+kSJ95
BX50RqBV64MyFs1rNM7r3wI8W8FWNYpvDdzETKuCMEQwXtaH1HS6p/P5kuMT7OIW
3ViHDuthWBS+Z1sUZh6Hk2R4db3HrZYCLZ5QLpoNIt2ZrtVwMGPdLeI92v5w++0o
DmW2pD7FICDFEVXB+DH+WTvdTYfXGM6635R94r72bREmE1zELyMy3iMqiF7UOmd3
CfEhlz5aiv9RBGz2crCaDJ/ZMY9+qEj4JEYJJMFljKG71kXUC/xvNcGTb7oN4odk
OKV+I3Tuc8GcYq03zczLkA==

key=this_is_pass
36进制
这边是套了一个36进制，如果细心点的话，应该是可以发现里面文本的内容是从0-9，a-z，26个，然后我也是给hint了，生怕看不出来，36进制怎么转码呢，直接int 36就可以，然后再加个long_to_bytes就可以解码了
pfbshz6vy6cw9zqe9d2xuv0pevbyzmq3biqj0bbbywfowy6d2vcfamwd144au0bioijq7oyf32grvzxtodeob5quei6bufpganywzzvyuj0jv9fxn3ghgisaemw5d59ftp84lo4wseqohfhbfpily6s0d3bbs9kg5xvq481b2ykbucfwlb2290l84b9d8i7r1ofmlxtnwglzt1t3ko602oryor147dnnotdn2gmzd68yrg3lna118ppj7oygmf2yjn049fidfih3a6axagk2oxcq0diwilkahq6f0wvekvmcbzdeo44r9n6k2pdvrpubm0k1lb67f50811vaxgwbfyx2ti3w1rlvysmemq649qt8g4cjps62xss63mq30mi43mz695t1t2egqvh8q2hjr3s5mta9l5t8wid5s8q7im3sc4lsaxmc6j81macut49clhweomtrhh5d4pk0n6rfesfsesaj18w9x7otzu4v6p74vtpec8spkbhc99g04l2mz7zkk0bwghov60xgrr53f3e55bxi6ztlzwu23lwd9k985vrn4skbcb978i8knspffief1r8b7j5kdfabz8qw8sxcp70xmt9eqysxikcojpahyr9jq9opg115nz4zub2gfre0znbr0rdrw777h2h528yz1offlzfi610w6e4lwgh2o71ywdl6a6ursgb8mo2o54drm8x9cf0k89xbhb5pqwyjw0lvd4cvv8m65
morese，wav
忘记复制密文了，这边应该是吧36进制转成莫斯了吧，出题脚本给你们看看
import timeimport winsoundfreq1=1500   #短音发声频率freq2=2000   #长音发声频率interv_short = 100  #短音“.”的发声时长interv_long = 300   #长音“-”的发声时长msg = input('输入要发送的消息:')msg = msg.upper()   #转换大写，摩斯码中不区分大小写code_dict = {'0': '-----', '1': '.----', '2': '..---', '3': '...--', '4': '....-',             '5': '.....', '6': '-....', '7': '--...', '8': '---..', '9': '----.',             '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': '--..',             '.': '.-.-.-', ':': '---...',',': '--..--', ';': '-.-.-.', '?': '..--..',             '=': '-...-', "'": '.----.', '/': '-..-.', '!': '-.-.--','--': '-....-',             '-': '..--.-', '"': '.-..-.', '(': '-.--.', ')': '-.--.-'}for m in range (len(msg)):    print('m:',m)    code = code_dict.get(msg[m])    if code is None:        print('该符号不在字典中')        continue    print('code',code)    for c in code:        if c == '.':            ret = winsound.Beep(freq1,interv_short)            # print('ret = ',ret)            time.sleep(0.1) #加入0.1s延时        elif c == '-':            ret = winsound.Beep(freq2,interv_long)            # print('ret = ',ret)            time.sleep(0.1)        else:            print('错误编码')    time.sleep(1)
脚本也是网上B站上找的，不是自己写的，但是看了下也是可以理解的，主要就是winsound.Beep控制声音长短，发出声音，然后使用电脑的立体声混音录就好了（这个灵感来自春哥，之前看群里讨论mmstv看到的）
然后就得到了一个.wav文件了
这边将前面的hint都给到了Audacity的元数据标签里面（编辑元数据）
但是我没有保存，所以直接查看属性不能看到。
百度网盘
这边因为文件太大了，然后就直接转网盘变小
https://pan.baidu.com/s/1Hkp7pt-7Yg08_7v5zwFMuA?pwd=t51r
零宽
将百度网盘的链接存在一个零宽里面去，这边可能好多人都还没搞懂零宽到底怎么搞，只会复制进去，然后解码，其实很简单
一般来说怎么判断就是把字符全选，复制到kali虚拟机里面
我们可以看到，在字符串中有着许多的不可见字符就是Unicode字符，由此我们可以得到
关于这边解密的东西，不是乱选的，而是根据上面所包含的字符来选的，然后直接decode就可以得到
压缩，逆序，转01，改黑白,出二维坐标index.txt
然后将得到的文本进行压缩包，然后读取，将他逆序，转成01字符串，再将01字符串转成黑白图片。可以将他看成二维数组，给出坐标。
from Crypto.Util.number import *import mathimport PILfrom PIL import Imagewith open('flag.zip','rb') as f:    data  = f.read()[::-1]    a=bin(bytes_to_long(data))[2:].zfill(len(data)*8)print(len(a))print(math.sqrt(48432))print(221*221-48432)# print(long_to_bytes(int(a,2)))a='0'*409+aMAX = 221img = Image.new("RGB",(MAX,MAX))str1 = ai=0print(str1[53])with open('index.txt','w') as f:    for y in range (0,MAX):        for x in range (0,MAX):            # print(i)            # print(str1)            if(str1[i] == '1'):                img.putpixel([x,y],(0, 0, 0))                str2=str(x)+','+str(y)                f.write(str2)                f.write('\n')            else:                img.putpixel([x,y],(255,255,255))            i = i+1# img.show()f.close()img.save("1.png")
这边是给了一个hint的，就是梅花香自苦寒来，这算是我第一个接触python写脚本的题目吧，buu上比较靠前的一个misc题的（不知道师傅们能不能理解，如果不能理解的话给大家磕个头了）解题脚本就不给了，网上搜一搜就有了
flag.png oursecret 秘钥：lsb
一个oursecret，藏文件，经典，秘钥就藏在lsb里面了
藏坐标 index.txt
秘钥 isctfgood
然后再进行一次百度网盘缩小
百度网盘 https://pan.baidu.com/s/1QjFr09a7XRS5J7ZXAPbJsQ?pwd=tpde
slienteye 秘钥
将链接藏在一个jpg文件中
这边在出题的时候发现了一个很神奇的现象（之后再去研究研究，有懂的师傅可以告诉我呜呜）
秘钥就是jpg图片改宽高，这个考点不是很常见，所以也给了hint，但是不能改差，改出错了会导致slienteye读不出来数据了
ftp文件传输流量
简单的套一层流量，水平有限，并且考虑到比赛新生难度，也是没有出的很奇怪，直接导出数据就可以了
套个取证，desktop压缩包 压缩包密码是开机，密码
这边就是最开始了地方了，一个找取证的密码，一个filescan。
总结
个人感觉还是搜一搜，可以做的，emmmm，给大家磕一个

NotionNext BLOG

祥云杯misc/re

MISC

strange_forensics

ps:踩坑

1.创建vtypes

2.获取符号表

3.制作用户配置文件

4.开始做题

总结

REVERSE

rocket

engtom

ps：踩坑

第四届杭州师范大学校赛出题人miscwp

致我那逝去的青春

snake

babyLSB

蹦蹦炸弹

part1

part2

part3（明文攻击可能是以后常考的一个考点了，freebuf那篇文章yyds）

Linux内存取证出题记录

1、确定版本

2、开始出题

Windows7内存取证出题记录

Step1:环境镜像

Step2:SP1问题

Step3:具体解决方法

1、创建ISO镜像

2、导入镜像

3、打开文件

Step4:打补丁

Step5:开始出题

《套神看了都摇头》出题记录

flag

千千秀字栅栏

与佛论禅

base64

AES(https://www.sojson.com/encrypt_aes.html)

36进制

morese，wav

百度网盘

零宽

压缩，逆序，转01，改黑白,出二维坐标index.txt

flag.png oursecret 秘钥：lsb

slienteye 秘钥

ftp文件传输流量

套个取证，desktop压缩包 压缩包密码是开机，密码

总结

`part3（明文攻击可能是以后常考的一个考点了，freebuf那篇文章yyds）`

套个取证，desktop压缩包压缩包密码是开机，密码