#!/usr/bin/python
# -*- coding: utf8 -*-

import json
import struct
import sys
import binascii
import cryptoSB
import copy

from jsoncomment import JsonComment

__Align = 16
__Align_16_en = 0

__TEST = 0

__Align_pub_key_apend = 512
__Align_sign_size = 512

g_magic_size = 8
g_total_len_size = 4
g_bl_version_size = 4
g_img_number_size = 4
g_ls_cmd_number_size = 4
g_mi_header_info_size = (g_magic_size + g_total_len_size + g_bl_version_size + g_img_number_size + g_ls_cmd_number_size)

g_img_header_size = 96
g_ls_cmd_size = 8

g_img_oneoffset_table_size = 4
g_img_onehash_table_size = 64

g_public_key_size = __Align_pub_key_apend
g_rsa_n_size = __Align_pub_key_apend
g_sbc_auth_inf_size = 4
g_sbc_auth_key_hash_size = 4
g_sbc_auth_alg_size = 4
g_sbc_auth_alg_hash_size = 4
g_sbc_rsa_pad_sel_size = 4
g_sbc_pub_key_len_size = 4
g_sbc_size = (g_public_key_size + g_rsa_n_size + g_sbc_auth_inf_size + g_sbc_auth_key_hash_size + g_sbc_auth_alg_size + g_sbc_auth_alg_hash_size + g_sbc_rsa_pad_sel_size + g_sbc_pub_key_len_size)

g_boot_hash_size = 64
g_signature_size = __Align_sign_size
g_auth_size = (g_boot_hash_size + g_signature_size)

g_ck_magic_size = 16
g_ck_soc_id_size = 32
g_ck_pub_key_size = __Align_pub_key_apend
g_ck_auth_algo_size = 4
g_ck_put_key_len_size = 4
g_ck_signature_size = __Align_sign_size
g_ck_size = (g_ck_magic_size + g_ck_soc_id_size + g_ck_pub_key_size + g_ck_auth_algo_size + g_ck_put_key_len_size + g_ck_signature_size)

def to_int(s):
    if isinstance(s, (str, unicode)):
        return int(s, 0)
    else:
        return s

def byte_to_int(bytes):
    result = 0

    for b in bytes:
        result = result*256 + ord(b)

    return result

def read_desc(mi_desc_fn):
    #desc = json.load(open(mi_desc_fn))

    parser = JsonComment(json)
    desc = parser.loads(open(mi_desc_fn).read())

    for img in desc['images']:
        img['img_enc_alg'] = to_int(img['img_enc_alg'])
        img['img_enc_inf'] = to_int(img['img_enc_inf'])

        '''0627 remove int assign avoid key start is (0x00..)'''
        #img['img_iv'] = to_int(img['img_iv'])

    return desc


def gen_ver_magic(major, minor, revision):
    major = to_int(major)
    minor = to_int(minor)
    revision = to_int(revision)

    x = major ^ 0xaa
    y = minor ^ 0x55
    z = revision ^ 0x99
    checksum = (x + y + z) & 0xff

    return (major << 0) | (minor << 8) | (revision << 16) | (checksum << 24)

def my_gen_ver_magic(major, minor, revision):
    major = to_int(major)
    minor = to_int(minor)
    revision = to_int(revision)

    x = major ^ 0xaa
    y = minor ^ 0x55
    z = revision ^ 0x99
    checksum = (x + y + z) & 0xff

    highmagic = byte_to_int(b'\x27\x21\xca\xfe')
    #print(hex(highmagic))

    return (major << 0) | (minor << 8) | (revision << 16) | (checksum << 24), highmagic

def my_gen_mtk_magic(magic):
    magic_str = my_to_bytes(magic, g_magic_size, endianess='little')

    lowmagic = byte_to_int(magic_str[4:8])
    highmagic = byte_to_int(magic_str[0:4])

    return lowmagic, highmagic

