-
-
Notifications
You must be signed in to change notification settings - Fork 46
/
loadconfig.go
1521 lines (1254 loc) · 55.5 KB
/
loadconfig.go
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
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
// Copyright 2018 Saferwall. All rights reserved.
// Use of this source code is governed by Apache v2 license
// license that can be found in the LICENSE file.
// References:
// https://www.virtualbox.org/svn/vbox/trunk/include/iprt/formats/pecoff.h
// https://github.com/hdoc/llvm-project/blob/release/15.x/llvm/include/llvm/Object/COFF.h
// https://ffri.github.io/ProjectChameleon/new_reloc_chpev2/
// https://blogs.blackberry.com/en/2019/09/teardown-windows-10-on-arm-x86-emulation
// DVRT: https://www.alex-ionescu.com/?p=323
// https://xlab.tencent.com/en/2016/11/02/return-flow-guard/
// https://denuvosoftwaresolutions.github.io/DVRT/dvrt.html
// BlueHat v18 || Retpoline: The Anti sectre type 2 mitigation in windows: https://www.youtube.com/watch?v=ZfxXjDQRpsU
package pe
import (
"bytes"
"encoding/binary"
"fmt"
"reflect"
)
// ImageGuardFlagType represents the type for load configuration image guard flags.
type ImageGuardFlagType uint8
// GFIDS table entry flags.
const (
// ImageGuardFlagFIDSuppressed indicates that the call target is explicitly
// suppressed (do not treat it as valid for purposes of CFG).
ImageGuardFlagFIDSuppressed = 0x1
// ImageGuardFlagExportSuppressed indicates that the call target is export
// suppressed. See Export suppression for more details.
ImageGuardFlagExportSuppressed = 0x2
)
// The GuardFlags field contains a combination of one or more of the
// following flags and subfields:
const (
// ImageGuardCfInstrumented indicates that the module performs control flow
// integrity checks using system-supplied support.
ImageGuardCfInstrumented = 0x00000100
// ImageGuardCfWInstrumented indicates that the module performs control
// flow and write integrity checks.
ImageGuardCfWInstrumented = 0x00000200
// ImageGuardCfFunctionTablePresent indicates that the module contains
// valid control flow target metadata.
ImageGuardCfFunctionTablePresent = 0x00000400
// ImageGuardSecurityCookieUnused indicates that the module does not make
// use of the /GS security cookie.
ImageGuardSecurityCookieUnused = 0x00000800
// ImageGuardProtectDelayLoadIAT indicates that the module supports read
// only delay load IAT.
ImageGuardProtectDelayLoadIAT = 0x00001000
// ImageGuardDelayLoadIATInItsOwnSection indicates that the Delayload
// import table in its own .didat section (with nothing else in it) that
// can be freely reprotected.
ImageGuardDelayLoadIATInItsOwnSection = 0x00002000
// ImageGuardCfExportSuppressionInfoPresent indicates that the module
// contains suppressed export information. This also infers that the
// address taken IAT table is also present in the load config.
ImageGuardCfExportSuppressionInfoPresent = 0x00004000
// ImageGuardCfEnableExportSuppression indicates that the module enables
// suppression of exports.
ImageGuardCfEnableExportSuppression = 0x00008000
// ImageGuardCfLongJumpTablePresent indicates that the module contains
// long jmp target information.
ImageGuardCfLongJumpTablePresent = 0x00010000
)
const (
// ImageGuardCfFunctionTableSizeMask indicates that the mask for the
// subfield that contains the stride of Control Flow Guard function table
// entries (that is, the additional count of bytes per table entry).
ImageGuardCfFunctionTableSizeMask = 0xF0000000
// ImageGuardCfFunctionTableSizeShift indicates the shift to right-justify
// Guard CF function table stride.
ImageGuardCfFunctionTableSizeShift = 28
)
const (
ImageDynamicRelocationGuardRfPrologue = 0x00000001
ImageDynamicRelocationGuardREpilogue = 0x00000002
)
// Software enclave information.
const (
ImageEnclaveLongIDLength = 32
ImageEnclaveShortIDLength = 16
)
const (
// ImageEnclaveImportMatchNone indicates that none of the identifiers of the
// image need to match the value in the import record.
ImageEnclaveImportMatchNone = 0x00000000
// ImageEnclaveImportMatchUniqueId indicates that the value of the enclave
// unique identifier of the image must match the value in the import record.
// Otherwise, loading of the image fails.
ImageEnclaveImportMatchUniqueID = 0x00000001
// ImageEnclaveImportMatchAuthorId indicates that the value of the enclave
// author identifier of the image must match the value in the import record.
// Otherwise, loading of the image fails. If this flag is set and the import
// record indicates an author identifier of all zeros, the imported image
// must be part of the Windows installation.
ImageEnclaveImportMatchAuthorID = 0x00000002
// ImageEnclaveImportMatchFamilyId indicates that the value of the enclave
// family identifier of the image must match the value in the import record.
// Otherwise, loading of the image fails.
ImageEnclaveImportMatchFamilyID = 0x00000003
// ImageEnclaveImportMatchImageId indicates that the value of the enclave
// image identifier must match the value in the import record. Otherwise,
// loading of the image fails.
ImageEnclaveImportMatchImageID = 0x00000004
)
// ImageLoadConfigDirectory32 Contains the load configuration data of an image for x86 binaries.
type ImageLoadConfigDirectory32 struct {
// The actual size of the structure inclusive. May differ from the size
// given in the data directory for Windows XP and earlier compatibility.
Size uint32 `json:"size"`
// Date and time stamp value.
TimeDateStamp uint32 `json:"time_date_stamp"`
// Major version number.
MajorVersion uint16 `json:"major_version"`
// Minor version number.
MinorVersion uint16 `json:"minor_version"`
// The global loader flags to clear for this process as the loader starts
// the process.
GlobalFlagsClear uint32 `json:"global_flags_clear"`
// The global loader flags to set for this process as the loader starts the
// process.
GlobalFlagsSet uint32 `json:"global_flags_set"`
// The default timeout value to use for this process's critical sections
// that are abandoned.
CriticalSectionDefaultTimeout uint32 `json:"critical_section_default_timeout"`
// Memory that must be freed before it is returned to the system, in bytes.
DeCommitFreeBlockThreshold uint32 `json:"de_commit_free_block_threshold"`
// Total amount of free memory, in bytes.
DeCommitTotalFreeThreshold uint32 `json:"de_commit_total_free_threshold"`
// [x86 only] The VA of a list of addresses where the LOCK prefix is used so
// that they can be replaced with NOP on single processor machines.
LockPrefixTable uint32 `json:"lock_prefix_table"`
// Maximum allocation size, in bytes.
MaximumAllocationSize uint32 `json:"maximum_allocation_size"`
// Maximum virtual memory size, in bytes.
VirtualMemoryThreshold uint32 `json:"virtual_memory_threshold"`
// Process heap flags that correspond to the first argument of the HeapCreate
// function. These flags apply to the process heap that is created during
// process startup.
ProcessHeapFlags uint32 `json:"process_heap_flags"`
// Setting this field to a non-zero value is equivalent to calling
// SetProcessAffinityMask with this value during process startup (.exe only)
ProcessAffinityMask uint32 `json:"process_affinity_mask"`
// The service pack version identifier.
CSDVersion uint16 `json:"csd_version"`
// Must be zero.
DependentLoadFlags uint16 `json:"dependent_load_flags"`
// Reserved for use by the system.
EditList uint32 `json:"edit_list"`
// A pointer to a cookie that is used by Visual C++ or GS implementation.
SecurityCookie uint32 `json:"security_cookie"`
// [x86 only] The VA of the sorted table of RVAs of each valid, unique SE
// handler in the image.
SEHandlerTable uint32 `json:"se_handler_table"`
// [x86 only] The count of unique handlers in the table.
SEHandlerCount uint32 `json:"se_handler_count"`
// The VA where Control Flow Guard check-function pointer is stored.
GuardCFCheckFunctionPointer uint32 `json:"guard_cf_check_function_pointer"`
// The VA where Control Flow Guard dispatch-function pointer is stored.
GuardCFDispatchFunctionPointer uint32 `json:"guard_cf_dispatch_function_pointer"`
// The VA of the sorted table of RVAs of each Control Flow Guard function in
// the image.
GuardCFFunctionTable uint32 `json:"guard_cf_function_table"`
// The count of unique RVAs in the above table.
GuardCFFunctionCount uint32 `json:"guard_cf_function_count"`
// Control Flow Guard related flags.
GuardFlags uint32 `json:"guard_flags"`
// Code integrity information.
CodeIntegrity ImageLoadConfigCodeIntegrity `json:"code_integrity"`
// The VA where Control Flow Guard address taken IAT table is stored.
GuardAddressTakenIATEntryTable uint32 `json:"guard_address_taken_iat_entry_table"`
// The count of unique RVAs in the above table.
GuardAddressTakenIATEntryCount uint32 `json:"guard_address_taken_iat_entry_count"`
// The VA where Control Flow Guard long jump target table is stored.
GuardLongJumpTargetTable uint32 `json:"guard_long_jump_target_table"`
// The count of unique RVAs in the above table.
GuardLongJumpTargetCount uint32 `json:"guard_long_jump_target_count"`
DynamicValueRelocTable uint32 `json:"dynamic_value_reloc_table"`
// Not sure when this was renamed from HybridMetadataPointer.
CHPEMetadataPointer uint32 `json:"chpe_metadata_pointer"`
GuardRFFailureRoutine uint32 `json:"guard_rf_failure_routine"`
GuardRFFailureRoutineFunctionPointer uint32 `json:"guard_rf_failure_routine_function_pointer"`
DynamicValueRelocTableOffset uint32 `json:"dynamic_value_reloc_table_offset"`
DynamicValueRelocTableSection uint16 `json:"dynamic_value_reloc_table_section"`
Reserved2 uint16 `json:"reserved_2"`
GuardRFVerifyStackPointerFunctionPointer uint32 `json:"guard_rf_verify_stack_pointer_function_pointer"`
HotPatchTableOffset uint32 `json:"hot_patch_table_offset"`
Reserved3 uint32 `json:"reserved_3"`
EnclaveConfigurationPointer uint32 `json:"enclave_configuration_pointer"`
VolatileMetadataPointer uint32 `json:"volatile_metadata_pointer"`
GuardEHContinuationTable uint32 `json:"guard_eh_continuation_table"`
GuardEHContinuationCount uint32 `json:"guard_eh_continuation_count"`
GuardXFGCheckFunctionPointer uint32 `json:"guard_xfg_check_function_pointer"`
GuardXFGDispatchFunctionPointer uint32 `json:"guard_xfg_dispatch_function_pointer"`
GuardXFGTableDispatchFunctionPointer uint32 `json:"guard_xfg_table_dispatch_function_pointer"`
CastGuardOSDeterminedFailureMode uint32 `json:"cast_guard_os_determined_failure_mode"`
GuardMemcpyFunctionPointer uint32 `json:"guard_memcpy_function_pointer"`
}
// ImageLoadConfigDirectory64 Contains the load configuration data of an image for x64 binaries.
type ImageLoadConfigDirectory64 struct {
// The actual size of the structure inclusive. May differ from the size
// given in the data directory for Windows XP and earlier compatibility.
Size uint32 `json:"size"`
// Date and time stamp value.
TimeDateStamp uint32 `json:"time_date_stamp"`
// Major version number.
MajorVersion uint16 `json:"major_version"`
// Minor version number.
MinorVersion uint16 `json:"minor_version"`
// The global loader flags to clear for this process as the loader starts
// the process.
GlobalFlagsClear uint32 `json:"global_flags_clear"`
// The global loader flags to set for this process as the loader starts the
// process.
GlobalFlagsSet uint32 `json:"global_flags_set"`
// The default timeout value to use for this process's critical sections
// that are abandoned.
CriticalSectionDefaultTimeout uint32 `json:"critical_section_default_timeout"`
// Memory that must be freed before it is returned to the system, in bytes.
DeCommitFreeBlockThreshold uint64 `json:"de_commit_free_block_threshold"`
// Total amount of free memory, in bytes.
DeCommitTotalFreeThreshold uint64 `json:"de_commit_total_free_threshold"`
// [x86 only] The VA of a list of addresses where the LOCK prefix is used so
// that they can be replaced with NOP on single processor machines.
LockPrefixTable uint64 `json:"lock_prefix_table"`
// Maximum allocation size, in bytes.
MaximumAllocationSize uint64 `json:"maximum_allocation_size"`
// Maximum virtual memory size, in bytes.
VirtualMemoryThreshold uint64 `json:"virtual_memory_threshold"`
// Setting this field to a non-zero value is equivalent to calling
// SetProcessAffinityMask with this value during process startup (.exe only)
ProcessAffinityMask uint64 `json:"process_affinity_mask"`
// Process heap flags that correspond to the first argument of the HeapCreate
// function. These flags apply to the process heap that is created during
// process startup.
ProcessHeapFlags uint32 `json:"process_heap_flags"`
// The service pack version identifier.
CSDVersion uint16 `json:"csd_version"`
// Must be zero.
DependentLoadFlags uint16 `json:"dependent_load_flags"`
// Reserved for use by the system.
EditList uint64 `json:"edit_list"`
// A pointer to a cookie that is used by Visual C++ or GS implementation.
SecurityCookie uint64 `json:"security_cookie"`
// [x86 only] The VA of the sorted table of RVAs of each valid, unique SE
// handler in the image.
SEHandlerTable uint64 `json:"se_handler_table"`
// [x86 only] The count of unique handlers in the table.
SEHandlerCount uint64 `json:"se_handler_count"`
// The VA where Control Flow Guard check-function pointer is stored.
GuardCFCheckFunctionPointer uint64 `json:"guard_cf_check_function_pointer"`
// The VA where Control Flow Guard dispatch-function pointer is stored.
GuardCFDispatchFunctionPointer uint64 `json:"guard_cf_dispatch_function_pointer"`
// The VA of the sorted table of RVAs of each Control Flow Guard function in
// the image.
GuardCFFunctionTable uint64 `json:"guard_cf_function_table"`
// The count of unique RVAs in the above table.
GuardCFFunctionCount uint64 `json:"guard_cf_function_count"`
// Control Flow Guard related flags.
GuardFlags uint32 `json:"guard_flags"`
// Code integrity information.
CodeIntegrity ImageLoadConfigCodeIntegrity `json:"code_integrity"`
// The VA where Control Flow Guard address taken IAT table is stored.
GuardAddressTakenIATEntryTable uint64 `json:"guard_address_taken_iat_entry_table"`
// The count of unique RVAs in the above table.
GuardAddressTakenIATEntryCount uint64 `json:"guard_address_taken_iat_entry_count"`
// The VA where Control Flow Guard long jump target table is stored.
GuardLongJumpTargetTable uint64 `json:"guard_long_jump_target_table"`
// The count of unique RVAs in the above table.
GuardLongJumpTargetCount uint64 `json:"guard_long_jump_target_count"`
DynamicValueRelocTable uint64 `json:"dynamic_value_reloc_table"`
// Not sure when this was renamed from HybridMetadataPointer.
CHPEMetadataPointer uint64 `json:"chpe_metadata_pointer"`
GuardRFFailureRoutine uint64 `json:"guard_rf_failure_routine"`
GuardRFFailureRoutineFunctionPointer uint64 `json:"guard_rf_failure_routine_function_pointer"`
DynamicValueRelocTableOffset uint32 `json:"dynamic_value_reloc_table_offset"`
DynamicValueRelocTableSection uint16 `json:"dynamic_value_reloc_table_section"`
Reserved2 uint16 `json:"reserved_2"`
GuardRFVerifyStackPointerFunctionPointer uint64 `json:"guard_rf_verify_stack_pointer_function_pointer"`
HotPatchTableOffset uint32 `json:"hot_patch_table_offset"`
Reserved3 uint32 `json:"reserved_3"`
EnclaveConfigurationPointer uint64 `json:"enclave_configuration_pointer"`
VolatileMetadataPointer uint64 `json:"volatile_metadata_pointer"`
GuardEHContinuationTable uint64 `json:"guard_eh_continuation_table"`
GuardEHContinuationCount uint64 `json:"guard_eh_continuation_count"`
GuardXFGCheckFunctionPointer uint64 `json:"guard_xfg_check_function_pointer"`
GuardXFGDispatchFunctionPointer uint64 `json:"guard_xfg_dispatch_function_pointer"`
GuardXFGTableDispatchFunctionPointer uint64 `json:"guard_xfg_table_dispatch_function_pointer"`
CastGuardOSDeterminedFailureMode uint64 `json:"cast_guard_os_determined_failure_mode"`
GuardMemcpyFunctionPointer uint64 `json:"guard_memcpy_function_pointer"`
}
// ImageCHPEMetadataX86 represents the X86_IMAGE_CHPE_METADATA_X86.
type ImageCHPEMetadataX86 struct {
Version uint32 `json:"version"`
CHPECodeAddressRangeOffset uint32 `json:"chpe_code_address_range_offset"`
CHPECodeAddressRangeCount uint32 `json:"chpe_code_address_range_count"`
WoWA64ExceptionHandlerFunctionPtr uint32 `json:"wow_a64_exception_handler_function_ptr"`
WoWA64DispatchCallFunctionPtr uint32 `json:"wow_a64_dispatch_call_function_ptr"`
WoWA64DispatchIndirectCallFunctionPtr uint32 `json:"wow_a64_dispatch_indirect_call_function_ptr"`
WoWA64DispatchIndirectCallCfgFunctionPtr uint32 `json:"wow_a64_dispatch_indirect_call_cfg_function_ptr"`
WoWA64DispatchRetFunctionPtr uint32 `json:"wow_a64_dispatch_ret_function_ptr"`
WoWA64DispatchRetLeafFunctionPtr uint32 `json:"wow_a64_dispatch_ret_leaf_function_ptr"`
WoWA64DispatchJumpFunctionPtr uint32 `json:"wow_a64_dispatch_jump_function_ptr"`
CompilerIATPointer uint32 `json:"compiler_iat_pointer"` // Present if Version >= 2
WoWA64RDTSCFunctionPtr uint32 `json:"wow_a64_rdtsc_function_ptr"` // Present if Version >= 3
}
type CodeRange struct {
Begin uint32 `json:"begin"`
Length uint32 `json:"length"`
Machine uint8 `json:"machine"`
}
type CompilerIAT struct {
RVA uint32 `json:"rva"`
Value uint32 `json:"value"`
Description string `json:"description"`
}
type HybridPE struct {
CHPEMetadata interface{} `json:"chpe_metadata"`
CodeRanges []CodeRange `json:"code_ranges"`
CompilerIAT []CompilerIAT `json:"compiler_iat"`
}
// ImageDynamicRelocationTable represents the DVRT header.
type ImageDynamicRelocationTable struct {
// Until now, there is only one version of the DVRT header (1)..
Version uint32 `json:"version"`
// Size represents the number of bytes after the header that contains
// retpoline information.
Size uint32 `json:"size"`
// IMAGE_DYNAMIC_RELOCATION DynamicRelocations[0];
}
// Dynamic value relocation entries following IMAGE_DYNAMIC_RELOCATION_TABLE.
// Each block starts with the header.
// ImageDynamicRelocation32 represents the 32-bit version of a reloc entry.
type ImageDynamicRelocation32 struct {
// Symbol field identifies one of the existing types of dynamic relocations
// so far (values 3, 4 and 5).
Symbol uint32 `json:"symbol"`
// Then, for each page, there is a block that starts with a relocation entry.
// BaseRelocSize represents the size of the block.
BaseRelocSize uint32 `json:"base_reloc_size"`
// IMAGE_BASE_RELOCATION BaseRelocations[0];
}
// ImageDynamicRelocation64 represents the 64-bit version of a reloc entry.
type ImageDynamicRelocation64 struct {
// Symbol field identifies one of the existing types of dynamic relocations
// so far (values 3, 4 and 5).
Symbol uint64 `json:"symbol"`
// Then, for each page, there is a block that starts with a relocation entry.
// BaseRelocSize represents the size of the block.
BaseRelocSize uint32 `json:"base_reloc_size"`
// IMAGE_BASE_RELOCATION BaseRelocations[0];
}
type ImageDynamicRelocation32v2 struct {
HeaderSize uint32 `json:"header_size"`
FixupInfoSize uint32 `json:"fixup_info_size"`
Symbol uint32 `json:"symbol"`
SymbolGroup uint32 `json:"symbol_group"`
Flags uint32 `json:"flags"`
// ... variable length header fields
// UCHAR FixupInfo[FixupInfoSize]
}
type ImageDynamicRelocation64v2 struct {
HeaderSize uint32 `json:"header_size"`
FixupInfoSize uint32 `json:"fixup_info_size"`
Symbol uint64 `json:"symbol"`
SymbolGroup uint32 `json:"symbol_group"`
Flags uint32 `json:"flags"`
// ... variable length header fields
// UCHAR FixupInfo[FixupInfoSize]
}
type ImagePrologueDynamicRelocationHeader struct {
PrologueByteCount uint8 `json:"prologue_byte_count"`
// UCHAR PrologueBytes[PrologueByteCount];
}
type ImageEpilogueDynamicRelocationHeader struct {
EpilogueCount uint32 `json:"epilogue_count"`
EpilogueByteCount uint8 `json:"epilogue_byte_count"`
BranchDescriptorElementSize uint8 `json:"branch_descriptor_element_size"`
BranchDescriptorCount uint8 `json:"branch_descriptor_count"`
// UCHAR BranchDescriptors[...];
// UCHAR BranchDescriptorBitMap[...];
}
type CFGFunction struct {
// RVA of the target CFG call.
RVA uint32 `json:"rva"`
// Flags attached to each GFIDS entry if any call targets have metadata.
Flags ImageGuardFlagType `json:"flags"`
Description string `json:"description"`
}
type CFGIATEntry struct {
RVA uint32 `json:"rva"`
IATValue uint32 `json:"iat_value"`
INTValue uint32 `json:"int_value"`
Description string `json:"description"`
}
type RelocBlock struct {
ImgBaseReloc ImageBaseRelocation `json:"img_base_reloc"`
TypeOffsets []interface{} `json:"type_offsets"`
}
type RelocEntry struct {
// Could be ImageDynamicRelocation32{} or ImageDynamicRelocation64{}
ImageDynamicRelocation interface{} `json:"image_dynamic_relocation"`
RelocBlocks []RelocBlock `json:"reloc_blocks"`
}
// ImageImportControlTransferDynamicRelocation represents the Imported Address
// Retpoline (type 3), size = 4 bytes.
type ImageImportControlTransferDynamicRelocation struct {
PageRelativeOffset uint16 `json:"page_relative_offset"` // (12 bits)
// 1 - the opcode is a CALL
// 0 - the opcode is a JMP.
IndirectCall uint16 `json:"indirect_call"` // (1 bit)
IATIndex uint32 `json:"iat_index"` // (19 bits)
}
// ImageIndirectControlTransferDynamicRelocation represents the Indirect Branch
// Retpoline (type 4), size = 2 bytes.
type ImageIndirectControlTransferDynamicRelocation struct {
PageRelativeOffset uint16 `json:"page_relative_offset"` // (12 bits)
IndirectCall uint8 `json:"indirect_call"` // (1 bit)
RexWPrefix uint8 `json:"rex_w_prefix"` // (1 bit)
CfgCheck uint8 `json:"cfg_check"` // (1 bit)
Reserved uint8 `json:"reserved"` // (1 bit)
}
// ImageSwitchableBranchDynamicRelocation represents the Switchable Retpoline
// (type 5), size = 2 bytes.
type ImageSwitchableBranchDynamicRelocation struct {
PageRelativeOffset uint16 `json:"page_relative_offset"` // (12 bits)
RegisterNumber uint16 `json:"register_number"` // (4 bits)
}
// DVRT represents the Dynamic Value Relocation Table.
// The DVRT was originally introduced back in the Windows 10 Creators Update to
// improve kernel address space layout randomization (KASLR). It allowed the
// memory manager’s page frame number (PFN) database and page table self-map to
// be assigned dynamic addresses at runtime. The DVRT is stored directly in the
// binary and contains a series of relocation entries for each symbol (i.e.
// address) that is to be relocated. The relocation entries are themselves
// arranged in a hierarchical fashion grouped first by symbol and then by
// containing page to allow for a compact description of all locations in the
// binary that reference a relocatable symbol.
// Reference: https://techcommunity.microsoft.com/t5/windows-os-platform-blog/mitigating-spectre-variant-2-with-retpoline-on-windows/ba-p/295618
type DVRT struct {
ImageDynamicRelocationTable `json:"image_dynamic_relocation_table"`
Entries []RelocEntry `json:"entries"`
}
type Enclave struct {
// Points to either ImageEnclaveConfig32{} or ImageEnclaveConfig64{}.
Config interface{} `json:"config"`
Imports []ImageEnclaveImport `json:"imports"`
}
type RangeTableEntry struct {
RVA uint32 `json:"rva"`
Size uint32 `json:"size"`
}
type VolatileMetadata struct {
Struct ImageVolatileMetadata `json:"struct"`
AccessRVATable []uint32 `json:"access_rva_table"`
InfoRangeTable []RangeTableEntry `json:"info_range_table"`
}
type LoadConfig struct {
Struct interface{} `json:"struct"`
SEH []uint32 `json:"seh"`
GFIDS []CFGFunction `json:"gfids"`
CFGIAT []CFGIATEntry `json:"cfgiat"`
CFGLongJump []uint32 `json:"cfg_long_jump"`
CHPE *HybridPE `json:"chpe"`
DVRT *DVRT `json:"dvrt"`
Enclave *Enclave `json:"enclave"`
VolatileMetadata *VolatileMetadata `json:"volatile_metadata"`
}
// ImageLoadConfigCodeIntegrity Code Integrity in load config (CI).
type ImageLoadConfigCodeIntegrity struct {
// Flags to indicate if CI information is available, etc.
Flags uint16 `json:"flags"`
// 0xFFFF means not available
Catalog uint16 `json:"catalog"`
CatalogOffset uint32 `json:"catalog_offset"`
// Additional bitmask to be defined later
Reserved uint32 `json:"reserved"`
}
type ImageEnclaveConfig32 struct {
// The size of the IMAGE_ENCLAVE_CONFIG32 structure, in bytes.
Size uint32 `json:"size"`
// The minimum size of the IMAGE_ENCLAVE_CONFIG32 structure that the image
// loader must be able to process in order for the enclave to be usable.
// This member allows an enclave to inform an earlier version of the image
// loader that the image loader can safely load the enclave and ignore optional
// members added to IMAGE_ENCLAVE_CONFIG32 for later versions of the enclave.
// If the size of IMAGE_ENCLAVE_CONFIG32 that the image loader can process is
// less than MinimumRequiredConfigSize, the enclave cannot be run securely.
// If MinimumRequiredConfigSize is zero, the minimum size of the
// IMAGE_ENCLAVE_CONFIG32 structure that the image loader must be able to
// process in order for the enclave to be usable is assumed to be the size
// of the structure through and including the MinimumRequiredConfigSize member.
MinimumRequiredConfigSize uint32 `json:"minimum_required_config_size"`
// A flag that indicates whether the enclave permits debugging.
PolicyFlags uint32 `json:"policy_flags"`
// The number of images in the array of images that the ImportList member
// points to.
NumberOfImports uint32 `json:"number_of_imports"`
// The relative virtual address of the array of images that the enclave
// image may import, with identity information for each image.
ImportList uint32 `json:"import_list"`
// The size of each image in the array of images that the ImportList member
// points to.
ImportEntrySize uint32 `json:"import_entry_size"`
// The family identifier that the author of the enclave assigned to the enclave.
FamilyID [ImageEnclaveShortIDLength]uint8 `json:"family_id"`
// The image identifier that the author of the enclave assigned to the enclave.
ImageID [ImageEnclaveShortIDLength]uint8 `json:"image_id"`
// The version number that the author of the enclave assigned to the enclave.
ImageVersion uint32 `json:"image_version"`
// The security version number that the author of the enclave assigned to
// the enclave.
SecurityVersion uint32 `json:"security_version"`
// The expected virtual size of the private address range for the enclave,
// in bytes.
EnclaveSize uint32 `json:"enclave_size"`
// The maximum number of threads that can be created within the enclave.
NumberOfThreads uint32 `json:"number_of_threads"`
// A flag that indicates whether the image is suitable for use as the
// primary image in the enclave.
EnclaveFlags uint32 `json:"enclave_flags"`
}
type ImageEnclaveConfig64 struct {
// The size of the IMAGE_ENCLAVE_CONFIG32 structure, in bytes.
Size uint32 `json:"size"`
// The minimum size of the IMAGE_ENCLAVE_CONFIG32 structure that the image
// loader must be able to process in order for the enclave to be usable.
// This member allows an enclave to inform an earlier version of the image
// loader that the image loader can safely load the enclave and ignore
// optional members added to IMAGE_ENCLAVE_CONFIG32 for later versions of
// the enclave.
// If the size of IMAGE_ENCLAVE_CONFIG32 that the image loader can process
// is less than MinimumRequiredConfigSize, the enclave cannot be run securely.
// If MinimumRequiredConfigSize is zero, the minimum size of the
// IMAGE_ENCLAVE_CONFIG32 structure that the image loader must be able to
// process in order for the enclave to be usable is assumed to be the size
// of the structure through and including the MinimumRequiredConfigSize member.
MinimumRequiredConfigSize uint32 `json:"minimum_required_config_size"`
// A flag that indicates whether the enclave permits debugging.
PolicyFlags uint32 `json:"policy_flags"`
// The number of images in the array of images that the ImportList member
// points to.
NumberOfImports uint32 `json:"number_of_imports"`
// The relative virtual address of the array of images that the enclave
// image may import, with identity information for each image.
ImportList uint32 `json:"import_list"`
// The size of each image in the array of images that the ImportList member
// points to.
ImportEntrySize uint32 `json:"import_entry_size"`
// The family identifier that the author of the enclave assigned to the enclave.
FamilyID [ImageEnclaveShortIDLength]uint8 `json:"family_id"`
// The image identifier that the author of the enclave assigned to the enclave.
ImageID [ImageEnclaveShortIDLength]uint8 `json:"image_id"`
// The version number that the author of the enclave assigned to the enclave.
ImageVersion uint32 `json:"image_version"`
// The security version number that the author of the enclave assigned to the enclave.
SecurityVersion uint32 `json:"security_version"`
// The expected virtual size of the private address range for the enclave,in bytes.
EnclaveSize uint64 `json:"enclave_size"`
// The maximum number of threads that can be created within the enclave.
NumberOfThreads uint32 `json:"number_of_threads"`
// A flag that indicates whether the image is suitable for use as the primary
// image in the enclave.
EnclaveFlags uint32 `json:"enclave_flags"`
}
// ImageEnclaveImport defines a entry in the array of images that an enclave can import.
type ImageEnclaveImport struct {
// The type of identifier of the image that must match the value in the import record.
MatchType uint32 `json:"match_type"`
// The minimum enclave security version that each image must have for the
// image to be imported successfully. The image is rejected unless its
// enclave security version is equal to or greater than the minimum value in
// the import record. Set the value in the import record to zero to turn off
// the security version check.
MinimumSecurityVersion uint32 `json:"minimum_security_version"`
// The unique identifier of the primary module for the enclave, if the
// MatchType member is IMAGE_ENCLAVE_IMPORT_MATCH_UNIQUE_ID. Otherwise,
// the author identifier of the primary module for the enclave..
UniqueOrAuthorID [ImageEnclaveLongIDLength]uint8 `json:"unique_or_author_id"`
// The family identifier of the primary module for the enclave.
FamilyID [ImageEnclaveShortIDLength]uint8 `json:"family_id"`
// The image identifier of the primary module for the enclave.
ImageID [ImageEnclaveShortIDLength]uint8 `json:"image_id"`
// The relative virtual address of a NULL-terminated string that contains
// the same value found in the import directory for the image.
ImportName uint32 `json:"import_name"`
// Reserved.
Reserved uint32 `json:"reserved"`
}
type ImageVolatileMetadata struct {
Size uint32 `json:"size"`
Version uint32 `json:"version"`
VolatileAccessTable uint32 `json:"volatile_access_table"`
VolatileAccessTableSize uint32 `json:"volatile_access_table_size"`
VolatileInfoRangeTable uint32 `json:"volatile_info_range_table"`
VolatileInfoRangeTableSize uint32 `json:"volatile_info_range_table_size"`
}
// The load configuration structure (IMAGE_LOAD_CONFIG_DIRECTORY) was formerly
// used in very limited cases in the Windows NT operating system itself to
// describe various features too difficult or too large to describe in the file
// header or optional header of the image. Current versions of the Microsoft
// linker and Windows XP and later versions of Windows use a new version of this
// structure for 32-bit x86-based systems that include reserved SEH technology.
// The data directory entry for a pre-reserved SEH load configuration structure
// must specify a particular size of the load configuration structure because
// the operating system loader always expects it to be a certain value. In that
// regard, the size is really only a version check. For compatibility with
// Windows XP and earlier versions of Windows, the size must be 64 for x86 images.
func (pe *File) parseLoadConfigDirectory(rva, size uint32) error {
// As the load config structure changes over time,
// we first read it size to figure out which one we have to cast against.
fileOffset := pe.GetOffsetFromRva(rva)
structSize, err := pe.ReadUint32(fileOffset)
if err != nil {
return err
}
// Use this helper function to print struct size.
// PrintLoadConfigStruct()
var loadCfg interface{}
// Boundary check
totalSize := fileOffset + size
// Integer overflow
if (totalSize > fileOffset) != (size > 0) {
return ErrOutsideBoundary
}
if fileOffset >= pe.size || totalSize > pe.size {
return ErrOutsideBoundary
}
if pe.Is32 {
loadCfg32 := ImageLoadConfigDirectory32{}
imgLoadConfigDirectory := make([]byte, binary.Size(loadCfg32))
copy(imgLoadConfigDirectory, pe.data[fileOffset:fileOffset+structSize])
buf := bytes.NewReader(imgLoadConfigDirectory)
err = binary.Read(buf, binary.LittleEndian, &loadCfg32)
loadCfg = loadCfg32
} else {
loadCfg64 := ImageLoadConfigDirectory64{}
imgLoadConfigDirectory := make([]byte, binary.Size(loadCfg64))
copy(imgLoadConfigDirectory, pe.data[fileOffset:fileOffset+structSize])
buf := bytes.NewReader(imgLoadConfigDirectory)
err = binary.Read(buf, binary.LittleEndian, &loadCfg64)
loadCfg = loadCfg64
}
if err != nil {
return err
}
// Save the load config struct.
pe.HasLoadCFG = true
pe.LoadConfig.Struct = loadCfg
// Retrieve SEH handlers if there are any..
if pe.Is32 {
handlers := pe.getSEHHandlers()
pe.LoadConfig.SEH = handlers
}
// Retrieve Control Flow Guard Function Targets if there are any.
pe.LoadConfig.GFIDS = pe.getControlFlowGuardFunctions()
// Retrieve Control Flow Guard IAT entries if there are any.
pe.LoadConfig.CFGIAT = pe.getControlFlowGuardIAT()
// Retrieve Long jump target functions if there are any.
pe.LoadConfig.CFGLongJump = pe.getLongJumpTargetTable()
// Retrieve compiled hybrid PE metadata if there are any.
pe.LoadConfig.CHPE = pe.getHybridPE()
// Retrieve dynamic value relocation table if there are any.
pe.LoadConfig.DVRT = pe.getDynamicValueRelocTable()
// Retrieve enclave configuration if there are any.
pe.LoadConfig.Enclave = pe.getEnclaveConfiguration()
// Retrieve volatile metadata table if there are any.
pe.LoadConfig.VolatileMetadata = pe.getVolatileMetadata()
return nil
}
// StringifyGuardFlags returns list of strings which describes the GuardFlags.
func StringifyGuardFlags(flags uint32) []string {
var values []string
guardFlagMap := map[uint32]string{
ImageGuardCfInstrumented: "Instrumented",
ImageGuardCfWInstrumented: "WriteInstrumented",
ImageGuardCfFunctionTablePresent: "TargetMetadata",
ImageGuardSecurityCookieUnused: "SecurityCookieUnused",
ImageGuardProtectDelayLoadIAT: "DelayLoadIAT",
ImageGuardDelayLoadIATInItsOwnSection: "DelayLoadIATInItsOwnSection",
ImageGuardCfExportSuppressionInfoPresent: "ExportSuppressionInfoPresent",
ImageGuardCfEnableExportSuppression: "EnableExportSuppression",
ImageGuardCfLongJumpTablePresent: "LongJumpTablePresent",
}
for k, s := range guardFlagMap {
if k&flags != 0 {
values = append(values, s)
}
}
return values
}
func (pe *File) getSEHHandlers() []uint32 {
var handlers []uint32
v := reflect.ValueOf(pe.LoadConfig.Struct)
// SEHandlerCount is found in index 19 of the struct.
SEHandlerCount := uint32(v.Field(19).Uint())
if SEHandlerCount > 0 {
SEHandlerTable := uint32(v.Field(18).Uint())
imageBase := pe.NtHeader.OptionalHeader.(ImageOptionalHeader32).ImageBase
rva := SEHandlerTable - imageBase
for i := uint32(0); i < SEHandlerCount; i++ {
offset := pe.GetOffsetFromRva(rva + i*4)
handler, err := pe.ReadUint32(offset)
if err != nil {
return handlers
}
handlers = append(handlers, handler)
}
}
return handlers
}
func (pe *File) getControlFlowGuardFunctions() []CFGFunction {
v := reflect.ValueOf(pe.LoadConfig.Struct)
var GFIDS []CFGFunction
var err error
// The GFIDS table is an array of 4 + n bytes, where n is given by :
// ((GuardFlags & IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK) >>
// IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_SHIFT).
// This allows for extra metadata to be attached to CFG call targets in
// the future. The only currently defined metadata is an optional 1-byte
// extra flags field (“GFIDS flags”) that is attached to each GFIDS
// entry if any call targets have metadata.
GuardFlags := v.Field(24).Uint()
n := (GuardFlags & ImageGuardCfFunctionTableSizeMask) >>
ImageGuardCfFunctionTableSizeShift
GuardCFFunctionCount := v.Field(23).Uint()
if GuardCFFunctionCount > 0 {
if pe.Is32 {
GuardCFFunctionTable := uint32(v.Field(22).Uint())
imageBase := pe.NtHeader.OptionalHeader.(ImageOptionalHeader32).ImageBase
rva := GuardCFFunctionTable - imageBase
offset := pe.GetOffsetFromRva(rva)
for i := uint32(1); i <= uint32(GuardCFFunctionCount); i++ {
cfgFunction := CFGFunction{}
var cfgFlags uint8
cfgFunction.RVA, err = pe.ReadUint32(offset)
if err != nil {
return GFIDS
}
if n > 0 {
err = pe.structUnpack(&cfgFlags, offset+4, uint32(n))
if err != nil {
return GFIDS
}
cfgFunction.Flags = ImageGuardFlagType(cfgFlags)
if cfgFlags == ImageGuardFlagFIDSuppressed ||
cfgFlags == ImageGuardFlagExportSuppressed {
exportName := pe.GetExportFunctionByRVA(cfgFunction.RVA)
cfgFunction.Description = exportName.Name
}
}
GFIDS = append(GFIDS, cfgFunction)
offset += 4 + uint32(n)
}
} else {
GuardCFFunctionTable := v.Field(22).Uint()
imageBase := pe.NtHeader.OptionalHeader.(ImageOptionalHeader64).ImageBase
rva := uint32(GuardCFFunctionTable - imageBase)
offset := pe.GetOffsetFromRva(rva)
for i := uint64(1); i <= GuardCFFunctionCount; i++ {
var cfgFlags uint8
cfgFunction := CFGFunction{}
cfgFunction.RVA, err = pe.ReadUint32(offset)
if err != nil {
return GFIDS
}
if n > 0 {
pe.structUnpack(&cfgFlags, offset+4, uint32(n))
cfgFunction.Flags = ImageGuardFlagType(cfgFlags)
if cfgFlags == ImageGuardFlagFIDSuppressed ||
cfgFlags == ImageGuardFlagExportSuppressed {
exportName := pe.GetExportFunctionByRVA(cfgFunction.RVA)
cfgFunction.Description = exportName.Name
}
}
GFIDS = append(GFIDS, cfgFunction)
offset += 4 + uint32(n)
}
}
}
return GFIDS
}
func (pe *File) getControlFlowGuardIAT() []CFGIATEntry {
v := reflect.ValueOf(pe.LoadConfig.Struct)
var GFGIAT []CFGIATEntry
var err error
// GuardAddressTakenIatEntryCount is found in index 27 of the struct.
// An image that supports CFG ES includes a GuardAddressTakenIatEntryTable
// whose count is provided by the GuardAddressTakenIatEntryCount as part
// of its load configuration directory. This table is structurally
// formatted the same as the GFIDS table. It uses the same GuardFlags
// IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK mechanism to encode extra
// optional metadata bytes in the address taken IAT table, though all
// metadata bytes must be zero for the address taken IAT table and are
// reserved.
GuardFlags := v.Field(24).Uint()
n := (GuardFlags & ImageGuardCfFunctionTableSizeMask) >>
ImageGuardCfFunctionTableSizeShift
GuardAddressTakenIatEntryCount := v.Field(27).Uint()
if GuardAddressTakenIatEntryCount > 0 {
if pe.Is32 {
GuardAddressTakenIatEntryTable := uint32(v.Field(26).Uint())
imageBase := pe.NtHeader.OptionalHeader.(ImageOptionalHeader32).ImageBase
rva := GuardAddressTakenIatEntryTable - imageBase
offset := pe.GetOffsetFromRva(rva)
for i := uint32(1); i <= uint32(GuardAddressTakenIatEntryCount); i++ {
cfgIATEntry := CFGIATEntry{}
cfgIATEntry.RVA, err = pe.ReadUint32(offset)
if err != nil {