Google Git
Sign in
nest-open-source / manifest_repos / sdk / 298baf23afcd1beb26cd47146293d6ea996a71fc / . / tools / mbn_tools.py
blob: 22bd646aa8502fbac84477a6b08d8b6ff743e9dd [file] [log] [blame]
#===============================================================================
#
# MBN TOOLS
#
# GENERAL DESCRIPTION
# Contains all MBN Utilities for image generation
#
# Copyright (c) 2010-2013, 2017 Qualcomm Technologies, Inc.
# All Rights Reserved.
# Confidential and Proprietary - Qualcomm Technologies, Inc.
#
#-------------------------------------------------------------------------------
# EDIT HISTORY FOR FILE
#
# This section contains comments describing changes made to the module.
# Notice that changes are listed in reverse chronological order.
#
# when who what, where, why
# -------- --- ---------------------------------------------------------
# 04/11/17 an Updated Copyright
# 06/06/13 yliong CR 497042: Signed and encrypted image is corrupted. MRC features.
# 03/18/13 dhaval Add support for hashing elf segments with SHA256 and
# sync up to mpss, adsp mbn-tools
# 01/14/13 kedara Remove dependency on .builds, cust<bid>.h, targ<bid>.h files
# 08/30/12 kedara Add virtual block suppport
# 02/24/12 dh Add ssd side effect file names
# 07/08/11 aus Added support for image_id in SBL image header as required by PBL
# Sahara mode
# 10/20/11 dxiang Clean up
#===============================================================================
import stat
import csv
import itertools
import struct
import os
import subprocess
import shutil
import hashlib
#----------------------------------------------------------------------------
# GLOBAL VARIABLES BEGIN
#----------------------------------------------------------------------------
PAD_BYTE_1 = 255 # Padding byte 1s
PAD_BYTE_0 = 0 # Padding byte 0s
SHA256_SIGNATURE_SIZE = 256 # Support SHA256
MAX_NUM_ROOT_CERTS = 4 # Maximum number of OEM root certificates
MI_BOOT_IMG_HDR_SIZE = 40 # sizeof(mi_boot_image_header_type)
MI_BOOT_IMG_HDR_SIZE_V6 = 48 # V6 sizeof(mi_boot_image_header_type)
MI_BOOT_SBL_HDR_SIZE = 80 # sizeof(sbl_header)
BOOT_HEADER_LENGTH = 20 # Boot Header Number of Elements
SBL_HEADER_LENGTH = 20 # SBL Header Number of Elements
FLASH_PARTI_VERSION = 3 # Flash Partition Version Number
FLASH_PARTI_VERSION_V6 = 6 # V6 Flash Partition Version Number
MAX_PHDR_COUNT = 100 # Maximum allowable program headers
CERT_CHAIN_ONEROOT_MAXSIZE = 6*1024 # Default Cert Chain Max Size for one root
VIRTUAL_BLOCK_SIZE = 131072 # Virtual block size for MCs insertion in SBL1 if ENABLE_VIRTUAL_BLK ON
MAGIC_COOKIE_LENGTH = 12 # Length of magic Cookie inserted per VIRTUAL_BLOCK_SIZE
MIN_IMAGE_SIZE_WITH_PAD = 256*1024 # Minimum image size for sbl1 Nand based OTA feature
SBL_AARCH64 = 0xF # Indicate that SBL is a Aarch64 image
SBL_AARCH32 = 0x0 # Indicate that SBL is a Aarch32 image
# Magic numbers filled in for boot headers
FLASH_CODE_WORD = 0x844BDCD1
UNIFIED_BOOT_COOKIE_MAGIC_NUMBER = 0x33836685
MAGIC_NUM = 0x73D71034
AUTODETECT_PAGE_SIZE_MAGIC_NUM = 0x7D0B435A
AUTODETECT_PAGE_SIZE_MAGIC_NUM64 = 0x7D0B5436
AUTODETECT_PAGE_SIZE_MAGIC_NUM128 = 0x7D0B6577
SBL_VIRTUAL_BLOCK_MAGIC_NUM = 0xD48B54C6
# ELF Definitions
ELF_HDR_COMMON_SIZE = 24
ELF32_HDR_SIZE = 52
ELF32_PHDR_SIZE = 32
ELF64_HDR_SIZE = 64
ELF64_PHDR_SIZE = 56
ELFINFO_MAG0_INDEX = 0
ELFINFO_MAG1_INDEX = 1
ELFINFO_MAG2_INDEX = 2
ELFINFO_MAG3_INDEX = 3
ELFINFO_MAG0 = 127 # 0x7F
ELFINFO_MAG1 = 69 # E
ELFINFO_MAG2 = 76 # L
ELFINFO_MAG3 = 70 # F
ELFINFO_CLASS_INDEX = 4
ELFINFO_CLASS_32 = 1
ELFINFO_CLASS_64 = 2
ELFINFO_VERSION_INDEX = 6
ELFINFO_VERSION_CURRENT = 1
ELF_BLOCK_ALIGN = 0x1000
ALIGNVALUE_1MB = 0x100000
ALIGNVALUE_4MB = 0x400000
# ELF Program Header Types
NULL_TYPE = 0x0
LOAD_TYPE = 0x1
DYNAMIC_TYPE = 0x2
INTERP_TYPE = 0x3
NOTE_TYPE = 0x4
SHLIB_TYPE = 0x5
PHDR_TYPE = 0x6
TLS_TYPE = 0x7
PHDR_ENTR_TYPE = 0x64000001
outputdir = "/bin/gzip"
"""
The eight bits between 20 and 27 in the p_flags field in ELF program headers
is not used by the standard ELF format. We use this byte to hold OS and processor
specific fields as recommended by ARM.
The bits in this byte are defined as follows:
Pool Indx Segment type Access type Page/non page
bits in p_flags /-----27-----/----26-24-------/---- 23-21----/------20-------/
After parsing segment description strings in the SCL file, the appropriate segment
flag values are chosen from the follow definitions. The mask defined below is then
used to update the existing p_flags field in the program headers with the updated
values.
"""
# Mask for bits 20-27 to parse program header p_flags
MI_PBT_FLAGS_MASK = 0x0FF00000
# Helper defines to help parse ELF program headers
MI_PROG_BOOT_DIGEST_SIZE = 20
MI_PBT_FLAG_SEGMENT_TYPE_MASK = 0x07000000
MI_PBT_FLAG_SEGMENT_TYPE_SHIFT = 0x18
MI_PBT_FLAG_PAGE_MODE_MASK = 0x00100000
MI_PBT_FLAG_PAGE_MODE_SHIFT = 0x14
MI_PBT_FLAG_ACCESS_TYPE_MASK = 0x00E00000
MI_PBT_FLAG_ACCESS_TYPE_SHIFT = 0x15
MI_PBT_FLAG_POOL_INDEX_MASK = 0x08000000
MI_PBT_FLAG_POOL_INDEX_SHIFT = 0x1B
# Segment Type
MI_PBT_L4_SEGMENT = 0x0
MI_PBT_AMSS_SEGMENT = 0x1
MI_PBT_HASH_SEGMENT = 0x2
MI_PBT_BOOT_SEGMENT = 0x3
MI_PBT_L4BSP_SEGMENT = 0x4
MI_PBT_SWAPPED_SEGMENT = 0x5
MI_PBT_SWAP_POOL_SEGMENT = 0x6
MI_PBT_PHDR_SEGMENT = 0x7
# Page/Non-Page Type
MI_PBT_NON_PAGED_SEGMENT = 0x0
MI_PBT_PAGED_SEGMENT = 0x1
# Access Type
MI_PBT_RW_SEGMENT = 0x0
MI_PBT_RO_SEGMENT = 0x1
MI_PBT_ZI_SEGMENT = 0x2
MI_PBT_NOTUSED_SEGMENT = 0x3
MI_PBT_SHARED_SEGMENT = 0x4
# ELF Segment Flag Definitions
MI_PBT_ELF_AMSS_NON_PAGED_RO_SEGMENT = 0x01200000
MI_PBT_ELF_AMSS_PAGED_RO_SEGMENT = 0x01300000
MI_PBT_ELF_SWAP_POOL_NON_PAGED_ZI_SEGMENT_INDEX0 = 0x06400000
MI_PBT_ELF_SWAPPED_PAGED_RO_SEGMENT_INDEX0 = 0x05300000
MI_PBT_ELF_SWAP_POOL_NON_PAGED_ZI_SEGMENT_INDEX1 = 0x0E400000
MI_PBT_ELF_SWAPPED_PAGED_RO_SEGMENT_INDEX1 = 0x0D300000
MI_PBT_ELF_AMSS_NON_PAGED_ZI_SEGMENT = 0x01400000
MI_PBT_ELF_AMSS_PAGED_ZI_SEGMENT = 0x01500000
MI_PBT_ELF_AMSS_NON_PAGED_RW_SEGMENT = 0x01000000
MI_PBT_ELF_AMSS_PAGED_RW_SEGMENT = 0x01100000
MI_PBT_ELF_AMSS_NON_PAGED_NOTUSED_SEGMENT = 0x01600000
MI_PBT_ELF_AMSS_PAGED_NOTUSED_SEGMENT = 0x01700000
MI_PBT_ELF_AMSS_NON_PAGED_SHARED_SEGMENT = 0x01800000
MI_PBT_ELF_AMSS_PAGED_SHARED_SEGMENT = 0x01900000
MI_PBT_ELF_HASH_SEGMENT = 0x02200000
MI_PBT_ELF_BOOT_SEGMENT = 0x03200000
MI_PBT_ELF_PHDR_SEGMENT = 0x07000000
MI_PBT_ELF_NON_PAGED_L4BSP_SEGMENT = 0x04000000
MI_PBT_ELF_PAGED_L4BSP_SEGMENT = 0x04100000
MI_PBT_ELF_AMSS_RELOCATABLE_IMAGE = 0x8000000
#----------------------------------------------------------------------------
# GLOBAL VARIABLES END
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# CLASS DEFINITIONS BEGIN
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# OS Type ID Class
#----------------------------------------------------------------------------
class OSType:
BMP_BOOT_OS = 0
WM_BOOT_OS = 1
ANDROID_BOOT_OS = 2
CHROME_BOOT_OS = 3
SYMBIAN_BOOT_OS = 4
LINUX_BOOT_OS = 5
#----------------------------------------------------------------------------
# Image Type ID Class - These values must be kept consistent with mibib.h
#----------------------------------------------------------------------------
class ImageType:
NONE_IMG = 0
OEM_SBL_IMG = 1
AMSS_IMG = 2
QCSBL_IMG = 3
HASH_IMG = 4
APPSBL_IMG = 5
APPS_IMG = 6
HOSTDL_IMG = 7
DSP1_IMG = 8
FSBL_IMG = 9
DBL_IMG = 10
OSBL_IMG = 11
DSP2_IMG = 12
EHOSTDL_IMG = 13
NANDPRG_IMG = 14
NORPRG_IMG = 15
RAMFS1_IMG = 16
RAMFS2_IMG = 17
ADSP_Q5_IMG = 18
APPS_KERNEL_IMG = 19
BACKUP_RAMFS_IMG = 20
SBL1_IMG = 21
SBL2_IMG = 22
RPM_IMG = 23
SBL3_IMG = 24
TZ_IMG = 25
PSI_IMG = 32
#----------------------------------------------------------------------------
# Global Image Type Table
# Format of the look-up table:
# KEY - IMAGE_TYPE string as passed into mbn_builder.py
# VALUE - [Specific ImageType ID enum, Template key string, MBN Type]
#----------------------------------------------------------------------------
image_id_table = {
'appsbl': [ImageType.APPSBL_IMG, 'APPSBL_IMG', 'bin'],
'dbl': [ImageType.DBL_IMG, 'DBL_IMG', 'bin'],
'osbl': [ImageType.OSBL_IMG, 'OSBL_IMG', 'bin'],
'amss': [ImageType.AMSS_IMG, 'AMSS_IMG', 'elf'],
'amss_mbn': [ImageType.HASH_IMG, 'HASH_IMG', 'elf'],
'apps': [ImageType.APPS_IMG, 'APPS_IMG', 'bin'],
'hostdl': [ImageType.HOSTDL_IMG, 'HOSTDL_IMG', 'bin'],
'ehostdl': [ImageType.EHOSTDL_IMG, 'EHOSTDL_IMG', 'bin'],
'emmcbld': [ImageType.EHOSTDL_IMG, 'EMMCBLD_IMG', 'bin'],
'qdsp6fw': [ImageType.DSP1_IMG, 'DSP1_IMG', 'elf'],
'qdsp6sw': [ImageType.DSP2_IMG, 'DSP2_IMG', 'elf'],
'qdsp5': [ImageType.ADSP_Q5_IMG, 'ADSP_Q5_IMG', 'bin'],
'tz': [ImageType.TZ_IMG, 'TZ_IMG', 'elf'],
'tz_rumi': [ImageType.TZ_IMG, 'TZ_IMG', 'elf'],
'tz_virtio': [ImageType.TZ_IMG, 'TZ_IMG', 'elf'],
'tzbsp_no_xpu': [ImageType.TZ_IMG, 'TZ_IMG', 'elf'],
'tzbsp_with_test': [ImageType.TZ_IMG, 'TZ_IMG', 'elf'],
'rpm': [ImageType.RPM_IMG, 'RPM_IMG', 'elf'],
'sbl1': [ImageType.SBL1_IMG, 'SBL1_IMG', 'bin'],
'sbl2': [ImageType.SBL2_IMG, 'SBL2_IMG', 'bin'],
'sbl3': [ImageType.SBL3_IMG, 'SBL3_IMG', 'bin'],
'efs1': [ImageType.RAMFS1_IMG, 'RAMFS1_IMG', 'bin'],
'efs2': [ImageType.RAMFS2_IMG, 'RAMFS2_IMG', 'bin'],
'pmic': [ImageType.PSI_IMG, 'PSI_IMG', 'elf'],
# DO NOT add any additional image information
}
#----------------------------------------------------------------------------
# Header Class Notes:
# In order to properly read and write the header structures as binary data,
# the Python Struct library is used to align and package up the header objects
# All Struct objects are initialized by a special string with the following
# notation. These structure objects are then used to decode binary data in order
# to fill out the appropriate class in Python, or they are used to package up
# the Python class so that we may write the binary data out.
#----------------------------------------------------------------------------
"""
Format | C Type | Python Type | Standard Size
-----------------------------------------------------
1) 'X's | char * | string | 'X' bytes
2) H | unsigned short | integer | 2 bytes
3) I | unsigned int | integer | 4 bytes
"""
#----------------------------------------------------------------------------
# ELF Header Class
#----------------------------------------------------------------------------
class Elf_Ehdr_common:
# Structure object to align and package the ELF Header
s = struct.Struct('16sHHI')
def __init__(self, data):
unpacked_data = (Elf_Ehdr_common.s).unpack(data)
self.unpacked_data = unpacked_data
self.e_ident = unpacked_data[0]
self.e_type = unpacked_data[1]
self.e_machine = unpacked_data[2]
self.e_version = unpacked_data[3]
def printValues(self):
print("ATTRIBUTE / VALUE")
for attr, value in self.__dict__.iteritems():
print(attr, value)
#----------------------------------------------------------------------------
# ELF Header Class
#----------------------------------------------------------------------------
class Elf32_Ehdr:
# Structure object to align and package the ELF Header
s = struct.Struct('16sHHIIIIIHHHHHH')
def __init__(self, data):
unpacked_data = (Elf32_Ehdr.s).unpack(data)
self.unpacked_data = unpacked_data
self.e_ident = unpacked_data[0]
self.e_type = unpacked_data[1]
self.e_machine = unpacked_data[2]
self.e_version = unpacked_data[3]
self.e_entry = unpacked_data[4]
self.e_phoff = unpacked_data[5]
self.e_shoff = unpacked_data[6]
self.e_flags = unpacked_data[7]
self.e_ehsize = unpacked_data[8]
self.e_phentsize = unpacked_data[9]
self.e_phnum = unpacked_data[10]
self.e_shentsize = unpacked_data[11]
self.e_shnum = unpacked_data[12]
self.e_shstrndx = unpacked_data[13]
def printValues(self):
print("ATTRIBUTE / VALUE")
for attr, value in self.__dict__.iteritems():
print(attr, value)
def getPackedData(self):
values = [self.e_ident,
self.e_type,
self.e_machine,
self.e_version,
self.e_entry,
self.e_phoff,
self.e_shoff,
self.e_flags,
self.e_ehsize,
self.e_phentsize,
self.e_phnum,
self.e_shentsize,
self.e_shnum,
self.e_shstrndx
]
return (Elf32_Ehdr.s).pack(*values)
#----------------------------------------------------------------------------
# ELF Program Header Class
#----------------------------------------------------------------------------
class Elf32_Phdr:
# Structure object to align and package the ELF Program Header
s = struct.Struct('I' * 8)
def __init__(self, data):
unpacked_data = (Elf32_Phdr.s).unpack(data)
self.unpacked_data = unpacked_data
self.p_type = unpacked_data[0]
self.p_offset = unpacked_data[1]
self.p_vaddr = unpacked_data[2]
self.p_paddr = unpacked_data[3]
self.p_filesz = unpacked_data[4]
self.p_memsz = unpacked_data[5]
self.p_flags = unpacked_data[6]
self.p_align = unpacked_data[7]
def printValues(self):
print("ATTRIBUTE / VALUE")
for attr, value in self.__dict__.iteritems():
print(attr, value)
def getPackedData(self):
values = [self.p_type,
self.p_offset,
self.p_vaddr,
self.p_paddr,
self.p_filesz,
self.p_memsz,
self.p_flags,
self.p_align
]
return (Elf32_Phdr.s).pack(*values)
#----------------------------------------------------------------------------
# ELF Header Class
#----------------------------------------------------------------------------
class Elf64_Ehdr:
# Structure object to align and package the ELF Header
s = struct.Struct('16sHHIQQQIHHHHHH')
def __init__(self, data):
unpacked_data = (Elf64_Ehdr.s).unpack(data)
self.unpacked_data = unpacked_data
self.e_ident = unpacked_data[0]
self.e_type = unpacked_data[1]
self.e_machine = unpacked_data[2]
self.e_version = unpacked_data[3]
self.e_entry = unpacked_data[4]
self.e_phoff = unpacked_data[5]
self.e_shoff = unpacked_data[6]
self.e_flags = unpacked_data[7]
self.e_ehsize = unpacked_data[8]
self.e_phentsize = unpacked_data[9]
self.e_phnum = unpacked_data[10]
self.e_shentsize = unpacked_data[11]
self.e_shnum = unpacked_data[12]
self.e_shstrndx = unpacked_data[13]
def printValues(self):
print("ATTRIBUTE / VALUE")
for attr, value in self.__dict__.iteritems():
print(attr, value)
def getPackedData(self):
values = [self.e_ident,
self.e_type,
self.e_machine,
self.e_version,
self.e_entry,
self.e_phoff,
self.e_shoff,
self.e_flags,
self.e_ehsize,
self.e_phentsize,
self.e_phnum,
self.e_shentsize,
self.e_shnum,
self.e_shstrndx
]
return (Elf64_Ehdr.s).pack(*values)
#----------------------------------------------------------------------------
# ELF Program Header Class
#----------------------------------------------------------------------------
class Elf64_Phdr:
# Structure object to align and package the ELF Program Header
s = struct.Struct('IIQQQQQQ')
def __init__(self, data):
unpacked_data = (Elf64_Phdr.s).unpack(data)
self.unpacked_data = unpacked_data
self.p_type = unpacked_data[0]
self.p_flags = unpacked_data[1]
self.p_offset = unpacked_data[2]
self.p_vaddr = unpacked_data[3]
self.p_paddr = unpacked_data[4]
self.p_filesz = unpacked_data[5]
self.p_memsz = unpacked_data[6]
self.p_align = unpacked_data[7]
def printValues(self):
print("ATTRIBUTE / VALUE")
for attr, value in self.__dict__.iteritems():
print(attr, value)
def getPackedData(self):
values = [self.p_type,
self.p_flags,
self.p_offset,
self.p_vaddr,
self.p_paddr,
self.p_filesz,
self.p_memsz,
self.p_align
]
return (Elf64_Phdr.s).pack(*values)
#----------------------------------------------------------------------------
# ELF Segment Information Class
#----------------------------------------------------------------------------
class SegmentInfo:
def __init__(self):
self.flag = 0
self.start_addr = 0
def printValues(self):
print('Flag: ' + str(self.flag))
print('Start Address: ' + str(hex(self.start_addr)))
#----------------------------------------------------------------------------
# Regular Boot Header Class
#----------------------------------------------------------------------------
class Boot_Hdr:
def __init__(self, init_val):
self.image_id = ImageType.NONE_IMG
self.flash_parti_ver = FLASH_PARTI_VERSION
self.image_src = init_val
self.image_dest_ptr = init_val
self.image_size = init_val
self.code_size = init_val
self.sig_ptr = init_val
self.sig_size = init_val
self.cert_chain_ptr = init_val
self.cert_chain_size = init_val
self.magic_number1 = init_val
self.version = init_val
self.OS_type = init_val
self.boot_apps_parti_entry = init_val
self.boot_apps_size_entry = init_val
self.boot_apps_ram_loc = init_val
self.reserved_ptr = init_val
self.reserved_1 = init_val
self.reserved_2 = init_val
self.reserved_3 = init_val
def getLength(self):
return BOOT_HEADER_LENGTH
def writePackedData(self, target, write_full_hdr):
values = [self.image_id,
self.flash_parti_ver,
self.image_src,
self.image_dest_ptr,
self.image_size,
self.code_size ,
self.sig_ptr,
self.sig_size,
self.cert_chain_ptr,
self.cert_chain_size,
self.magic_number1,
self.version,
self.OS_type,
self.boot_apps_parti_entry,
self.boot_apps_size_entry,
self.boot_apps_ram_loc,
self.reserved_ptr,
self.reserved_1,
self.reserved_2,
self.reserved_3 ]
# Write 10 entries(40B) or 20 entries(80B) of boot header
if write_full_hdr is False:
s = struct.Struct('I'* 10)
values = values[:10]
else:
s = struct.Struct('I' * self.getLength())
packed_data = s.pack(*values)
fp = OPEN(target,'wb')
fp.write(packed_data)
fp.close()
return s.size
#----------------------------------------------------------------------------
# V6 Regular Boot Header Class
#----------------------------------------------------------------------------
class Boot_Hdr_V6:
def __init__(self, init_val):
self.image_id = ImageType.NONE_IMG
self.flash_parti_ver = FLASH_PARTI_VERSION_V6
self.qti_sig_size = init_val
self.qti_cert_chain_size = init_val
self.image_size = init_val
self.code_size = init_val
self.sig_ptr = init_val
self.sig_size = init_val
self.cert_chain_ptr = init_val
self.cert_chain_size = init_val
self.oem_metadata_size = init_val
self.qti_metadata_size = init_val
self.magic_number1 = init_val
self.version = init_val
self.OS_type = init_val
self.boot_apps_parti_entry = init_val
self.boot_apps_size_entry = init_val
self.boot_apps_ram_loc = init_val
self.reserved_ptr = init_val
self.reserved_1 = init_val
self.reserved_2 = init_val
self.reserved_3 = init_val
def getLength(self):
return BOOT_HEADER_LENGTH
def writePackedData(self, target, write_full_hdr):
values = [self.image_id,
self.flash_parti_ver,
self.qti_sig_size,
self.qti_cert_chain_size,
self.image_size,
self.code_size ,
self.sig_ptr,
self.sig_size,
self.cert_chain_ptr,
self.cert_chain_size,
self.oem_metadata_size,
self.qti_metadata_size,
self.magic_number1,
self.version,
self.OS_type,
self.boot_apps_parti_entry,
self.boot_apps_size_entry,
self.boot_apps_ram_loc,
self.reserved_ptr,
self.reserved_1,
self.reserved_2,
self.reserved_3 ]
# Write 12 entries(48B) or 20 entries(80B) of boot header
if write_full_hdr is False:
s = struct.Struct('I'* 12)
values = values[:12]
else:
s = struct.Struct('I' * self.getLength())
packed_data = s.pack(*values)
fp = OPEN(target,'wb')
fp.write(packed_data)
fp.close()
return s.size
#----------------------------------------------------------------------------
# SBL Boot Header Class
#----------------------------------------------------------------------------
class Sbl_Hdr:
def __init__(self, init_val):
self.codeword = init_val
self.magic = init_val
self.image_id = init_val
self.reserved_1 = init_val
self.reserved_2 = init_val
self.image_src = init_val
self.image_dest_ptr = init_val
self.image_size = init_val
self.code_size = init_val
self.sig_ptr = init_val
self.sig_size = init_val
self.cert_chain_ptr = init_val
self.cert_chain_size = init_val
self.oem_root_cert_sel = init_val
self.oem_num_root_certs = init_val
self.booting_image_config = init_val
self.reserved_6 = init_val
self.reserved_7 = init_val
self.reserved_8 = init_val
self.reserved_9 = init_val
def getLength(self):
return SBL_HEADER_LENGTH
def writePackedData(self, target):
values = [self.codeword,
self.magic,
self.image_id,
self.reserved_1,
self.reserved_2,
self.image_src,
self.image_dest_ptr,
self.image_size,
self.code_size,
self.sig_ptr,
self.sig_size,
self.cert_chain_ptr,
self.cert_chain_size,
self.oem_root_cert_sel,
self.oem_num_root_certs,
self.booting_image_config,
self.reserved_6,
self.reserved_7,
self.reserved_8,
self.reserved_9 ]
s = struct.Struct('I' * self.getLength())
packed_data = s.pack(*values)
fp = OPEN(target,'wb')
fp.write(packed_data)
fp.close()
return s.size
#----------------------------------------------------------------------------
# CLASS DEFINITIONS END
#----------------------------------------------------------------------------
#------------------------------------------------------------------------------
# Hooks for Scons
#------------------------------------------------------------------------------
def exists(env):
return env.Detect('mbn_tools')
def generate(env):
#----------------------------------------------------------------------------
# Generate Global Dictionary
#----------------------------------------------------------------------------
generate_global_dict(env)
#----------------------------------------------------------------------------
# Assign Build Configurable Values
#----------------------------------------------------------------------------
init_build_vars(env)
#----------------------------------------------------------------------------
# Add Methods to Environment
#----------------------------------------------------------------------------
env.AddMethod(filter_dictionary, "FilterDictionary")
env.AddMethod(image_auth, "ImageAuth")
env.AddMethod(image_header, "ImageHeader")
env.AddMethod(pboot_gen_elf, "PBootGenElf")
env.AddMethod(pboot_add_hash, "PBootAddHash")
env.AddMethod(modify_elf_flags, "ModifyElfFlags")
env.AddMethod(generate_code_hash, "GenerateCodeHash")
env.AddMethod(insert_SBL1_magicCookie, "InsertSBLMagicCookie")
env.AddMethod(modify_relocatable_flags, "ModifyRelocatableFlags")
#----------------------------------------------------------------------------
# Load Encryption Tools and Methods if required
#----------------------------------------------------------------------------
if 'USES_ENCRYPT_MBN' in env:
# Add Encryption Tools to environment
env.Tool('pil_encrypt', toolpath = ['${BUILD_ROOT}/core/securemsm/ssd/tools/pil_encrypt'])
env.AddMethod(get_ssd_se_fname, "GetSSDSideEffectFileName")
env.AddMethod(encrypt_elf_segments, "EncryptElfSegments")
env.AddMethod(generate_meta_data, "GenerateMetaData")
env.AddMethod(encrypt_mbn, "EncryptMBN")
return None
#----------------------------------------------------------------------------
# BOOT TOOLS BEGIN
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# generate_meta_data
#----------------------------------------------------------------------------
def generate_meta_data(env, meta_out_file_name, add_magic_num = False):
'''
Make call to SSD API to return buffer filled with XML header information.
The XML header which we write contains information regarding the algorithms
being used along with specific key values which are to be used for encrpytion.
'''
xml_header = env.SSDGetMetaData(add_magic_num)
# Initialize
xml_target_file = open(meta_out_file_name,'wb')
xml_header_size = len(xml_header)
# Write XML buffer into target file
xml_target_file.write(xml_header)
# Pad if necessary to the maximum size
if xml_header_size <= XML_HEADER_MAXSIZE:
bytes_to_pad = XML_HEADER_MAXSIZE - xml_header_size
pad_file(xml_target_file, bytes_to_pad, PAD_BYTE_1)
xml_target_file.close()
else:
xml_target_file.close()
raise RuntimeError("XML Size too large: " + str(xml_header_size))
#----------------------------------------------------------------------------
# encrypt_mbn
#----------------------------------------------------------------------------
def encrypt_mbn(env, mbn_in_file_name, mbn_out_file_name):
# Open Files
mbn_in_fp = OPEN(mbn_in_file_name, "rb")
mbn_out_fp = OPEN(mbn_out_file_name, "wb+")
# encrypt the input file content and write to output file
mbn_file_size = os.path.getsize(mbn_in_file_name)
file_buff = mbn_in_fp.read(mbn_file_size)
encrypted_buf = env.SSDEncryptSegment(0, file_buff, mbn_file_size)
mbn_out_fp.write(encrypted_buf)
# Close Files
mbn_in_fp.close()
mbn_out_fp.close()
# Clean up encryption files
env.SSDDeInit()
#----------------------------------------------------------------------------
# get_ssd_se_fname
#----------------------------------------------------------------------------
def get_ssd_se_fname(env):
return env.SSDGetSideEffectFileName()
#----------------------------------------------------------------------------
# encrypt_elf_segments
#----------------------------------------------------------------------------
def encrypt_elf_segments(env, elf_in_file_name,
elf_out_file_name):
# Open Files
elf_in_fp = OPEN(elf_in_file_name, "rb")
elf_out_fp = OPEN(elf_out_file_name, "wb+")
# Initialize
[elf_header, phdr_table] = preprocess_elf_file(elf_in_file_name)
encrypted_seg_counter = 0
# Copy input file to output file
shutil.copyfileobj(elf_in_fp, elf_out_fp, os.path.getsize(elf_in_file_name))
# Begin ELF segment encryption
for i in range(elf_header.e_phnum):
curr_phdr = phdr_table[i]
# Only encrypt segments of LOAD_TYPE. Do not encrypt the hash segment.
if curr_phdr.p_type == LOAD_TYPE and \
MI_PBT_SEGMENT_TYPE_VALUE(curr_phdr.p_flags) != MI_PBT_HASH_SEGMENT:
# Read full segment into buffer
elf_in_fp.seek(curr_phdr.p_offset)
data_len = curr_phdr.p_filesz
file_buff = elf_in_fp.read(data_len)
# Call encryption routine on buffer
encrypted_buf = env.SSDEncryptSegment(encrypted_seg_counter, file_buff, data_len)
encrypted_seg_counter += 1
# Write encrypted segment into output file in same location
elf_out_fp.seek(curr_phdr.p_offset)
elf_out_fp.write(encrypted_buf)
# Close Files
elf_in_fp.close()
elf_out_fp.close()
# Clean up encryption files
env.SSDDeInit()
#----------------------------------------------------------------------------
# image_header
#----------------------------------------------------------------------------
def image_header(env, gen_dict,
code_file_name,
output_file_name,
secure_type,
header_format = 'reg',
requires_preamble = False,
preamble_file_name = None,
elf_file_name = None,
write_full_hdr = False,
in_code_size = None,
cert_chain_size_in = CERT_CHAIN_ONEROOT_MAXSIZE,
num_of_pages = None,
mbn_version = None):
# Preliminary checks
if (requires_preamble is True) and (preamble_file_name is None):
raise RuntimeError("Image Header requires a preamble file")
if (gen_dict['IMAGE_KEY_MBN_TYPE'] == 'elf') and (elf_file_name is None):
raise RuntimeError("ELF Image Headers require an elf file")
if (in_code_size is None) and (os.path.exists(code_file_name) is False):
raise RuntimeError("Code size unavailable, and input file does not exist")
# Initialize
if in_code_size is not None:
code_size = in_code_size
else:
code_size = os.path.getsize(code_file_name)
image_dest = 0
image_source = 0
# If secure build, set signature and cert chain sizes
if secure_type == 'secure':
signature_size = SHA256_SIGNATURE_SIZE
cert_chain_size = cert_chain_size_in
image_size = code_size + cert_chain_size + signature_size
if (image_size % 4) != 0:
image_size += (4 - (image_size % 4))
else:
signature_size = 0
cert_chain_size = 0
image_size = code_size
# For ELF or hashed images, image destination will be determined from an ELF input file
if gen_dict['IMAGE_KEY_MBN_TYPE'] == 'elf':
image_dest = get_hash_address(elf_file_name) + MI_BOOT_IMG_HDR_SIZE
elif gen_dict['IMAGE_KEY_MBN_TYPE'] == 'bin':
image_dest = gen_dict['IMAGE_KEY_IMAGE_DEST']
image_source = gen_dict['IMAGE_KEY_IMAGE_SOURCE']
# Build the header based on format specified
if header_format == 'sbl':
boot_sbl_header = Sbl_Hdr(init_val = int('0xFFFFFFFF',16))
boot_sbl_header.codeword = FLASH_CODE_WORD
boot_sbl_header.magic = MAGIC_NUM
boot_sbl_header.image_id = gen_dict['IMAGE_KEY_IMAGE_ID']
boot_sbl_header.image_src = MI_BOOT_SBL_HDR_SIZE
boot_sbl_header.image_dest_ptr = image_dest
boot_sbl_header.image_size = image_size
boot_sbl_header.code_size = code_size
boot_sbl_header.sig_ptr = image_dest + code_size
boot_sbl_header.sig_size = signature_size
boot_sbl_header.cert_chain_ptr = image_dest + code_size + signature_size
boot_sbl_header.cert_chain_size = cert_chain_size
boot_sbl_header.oem_root_cert_sel = gen_dict['IMAGE_KEY_OEM_ROOT_CERT_SEL']
boot_sbl_header.oem_num_root_certs = gen_dict['IMAGE_KEY_OEM_NUM_ROOT_CERTS']
if 'USES_SBL_FOR_AARCH64' in env:
boot_sbl_header.booting_image_config = SBL_AARCH64
elif 'USES_SBL_FOR_AARCH632' in env:
boot_sbl_header.booting_image_config = SBL_AARCH32
# If preamble is required, output the preamble file and update the boot_sbl_header
if requires_preamble is True:
boot_sbl_header = image_preamble(gen_dict, preamble_file_name, boot_sbl_header, num_of_pages)
# Package up the header and write to output file
boot_sbl_header.writePackedData(target = output_file_name)
elif header_format == 'reg' and mbn_version != 6:
boot_header = Boot_Hdr(init_val = int('0x0',16))
boot_header.image_id = gen_dict['IMAGE_KEY_IMAGE_ID']
boot_header.image_src = image_source
boot_header.image_dest_ptr = image_dest
boot_header.image_size = image_size
boot_header.code_size = code_size
boot_header.sig_ptr = image_dest + code_size
boot_header.sig_size = signature_size
boot_header.cert_chain_ptr = image_dest + code_size + signature_size
boot_header.cert_chain_size = cert_chain_size
# Package up the header and write to output file
boot_header.writePackedData(target = output_file_name, write_full_hdr = write_full_hdr)
elif header_format == 'reg' and mbn_version == 6:
boot_header = Boot_Hdr_V6(init_val = int('0x0',16))
boot_header.image_id = gen_dict['IMAGE_KEY_IMAGE_ID']
boot_header.qti_sig_size = 0
boot_header.qti_cert_chain_size = 0
boot_header.image_size = image_size
boot_header.code_size = code_size
boot_header.sig_ptr = 0
boot_header.sig_size = signature_size
boot_header.cert_chain_ptr = 0
boot_header.cert_chain_size = cert_chain_size
boot_header.oem_metadata_size = 0
boot_header.qti_metadata_size = 0
# Package up the header and write to output file
boot_header.writePackedData(target = output_file_name, write_full_hdr = write_full_hdr)
else:
raise RuntimeError("Header format not supported: " + str(header_format))
return 0
#----------------------------------------------------------------------------
# pboot_gen_elf
#----------------------------------------------------------------------------
def pboot_gen_elf(env, elf_in_file_name,
hash_out_file_name,
compress_method,
elf_out_file_name,
secure_type = 'non_secure',
hash_seg_max_size = None,
last_phys_addr = None,
append_xml_hdr = False,
cert_chain_size_in = CERT_CHAIN_ONEROOT_MAXSIZE,
mbn_version = None):
global MI_PROG_BOOT_DIGEST_SIZE
iarrPhdrFileLen = []
iarrPhdrFileOff = []
if mbn_version == 6:
sha_algo = 'sha384'
MI_PROG_BOOT_DIGEST_SIZE = 48
elif mbn_version == 3:
sha_algo = 'sha256'
MI_PROG_BOOT_DIGEST_SIZE = 32
else:
sha_algo = 'sha1'
MI_PROG_BOOT_DIGEST_SIZE = 20
# Open Files
elf_in_fp = OPEN(elf_in_file_name, "rb")
hash_out_fp = OPEN(hash_out_file_name, "wb+")
if elf_out_file_name is not None:
elf_out_fp = OPEN(elf_out_file_name, "wb+")
# Initialize
[elf_header, phdr_table] = preprocess_elf_file(elf_in_file_name)
num_phdrs = elf_header.e_phnum
phdr_total_size = num_phdrs * elf_header.e_phentsize
phdr_size = elf_header.e_phentsize
hashtable_size = 0
hashtable_shift = 0
if compress_method == "com":
is_com = True
else:
is_com = False
if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
new_phdr = Elf64_Phdr(b'\0' * ELF64_PHDR_SIZE)
elf_header_size = ELF64_HDR_SIZE
is_elf64 = True
else:
new_phdr = Elf32_Phdr(b'\0' * ELF32_PHDR_SIZE)
elf_header_size = ELF32_HDR_SIZE
is_elf64 = False
hash = b'\0' * MI_PROG_BOOT_DIGEST_SIZE
phdr_start = 0
bytes_to_pad = 0
hash_seg_end = 0
# Process program headers if an output elf is specified
if elf_out_file_name is not None:
# Assert limit on number of program headers in input ELF
if num_phdrs > MAX_PHDR_COUNT:
raise RuntimeError("Input ELF has exceeded maximum number of program headers")
# Create new program header for the ELF Header + Program Headers
new_phdr.p_type = NULL_TYPE
new_phdr.p_flags = MI_PBT_ELF_PHDR_SEGMENT
# If hash table program header is not found, make sure to include it
elf_header.e_phnum += 2
# Create an empty hash entry for PHDR_TYPE
hash_out_fp.write(b'\0' * MI_PROG_BOOT_DIGEST_SIZE)
hashtable_size += MI_PROG_BOOT_DIGEST_SIZE
# Create an empty hash entry for the hash segment itself
hash_out_fp.write(b'\0' * MI_PROG_BOOT_DIGEST_SIZE)
hashtable_size += MI_PROG_BOOT_DIGEST_SIZE
# Begin hash table generation
for i in range(num_phdrs):
curr_phdr = phdr_table[i]
if (MI_PBT_PAGE_MODE_VALUE(curr_phdr.p_flags) == MI_PBT_PAGED_SEGMENT):
seg_offset = curr_phdr.p_offset
seg_size = curr_phdr.p_filesz
hash_size = 0
# Check if the vaddr is page aligned
off = curr_phdr.p_vaddr & (ELF_BLOCK_ALIGN - 1)
if int(off) != 0:
seg_size -= (ELF_BLOCK_ALIGN - off)
seg_offset += (ELF_BLOCK_ALIGN - off)
# Seg_size should be page aligned
if (seg_size & (ELF_BLOCK_ALIGN - 1)) > 0:
raise RuntimeError("seg_size: " + hex(seg_size) + " is not ELF page aligned!")
off = seg_offset + seg_size
while seg_offset < off:
if seg_offset < ELF_BLOCK_ALIGN:
hash_size = seg_offset
else:
hash_size = ELF_BLOCK_ALIGN
elf_in_fp.seek(seg_offset)
fbuf = elf_in_fp.read(hash_size)
if MI_PBT_CHECK_FLAG_TYPE(curr_phdr.p_flags) is True:
hash = generate_hash(fbuf, sha_algo)
else:
hash = b'\0' * MI_PROG_BOOT_DIGEST_SIZE
# Write hash to file
hash_out_fp.write(hash)
hashtable_size += MI_PROG_BOOT_DIGEST_SIZE
seg_offset += ELF_BLOCK_ALIGN
# Copy the hash entry for all that are PAGED segments and those that are not the PHDR type. This is for
# backward tool compatibility where some images are generated using older exe tools.
elif((MI_PBT_PAGE_MODE_VALUE(curr_phdr.p_flags) == MI_PBT_NON_PAGED_SEGMENT) and (curr_phdr.p_type is not PHDR_TYPE)):
# Read full hash entry into buffer
elf_in_fp.seek(curr_phdr.p_offset)
data_len = curr_phdr.p_filesz
file_buff = elf_in_fp.read(data_len)
if ((is_com == True) and ((curr_phdr.p_type is LOAD_TYPE) or (curr_phdr.p_type == PHDR_ENTR_TYPE))):
com_data_len = 0
if(data_len > 0):
srcfile = "comfile" + str(i)
Comfile = "comfile" + str(i) + ".gz"
src_in_fp = OPEN(srcfile,"wb+")
src_in_fp.write(file_buff)
src_in_fp.close()
prc = subprocess.Popen([
outputdir,
'-n',
'-k',
'-S.gz',
'-f',
'-6',
str(srcfile),
])
prc.wait()
if prc.returncode != 0:
print('ERROR: unable to create compressed file Segment for' + str(Comfile))
else:
com_out_fp = OPEN(Comfile, "rb")
com_out_fp.seek(0,2)
com_data_len = com_out_fp.tell()
iarrPhdrFileLen.append(com_data_len)
com_out_fp.close()
src_in_fp = OPEN(srcfile,"rb")
src_in_fp.seek(0,2)
data_len = src_in_fp.tell()
src_in_fp.seek(0,0)
file_buff = src_in_fp.read(data_len)
src_in_fp.close()
else:
iarrPhdrFileLen.append(curr_phdr.p_filesz)
elif (is_com == True):
iarrPhdrFileLen.append(curr_phdr.p_filesz)
if (MI_PBT_CHECK_FLAG_TYPE(curr_phdr.p_flags) is True) and (data_len > 0):
hash = generate_hash(file_buff, sha_algo)
else:
hash = b'\0' * MI_PROG_BOOT_DIGEST_SIZE
# Write hash to file
hash_out_fp.write(hash)
hashtable_size += MI_PROG_BOOT_DIGEST_SIZE
# End hash table generation
# Generate the rest of the ELF output file if specified
if elf_out_file_name is not None:
# Preempt hash table size if necessary
if secure_type == 'secure':
hashtable_size += (SHA256_SIGNATURE_SIZE + cert_chain_size_in)
if append_xml_hdr is True:
hashtable_size += XML_HEADER_MAXSIZE
# Initialize the hash table program header
if mbn_version == 6:
[hash_Phdr, pad_hash_segment, hash_tbl_end_addr, hash_tbl_offset] = \
initialize_hash_phdr(elf_in_file_name, hashtable_size, MI_BOOT_IMG_HDR_SIZE_V6, ELF_BLOCK_ALIGN, is_elf64)
else:
[hash_Phdr, pad_hash_segment, hash_tbl_end_addr, hash_tbl_offset] = \
initialize_hash_phdr(elf_in_file_name, hashtable_size, MI_BOOT_IMG_HDR_SIZE, ELF_BLOCK_ALIGN, is_elf64)
# Check if hash segment max size parameter was passed
if (hash_seg_max_size is not None):
# Error checking for hash segment size validity
if hashtable_size > hash_seg_max_size:
raise RuntimeError("Hash table exceeds maximum hash segment size: " + hex(hash_seg_max_size))
if (hash_seg_max_size & (ELF_BLOCK_ALIGN-1)) != 0:
raise RuntimeError("Hash segment size passed is not ELF Block Aligned: " + hex(hash_seg_max_size))
# Check if hash physical address parameter was passed
if last_phys_addr is not None:
hash_Phdr.p_vaddr = last_phys_addr
hash_Phdr.p_paddr = last_phys_addr
# Check if hash segment max size was passed
if hash_seg_max_size is not None:
hash_Phdr.p_memsz = hash_seg_max_size
# Determine the end of the hash segment, make sure it's block aligned
bytes_to_pad = ELF_BLOCK_ALIGN - pad_hash_segment
hash_seg_end = hash_tbl_end_addr + bytes_to_pad
# Check if a shifting is required to accomodate for the hash segment.
# Get the minimum offset by going through the program headers.
# Note that the program headers in the input file do not contain
# the dummy program header for ELF + Program header, and the
# program header for the hashtable.
min_offset = phdr_table[0].p_offset
for i in range(num_phdrs):
curr_phdr = phdr_table[i]
if curr_phdr.p_offset < min_offset:
min_offset = curr_phdr.p_offset
if min_offset < hash_seg_end:
hashtable_shift = hash_seg_end - min_offset
# Move program headers to after ELF header
phdr_start = elf_header_size
# We copy over no section headers so assign these values to 0 in ELF Header
elf_header.e_shnum = 0
elf_header.e_shstrndx = 0
elf_header.e_shoff = 0
iprevoff = hashtable_shift
# Output remaining ELF segments
for i in range(num_phdrs):
# Increment the file offset before writing to the destination file
curr_phdr = phdr_table[i]
# We do not copy over program headers of PHDR type, decrement the program
# header count and continue the loop
if curr_phdr.p_type is PHDR_TYPE:
elf_header.e_phnum -= 1
continue
src_offset = curr_phdr.p_offset
if (is_com == True) :
Comfile = "comfile" + str(i) + ".gz"
if i > 0 :
Prev_phdr = phdr_table[i-1]
pAlign = curr_phdr.p_align
Com_Filsize = iarrPhdrFileLen[i-1]
else:
pAlign = curr_phdr.p_align
Com_Filsize =0
iprevoff = iprevoff + curr_phdr.p_offset
if(pAlign == 0):
pAlign = 1
NextSeg_offset = iprevoff + Com_Filsize
NextSeg_Modoffset = NextSeg_offset & (pAlign -1)
if(NextSeg_Modoffset) > 0 :
NextSeg_offset = NextSeg_offset + (pAlign - NextSeg_Modoffset)
iprevoff = NextSeg_offset
iarrPhdrFileOff.append(iprevoff)
# Copy the ELF segment
#file_copy_offset(elf_in_fp, src_offset, elf_out_fp, curr_phdr.p_offset + hashtable_shift, curr_phdr.p_filesz)
if(((curr_phdr.p_type is LOAD_TYPE) or (curr_phdr.p_type == PHDR_ENTR_TYPE)) and (curr_phdr.p_filesz > 0)) :
com_out_fp = OPEN(Comfile, "rb")
file_copy_offset(com_out_fp,0, elf_out_fp, iarrPhdrFileOff[i], iarrPhdrFileLen[i])
com_out_fp.close()
elif (curr_phdr.p_filesz > 0):
file_copy_offset(elf_in_fp,src_offset,elf_out_fp,iarrPhdrFileOff[i],iarrPhdrFileLen[i])
if(is_com == False) and (curr_phdr.p_filesz > 0):
file_copy_offset(elf_in_fp, src_offset, elf_out_fp, curr_phdr.p_offset + hashtable_shift, curr_phdr.p_filesz)
# Output remaining program headers and ELF segments
elf_header.e_phoff = phdr_start
# Output new program headers which we have generated
elf_out_fp.seek(phdr_start)
new_phdr.p_filesz = elf_header_size + (elf_header.e_phnum * phdr_size)
elf_out_fp.write(new_phdr.getPackedData())
elf_out_fp.write(hash_Phdr.getPackedData())
phdr_start += (2 * phdr_size)
# Increment the file offset before writing to the destination file
for i in range(num_phdrs):
curr_phdr = phdr_table[i]
if curr_phdr.p_type is PHDR_TYPE:
continue
if ((is_com == True) and ((curr_phdr.p_type is LOAD_TYPE) or (curr_phdr.p_type == PHDR_ENTR_TYPE))):
curr_phdr.p_type = curr_phdr.p_type | 0x68000000
if (is_com == True):
curr_phdr.p_offset = iarrPhdrFileOff[i]
curr_phdr.p_filesz = iarrPhdrFileLen[i]
else:
curr_phdr.p_offset += hashtable_shift
# Copy the program header
elf_out_fp.seek(phdr_start)
elf_out_fp.write(curr_phdr.getPackedData())
# Update phdr_start
phdr_start += phdr_size
# Finally, copy the new ELF header to the destination file
elf_out_fp.seek(0)
elf_out_fp.write(elf_header.getPackedData())
# Recalculate hash of ELF + program headers and output to hash output file
elf_out_fp.seek(0)
# Read the elf header
elfhdr_buff = elf_out_fp.read(elf_header_size)
# Seek to the program header offset listed in elf header.
elf_out_fp.seek(elf_header.e_phoff)
# Read the program header and compute hash
proghdr_buff = elf_out_fp.read(elf_header.e_phnum * phdr_size)
hash = generate_hash(elfhdr_buff + proghdr_buff, sha_algo)
# Write hash to file as first hash table entry
hash_out_fp.seek(0)
hash_out_fp.write(hash)
# Close files
elf_in_fp.close()
hash_out_fp.close()
if elf_out_file_name is not None:
elf_out_fp.close()
return 0
#----------------------------------------------------------------------------
# pboot_add_hash
#----------------------------------------------------------------------------
def pboot_add_hash(env, elf_in_file_name,
hash_tbl_file_name,
elf_out_file_name):
# Open files
elf_in_fp = OPEN(elf_in_file_name, "rb")
hash_tbl_fp = OPEN(hash_tbl_file_name, "rb")
elf_out_fp = OPEN(elf_out_file_name, "wb+")
# Initialize
[elf_header, phdr_table] = preprocess_elf_file(elf_in_file_name)
hash_size = os.path.getsize(hash_tbl_file_name)
hash_segment_found = False
# Attempt to find the location of the hash program header
for i in range(elf_header.e_phnum):
curr_phdr = phdr_table[i]
if curr_phdr.p_flags == MI_PBT_ELF_HASH_SEGMENT:
hash_segment_found = True
break
if hash_segment_found is True:
# Copy input file to output file
shutil.copyfileobj(elf_in_fp, elf_out_fp, os.path.getsize(elf_in_file_name))
# Update ELF to insert hash table at corresponding file offset
hash_hdr_offset = curr_phdr.p_offset
file_copy_offset(hash_tbl_fp, 0, elf_out_fp, hash_hdr_offset, hash_size)
else:
raise RuntimeError("Hash segment program header not found in file " + elf_in_file_name)
# Close files
elf_in_fp.close()
hash_tbl_fp.close()
elf_out_fp.close()
return 0
#----------------------------------------------------------------------------
# image_auth
#----------------------------------------------------------------------------
def image_auth(env, *args):
if len(args) < 7 or len(args) > 8:
raise RuntimeError("Usage Invalid")
# Initialize File Names
binary_in = args[0]
signature = args[1]
attestation_cert = args[2]
attestation_ca_cert = args[3]
root_cert = args[4]
cert_chain_out = args[5]
signed_image_out = args[6]
if len(args) == 8:
cert_size_max_in = args[7]
else:
cert_size_max_in = CERT_CHAIN_ONEROOT_MAXSIZE
# Creating list of certificates to support creation of certificate chains
# of lenth 1, 2, or 3 certificates
cert_list = []
num_certs = 0
if (os.path.exists(attestation_cert)):
cert_list.append(attestation_cert)
num_certs = num_certs + 1
if (os.path.exists(attestation_ca_cert)):
cert_list.append(attestation_ca_cert)
num_certs = num_certs + 1
if (os.path.exists(root_cert)):
cert_list.append(root_cert)
num_certs = num_certs + 1
if (num_certs == 0):
raise RuntimeError("Missing file(s) required for signing.\n")
# Create the Certificate Chain
concat_files (cert_chain_out, cert_list)
# Pad to ensure Certificate Chain Size is CERT_CHAIN_MAX_SIZE
cert_size = os.path.getsize(cert_chain_out)
if cert_size <= cert_size_max_in:
bytes_to_pad = cert_size_max_in - cert_size
cert_fp = OPEN(cert_chain_out,'ab')
pad_file(cert_fp, bytes_to_pad, PAD_BYTE_1)
cert_fp.close()
else:
raise RuntimeError("Certificate Size too large: " + str(cert_size))
# Create the Final Signed Image File
concat_files (signed_image_out, [binary_in, signature, cert_chain_out])
return 0
#----------------------------------------------------------------------------
# modify_relocatable_flags
#----------------------------------------------------------------------------
def modify_relocatable_flags(env, output_elf ):
# Offset into program header where the p_flags field is stored
phdr_align_flag_offset = 28
phdr_reloc_flag_offset = 24
# Initialize
[elf_header, phdr_table] = preprocess_elf_file(output_elf)
if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
curr_phdr = Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
elf_header_size = ELF64_HDR_SIZE
is_elf64 = True
else:
curr_phdr = Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
elf_header_size = ELF32_HDR_SIZE
is_elf64 = False
# Open files
elf_in_fp = OPEN(output_elf, "r+")
# Go to the start of the p_flag entry in the first program header
file_offset_align_flag = elf_header.e_phoff + phdr_align_flag_offset
# Change the align field in the program header in the ELF file
elf_in_fp.seek(file_offset_align_flag)
curr_phdr = phdr_table[0]
#default alignment value is 1MB unless otherwise specified
if 'USES_RELOC_ALIGN_VALUE_4MB' in env:
alignment_value = ALIGNVALUE_4MB
else:
alignment_value = ALIGNVALUE_1MB
#create new alignment value
new_align = (curr_phdr.p_align & 0) | alignment_value
# Create structure to package new flag field
s = struct.Struct('I')
new_flag_bytes = s.pack(new_align)
# Write the new flag value and incr ement offset
elf_in_fp.write(new_flag_bytes)
# Go to the start of the p_flag entry in the first program header
file_offset_reloc_flag = elf_header.e_phoff + phdr_reloc_flag_offset
# Change each program header flag in the ELF file with relocatable flag
for i in range(elf_header.e_phnum):
# Seek to correct location and create new p_flag value
elf_in_fp.seek(file_offset_reloc_flag)
curr_phdr = phdr_table[i]
new_flag = (curr_phdr.p_flags & ~MI_PBT_FLAGS_MASK) | (MI_PBT_ELF_AMSS_RELOCATABLE_IMAGE)
# Create structure to package new flag field
s = struct.Struct('I')
new_flag_bytes = s.pack(new_flag)
# Write the new flag value and increment offset
elf_in_fp.write(new_flag_bytes)
file_offset_reloc_flag += elf_header.e_phentsize
# Close files
elf_in_fp.close()
return 0
#----------------------------------------------------------------------------
# modify_elf_flags
#----------------------------------------------------------------------------
def modify_elf_flags(env, elf_in_file_name,
scl_file_name):
# Initialize
[elf_header, phdr_table] = preprocess_elf_file(elf_in_file_name)
segment_list = readSCL(scl_file_name, env['GLOBAL_DICT'])
if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
curr_phdr = Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
# Offset into program header where the p_flags field is stored
phdr_flag_off = 4
else:
curr_phdr = Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
# Offset into program header where the p_flags field is stored
phdr_flag_off = 24
# Open files
elf_in_fp = OPEN(elf_in_file_name, "r+")
# Check for corresponding number of segments
if len(segment_list) is not elf_header.e_phnum:
raise RuntimeError('SCL file and ELF file have different number of segments!')
# Go to the start of the p_flag entry in the first program header
file_offset = elf_header.e_phoff + phdr_flag_off
# Change each program header flag in the ELF file based off the SCL file
for i in range(elf_header.e_phnum):
# Seek to correct location and create new p_flag value
elf_in_fp.seek(file_offset)
curr_phdr = phdr_table[i]
new_flag = (curr_phdr.p_flags & ~MI_PBT_FLAGS_MASK) | (segment_list[i].flag)
# Create structure to package new flag field
s = struct.Struct('I')
new_flag_bytes = s.pack(new_flag)
# Write the new flag value and increment offset
elf_in_fp.write(new_flag_bytes)
file_offset += elf_header.e_phentsize
# Close files
elf_in_fp.close()
return 0
#----------------------------------------------------------------------------
# generate_code_hash
#----------------------------------------------------------------------------
def generate_code_hash(env, elf_in_file_name):
# Initialize
[elf_header, phdr_table] = preprocess_elf_file(elf_in_file_name)
if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
curr_phdr = Elf64_Phdr('\0' * ELF64_PHDR_SIZE)
# Offset into program header where the p_flags field is stored
phdr_flag_off = 4
else:
curr_phdr = Elf32_Phdr('\0' * ELF32_PHDR_SIZE)
# Offset into program header where the p_flags field is stored
phdr_flag_off = 24
# Open files
elf_in_fp = OPEN(elf_in_file_name, "rb+")
# Go to the start of the p_flag entry in the first program header
file_offset = elf_header.e_phoff + phdr_flag_off
# XXX Get these from env?
DP_CODE_ALIGN = 0x100
DP_PAGE_SIZE = 4096
DP_HASH_SIZE = 32 # SHA-256
DP_HASH_MAGIC = 0xC0DEDEC0
PH_PERM_RW = 0x06
PH_PERM_RX = 0x05
PH_PERM_RO = 0x04
PH_PERM_MASK = 0x07
page_size = DP_PAGE_SIZE
hash_size = DP_HASH_SIZE
# First identify the hash segment. It is the first RW section.
# Its Align should be 8, and its size a multiple of DP_HASH_SIZE;
hash_seg_idx = -1
for i in range(elf_header.e_phnum):
curr_phdr = phdr_table[i]
if (curr_phdr.p_align == 8 and
(curr_phdr.p_flags & PH_PERM_MASK) == PH_PERM_RW and
curr_phdr.p_filesz != 0 and (curr_phdr.p_filesz % DP_HASH_SIZE) == 0):
hash_seg_idx = i
# Validate the contents of the hash segment. It should be
# filled with DP_HASH_MAGIC
elf_in_fp.seek(curr_phdr.p_offset)
hash_data = "";
while (len(hash_data) < curr_phdr.p_filesz):
hash_data = hash_data + elf_in_fp.read(curr_phdr.p_filesz - len(hash_data))
hash_data = struct.unpack("I" * (curr_phdr.p_filesz / 4), hash_data)
for v in hash_data[:]:
if (v != DP_HASH_MAGIC):
hash_seg_idx = -1
break;
if (hash_seg_idx != -1):
break
if (hash_seg_idx == -1):
# return if there is no hash segment.
return 0
hash_phdr = phdr_table[hash_seg_idx]
# Now find the code segment for the hashes. Look for matching number of pages
code_seg_idx = -1
code_seg_pages = hash_phdr.p_filesz / DP_HASH_SIZE
for i in range(elf_header.e_phnum):
curr_phdr = phdr_table[i]
curr_pages = (curr_phdr.p_filesz + DP_PAGE_SIZE - 1) / DP_PAGE_SIZE
if (curr_phdr.p_align == DP_CODE_ALIGN and
(curr_phdr.p_flags & PH_PERM_MASK) == PH_PERM_RX and
curr_pages == code_seg_pages):
if (code_seg_idx != -1):
raise RuntimeError('Multiple code segments match for: ' + code_seg_pages + ' pages')
code_seg_idx = i
if (code_seg_idx == -1):
raise RuntimeError('No matching code segment found')
code_phdr = phdr_table[code_seg_idx]
# Now hash the pages in the code segment
hashes = []
elf_in_fp.seek(code_phdr.p_offset)
bytes_left = code_phdr.p_filesz;
while (bytes_left > 0):
bytes_in_page = min(bytes_left, DP_PAGE_SIZE)
page = "";
while (len(page) < bytes_in_page):
page = page + elf_in_fp.read(bytes_in_page - len(page))
if (len(page) < DP_PAGE_SIZE):
page = page + (struct.pack('b', 0) * (DP_PAGE_SIZE - len(page)))
hashes = hashes + [generate_hash(page, 'sha256')]
bytes_left -= bytes_in_page
# And write them to the hash segment
elf_in_fp.seek(hash_phdr.p_offset)
for h in hashes[:]:
elf_in_fp.write(h)
# Close files
elf_in_fp.close()
return 0
#----------------------------------------------------------------------------
# BOOT TOOLS END
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# HELPER FUNCTIONS BEGIN
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
# Create a list to hold all segment information from an input SCL file
#----------------------------------------------------------------------------
def readSCL(filename, global_dict):
scl_fp = OPEN(filename,'r')
# Initialize
file_data = scl_fp.readlines()
num_lines = len(file_data)
current_line = ''
previous_line = ''
strip_chars = '(){}[]'
i = 0
bracket_counter = 0
seg_list = []
# Parse through all lines
while i < num_lines:
# Save the last line read
previous_line = current_line
current_line = file_data[i]
# Look for the symbol '{' for the line to read.
# Use bracket counter to skip nested '{ }'
if ('{' in current_line):
if bracket_counter == 0:
# Create a new SegmentInfo class and set up tokens
new_scl_entry = SegmentInfo()
previous_line = previous_line.strip()
tokens = previous_line.split(' ')
# Check that at least two tokens were parsed
# Token 1: Segment Name
# Token 2: Start Address
if len(tokens) < 2:
raise RuntimeError('SCL Segment Syntax malformed: ' + previous_line)
# Get the segment flags corresponding to the segment name description
new_scl_entry.flag = getSegmentFlag(tokens[0].strip(strip_chars))
# Get the start address of the segment based off the SCL string
start_addr = tokens[1].strip(strip_chars)
try:
start_addr_final = eval(start_addr)
# Catch NameError and attempt to locate start address from dictionary
except NameError:
if start_addr in global_dict:
return global_dict[start_addr]
else:
raise RuntimeError('Unrecognized start address: ' + start_addr)
new_scl_entry.start_addr = start_addr_final
seg_list.append(new_scl_entry)
bracket_counter += 1
elif '}' in current_line:
bracket_counter -= 1
i+=1
scl_fp.close()
return seg_list
#----------------------------------------------------------------------------
# Given a string parsed from a SCL file, returns the ELF segment flags
#----------------------------------------------------------------------------
def getSegmentFlag(seg_info):
ret_val = None
# Define string values for various types of segments
RO = "RO"
RW = "RW"
ZI = "ZI"
PAGEABLE = "PAGED"
NOTPAGEABLE = "NOTPAGED"
SWAPABLE = "SWAPPED"
SWAP_POOL = "SWAP_POOL"
RESERVED = "RESERVED"
HASHTBL = "HASH"
SHARED = "SHARED"
NOTUSED = "NOTUSED"
BOOT_SEGMENT = "BOOT_SEGMENT"
CODE = "CODE"
L4BSP = "L4BSP"
POOL_INDEX_0 = "INDEX_0"
POOL_INDEX_1 = "INDEX_1"
if seg_info is None or len(seg_info) == 0:
raise RuntimeError('Invalid segment information passed: ' + seg_info)
# Conditional checks and assignments of the corresponding segment flag values
if NOTPAGEABLE in seg_info:
if RO in seg_info:
ret_val = MI_PBT_ELF_AMSS_NON_PAGED_RO_SEGMENT
elif CODE in seg_info:
ret_val = MI_PBT_ELF_AMSS_NON_PAGED_RO_SEGMENT
elif ZI in seg_info:
if SWAP_POOL in seg_info:
if POOL_INDEX_0 in seg_info:
ret_val = MI_PBT_ELF_SWAP_POOL_NON_PAGED_ZI_SEGMENT_INDEX0
else:
ret_val = MI_PBT_ELF_SWAP_POOL_NON_PAGED_ZI_SEGMENT_INDEX1
else:
ret_val = MI_PBT_ELF_AMSS_NON_PAGED_ZI_SEGMENT
elif NOTUSED in seg_info:
ret_val = MI_PBT_ELF_AMSS_NON_PAGED_NOTUSED_SEGMENT
elif SHARED in seg_info:
ret_val = MI_PBT_ELF_AMSS_NON_PAGED_SHARED_SEGMENT
elif HASHTBL in seg_info:
ret_val = MI_PBT_ELF_HASH_SEGMENT
elif BOOT_SEGMENT in seg_info:
ret_val = MI_PBT_ELF_BOOT_SEGMENT
elif L4BSP in seg_info:
ret_val = MI_PBT_ELF_NON_PAGED_L4BSP_SEGMENT
else:
ret_val = MI_PBT_ELF_AMSS_NON_PAGED_RW_SEGMENT
elif PAGEABLE in seg_info:
if RO in seg_info or CODE in seg_info:
if SWAPABLE in seg_info:
if POOL_INDEX_0 in seg_info:
ret_val = MI_PBT_ELF_SWAPPED_PAGED_RO_SEGMENT_INDEX0
else:
ret_val = MI_PBT_ELF_SWAPPED_PAGED_RO_SEGMENT_INDEX1
else:
ret_val = MI_PBT_ELF_AMSS_PAGED_RO_SEGMENT
elif ZI in seg_info:
ret_val = MI_PBT_ELF_AMSS_PAGED_ZI_SEGMENT
elif NOTUSED in seg_info:
ret_val = MI_PBT_ELF_AMSS_PAGED_NOTUSED_SEGMENT
elif SHARED in seg_info:
ret_val = MI_PBT_ELF_AMSS_PAGED_SHARED_SEGMENT
elif L4BSP in seg_info:
ret_val = MI_PBT_ELF_PAGED_L4BSP_SEGMENT
else:
ret_val = MI_PBT_ELF_AMSS_PAGED_RW_SEGMENT
else:
raise RuntimeError('The segment name is wrongly defined in the SCL file: ' + seg_info)
return ret_val
#----------------------------------------------------------------------------
# Pad a file with specific number of bytes
# Note: Assumes the fp is seeked to the correct location of padding
#----------------------------------------------------------------------------
def pad_file(fp, num_bytes, value):
if num_bytes < 0:
raise RuntimeError("Number of bytes to pad must be greater than zero")
while num_bytes > 0:
fp.write('%c' % value)
num_bytes -= 1
return
#----------------------------------------------------------------------------
# Concatenates the files listed in 'sources' in order and writes to 'target'
#----------------------------------------------------------------------------
def concat_files (target, sources):
if type(sources) is not list:
sources = [sources]
target_file = OPEN(target,'wb')
for fname in sources:
file = OPEN(fname,'rb')
while True:
bin_data = file.read(65536)
if not bin_data:
break
target_file.write(bin_data)
file.close()
target_file.close()
#----------------------------------------------------------------------------
# Parse build configurable values and assign to global variables for tools
#----------------------------------------------------------------------------
def init_build_vars(env):
# Maximum size of Certificate Chain used in Secure Boot
global CERT_CHAIN_ONEROOT_MAXSIZE
CERT_CHAIN_ONEROOT_MAXSIZE = get_dict_value(env['GLOBAL_DICT'], 'CERT_CHAIN_MAXSIZE', (6*1024))
# Maximum size of the XML Header used in encrypted ELF images
global XML_HEADER_MAXSIZE
XML_HEADER_MAXSIZE = get_dict_value(env['GLOBAL_DICT'], 'XML_HEADER_MAXSIZE', (2*1024))
#----------------------------------------------------------------------------
# Generates the global dictionary and add to the environment
#----------------------------------------------------------------------------
def generate_global_dict(env):
# Get file names for 'cust' and 'targ' auto-generated files inside 'build/ms'
cust_h = env.subst('CUST${BUILD_ID}.H').lower()
targ_h = env.subst('TARG${BUILD_ID}.H').lower()
cust_file_name = str(env.FindFile(cust_h, "${INC_ROOT}/build/ms"))
targ_file_name = str(env.FindFile(targ_h, "${INC_ROOT}/build/ms"))
# Check that files are present
if (os.path.exists(cust_file_name) is True) and \
(os.path.exists(targ_file_name) is True):
# Populate the dictionary from the auto-generated files
global_dict = populate_dictionary(targ_file_name, cust_file_name)
else:
global_dict = {}
# Add the dictionary to the environment
env.Replace(GLOBAL_DICT = global_dict)
#----------------------------------------------------------------------------
# Populate the dictionary from a list of input files
#----------------------------------------------------------------------------
def populate_dictionary(*args):
if len(args) < 1:
raise RuntimeError("At least 1 file must be specified as an input")
global_dict = {}
Fields = ["Define", "Key", "Value"]
# For each input file
for i in range(len(args)):
template_file_path = args[i]
instream = OPEN(template_file_path, 'r')
# Tokenize each line with a white space
values = csv.DictReader(instream, Fields, delimiter=" ")
for values in itertools.izip(values):
new_entry = values[0]
# Verify the parsed tokens
if (new_entry['Define'] == '#define') and \
(new_entry['Key'] != None) and \
(new_entry['Value'] != None):
new_key = new_entry['Key'].strip()
new_value = new_entry['Value'].strip()
# If value pair is empty string, assume feature definition is true
if new_value == '':
new_value = 'yes'
# Check for and handle text replacements as we parse
if global_dict is not None and len(global_dict.keys()) > 0:
for key in global_dict:
new_value = new_value.replace(key, str(global_dict.get(key)))
# Attempt to evaluate value
try:
new_value = eval(new_value)
# Catch exceptions and do not evaluate
except:
pass
# Add to global dictionary
global_dict[new_key] = new_value
instream.close()
return global_dict
#----------------------------------------------------------------------------
# Filter out a generic dictionary from the global dictionary
#----------------------------------------------------------------------------
def filter_dictionary(env, global_dict, **kwargs):
# Check for Image Type
# If IMAGE_TYPE parameter is not provided, raise error
if not kwargs.has_key('IMAGE_TYPE'):
raise RuntimeError("IMAGE_TYPE must be defined to use FilterDictionary.")
else:
image_type = kwargs.get('IMAGE_TYPE')
if type(image_type) is not str:
raise RuntimeError("IMAGE_TYPE must be of string type.")
# Check for Flash Type
# If FLASH_TYPE parameter is not provided, default to 'nand'
if not kwargs.has_key('FLASH_TYPE'):
flash_type = 'nand'
else:
flash_type = kwargs.get('FLASH_TYPE')
if type(flash_type) is not str:
raise RuntimeError("FLASH_TYPE must be of string type. ")
# Check for MBN Type
# If MBN_TYPE parameter is not provided, default to 'elf'
if not kwargs.has_key('MBN_TYPE'):
mbn_type = 'elf'
else:
mbn_type = kwargs.get('MBN_TYPE')
if mbn_type != 'elf' and mbn_type != 'bin':
raise RuntimeError("MBN_TYPE currently not supported: " + mbn_type)
# Check for Image ID
# If IMAGE_ID parameter is not provided, default to ID 0
if not kwargs.has_key('IMAGE_ID'):
image_id = ImageType.NONE_IMG
else:
image_id = kwargs.get('IMAGE_ID')
if type(image_id) is not int:
raise RuntimeError("IMAGE_ID must be of integer type.")
# Initialize
gen_dict = {}
image_dest = 0
image_source = 0
# Check for image_type
if image_type not in image_id_table:
id = image_id
id_match_str = image_type.upper() + "_IMG"
id_mbn_type = mbn_type
else:
id = image_id_table[image_type][0]
id_match_str = image_id_table[image_type][1]
id_mbn_type = image_id_table[image_type][2]
# Handle MBN Type and assign image destination address
if id_mbn_type == 'elf':
pass
elif id_mbn_type == 'bin':
template_key_match = 'IMAGE_KEY_' + id_match_str + "_DEST_ADDR"
if template_key_match in global_dict:
image_dest = global_dict[template_key_match]
else:
raise RuntimeError("Builds file does not have IMAGE_KEY pair for: " + image_type)
else:
raise RuntimeError("MBN_TYPE currently not supported: " + mbn_type)
# Assign generic dictionary key/value pairs
gen_dict['IMAGE_KEY_IMAGE_ID'] = id
gen_dict['IMAGE_KEY_IMAGE_DEST'] = image_dest
gen_dict['IMAGE_KEY_IMAGE_SOURCE'] = image_source
gen_dict['IMAGE_KEY_FLASH_TYPE'] = flash_type
gen_dict['IMAGE_KEY_MBN_TYPE'] = id_mbn_type
gen_dict['IMAGE_KEY_ID_MATCH_STR'] = id_match_str
gen_dict['IMAGE_KEY_FLASH_AUTO_DETECT_MAX_PAGE'] = \
get_dict_value(global_dict,'FLASH_AUTO_DETECT_MAX_PAGE', 8192)
gen_dict['IMAGE_KEY_FLASH_AUTO_DETECT_MIN_PAGE'] = \
get_dict_value(global_dict,'FLASH_AUTO_DETECT_MIN_PAGE', 2048)
gen_dict['IMAGE_KEY_MAX_SIZE_OF_VERIFY_BUFFER'] = \
get_dict_value(global_dict,'MAX_SIZE_OF_VERIFY_BUFFER', 8192)
gen_dict['IMAGE_KEY_BOOT_SMALL_PREAMBLE'] = \
get_dict_value(global_dict,'BOOT_SMALL_PREAMBLE', 1)
# Get OEM root certificate select and number
oem_root_cert_sel = get_dict_value(global_dict,'OEM_ROOT_CERT_SEL', 1)
oem_num_root_certs = get_dict_value(global_dict,'OEM_NUM_ROOT_CERTS', 1)
# Error checking for OEM configurable values
if oem_root_cert_sel in range(1, MAX_NUM_ROOT_CERTS + 1) and \
oem_num_root_certs in range(1, MAX_NUM_ROOT_CERTS + 1) and \
oem_root_cert_sel <= oem_num_root_certs:
gen_dict['IMAGE_KEY_OEM_ROOT_CERT_SEL'] = oem_root_cert_sel
gen_dict['IMAGE_KEY_OEM_NUM_ROOT_CERTS'] = oem_num_root_certs
else:
raise RuntimeError("Invalid OEM root certificate configuration values")
# Assign additional dictionary key/values pair as needed by tools.
return gen_dict
#----------------------------------------------------------------------------
# Get index value from dictionary if exists, otherwise return default
#----------------------------------------------------------------------------
def get_dict_value(dict, key_string, default):
key = 'IMAGE_KEY_' + key_string
if key in dict:
return dict[key]
else:
return default
#----------------------------------------------------------------------------
# Preprocess an ELF file and return the ELF Header Object and an
# array of ELF Program Header Objects
#----------------------------------------------------------------------------
def preprocess_elf_file(elf_file_name):
# Initialize
elf_fp = OPEN(elf_file_name, 'rb')
elf_header = Elf_Ehdr_common(elf_fp.read(ELF_HDR_COMMON_SIZE))
if verify_elf_header(elf_header) == False:
raise RuntimeError("ELF file failed verification: " + elf_file_name)
elf_fp.seek(0)
if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
elf_header = Elf64_Ehdr(elf_fp.read(ELF64_HDR_SIZE))
else:
elf_header = Elf32_Ehdr(elf_fp.read(ELF32_HDR_SIZE))
phdr_table = []
# Verify ELF header information
if verify_elf_header(elf_header) == False:
raise RuntimeError("ELF file failed verification: " + elf_file_name)
# Get program header size
phdr_size = elf_header.e_phentsize
# Find the program header offset
file_offset = elf_header.e_phoff
elf_fp.seek(file_offset)
# Read in the program headers
for i in range(elf_header.e_phnum):
if elf_header.e_ident[ELFINFO_CLASS_INDEX] == ELFINFO_CLASS_64:
phdr_table.append(Elf64_Phdr(elf_fp.read(phdr_size)))
else:
phdr_table.append(Elf32_Phdr(elf_fp.read(phdr_size)))
elf_fp.close()
return [elf_header, phdr_table]
#----------------------------------------------------------------------------
# Get the hash table address from an input ELF file
#----------------------------------------------------------------------------
def get_hash_address(elf_file_name):
[elf_header, phdr_table] = preprocess_elf_file(elf_file_name)
last_paddr = 0
last_paddr_segment = 0
# Find the segment with the largest physical address.
# Hash segment's physical address will be immediately after this segment.
for i in range(elf_header.e_phnum):
curr_phdr = phdr_table[i]
if curr_phdr.p_paddr > last_paddr:
# Skip the demand paging segment as it would be outside the physical RAM location
if MI_PBT_SEGMENT_TYPE_VALUE(curr_phdr.p_flags) != MI_PBT_SWAPPED_SEGMENT:
last_paddr = curr_phdr.p_paddr;
last_paddr_segment = i;
max_phdr = phdr_table[last_paddr_segment]
ret_val = (((max_phdr.p_paddr + max_phdr.p_memsz - 1) & \
~(ELF_BLOCK_ALIGN-1)) + ELF_BLOCK_ALIGN)
return ret_val
#----------------------------------------------------------------------------
# Verify ELF header contents from an input ELF file
#----------------------------------------------------------------------------
def verify_elf_header(elf_header):
if (elf_header.e_ident[ELFINFO_MAG0_INDEX] != ELFINFO_MAG0) or \
(elf_header.e_ident[ELFINFO_MAG1_INDEX] != ELFINFO_MAG1) or \
(elf_header.e_ident[ELFINFO_MAG2_INDEX] != ELFINFO_MAG2) or \
(elf_header.e_ident[ELFINFO_MAG3_INDEX] != ELFINFO_MAG3) or \
((elf_header.e_ident[ELFINFO_CLASS_INDEX] != ELFINFO_CLASS_64) and \
(elf_header.e_ident[ELFINFO_CLASS_INDEX] != ELFINFO_CLASS_32)) or \
(elf_header.e_ident[ELFINFO_VERSION_INDEX] != ELFINFO_VERSION_CURRENT):
return False
else:
return True
#----------------------------------------------------------------------------
# Perform file copy given offsets and the number of bytes to copy
#----------------------------------------------------------------------------
def file_copy_offset(in_fp, in_off, out_fp, out_off, num_bytes):
in_fp.seek(in_off)
read_in = in_fp.read(num_bytes)
out_fp.seek(out_off)
out_fp.write(read_in)
return num_bytes
#----------------------------------------------------------------------------
# sha1/sha256/sha384 hash routine wrapper
#----------------------------------------------------------------------------
def generate_hash(in_buf, sha_algo):
# Initialize a SHA object from the Python hash library
if sha_algo == 'sha384':
m = hashlib.sha384()
elif sha_algo == 'sha256':
m = hashlib.sha256()
else:
m = hashlib.sha1()
# Set the input buffer and return the output digest
m.update(in_buf)
return m.digest()
#----------------------------------------------------------------------------
# Initialize the hash program header.
#----------------------------------------------------------------------------
def initialize_hash_phdr(elf_in_file_name, hash_tbl_size, hdr_size, hdr_offset, is_elf64):
# Set hash header offset to page size boundary. Hash table will be
# located at first segment of elf image.
hash_hdr_size = hdr_size
hash_hdr_offset = hdr_offset
hash_tbl_offset = hash_hdr_offset + hash_hdr_size
hash_tbl_end_addr = hash_tbl_offset + hash_tbl_size;
pad_hash_segment = (hash_tbl_end_addr) & (ELF_BLOCK_ALIGN-1)
# Update the hash table program header
if is_elf64 is True:
hash_Phdr = Elf64_Phdr(b'\0'*ELF64_PHDR_SIZE)
else:
hash_Phdr = Elf32_Phdr(b'\0'*ELF32_PHDR_SIZE)
hash_Phdr.p_flags = MI_PBT_ELF_HASH_SEGMENT
hash_Phdr.p_align = ELF_BLOCK_ALIGN
hash_Phdr.p_offset = hash_hdr_offset
hash_Phdr.p_memsz = hash_hdr_size + hash_tbl_size + (ELF_BLOCK_ALIGN - pad_hash_segment)
hash_Phdr.p_filesz = hash_hdr_size + hash_tbl_size
hash_Phdr.p_type = NULL_TYPE
hash_Phdr.p_vaddr = get_hash_address(elf_in_file_name)
hash_Phdr.p_paddr = hash_Phdr.p_vaddr
return [hash_Phdr, pad_hash_segment, hash_tbl_end_addr, hash_tbl_offset]
#----------------------------------------------------------------------------
# image_preamble
#----------------------------------------------------------------------------
def image_preamble(gen_dict, preamble_file_name, boot_sbl_header, num_of_pages=None):
# Generate the preamble file
preamble_fp = OPEN(preamble_file_name, 'wb')
# Initialize
max_size_verify = gen_dict['IMAGE_KEY_MAX_SIZE_OF_VERIFY_BUFFER']
flash_max_page = gen_dict['IMAGE_KEY_FLASH_AUTO_DETECT_MAX_PAGE']
flash_min_page = gen_dict['IMAGE_KEY_FLASH_AUTO_DETECT_MIN_PAGE']
autodetectpage = [int('0xFFFFFFFF',16)] * max_size_verify
# The first three entries in the preamble must include the following values
autodetectpage[0] = FLASH_CODE_WORD
autodetectpage[1] = MAGIC_NUM
if (num_of_pages == 64):
autodetectpage[2] = AUTODETECT_PAGE_SIZE_MAGIC_NUM64
elif (num_of_pages == 128):
autodetectpage[2] = AUTODETECT_PAGE_SIZE_MAGIC_NUM128
else:
autodetectpage[2] = AUTODETECT_PAGE_SIZE_MAGIC_NUM
# Package the list into binary data to be written to the preamble
s = struct.Struct('I' * max_size_verify)
packed_data = s.pack(*autodetectpage)
# Output preamble pages based on maximum/minimum page size support
for i in range(flash_max_page/flash_min_page):
preamble_fp.write(packed_data[:flash_min_page])
# Determine appropriate amount of padding for the preamble and
# update the boot_sbl_header accordingly
if gen_dict['IMAGE_KEY_BOOT_SMALL_PREAMBLE'] == 1:
boot_sbl_header.image_src += (flash_max_page + flash_min_page)
amount_to_write = flash_min_page
else:
boot_sbl_header.image_src += flash_max_page * 2
amount_to_write = flash_max_page
pad_file(preamble_fp, amount_to_write, PAD_BYTE_1)
preamble_fp.close()
return boot_sbl_header
#----------------------------------------------------------------------------
# Helper functions to parse ELF program headers
#----------------------------------------------------------------------------
def MI_PBT_SEGMENT_TYPE_VALUE(x):
return ( ((x) & MI_PBT_FLAG_SEGMENT_TYPE_MASK) >> MI_PBT_FLAG_SEGMENT_TYPE_SHIFT )
def MI_PBT_PAGE_MODE_VALUE(x):
return ( ((x) & MI_PBT_FLAG_PAGE_MODE_MASK) >> MI_PBT_FLAG_PAGE_MODE_SHIFT )
def MI_PBT_ACCESS_TYPE_VALUE(x):
return ( ((x) & MI_PBT_FLAG_ACCESS_TYPE_MASK) >> MI_PBT_FLAG_ACCESS_TYPE_SHIFT )
def MI_PBT_CHECK_FLAG_TYPE(x):
return (MI_PBT_SEGMENT_TYPE_VALUE(x) != MI_PBT_HASH_SEGMENT) and \
(MI_PBT_ACCESS_TYPE_VALUE(x) != MI_PBT_NOTUSED_SEGMENT) and \
(MI_PBT_ACCESS_TYPE_VALUE(x) != MI_PBT_SHARED_SEGMENT)
#----------------------------------------------------------------------------
# Helper functions to open a file and return a valid file object
#----------------------------------------------------------------------------
def OPEN(file_name, mode):
try:
fp = open(file_name, mode)
except IOError:
raise RuntimeError("The file could not be opened: " + file_name)
# File open has succeeded with the given mode, return the file object
return fp
#----------------------------------------------------------------------------
# Helper functions to insert MCs in SBL1(Badger) if ENABLE_VIRTUAL_BLK is ON
#----------------------------------------------------------------------------
def insert_SBL1_magicCookie (env, target):
file = open(target, "rb")
#read the file contents
filedata = file.read()
length = len(filedata)
file.close()
if (length <= VIRTUAL_BLOCK_SIZE):
return None
else:
#remove the previous file
os.remove(target)
#generate new file for appending target data + required MCs
file = open(target, "ab")
while length > VIRTUAL_BLOCK_SIZE:
filedata_till_128kb = filedata[0:VIRTUAL_BLOCK_SIZE]
filedata_after_128kb = filedata[VIRTUAL_BLOCK_SIZE:length]
a = str(hex(FLASH_CODE_WORD))
mc1 = chr(int(a[8:10],16)) + chr(int(a[6:8],16)) + chr(int(a[4:6],16)) + chr(int(a[2:4],16))
b = str(hex(MAGIC_NUM))
mc2 = chr(int(b[8:10],16)) + chr(int(b[6:8],16)) + chr(int(b[4:6],16)) + chr(int(b[2:4],16))
c = str(hex(SBL_VIRTUAL_BLOCK_MAGIC_NUM))
mc3 = chr(int(c[8:10],16)) + chr(int(c[6:8],16)) + chr(int(c[4:6],16)) + chr(int(c[2:4],16))
#MC_inserted_data = filedata_till_128kb + mc1 + mc2 + mc3
file.write(filedata_till_128kb)
MC_inserted_data = mc1 + mc2 + mc3 + filedata_after_128kb
#filedata = filedata_after_128kb
filedata = MC_inserted_data
length = len(filedata)
#copy the leftover data (<128KB) in output file
if length > 0:
file.write(filedata)
#close the final output file
file.close()
# MC_insertion code end
#----------------------------------------------------------------------------
# Helper functions to remove MCs in SBL1(Badger)
#----------------------------------------------------------------------------
def remove_SBL1_magicCookie (env, target, dest):
file = open(target, "rb")
#read the file contents
filedata = file.read()
length = len(filedata)
file.close()
#generate new file for appending target data + required MCs
file = open(dest, "ab")
while length > VIRTUAL_BLOCK_SIZE:
filedata_till_128kb = filedata[0:VIRTUAL_BLOCK_SIZE]
# skipped 12 byte of Virtual Block Magic Cookie Header
filedata_after_128kb = filedata[VIRTUAL_BLOCK_SIZE+MAGIC_COOKIE_LENGTH:length]
file.write(filedata_till_128kb)
filedata = filedata_after_128kb
length = len(filedata)
#copy the leftover data (<128KB) in output file
if length > 0:
file.write(filedata)
#close the final output file
file.close()
# MC_removal code end
#----------------------------------------------------------------------------
# Helper functions to pad SBL1 image
# min_size defaults to 256k
# If page_size or num_of_pages is set to 0, the variable is unset
#----------------------------------------------------------------------------
def pad_SBL1_image (env, target, min_size_with_pad=MIN_IMAGE_SIZE_WITH_PAD, page_size=0, num_of_pages=0):
file = open(target, "rb")
#read the file contents
filedata = file.read()
length = len(filedata)
file.close()
multiple = 1
alignment = page_size * num_of_pages
if (length > alignment and alignment > 0):
import math
multiple = math.ceil(length/float(alignment))
final_image_size = max(min_size_with_pad, multiple * alignment)
if length < final_image_size:
sbl1_fp = open(target, 'ab')
pad_file (sbl1_fp, (final_image_size-length), PAD_BYTE_0)
sbl1_fp.close()
# SBL1 pad code end
#----------------------------------------------------------------------------
# HELPER FUNCTIONS END
#----------------------------------------------------------------------------