def pad_to_align(align, current_size):
    if not align:
        return ''

    pad_size = (align - current_size % align) % align
    pad = '\0' * pad_size

    return pad


def dump(data):
    for i in range(0, len(data)):
        if(i%16 == 0):
            print("[%04X]" % i),

        print("%02x" % ord(data[i])),
        if(((i+1)%16) == 0):
            print

def pack_load_script(mi_desc):
    ls_script = []
    reserved = 0
    images = mi_desc['images']
    img_num = len(images)

    ls_cmds = mi_desc['load_srcipt_cmd']
    ls_cmds_num = len(ls_cmds)
    #print("ls_cmds_num: %d" %ls_cmds_num)

    for i in range(ls_cmds_num):
        ls_cmd = ls_cmds[i]
        cmd = ls_cmd['cmd']

        if cmd == "LOAD":
            cmd_id = 0
            img_file = ls_cmd['img_file']
            addr = to_int(ls_cmd['addr'])

            img_id = -1
            for j in range(img_num):
                img = images[j]
                img_binary_name = img['img_file']
                if img_file == img_binary_name:
                    img_id = j
                    break

            if img_id == -1:
                print("Please check img file name")
                return

            packed_cmd = struct.pack('<BBHI', cmd_id, img_id, reserved, addr)
            #dump(packed_cmd)
            #print
        elif cmd == "MCU-ENTRY":
            cmd_id = 2
            mcu_id =  ls_cmd['mcu_id']
            addr = to_int(ls_cmd['addr'])
            packed_cmd = struct.pack('<BBHI', cmd_id, mcu_id, reserved, addr)
            #dump(packed_cmd)
            #print
        elif cmd == "MCU_RESET-ENTRY":
            cmd_id = 1
            mcu_id =  ls_cmd['mcu_id']
            addr = to_int(ls_cmd['addr'])
            packed_cmd = struct.pack('<BBHI', cmd_id, mcu_id, reserved, addr)
            #dump(packed_cmd)
            #print
        else:
            print("unknown command: %s" %cmd)
            return

        ls_script += packed_cmd

    #print("load script:")
    #dump(ls_script)

    return ls_script

def rsa_data_parser(mi_desc, sbc_rsa_pad_sel):
    rsa_dict = {"n":'', "e":'', "d":''}
    rsa_parse = []

    if(sbc_rsa_pad_sel == 0):
        rsa_d = mi_desc['rsa_data']
        rsa_data = rsa_d[0]

        rsa_dict['n'] = rsa_data['n']
        rsa_dict['e'] = rsa_data['e']
        rsa_dict['d'] = rsa_data['d']
        rsa_parse.append(rsa_dict)
        #print(rsa_parse)
    
        #rsa_parse.append(rsa_data['n'])
        #rsa_parse.append(rsa_data['e'])
        #rsa_parse.append(rsa_data['d'])
        rsa_parse.append(rsa_data['msg2hash'])
        rsa_parse.append(rsa_data['signvalue'])
        rsa_parse.append(rsa_data['shafunc'])
        rsa_parse.append(rsa_data['msgtest'])
        print("dump rsa_data_parser")
        #print(rsa_parse)
        #print(rsa_parse[0])
    else:
        rsa_d = mi_desc['rsa_data_pss']
        rsa_data = rsa_d[0]

        rsa_dict['n'] = rsa_data['n']
        rsa_dict['e'] = rsa_data['e']
        rsa_dict['d'] = rsa_data['d']
        rsa_parse.append(rsa_dict)
    
        rsa_parse.append(rsa_data['msg2hash'])
        rsa_parse.append(rsa_data['signvalue'])
        rsa_parse.append(rsa_data['salt'])
        rsa_parse.append(rsa_data['shafunc'])
        rsa_parse.append(rsa_data['msgtest'])
        print("dump rsa_data_parser")
        print(rsa_parse)

    return rsa_parse

