Lines Matching refs:self
53 def __init__(self, sig_algo, hash_algo, bit_length, sig_bytes, hash_bytes, pubkey_bytes): argument
54 self.sig_algo = sig_algo
55 self.hash_algo = hash_algo
56 self.bit_length = bit_length
57 self.sig_bytes = sig_bytes
58 self.hash_bytes = hash_bytes
59 self.pubkey_bytes = pubkey_bytes
76 def __init__(self, footer=None): argument
77 self.foot = footer
78 if self.foot:
79 (self.magic, self.certoffset, self.certsize, self.imagesize,
80 self.partition_size, _) = struct.unpack(self.FOOTER_FORMAT, footer)
81 if self.magic != self.FOOTERMAGIC:
86 def info_footer(self): argument
88 if self.foot:
89 msg += "\tMaigc: {}\n".format((self.magic).decode())
90 msg += "\tCert offset: {} bytes\n".format(hex(self.certoffset))
91 msg += "\tCert size: {} bytes\n".format(self.certsize)
92 msg += "\tImage size: {} bytes\n".format(self.imagesize)
93 msg += "\tPartition size: {} bytes\n\n".format(self.partition_size)
111 def __init__(self, cert=None): argument
112 self.cert = cert
117 cert_fd.write(self.cert)
119 if self.cert:
120 self.mgc, self.major, self.minor = struct.unpack('4s2I', self.cert[0:12])
121 self.version = '{}.{}'.format(self.major, self.minor)
122 if self.mgc != self.CERTMAGIC:
124 … self.img_org_len, self.img_len, self.partition = struct.unpack('2Q64s', self.cert[48:128])
125 self.rollback_location, self.rollback_index = struct.unpack('2Q', self.cert[128:144])
127 verity, self.hash_algo = struct.unpack('2I', self.cert[144:152])
128 self.verity_type = 'hash' if verity == 1 else 'hashtree'
129 self.salt_offset, self.salt_size = struct.unpack('2Q', self.cert[152:168])
131 self.digest_offset, self.digest_size, self.hashtree_offset, self.hashtree_size, \
132 self.data_block_size, self.hash_block_size, self.fec_num_roots, \
133 self.fec_offset, self.fec_size = struct.unpack('9Q', self.cert[168:240])
134 … self.salt = struct.unpack('{}s'.format(self.salt_size), self.cert[240:240 + self.salt_size])
135 self.digest = struct.unpack('{}s'.format(self.digest_size), \
136 … self.cert[240 + self.salt_size : 240 + self.salt_size + self.digest_size])
137 hash_payload_size = self.salt_size + self.digest_size
138 self.algo, self.flags, self.key_offset, self.key_len = struct.unpack('2I2Q', \
139 … self.cert[240 + hash_payload_size + 8 : 240 + hash_payload_size + 8 + 24])
140 … self.key = self.cert[240 + hash_payload_size + 112 : 240 + hash_payload_size + 112 + self.key_len]
145 def info_cert(self): argument
147 if self.cert:
148 msg += "\tHVB tool version: hvb tool {}\n".format(self.version)
149 msg += "\tOriginal Image length: {} bytes\n".format(self.img_org_len)
150 msg += "\tImage length: {} bytes (4K alignment)\n".format(self.img_len)
151 msg += "\tPartition name: {}\n".format(self.partition.decode())
152 msg += "\tverity type(hash/hashtree): {}\n".format(self.verity_type)
153 msg += "\tsalt size: {} bytes\n".format(self.salt_size)
154 if self.hash_algo not in self.HASH_ALGORITHMS:
155 raise HvbError("Unknown hash algorithm: {}".format(self.hash_algo))
156 msg += "\tHash algorithm: {}\n".format(self.HASH_ALGORITHMS[self.hash_algo])
157 msg += "\tdigest size: {} bytes\n".format(self.digest_size)
158 msg += "\thashtree size: {}\n".format(self.hashtree_size)
159 msg += "\tfec size: {}\n".format(self.fec_size)
161 msg += "\t\tsalt: {}\n".format((binascii.b2a_hex(self.salt[0]).decode()))
162 … msg += "\t\tdigest: {}\n".format((binascii.b2a_hex(self.digest[0]).decode()))
163 if self.hashtree_size != 0:
164 msg += "\t\thashtree offset: 0x{:x}\n".format(self.hashtree_offset)
165 if self.fec_size != 0:
166 msg += "\t\tfec offset: 0x{:x}\n".format(self.fec_offset)
167 if self.algo not in self.ALGORITHM_TYPES:
168 raise HvbError("Unknown algorithm type: {}".format(self.algo))
169 msg += "\tAlgorithm: {}\n".format(self.ALGORITHM_TYPES[self.algo])
170 … msg += "\tPublic key (sha256): {}\n\n".format(hashlib.sha256(self.key).hexdigest())
180 def __init__(self, pubkey): argument
181 self.pubkey = pubkey
182 self.modulus_bits = self.get_bit_length(self.pubkey)
193 if not out.lower().startswith(self.MODULUS_PREFIX):
196 self.modulus = out[len(self.MODULUS_PREFIX):].strip()
197 self.modulusdata = int(self.modulus, 16)
198 self.exponent = 65537
200 def get_bit_length(self, pubkey): argument
206 if self.BIT_LENGTH_KEYWORD in line:
207 bitlen = int(re.findall(b'\d+', line.split(self.BIT_LENGTH_KEYWORD)[-1])[0])
211 def calc_egcd(self, num1, num2): argument
214 egcd_g, egcd_y, egcd_x = self.calc_egcd(num2 % num1, num1)
217 def calc_modinv(self, num1, modulo): argument
218 modinv_gcd, modinv_x, _ = self.calc_egcd(num1, modulo)
223 def incode_long(self, num_bits, value): argument
230 def get_public_key(self): argument
231 pkey_n0 = 2 ** 64 - self.calc_modinv(self.modulusdata, 2 ** 64)
232 pkey_r = 2 ** self.modulusdata.bit_length()
233 pkey_prr = bytes(self.incode_long(self.modulus_bits, pkey_r * pkey_r % self.modulusdata))
234 modulus = bytes(self.incode_long(self.modulus_bits, self.modulusdata))
236 return struct.pack('!QQ', self.modulus_bits, pkey_n0) + modulus + pkey_prr
240 def __init__(self, message): argument
242 Exception.__init__(self, message)
253 def __init__(self, chunk_type, chunk_offset, nsparsed_output_offset, argument
266 self.chunk_type = chunk_type
267 self.chunk_offset = chunk_offset
268 self.nsparsed_chunk_offset = nsparsed_output_offset
269 self.nsparsed_output_size = nsparsed_output_size
270 self.sparsed_input_offset = input_offset
271 self.fill_data = fill_data
273 if self.chunk_type == self.CHUNK_TYPE_RAW:
274 if self.fill_data is not None:
276 if not self.sparsed_input_offset:
278 elif self.chunk_type == self.CHUNK_TYPE_FILL:
279 if self.fill_data is None:
281 if self.sparsed_input_offset:
283 elif self.chunk_type == self.CHUNK_TYPE_DONT_CARE:
284 if self.fill_data is not None:
286 if self.sparsed_input_offset:
298 def __init__(self, file_name): argument
299 self.image_file = file_name
300 self.is_sparse = False
301 self.block_size = 4096 # A block size is 4096 bytes.
302 self.total_blks = 0
303 self.total_chunks = 0
304 self.header_analyze()
306 def header_analyze(self): argument
307 self.img_handler = open(self.image_file, 'r+b')
308 self.img_handler.seek(0, os.SEEK_END)
309 self.img_size = self.img_handler.tell()
310 print("Initial image length: ", self.img_size)
312 self.img_handler.seek(0, os.SEEK_SET)
313 header = self.img_handler.read(self.SIMAGE_HEADER_SIZE)
329 chunk_hdr_sz, block_size, self.total_blks, self.total_chunks,
330 img_checksum) = struct.unpack(self.SIMAGE_HEADER_FORMAT, header)
331 if magic != self.SIMAGE_MAGIC:
334 self.block_size = block_size
336 if self.SIMAGE_HEADER_SIZE != file_hdr_sz:
341 self.chunks = list()
342 nsparsed_output_offset, nsparsed_chunk_nums = self.chunk_analyze()
343 self.sparse_end = self.img_handler.tell()
345 if self.total_blks != nsparsed_chunk_nums:
347 'but we saw {}'.format(self.total_blks, nsparsed_chunk_nums))
348 if self.sparse_end != self.img_size:
350 "file.".format(self.img_size - self.sparse_end))
352 self.nsparsed_chunk_offset_list = [c.nsparsed_chunk_offset for c in self.chunks]
353 self.is_sparse = True
354 self.img_size = nsparsed_output_offset
356 def chunk_analyze(self): argument
360 for i in range(self.total_chunks):
361 chunk_offset = self.img_handler.tell()
368 chunk_header = self.img_handler.read(ImageChunk.CHUNK_HEADER_SIZE)
373 if chunk_data_size != (chunk_sz * self.block_size):
375 … "size ({})".format(chunk_data_size, (chunk_sz * self.block_size)))
376 self.chunks.append(ImageChunk(ImageChunk.CHUNK_TYPE_RAW, chunk_offset,
377 … nsparsed_output_offset, chunk_sz * self.block_size,
378 self.img_handler.tell(), None))
379 self.img_handler.seek(chunk_data_size, os.SEEK_CUR)
384 fill_data = self.img_handler.read(4)
385 self.chunks.append(ImageChunk(ImageChunk.CHUNK_TYPE_FILL, chunk_offset,
386 … nsparsed_output_offset, chunk_sz * self.block_size,
392 self.chunks.append(ImageChunk(ImageChunk.CHUNK_TYPE_DONT_CARE, chunk_offset,
393 … nsparsed_output_offset, chunk_sz * self.block_size,
399 self.img_handler.read(4)
404 nsparsed_output_offset += chunk_sz * self.block_size
408 def update_chunks_and_blocks(self): argument
418 self.img_handler.seek(num_chunks_and_blocks_offset, os.SEEK_SET)
419 self.img_handler.write(struct.pack(num_chunks_and_blocks_format,
420 self.total_blks, self.total_chunks))
422 def append_dont_care(self, num_bytes): argument
431 if num_bytes % self.block_size != 0:
434 if not self.is_sparse:
435 self.img_handler.seek(0, os.SEEK_END)
438 self.img_handler.truncate(self.img_handler.tell() + num_bytes)
439 self.header_analyze()
442 self.total_chunks += 1
443 self.total_blks += num_bytes // self.block_size
444 self.update_chunks_and_blocks()
446 self.img_handler.seek(self.sparse_end, os.SEEK_SET)
447 self.img_handler.write(struct.pack(ImageChunk.CHUNK_HEADER_FORMAT,
450 num_bytes // self.block_size,
452 self.header_analyze()
454 def append_raw(self, data): argument
463 print("SELF>BLOCK_SIZE: ", self.block_size)
464 if len(data) % self.block_size != 0:
467 if not self.is_sparse:
468 self.img_handler.seek(0, os.SEEK_END)
469 self.img_handler.write(data)
470 self.header_analyze()
473 self.total_chunks += 1
474 self.total_blks += len(data) // self.block_size
475 self.update_chunks_and_blocks()
477 self.img_handler.seek(self.sparse_end, os.SEEK_SET)
478 self.img_handler.write(struct.pack(ImageChunk.CHUNK_HEADER_FORMAT,
481 len(data) // self.block_size,
484 self.img_handler.write(data)
485 self.header_analyze()
487 def append_fill(self, fill_data, size): argument
497 if len(fill_data) != 4 or size % 4 != 0 or size % self.block_size != 0:
500 if not self.is_sparse:
501 self.img_handler.seek(0, os.SEEK_END)
502 self.img_handler.write(fill_data * (size // 4))
503 self.header_analyze()
506 self.total_chunks += 1
507 self.total_blks += size // self.block_size
508 self.update_chunks_and_blocks()
510 self.img_handler.seek(self.sparse_end, os.SEEK_SET)
511 self.img_handler.write(struct.pack(ImageChunk.CHUNK_HEADER_FORMAT,
514 size // self.block_size,
516 self.img_handler.write(fill_data)
517 self.header_analyze()
519 def seek(self, offset): argument
530 self._file_pos = offset
532 def read(self, size): argument
547 if not self.is_sparse:
548 self.img_handler.seek(self._file_pos)
549 data = self.img_handler.read(size)
550 self._file_pos += len(data)
554 chunk_idx = bisect.bisect_right(self.nsparsed_chunk_offset_list,
555 self._file_pos) - 1
559 chunk = self.chunks[chunk_idx]
560 chunk_pos_offset = self._file_pos - chunk.nsparsed_chunk_offset
564 self.img_handler.seek(chunk.sparsed_input_offset + chunk_pos_offset)
565 data.extend(self.img_handler.read(chunk_pos_to_go))
576 self._file_pos += chunk_pos_to_go
579 if chunk_idx >= len(self.nsparsed_chunk_offset_list):
584 def tell(self): argument
590 return self._file_pos
592 def calc_truncate_location(self): argument
595 def truncate(self, size): argument
605 if not self.is_sparse:
606 self.img_handler.truncate(size)
607 self.header_analyze()
610 if size % self.block_size != 0:
614 if size == self.img_size:
618 if size < self.img_size:
619 chunk_idx = bisect.bisect_right(self.nsparsed_chunk_offset_list, size) - 1
620 chunk = self.chunks[chunk_idx]
626 if num_to_keep % self.block_size != 0:
642 chunk_sz = num_to_keep // self.block_size
644 self.img_handler.seek(chunk.nsparsed_chunk_offset)
645 self.img_handler.write(struct.pack(ImageChunk.CHUNK_HEADER_FORMAT,
655 self.total_chunks = chunk_idx_for_update
656 self.total_blks = 0
658 self.total_blks += self.chunks[i].nsparsed_output_size // self.block_size
659 self.update_chunks_and_blocks()
660 self.img_handler.truncate(truncate_at)
663 self.header_analyze()
666 self.append_dont_care(size - self.img_size)
703 def __init__(self): argument
704 self.img = _params['image']
705 self.partition = _params['partition']
706 self.partition_size = _params['partition_size']
707 self.vertype = _params['verity_type'].lower() # verity type: hash - 1 or hashtree - 2 (fix)
708 self.algo = _params['algorithm']
709 self.pubkey = _params['pubkey']
710 self.privkey = _params['privkey']
711 self.hash_algo = _params['hash_algo']
712 self.block_size = _params['block_size']
713 self.padding_size = _params['padding_size']
714 self.signed_img = _params['output']
716 self.salt = binascii.a2b_hex(_params['salt'])
718 self.hashtree = b''
719 self.digest = b''
720 self.fec = b''
721 self.hvb_cert_content = b''
723 self.original_image_info()
725 def original_image_info(self): argument
726 if self.img is None:
729 self.image_handle = ImageHandle(self.img)
730 self.original_image_length = self.image_handle.img_size
732 self.img_len_with_padding = round_to_multiple(self.original_image_length, self.block_size)
733 print("Image length(%s): %d bytes" % (self.img, self.original_image_length))
735 def hvb_header(self): argument
736 self.hvb_cert_content = self.MAGIC
737 self.hvb_cert_content += struct.pack('I', self.HVB_VERSION_MAJOR)
738 self.hvb_cert_content += struct.pack('I', self.HVB_VERSION_MINOR)
739 self.hvb_cert_content += self.VERITY_RESERVED
741 def hvb_image_info(self): argument
743 …partition_name = (self.partition).encode('utf-8') + b'\0' * (max_partition_name_len - len(self.par…
745 self.hvb_cert_content += struct.pack('Q', self.original_image_length)
746 self.hvb_cert_content += struct.pack('Q', self.img_len_with_padding)
747 self.hvb_cert_content += partition_name
748 …self.hvb_cert_content += struct.pack('2Q', int(_params['rollback_location']), int(_params['rollbac…
750 def image_hash(self): argument
752 if self.vertype == 'hash':
754 elif self.vertype == 'hashtree':
759 print("digest: ", binascii.b2a_hex(self.digest))
760 print("digest size: ", len(self.digest))
764 salt_size = struct.pack('Q', len(self.salt))
765 digest_offset = struct.pack('Q', 240 + len(self.salt))
766 digest_size = struct.pack('Q', len(self.digest))
769 def generate_hash_tree(self, hash_level_offsets, tree_size): argument
772 hash_src_size = self.image_handle.img_size
776 while hash_src_size > self.block_size:
781 hasher = hashlib.new(self.hash_algo, self.salt)
784 end = min(remaining, self.block_size)
785 self.image_handle.seek(begin)
786 data = self.image_handle.read(end)
789 data = hash_ret[offset : offset + self.block_size]
793 if len(data) < self.block_size:
794 hasher.update(b'\0' * (self.block_size - len(data)))
798 … level_output_padding = round_to_multiple(len(level_output), self.block_size) - len(level_output)
807 hasher = hashlib.new(self.hash_algo, self.salt)
812 def create_hashtree(self, digest_size): argument
818 size = self.image_handle.img_size
820 while size > self.block_size:
821 blocknum = size // self.block_size
822 level_size = round_to_multiple(blocknum * digest_size, self.block_size)
834 rootdigest, self.hashtree = self.generate_hash_tree(level_offsets, treesize)
835 if len(self.hashtree) % self.block_size != 0:
836 self.hashtree += b'\0' * (self.block_size - len(self.hashtree) % self.block_size)
840 def image_hash_tree(self): argument
841 image_hashtree = {"hashtree_offset": self.img_len_with_padding, \
842 "hashtree_size": len(self.hashtree), "data_block_size": self.block_size, \
843 "hash_block_size": self.block_size, "fec_num_roots": 0, \
844 "fec_offset": 240 + len(self.salt) + len(self.digest), "fec_size": 0}
851 def hvb_hash_info(self): argument
853 if self.vertype == 'hash':
856 self.image_handle.seek(0)
857 image_content = self.image_handle.read(self.image_handle.img_size)
858 hasher = hashlib.new(self.hash_algo, self.salt)
860 self.digest = hasher.digest()
861 elif self.vertype == 'hashtree':
864 hashtree_hasher = hashlib.new(self.hash_algo, self.salt)
867 print("hash_algo: {}, salt: {}".format(self.hash_algo, self.salt))
869 remainder = self.block_size - self.image_handle.img_size % self.block_size
870 if remainder != self.block_size:
871 self.image_handle.append_raw(b'\0' * remainder)
872 self.img_len_with_padding = self.image_handle.img_size
873 self.digest = self.create_hashtree(digest_size)
875 print("[hvbtool][ERROR]: Invalid verity_type: %d", self.vertype)
878 imghash = self.image_hash()
879 imghashtree = self.image_hash_tree()
880 hashpayload = self.salt + self.digest
883 self.hashinfo_size = len(hashinfo)
884 self.hvb_cert_content += struct.pack('I', verity_type) + hashinfo
886 def hvb_signature_info(self): argument
889 if self.algo not in self.ALGORITHMS:
890 raise HvbError("Unknown algorithm: {}".format(self.algo))
891 algo = self.ALGORITHMS[self.algo]
893 keyblock_offset = 144 + self.hashinfo_size + 112
896 key = RSAPublicKey(self.pubkey)
903 sig_length = len(self.hvb_cert_content) + 112 + len(keyblock)
905 self.hvb_cert_content += struct.pack('Q', sig_length) + struct.pack('I', algo.sig_algo) \
916 tmp_fd.write(self.hvb_cert_content)
918 cmd = ['openssl', 'dgst', '-sign', self.privkey, '-sigopt', 'rsa_padding_mode:pss',
919 '-sigopt', 'rsa_pss_saltlen:{}'.format(len(self.salt)), '-sha256', '-out',
930 self.hvb_cert_content += sigcontent
932 def hvb_footer_info(self): argument
933 self.footer = b''
934 footer_magic = self.MAGIC + b'\0' * 4
935 self.partition_size = int(self.partition_size)
937 cert_size = len(self.hvb_cert_content)
938 cert_offset = self.img_len_with_padding + len(self.hashtree)
940 if self.padding_size is not None:
941 cert_offset = self.partition_size - self.padding_size
943 …print("cert_size: %x, cert_offset: %x, partition_size: %x" % (cert_size, cert_offset, self.partiti…
944 self.footer += footer_magic \
945 … + struct.pack('4Q', cert_offset, cert_size, self.original_image_length, self.partition_size) \
948 def hvb_make_rvt_image(self): argument
949 self.img = 'tmp_rvt.img'
951 rvtcontent += self.RVT_MAGIC
974 if os.path.exists(self.img):
975 os.remove(self.img)
979 with os.fdopen(os.open(self.img, flags, modes), 'wb') as rvt_fd:
982 self.original_image_info()
983 self.hvb_make_image()
985 def hvb_combine_image_info(self): argument
987 hashtree_length = len(self.hashtree)
988 hvb_cert_length = len(self.hvb_cert_content)
989 image = os.path.abspath(self.img)
990 signed_image = os.path.abspath(self.signed_img)
995 padding = round_to_multiple(image.img_size, self.block_size)
1001 padding = round_to_multiple((hvb_cert_length + self.FOOTER_SIZE), self.block_size)
1002 if padding > (hvb_cert_length + self.FOOTER_SIZE):
1003 …cert_and_footer = self.hvb_cert_content + b'\0' * (padding - (self.FOOTER_SIZE + hvb_cert_length))…
1004 self.footer
1006 cert_and_footer = self.hvb_cert_content + self.footer
1008 if self.partition_size < image.img_size + hashtree_length + len(cert_and_footer):
1011 cert_and_footer = self.hvb_cert_content + b'\0' * (self.partition_size - image.img_size - \
1012 hashtree_length - hvb_cert_length - self.FOOTER_SIZE) + self.footer
1013 image.append_raw(self.hashtree)
1016 def parse_rvt_image(self, handle): argument
1024 if magic != self.RVT_MAGIC:
1039 def hvb_make_image(self): argument
1040 self.hvb_header()
1041 self.hvb_image_info()
1042 self.hvb_hash_info()
1043 self.hvb_signature_info()
1044 self.hvb_footer_info()
1045 self.hvb_combine_image_info()
1047 def hvb_parse_image(self): argument
1049 image = ImageHandle(self.img)
1050 image.seek(self.original_image_length - self.FOOTER_SIZE)
1051 footer_bin = image.read(self.FOOTER_SIZE)
1061 self.parse_rvt_image(image)
1065 def hvb_erase_image(self): argument
1067 image = ImageHandle(self.img)
1068 image.seek(self.original_image_length - self.FOOTER_SIZE)
1069 footer_bin = image.read(self.FOOTER_SIZE)