llvm/test/tools/llvm-objcopy/MachO/Inputs/code-signature-check.py

   1 """Checks the validity of MachO binary signatures
   2
   3 MachO binaries sometimes include a LC_CODE_SIGNATURE load command
   4 and corresponding section in the __LINKEDIT segment that together
   5 work to "sign" the binary. This script is used to check the validity
   6 of this signature.
   7
   8 Usage:
   9     ./code-signature-check.py my_binary 800 300 0 800
  10
  11 Arguments:
  12    binary - The MachO binary to be tested
  13    offset - The offset from the start of the binary to where the code signature section begins
  14    size - The size of the code signature section in the binary
  15    code_offset - The point in the binary to begin hashing
  16    code_size - The length starting from code_offset to hash
  17 """
  18
  19 import argparse
  20 import collections
  21 import hashlib
  22 import itertools
  23 import struct
  24 import sys
  25 import typing
  26
  27
  28 class CodeDirectoryVersion:
  29     SUPPORTSSCATTER = 0x20100
  30     SUPPORTSTEAMID = 0x20200
  31     SUPPORTSCODELIMIT64 = 0x20300
  32     SUPPORTSEXECSEG = 0x20400
  33
  34
  35 class CodeDirectory:
  36     @staticmethod
  37     def make(
  38         buf: memoryview,
  39     ) -> typing.Union[
  40         "CodeDirectoryBase",
  41         "CodeDirectoryV20100",
  42         "CodeDirectoryV20200",
  43         "CodeDirectoryV20300",
  44         "CodeDirectoryV20400",
  45     ]:
  46         _magic, _length, version = struct.unpack_from(">III", buf, 0)
  47         subtype = {
  48             CodeDirectoryVersion.SUPPORTSSCATTER: CodeDirectoryV20100,
  49             CodeDirectoryVersion.SUPPORTSTEAMID: CodeDirectoryV20200,
  50             CodeDirectoryVersion.SUPPORTSCODELIMIT64: CodeDirectoryV20300,
  51             CodeDirectoryVersion.SUPPORTSEXECSEG: CodeDirectoryV20400,
  52         }.get(version, CodeDirectoryBase)
  53
  54         return subtype._make(struct.unpack_from(subtype._format(), buf, 0))
  55
  56
  57 class CodeDirectoryBase(typing.NamedTuple):
  58     magic: int
  59     length: int
  60     version: int
  61     flags: int
  62     hashOffset: int
  63     identOffset: int
  64     nSpecialSlots: int
  65     nCodeSlots: int
  66     codeLimit: int
  67     hashSize: int
  68     hashType: int
  69     platform: int
  70     pageSize: int
  71     spare2: int
  72
  73     @staticmethod
  74     def _format() -> str:
  75         return ">IIIIIIIIIBBBBI"
  76
  77
  78 class CodeDirectoryV20100(typing.NamedTuple):
  79     magic: int
  80     length: int
  81     version: int
  82     flags: int
  83     hashOffset: int
  84     identOffset: int
  85     nSpecialSlots: int
  86     nCodeSlots: int
  87     codeLimit: int
  88     hashSize: int
  89     hashType: int
  90     platform: int
  91     pageSize: int
  92     spare2: int
  93
  94     scatterOffset: int
  95
  96     @staticmethod
  97     def _format() -> str:
  98         return CodeDirectoryBase._format() + "I"
  99
 100
 101 class CodeDirectoryV20200(typing.NamedTuple):
 102     magic: int
 103     length: int
 104     version: int
 105     flags: int
 106     hashOffset: int
 107     identOffset: int
 108     nSpecialSlots: int
 109     nCodeSlots: int
 110     codeLimit: int
 111     hashSize: int
 112     hashType: int
 113     platform: int
 114     pageSize: int
 115     spare2: int
 116
 117     scatterOffset: int
 118
 119     teamOffset: int
 120
 121     @staticmethod
 122     def _format() -> str:
 123         return CodeDirectoryV20100._format() + "I"
 124
 125
 126 class CodeDirectoryV20300(typing.NamedTuple):
 127     magic: int
 128     length: int
 129     version: int
 130     flags: int
 131     hashOffset: int
 132     identOffset: int
 133     nSpecialSlots: int
 134     nCodeSlots: int
 135     codeLimit: int
 136     hashSize: int
 137     hashType: int
 138     platform: int
 139     pageSize: int
 140     spare2: int
 141
 142     scatterOffset: int
 143
 144     teamOffset: int
 145
 146     spare3: int
 147     codeLimit64: int
 148
 149     @staticmethod
 150     def _format() -> str:
 151         return CodeDirectoryV20200._format() + "IQ"
 152
 153
 154 class CodeDirectoryV20400(typing.NamedTuple):
 155     magic: int
 156     length: int
 157     version: int
 158     flags: int
 159     hashOffset: int
 160     identOffset: int
 161     nSpecialSlots: int
 162     nCodeSlots: int
 163     codeLimit: int
 164     hashSize: int
 165     hashType: int
 166     platform: int
 167     pageSize: int
 168     spare2: int
 169
 170     scatterOffset: int
 171
 172     teamOffset: int
 173
 174     spare3: int
 175     codeLimit64: int
 176
 177     execSegBase: int
 178     execSegLimit: int
 179     execSegFlags: int
 180
 181     @staticmethod
 182     def _format() -> str:
 183         return CodeDirectoryV20300._format() + "QQQ"
 184
 185
 186 class CodeDirectoryBlobIndex(typing.NamedTuple):
 187     type_: int
 188     offset: int
 189
 190     @staticmethod
 191     def make(buf: memoryview) -> "CodeDirectoryBlobIndex":
 192         return CodeDirectoryBlobIndex._make(
 193             struct.unpack_from(CodeDirectoryBlobIndex.__format(), buf, 0)
 194         )
 195
 196     @staticmethod
 197     def bytesize() -> int:
 198         return struct.calcsize(CodeDirectoryBlobIndex.__format())
 199
 200     @staticmethod
 201     def __format() -> str:
 202         return ">II"
 203
 204
 205 class CodeDirectorySuperBlob(typing.NamedTuple):
 206     magic: int
 207     length: int
 208     count: int
 209     blob_indices: typing.List[CodeDirectoryBlobIndex]
 210
 211     @staticmethod
 212     def make(buf: memoryview) -> "CodeDirectorySuperBlob":
 213         super_blob_layout = ">III"
 214         super_blob = struct.unpack_from(super_blob_layout, buf, 0)
 215
 216         offset = struct.calcsize(super_blob_layout)
 217         blob_indices = []
 218         for idx in range(super_blob[2]):
 219             blob_indices.append(CodeDirectoryBlobIndex.make(buf[offset:]))
 220             offset += CodeDirectoryBlobIndex.bytesize()
 221
 222         return CodeDirectorySuperBlob(*super_blob, blob_indices)
 223
 224
 225 def unpack_null_terminated_string(buf: memoryview) -> str:
 226     b = bytes(itertools.takewhile(lambda b: b != 0, buf))
 227     return b.decode()
 228
 229
 230 def main():
 231     parser = argparse.ArgumentParser()
 232     parser.add_argument(
 233         "binary", type=argparse.FileType("rb"), help="The file to analyze"
 234     )
 235     parser.add_argument(
 236         "offset", type=int, help="Offset to start of Code Directory data"
 237     )
 238     parser.add_argument("size", type=int, help="Size of Code Directory data")
 239     parser.add_argument(
 240         "code_offset", type=int, help="Offset to start of code pages to hash"
 241     )
 242     parser.add_argument("code_size", type=int, help="Size of the code pages to hash")
 243
 244     args = parser.parse_args()
 245
 246     args.binary.seek(args.offset)
 247     super_blob_bytes = args.binary.read(args.size)
 248     super_blob_mem = memoryview(super_blob_bytes)
 249
 250     super_blob = CodeDirectorySuperBlob.make(super_blob_mem)
 251     print(super_blob)
 252
 253     for blob_index in super_blob.blob_indices:
 254         code_directory_offset = blob_index.offset
 255         code_directory = CodeDirectory.make(super_blob_mem[code_directory_offset:])
 256         print(code_directory)
 257
 258         ident_offset = code_directory_offset + code_directory.identOffset
 259         print(
 260             "Code Directory ID: "
 261             + unpack_null_terminated_string(super_blob_mem[ident_offset:])
 262         )
 263
 264         code_offset = args.code_offset
 265         code_end = code_offset + args.code_size
 266         page_size = 1 << code_directory.pageSize
 267         args.binary.seek(code_offset)
 268
 269         hashes_offset = code_directory_offset + code_directory.hashOffset
 270         for idx in range(code_directory.nCodeSlots):
 271             hash_bytes = bytes(
 272                 super_blob_mem[hashes_offset : hashes_offset + code_directory.hashSize]
 273             )
 274             hashes_offset += code_directory.hashSize
 275
 276             hasher = hashlib.sha256()
 277             read_size = min(page_size, code_end - code_offset)
 278             hasher.update(args.binary.read(read_size))
 279             calculated_hash_bytes = hasher.digest()
 280             code_offset += read_size
 281
 282             print("%s <> %s" % (hash_bytes.hex(), calculated_hash_bytes.hex()))
 283
 284             if hash_bytes != calculated_hash_bytes:
 285                 sys.exit(-1)
 286
 287
 288 if __name__ == "__main__":
 289     main()