def ck_rsa_data_parser(mi_desc, sbc_rsa_pad_sel):
    rsa_dict = {"n":'', "e":'', "d":''}
    rsa_parse = []

    if(sbc_rsa_pad_sel == 0):
        rsa_d = mi_desc['ck_rsa_data']
        rsa_data = rsa_d[0]

        rsa_dict['n'] = rsa_data['n']
        rsa_dict['e'] = rsa_data['e']
        rsa_dict['d'] = rsa_data['d']
        rsa_parse.append(rsa_dict)
        #print(rsa_parse)

        #rsa_parse.append(rsa_data['n'])
        #rsa_parse.append(rsa_data['e'])
        #rsa_parse.append(rsa_data['d'])
        rsa_parse.append(rsa_data['msg2hash'])
        rsa_parse.append(rsa_data['signvalue'])
        rsa_parse.append(rsa_data['shafunc'])
        rsa_parse.append(rsa_data['msgtest'])
        print("dump rsa_data_parser")
        #print(rsa_parse)
        #print(rsa_parse[0])
    else:
        rsa_d = mi_desc['ck_rsa_data_pss']
        rsa_data = rsa_d[0]

        rsa_dict['n'] = rsa_data['n']
        rsa_dict['e'] = rsa_data['e']
        rsa_dict['d'] = rsa_data['d']
        rsa_parse.append(rsa_dict)

        rsa_parse.append(rsa_data['msg2hash'])
        rsa_parse.append(rsa_data['signvalue'])
        rsa_parse.append(rsa_data['salt'])
        rsa_parse.append(rsa_data['shafunc'])
        rsa_parse.append(rsa_data['msgtest'])
        print("dump rsa_data_parser")
        print(rsa_parse)

    return rsa_parse

def my_pack_images(mi_desc, privk, enckey, align=None, img_dir=''):
    '''
    mipack_file
        mi_header_info
            u32 magic
            u32 total_len
            u32 bl_version
            u32 img_number (N)
            u32 load_script_cmd_number (M)

        img_info[1]~img_info[N]
            u32     img_length
            u32     img_offset
            64Byes  img_hash
            u32     img_enc_inf
            u32     img_enc_alg
            16Bytes img_iv

        load_script_cmd[1]~load_script_cmd[M]
            u64     cmd

        sbc data
            512Bytes sbc_pub_key
            512Bytes sbc_rsa_n
            u32     sbc_auth_info
            u32     sbc_key_hash 
            u32     sbc_auth_algo_dsa
            u32     sbc_auth_algo_hash
            u32     sbc_rsa_pad_sel
            u32     sbc_pub_key_len

        auth data
            64Bytes boothash
            512Bytes signature

        [img binary 1]
        ...
        [img binary 1]
    '''

    key_mode = 0

    mi_header_struct = struct.Struct('<IIIIII')
    sbc_struct = struct.Struct('<IIIIII')
    ck_struct = struct.Struct('<II')


    #run hash
    hash = cryptoSB.HASH()

    # ver_magic
    #version = mi_desc['version']
    #major, minor, revision = version.split('.')
    #ver_magic_l, ver_magic_h = my_gen_ver_magic(major, minor, revision)

    ver_magic_l, ver_magic_h = my_gen_mtk_magic(to_int(mi_desc['magic_num']))

    # bl region
    bl_version = mi_desc['bl_version']
    images = mi_desc['images']
    img_num = len(images)
    ls_cmds = mi_desc['load_srcipt_cmd']
    ls_cmds_num = len(ls_cmds)

    '''size of bl + imgl + sbc + auth'''
    # Fixed size section: mi_header, sbc data, auth data
    # Non-fixed size section: img_info, load script
    bl_total_len = g_mi_header_info_size + g_sbc_size + g_auth_size
    #bl_total_len = g_mi_header_info_size + g_sbc_size + g_auth_size + g_ck_size
    bl_total_len += img_num * g_img_header_size
    bl_total_len += ls_cmds_num * g_ls_cmd_size


    #print("==== multi-image header size ====")
    #print("g_mi_header_info_size=%d, g_sbc_size=%d, g_auth_size=%d, bl_total_len = %d" %(g_mi_header_info_size, g_sbc_size, g_auth_size, bl_total_len))

    #img_header_table = []
    img_headers = []
    bins = []
    sbc_region = []
    hashtable = []
    imagetmp = [[], [], [], [], [], [], [], [], [], []]
    packtmp = []
    blh_hash = []
    signaturelist = []
    ck_region = []
    cksignaturelist = []

    imagesize = []


    sbc_auth_alg = mi_desc['sbc_auth_alg']
    sbc_rsa_pad_sel = mi_desc['sbc_rsa_pad_sel']
    ''' parer rsa test pattern '''
    rsa_parse = rsa_data_parser(mi_desc, sbc_rsa_pad_sel)

    # sbc region
    ##pub_key = to_int(mi_desc['public_key'])
    ##public_key = my_binify(pub_key)
    '''20180627 remove int assign avoid key start is (0x00..)'''
    pub_key = (mi_desc['public_key'])
    public_key = cryptoSB.strip_key(pub_key)
    pubk = b'\x04' + public_key

    rsa_e = cryptoSB.my_a2b_hex(rsa_parse[0]['e'])
    rsa_n = cryptoSB.my_a2b_hex(rsa_parse[0]['n']) 
    if((sbc_auth_alg == 0) or (sbc_auth_alg == 1) or (sbc_auth_alg == 2)):
        public_key_append = my_pad_to_align(public_key, __Align_pub_key_apend)
        sbc_region.append(public_key_append)

        #sbc_rsa_n = (mi_desc['sbc_rsa_n'])
        #rsa_modulus = cryptoSB.strip_key(sbc_rsa_n)
        rsa_modulus_append = my_pad_to_align(rsa_n, __Align_pub_key_apend)
        sbc_region.append(rsa_modulus_append)
    elif((sbc_auth_alg == 3) or (sbc_auth_alg == 4) or (sbc_auth_alg == 5)):
        rsa_e_append = my_pad_to_align(rsa_e, __Align_pub_key_apend)
        sbc_region.append(rsa_e_append)
        rsa_n_append = my_pad_to_align(rsa_n, __Align_pub_key_apend)
        sbc_region.append(rsa_n_append)


    #print("======= sbc region =========")
    sbc_auth_inf = mi_desc['sbc_auth_inf']
    #print("sbc_auth_inf = 0x%x" %sbc_auth_inf)
    sbc_key_hash = mi_desc['sbc_key_hash']
    sbc_auth_alg = mi_desc['sbc_auth_alg']
    #print("sbc_auth_alg = 0x%x" %sbc_auth_alg)
    sbc_auth_alg_hash = mi_desc['sbc_auth_alg_hash']
    sbc_rsa_pad_sel = mi_desc['sbc_rsa_pad_sel']
    sbc_pub_key_len = mi_desc['sbc_pub_key_len']
    sbc = sbc_struct.pack(sbc_auth_inf, sbc_key_hash, sbc_auth_alg, sbc_auth_alg_hash, sbc_rsa_pad_sel, sbc_pub_key_len)
    sbc_region.append(sbc)

	#print("======= ck region =========")
    ck_mg = (mi_desc['ck_magic_num'])
    ck_magic = cryptoSB.strip_key(ck_mg)
    ck_region.append(ck_magic)
    ck_sid = (mi_desc['ck_soc_id'])
    ck_soc_id = cryptoSB.strip_key(ck_sid)
    ck_region.append(ck_soc_id)
    ck_pkey = (mi_desc['ck_pub_key'])

    ck_pub_key = cryptoSB.strip_key(ck_pkey)
    ck_pub_key_append = my_pad_to_align(ck_pub_key, __Align_pub_key_apend)
    ck_region.append(ck_pub_key_append)
    ck_pubk = b'\x04' + ck_pub_key

    ck_rsa_n = (mi_desc['ck_rsa_n'])
    ck_rsa_modulus = cryptoSB.strip_key(ck_rsa_n)
    ck_rsa_modulus_append = my_pad_to_align(ck_rsa_modulus, __Align_pub_key_apend)
    ck_region.append(ck_rsa_modulus_append)

    ck_auth_algo = mi_desc['ck_auth_algo']
    ck_pub_key_len = mi_desc['ck_pub_key_len']
    ck = ck_struct.pack(ck_auth_algo, ck_pub_key_len)
    ck_region.append(ck)

    ck_en = mi_desc['change_key_en']
    sign_ck_priv_key = mi_desc['sign_ck_priv_key']
    signckprivk = cryptoSB.strip_key(sign_ck_priv_key)

    # pad before 1st image

    #pad = pad_to_align(64, expected_size)
    #bins.append(pad)
    #expected_size += len(pad)


    # images
    # 512 bytes aligned (20200310)
    img_offset = (bl_total_len + 511) & (~511)
    img_offset_table = []

    for i in range(img_num):
        #print("\n\n======== Start image step: =========")


        img = images[i]
        img_file = img['img_file']
        img_enc_inf = img['img_enc_inf']
        img_enc_alg = img['img_enc_alg']
        #print("img_enc_inf=0x%x" %img_enc_inf)

        bin = open(img_dir + '/' + img_file, 'rb').read()

        iv_int = img['img_iv']
        #iv = my_binify(iv_int)
        '''0627 remove int assign avoid key start is (0x00..)'''
        iv = cryptoSB.strip_key(iv_int)
        iv0= int(iv[0:4].encode('hex'), 16)
        iv1= int(iv[4:8].encode('hex'), 16)
        iv2= int(iv[8:12].encode('hex'), 16)
        iv3= int(iv[12:16].encode('hex'), 16)
        #print type(iv)
        #print("IV:")
        #cryptoSB.dump(iv)


        if(img_enc_inf == 1):
            '''image encrypt'''
            out = cryptoSB.my_img_enc(bin, enckey, iv, img_enc_alg, __Align)
            bins.append(out)
            #bins = out
        elif(img_enc_inf == 2):
            '''image encrypt'''
            out = cryptoSB.my_img_enc(bin, enckey, iv, img_enc_alg, __Align)
            bins.append(out)
            #bins = out
        else:
            '''plaintext image'''
            out = my_pad_to_align(bin, __Align)
            bins.append(out)
            #bins = out

        # binary length should be 16 bytes aligned
        length = len(out)

        imagesize.append(length)
        #print("")
        #print("image[%d] offset : 0x%x" %(i, img_offset))
        #print("image[%d] size   : 0x%x" %(i, imagesize[i]))

        imagetmp[i] = copy.copy(bins)

        img_str = ''.join(bins)
        #print type(img_str)
        #print("========= image[%d] binary ==========" %i)
        #cryptoSB.dump(img_str)


        # hash each (image header + image binary)
        #print('')
        #print("========= image[%d] binary hash ==========" %i)
        hashvalue = cryptoSB.sb_hash(img_str, sbc_auth_alg_hash)
        imghash = my_pad_to_align(hashvalue, g_boot_hash_size)
        #cryptoSB.dump(imghash)

        # img_header
        img_hdr = struct.pack('<II',
                                length,
                                img_offset)
        img_hdr += "".join(imghash)
        '''20180719 fix IV order fail'''
        img_hdr += struct.pack('<II16s',
                                img_enc_inf,
                                img_enc_alg,
                                iv)


        img_offset_table.append(str(img_offset))
        length = (length + 511) & (~511)
        img_offset += length
        #img_offset_table.append(my_to_bytes(img_offset, 4, endianess='little'))

        #print("\n=====>")
        #print("image[%d] header info :" %i)
        #cryptoSB.dump(img_hdr)
        img_headers.append(img_hdr)

        #img_headers.remove(img_hdr)
        while len(bins) > 0:
            bins.pop()


    #print("\n\nSTART to pack all sections ...")
    pack = []

    #print("======== append mi_header info ==========")
    total_len = int(img_offset_table[img_num-1]) + int(imagesize[img_num-1])

    mi_header = mi_header_struct.pack(
                        ver_magic_l,
                        ver_magic_h,
                        total_len,
                        bl_version,
                        img_num,
                        ls_cmds_num)


    pack.append(mi_header)

    # append image info
    for i in range(img_num):
        pack += img_headers[i]


    ls_script = pack_load_script(mi_desc)
    if ls_script == None:
        print("pack_load_script fail")
        return

    # append load script
    pack += ls_script

    # append sbc data
    pack += sbc_region

    # for easy view. please remove it while release final
    '''align for (bl + imgl + sbc)'''
    if(__Align_16_en == 1):
        padnum = pad_to_align(16, len(''.join(pack)))
        pack.append(padnum)

    #print("======== append mi_header hash: ==========")
    bl_header = ''.join(pack)
    #cryptoSB.dump(bl_header)
    blh = copy.copy(bl_header)
    boothash = cryptoSB.sb_hash(blh, sbc_auth_alg_hash)
    boothash_append = my_pad_to_align(boothash, g_boot_hash_size)
    #cryptoSB.dump(boothash_append)
    blh_hash.append(boothash_append)

    # append hash
    pack += blh_hash

    #print("======== append mi_header signature: =========")
    #privk = "\xc1\xbe\xe4\xfa\x86\xaf\x86\x84\x67\x7c\xae\xee\xa8\x8a\xb0\x72\x3e\x55\x4a\xef\x01\x60\xb8\xfc\x65\x3c\x0e\x00\x08\x0f\x4f\x78"
    #pubk = "\x04\x14\xc1\xcf\x10\x99\x9d\x3a\x98\xf3\x71\xb8\xd8\x9b\x3b\x26\xb2\x9e\xe1\xbd\x99\xf3\xe0\x39\x3d\x34\x21\x6a\x6f\x49\x58\x7a\xb1\xdd\x8a\xba\x7a\x9d\x02\x99\x5f\xda\xa0\xb8\x62\x82\xae\xc2\xd0\xc6\x88\xc2\x26\x03\x97\x86\x65\x46\xbb\x20\xc9\xd1\x44\xb9\x84"

    if sbc_auth_inf == 0:
        padbytes = '\0' * g_signature_size
        signaturelist.append(padbytes)
    else:
        pem_key_format = mi_desc['pem_key_format']
        if(pem_key_format == 1):
            '''PEM format'''
            key_mode = 1
        elif(pem_key_format == 2):
            '''DER format'''
            key_mode = 2
        else:
            '''String format'''
            key_mode = 0

        #ecdsa = cryptoSB.ECDSA()
        #signature = ecdsa.sign(privk, pubk, boothash, sbc_auth_alg)
        ''' 20180616 fix the sb_sign msg error : not boothash -> blh is right'''
        if(ck_en == 0):
            print("original format: no change key:")
            signature = cryptoSB.sb_sign(privk, pubk, blh, sbc_auth_alg, sbc_auth_alg_hash, rsa_parse, sbc_rsa_pad_sel, key_mode)
        else:
            signature = cryptoSB.sb_sign(signckprivk, pubk, blh, sbc_auth_alg, sbc_auth_alg_hash, ck_rsa_parse, sbc_rsa_pad_sel, key_mode)

        #print("signature size = %d" %len(signature))
        signature_append = my_pad_to_align(signature, g_signature_size)
        #cryptoSB.dump(signature_append)
        signaturelist.append(signature_append)

        #check verify
        #ret = ecdsa.verify(pubk, boothash, signature, sbc_auth_alg)
        #print("ecdsa verify: %s" %ret)


    #dump("".join(signaturelist))
    # append signature
    pack += signaturelist

    # for easy view, please remove it while release final
    '''align for (bl + imgl + sbc + auth + ck)'''
    if(__Align_16_en == 1):
        padnum = pad_to_align(16, len(''.join(pack)))
        pack.append(padnum)

    # append ck field
    ''' Skipped: no use on 2735
    pack += ck_region

    ck_field = ''.join(ck_region)
    cryptoSB.dump(ck_field)
    ckf = copy.copy(ck_field)

    ck_signature = cryptoSB.sb_sign(privk, pubk, ckf, sbc_auth_alg, sbc_auth_alg_hash, rsa_parse, sbc_rsa_pad_sel, key_mode)
    #print("ck_signature size = %d" %len(ck_signature))
    ck_signature_append = my_pad_to_align(ck_signature, g_signature_size)
    #cryptoSB.dump(ck_signature_append)
    cksignaturelist.append(ck_signature_append)

    pack += cksignaturelist
    '''
    # end append ck field

    # append image binary
    for i in range(img_num):
        offset = int(img_offset_table[i])
        pad_num = offset - len(''.join(pack))
        #print("offset = %d" %offset)
        #print("pad_num = %d" %pad_num)

        padbytes = '\0' * pad_num
        pack.append(padbytes)
        pack += imagetmp[i]

    #print(len(''.join(pack)))

    # clear list
    while len(signaturelist) > 0:
        signaturelist.pop()


    return ''.join(pack)

'''support to_bytes to python 2.7'''
def my_to_bytes(n, length, endianess='big'):
    h = '%x' % n
    s = ('0'*(len(h) % 2) + h).zfill(length*2).decode('hex')
    return s if endianess == 'big' else s[::-1]

'''long to byte string'''
def my_binify(x):
    h = hex(x)[2:].rstrip('L')
    return binascii.unhexlify(h)

def my_binify2(x):
    if(hex(x)[0:2] == '0x'):
        h = hex(x)[2:].rstrip('L')
    else:
        h = hex(x).rstrip('L')

    return binascii.unhexlify(h)

def my_pad_to_align(x, align):
    if(align == 0):
        return x
    else:
        size = len(x)
        #print("size 0x%x" %size)
        pad_size = (align - size % align) % align
        for i in range(0, pad_size, 1):
            x += b'\x00'

        #cryptoSB.dump(x)
        return x


def img_enc(mi_desc, key, align=None):

    images = mi_desc['images']
    img_num = len(images)

    img = images[0]
    #load_addr = img['load_addr']
    #entrypoint = img['entrypoint']
    img_file = img['img_file']
    img_enc_alg = img['img_enc_alg']
    #print(img_enc_alg)
    img_enc_inf = img['img_enc_inf']
    #print(img_enc_inf)
    iv = img['img_iv']
    iv = my_binify(iv)
    #print type(iv)
    #print("img_enc dump:")
    #cryptoSB.dump(iv)

    bin = open(img_file, 'rb').read()
    #cryptoSB.dump(bin)

    #align
    bin = my_pad_to_align(bin, 64)

    aes = cryptoSB.AESCipher(key, 16)
    encmsg = aes.aes_encrypt(bin)
    #print("result image enc:")
    #cryptoSB.dump(encmsg)

    return encmsg


if __name__ == '__main__':
    import os, sys, getopt


    def print_usage():
        print ('usage:', os.path.basename(sys.argv[0]), "[options] <image config>.json\n", \
            'options:\n', \
            '\t[-o | --output out.img]\n', \
            '\t[-h | --help]\n', \
            '\t[-i | --input]\n', \
            '\t[-k | --prikey hexkey e.g. 0x0102..]\n', \
            '\t[-s | --enckey hexkey e.g. 0x0102..]\n', \
            '\t[-p | --pemdir <pem path>\n', \
            '\t[-d | --imgdir <image path>\n')


    def main():
        opts, args = getopt.getopt(sys.argv[1:],
                                   'ho:a:i:k:s:p:d:',
                                   ['help', 'output=', 'align=', 'input=',
                                    'prikey=', 'enckey=', 'pemdir=', 'imgdir=']
                                  )

        out_name = None
        align = 0
        infile_name = None
        aeskey = None
        pubkey = None
        privk = None
        pem_dir = "binfile"
        img_dir = ''

        for o, a in opts:
            if o in ('-h', '--help'):
                print_usage()
                sys.exit()
            elif o in ('-o', '--output'):
                out_name = a
            elif o in ('-a', '--align'):
                align = int(a)
            elif o in ('-i', '--input'):
                ## doesn't need currently
                infile_name = a
            elif o in ('-k', '--prikey'):
                privkey = a
            elif o in ('-s', '--enckey'):
                aeskey = a
            elif o in ('-p', '--pemdir'):
                pem_dir = a
            elif o in ('-d', '--imgdir'):
                img_dir = a
            else:
                print_usage()
                sys.exit(1)

        if len(args) >= 1:
            mi_desc_fn = args[0]
        else:
            print_usage()
            sys.exit(1)

        if not out_name:
            fn, ext = os.path.splitext(mi_desc_fn)
            out_name = fn + '.img'

        """ read json script """
        mi_desc = read_desc(mi_desc_fn)

        #mipack = pack_images(mi_desc, align)

        #print 'output: %s (%d bytes)' % (out_name, len(mipack))
        #open(out_name, 'wb').write(mipack)

        cmd_line_key = mi_desc['cmd_line_key']
        sign_priv_key = mi_desc['sign_priv_key']
        aes_enc_sym_key = mi_desc['aes_enc_sym_key']

        """ Where is the key input from """

        pem_key_format = mi_desc['pem_key_format']
        if(pem_key_format == 1):
            sbc_auth_alg = mi_desc['sbc_auth_alg']
            if(sbc_auth_alg == 0):
                key_path = pem_dir + "/ecdsa_p256_private.pem"
                #print(key_path)
                privk = open(key_path,"rb").read()
                #privk = open("binfile/ecdsa_p256_private.pem","rb").read()
                #pubk_pem = open("binfile/ecdsa_p256_public.pem","rb").read()
            elif(sbc_auth_alg == 1):
                privk = open("binfile/ecdsa_p384_private.pem","rb").read()

            key = cryptoSB.strip_key(aes_enc_sym_key)

        else:
            if(cmd_line_key == 1):
                key = cryptoSB.strip_key(aeskey)
                privk = cryptoSB.strip_key(privkey)
                #print("dump privkey:")
                #cryptoSB.dump(privk)
            elif(cmd_line_key == 0):
                key = cryptoSB.strip_key(aes_enc_sym_key)
                privk = cryptoSB.strip_key(sign_priv_key)
                #print("dump privkey:")
                #cryptoSB.dump(privk)
            else:
                prnit("ERROR: please check cmd_line_key json")


        #run hash
        #hash = cryptoSB.HASH()
        #imghash = hash.hash_sha256(enc_data)
        #cryptoSB.dump(imghash)

        mipack = my_pack_images(mi_desc, privk, key, align, img_dir)
        if mipack == None:
            print("my_pack_images fail")
            return

        #out_name = 'my_' + fn + '.img'
        #out_name = fn + '.img'
        print('output: %s (%d bytes)' % (out_name, len(mipack)))
        open(out_name, 'wb').write(mipack)

    main()