boot/cypress/scripts/memorymap.py

"""MCUBoot Flash Map Converter (JSON to .h)
Copyright (c) 2025 Infineon Technologies AG
"""

import sys
import getopt
import json
import os
from enum import Enum
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes

MAX_IMAGE_NUMBERS = 16
NONCE_GEN_RETRIES = 10
NONCE_RAND_SIZE = 12
AES_BLOCK_SIZE = 16
IMG_OK_OFFSET = 8 + 16  # flag_size + magic_size
IMG_OK_VALUE = 0x01
SHAB_ADDR = 0x08000000

class Error(Enum):
    ''' Application error codes '''
    ARG             = 1
    POLICY          = 2
    FLASH           = 3
    IO              = 4
    JSON            = 5
    VALUE           = 6
    CONFIG_MISMATCH = 7

SERVICE_APP_SZ = 0x20

c_array = 'flash_areas'

# Supported Platforms
cm0pCore = {
    'cortex-m0+': 'CM0P',
    'cm0+': 'CM0P',
    'm0+': 'CM0P',
    'cortex-m0p': 'CM0P',
    'cm0p': 'CM0P',
    'm0p': 'CM0P',
    'cortex-m0plus': 'CM0P',
    'cm0plus': 'CM0P',
    'm0plus': 'CM0P'
}

cm4Core = {
    'cortex-m4': 'CM4',
    'cm4': 'CM4',
    'm4': 'CM4'
}

cm33Core = {
    'cortex-m33': 'CM33',
    'cm33': 'CM33',
    'm33': 'CM33'
}

cm7Core = {
    'cortex-m7': 'CM7',
    'cm7': 'CM7',
    'm7': 'CM7'
}

allCores_PSOC_06x = {**cm0pCore, **cm4Core}

common_PSOC_061 = {
    'flashAddr': 0x10000000,
    'eraseSize': 0x200,  # 512 bytes
    'smifAddr': 0x18000000,
    'smifSize': 0x8000000,  # i.e., window size
    'VTAlign': 0x400,  # Vector Table alignment
    'allCores': cm4Core,
    'bootCore': 'Cortex-M4',
    'appCore': 'Cortex-M4'
}

common_PSOC_06x = {
    'flashAddr': 0x10000000,
    'eraseSize': 0x200,  # 512 bytes
    'smifAddr': 0x18000000,
    'smifSize': 0x8000000,  # i.e., window size
    'VTAlign': 0x400,  # Vector Table alignment
    'allCores': allCores_PSOC_06x,
    'bootCore': 'Cortex-M0+',
    'appCore': 'Cortex-M4'
}

common_CYW20829 = {
    'flashSize': 0,  # n/a
    'smifAddr': 0x60000000,
    'smifSize': 0x8000000,  # i.e., window size
    'VTAlign': 0x200,  # Vector Table alignment
    'allCores': cm33Core,
    'bootCore': 'Cortex-M33',
    'appCore': 'Cortex-M33',
    'bitsPerCnt': False
}

common_XMC7000 = {
    'flashAddr': 0x10000000,
    'eraseSize': 0x8000,  # 32k
    'smifAddr': 0x18000000,
    'smifSize': 0x8000000,  # i.e., window size
    'VTAlign': 0x400,  # Vector Table alignment
    'allCores': cm7Core,
    'bootCore': 'Cortex-M7',
    'appCore': 'Cortex-M7'
}

platDict = {
    'PSOC_061_2M': {
        'flashSize': 0x200000,  # 2 MBytes
        **common_PSOC_061
    },
    'PSOC_061_1M': {
        'flashSize': 0x100000,  # 1 MByte
        **common_PSOC_061
    },
    'PSOC_061_512K': {
        'flashSize': 0x80000,  # 512 KBytes
        **common_PSOC_061
    },

    'PSOC_062_2M': {
        'flashSize': 0x200000,  # 2 MBytes
        **common_PSOC_06x
    },
    'PSOC_062_1M': {
        'flashSize': 0x100000,  # 1 MByte
        **common_PSOC_06x
    },
    'PSOC_062_512K': {
        'flashSize': 0x80000,  # 512 KBytes
        **common_PSOC_06x
    },

    'PSOC_063_1M': {
        'flashSize': 0x100000,  # 1 MByte
        **common_PSOC_06x
    },

    'XMC7200': {
        'flashSize': 0x100000,  # 1 MByte
        **common_XMC7000
    },

    'XMC7100': {
        'flashSize': 0x100000,  # 1 MByte
        **common_PSOC_06x
    },

    'CYW20829': {
        **common_CYW20829
    },

    'CYW89829': {
        **common_CYW20829
    }
}

# Supported SPI Flash ICs
flashDict = {
    # Fudan
    'FM25Q04': {
        'flashSize': 0x80000,  # 4 Mbits
        'eraseSize': 0x1000,  # 128 uniform sectors with 4K-byte each
    },
    'FM25W04': {
        'flashSize': 0x80000,  # 4 Mbits
        'eraseSize': 0x1000,  # 128 uniform sectors with 4K-byte each
    },
    'FM25Q08': {
        'flashSize': 0x100000,  # 8 Mbits
        'eraseSize': 0x1000,  # 256 uniform sectors with 4K-byte each
    },
    'FM25W08': {
        'flashSize': 0x100000,  # 8 Mbits
        'eraseSize': 0x1000,  # 256 uniform sectors with 4K-byte each
    },
    # Puya
    'P25Q05H': {
        'flashSize': 0x10000,  # 512 Kbits
        'eraseSize': 0x1000,  # Uniform 4K-byte Sector Erase
    },
    'P25Q10H': {
        'flashSize': 0x20000,  # 1 Mbit
        'eraseSize': 0x1000,  # Uniform 4K-byte Sector Erase
    },
    'P25Q20H': {
        'flashSize': 0x40000,  # 2 Mbits
        'eraseSize': 0x1000,  # Uniform 4K-byte Sector Erase
    },
    'P25Q40H': {
        'flashSize': 0x80000,  # 4 Mbits
        'eraseSize': 0x1000,  # Uniform 4K-byte Sector Erase
    },
    # Infineon
    'S25HS256T': {
        'flashSize': 0x2000000,  # 256 Mbits
        'eraseSize': 0x40000,  # Uniform Sector Architecture
    },
    'S25HS512T': {
        'flashSize': 0x4000000,  # 512 Mbits
        'eraseSize': 0x40000,  # Uniform Sector Architecture
    },
    'S25HS01GT': {
        'flashSize': 0x8000000,  # 1 Gbit
        'eraseSize': 0x40000,  # Uniform Sector Architecture
    }
}


def is_overlap(fa1off, fa1size, fa2off, fa2size, align):
    """Check if two flash areas on the same device overlap"""
    mask = align - 1
    assert align > 0 and (align & mask) == 0  # ensure align is a power of 2
    fa1end = (fa1off + fa1size + mask) & ~mask
    fa2end = (fa2off + fa2size + mask) & ~mask
    fa1off = fa1off & ~mask
    fa2off = fa2off & ~mask
    return fa1off < fa2end and fa2off < fa1end


def is_same_mem(fa1addr, fa2addr):
    """Check if two addresses belong to the same memory"""
    if fa1addr is None or fa2addr is None:
        return False
    mask = 0xFF000000
    return (fa1addr & mask) == (fa2addr & mask)


class CmdLineParams:
    """Command line parameters"""

    def __init__(self):
        self.plat_id = ''
        self.in_file = ''
        self.out_file = ''
        self.mk_file = ''
        self.fa_file = ''
        self.nonce_file = None
        self.img_id = None
        self.policy = None
        self.set_core = False
        self.image_boot_config = False

        usage = 'USAGE:\n' + sys.argv[0] + \
                ''' -p <platform> -i <flash_map.json> -o <memorymap.c> -k <memorymap.mk> -a <memorymap.h> -d <img_id> -c <policy.json>

OPTIONS:
-h  --help              Display the usage information
-p  --platform          Target (e.g., PSOC_062_512K)
-i  --ifile             JSON flash map file
-o  --ofile             C file to be generated
-k  --mk_file           Path where to create 'memorymap.mk'
-a  --fa_file           Path where to create 'memorymap.h'
-n  --nonce_file        Path where to create file with NONCE
-d  --img_id            ID of application to build
-c  --policy            Policy file in JSON format
-m  --core              Detect and set Cortex-M CORE
-x  --image_boot_config Generate image boot config structure
'''

        try:
            opts, unused = getopt.getopt(
                sys.argv[1:], 'h:i:o:k:a:n:p:d:c:x:m',
                ['help', 'platform=', 'ifile=', 'ofile=', 'mk_file=', 'fa_file=',
                 'nonce_file=', 'img_id=', 'policy=', 'core', 'image_boot_config'])
        except getopt.GetoptError:
            print(usage, file=sys.stderr)
            sys.exit(Error.ARG)

        for opt, arg in opts:
            if opt in ('-h', '--help'):
                print(usage, file=sys.stderr)
                sys.exit()
            elif opt in ('-p', '--platform'):
                self.plat_id = arg
            elif opt in ('-i', '--ifile'):
                self.in_file = arg
            elif opt in ('-o', '--ofile'):
                self.out_file = arg
            elif opt in ('-k', '--mk_file'):
                self.mk_file = arg
            elif opt in ('-a', '--fa_file'):
                self.fa_file = arg
            elif opt in ('-n', '--nonce_file'):
                self.nonce_file = arg
            elif opt in ('-d', '--img_id'):
                self.img_id = arg
            elif opt in ('-c', '--policy'):
                self.policy = arg
            elif opt in ('-m', '--core'):
                self.set_core = True
            elif opt in ('x', '--image_boot_config'):
                self.image_boot_config = True

        if any(len(x) == 0 for x in (self.in_file, self.out_file, self.mk_file, self.fa_file)):
            print(usage, file=sys.stderr)
            sys.exit(Error.ARG)


class AreaList:
    '''
    A List of flash areas
    ...

    Attributes
    ----------
    plat : dict
        Platform settings

    flash : dict
        External flash settings

    use_overwrite : bool
        Overwrite configuration in use

    areas : list
        Flash area parameter list

    peers : set
        Peers

    trailers : set
        Flash area trailers

    internal_flash : bool
        Internal flash in use

    external_flash : bool
        External flash in use

    external_flash_xip : bool
        External XIP in use

    Methods
    -------
    get_min_erase_size:
        Calculate minimum erase block size for int./ext. Flash

    get_img_trailer_size:
        Calculate image trailer size

    process_int_area:
        Process internal flash area

    process_ext_area:
        Process external flash area

    chk_area:
        Check area location (internal/external flash)

    add_area:
        Add flash area to AreaList.
        Internal/external flash is detected by address.

    generate_c_source:
        Generate C source

    create_flash_area_id:
        Creates flash_area_id.h file.
    '''

    def __init__(self, plat, flash, use_overwrite):
        self.plat = plat
        self.flash = flash
        self.use_overwrite = use_overwrite
        self.use_direct_xip = False
        self.areas = []
        self.peers = {}
        self.trailers = {}
        self.internal_flash = False
        self.external_flash = False
        self.external_flash_xip = False

    def get_min_erase_size(self):
        '''Calculate minimum erase block size for int./ext. Flash '''
        return self.plat['eraseSize'] if self.plat['flashSize'] > 0 \
            else self.flash['eraseSize']

    def get_img_trailer_size(self):
        '''Calculate image trailer size'''
        return self.get_min_erase_size()

    def process_int_area(self, title, addr, fa_size,
                         img_trailer_size, shared_slot):
        '''
        Process internal flash area
        Parameters:
        ----------
        title : str
            Area name

        addr : int
            Area address

        fa_size : int
            Area size

        img_trailer_size : int
            Trailer size

        shared_slot : bool
            Shared slot option in use

        Returns:
        ----------
        fa_device_id : str

        fa_off : int

        slot_sectors : int
        '''
        fa_device_id = 'FLASH_DEVICE_INTERNAL_FLASH'
        fa_off = addr - self.plat['flashAddr']
        if img_trailer_size is not None:
            if self.use_overwrite:
                if shared_slot:
                    print('Shared slot', title,
                          'is not supported in OVERWRITE mode',
                          file=sys.stderr)
                    sys.exit(Error.CONFIG_MISMATCH)
            else:
                # Check trailer alignment (start at the sector boundary)
                align = (fa_off + fa_size - img_trailer_size) % \
                        self.plat['eraseSize']
                if align != 0:
                    addr += self.plat['eraseSize'] - align
                    if addr + fa_size <= \
                            self.plat['flashAddr'] + self.plat['flashSize']:
                        print('Misaligned', title,
                              '- suggested address', hex(addr),
                              file=sys.stderr)
                    else:
                        print('Misaligned', title, file=sys.stderr)
                    sys.exit(Error.CONFIG_MISMATCH)
        else:
            # Check alignment (flash area should start at the sector boundary)
            if fa_off % self.plat['eraseSize'] != 0:
                print('Misaligned', title, file=sys.stderr)
                sys.exit(Error.CONFIG_MISMATCH)
        slot_sectors = int((fa_off % self.plat['eraseSize'] +
                            fa_size + self.plat['eraseSize'] - 1) //
                           self.plat['eraseSize'])
        return fa_device_id, fa_off, slot_sectors

    def process_ext_area(self, title, addr, fa_size,
                         img_trailer_size, shared_slot):
        '''
        Process external flash area
        Parameters:
        ----------
        title : str
            Area name

        addr : int
            Area address

        fa_size : int
            Area size

        img_trailer_size : int
            Trailer size

        shared_slot : bool
            Shared slot option in use

        Returns:
        ----------
        fa_device_id : str

        fa_off : int

        slot_sectors : int
        '''
        if self.flash is None:
            print('Unspecified SPI Flash IC',
                  file=sys.stderr)
            sys.exit(Error.FLASH)
        if addr + fa_size <= \
                self.plat['smifAddr'] + self.flash['flashSize']:
            flash_idx = 'CY_BOOT_EXTERNAL_DEVICE_INDEX'
            fa_device_id = f'FLASH_DEVICE_EXTERNAL_FLASH({flash_idx})'
            fa_off = addr - self.plat['smifAddr']
        else:
            print('Misfitting', title, file=sys.stderr)
            sys.exit(Error.CONFIG_MISMATCH)
        if img_trailer_size is not None:
            if self.use_overwrite:
                if shared_slot:
                    print('Shared slot', title,
                          'is not supported in OVERWRITE mode',
                          file=sys.stderr)
                    sys.exit(Error.CONFIG_MISMATCH)
            else:
                # Check trailer alignment (start at the sector boundary)
                align = (fa_off + fa_size - img_trailer_size) % \
                        self.flash['eraseSize']
                if align != 0:
                    peer_addr = self.peers.get(addr)
                    if shared_slot:
                        # Special case when using both int. and ext. memory
                        if self.plat['flashSize'] > 0 and \
                                align % self.plat['eraseSize'] == 0:
                            print('Note:', title, 'requires', align,
                                  'padding bytes before trailer',
                                  file=sys.stderr)
                        else:
                            print('Misaligned', title, file=sys.stderr)
                            sys.exit(Error.CONFIG_MISMATCH)
                    elif is_same_mem(addr, peer_addr) and \
                            addr % self.flash['eraseSize'] == \
                            peer_addr % self.flash['eraseSize']:
                        pass  # postpone checking
                    else:
                        addr += self.flash['eraseSize'] - align
                        if addr + fa_size <= \
                                self.plat['smifAddr'] + self.flash['flashSize']:
                            print('Misaligned', title,
                                  '- suggested address', hex(addr),
                                  file=sys.stderr)
                        else:
                            print('Misaligned', title, file=sys.stderr)
                        sys.exit(Error.CONFIG_MISMATCH)
        else:
            # Check alignment (flash area should start at the sector boundary)
            if fa_off % self.flash['eraseSize'] != 0:
                print('Misaligned', title, file=sys.stderr)
                sys.exit(Error.CONFIG_MISMATCH)
        slot_sectors = int((fa_off % self.flash['eraseSize'] +
                            fa_size + self.flash['eraseSize'] - 1) //
                           self.flash['eraseSize'])
        self.external_flash = True
        if self.flash['XIP']:
            self.external_flash_xip = True
        return fa_device_id, fa_off, slot_sectors

    def chk_area(self, addr, fa_size, peer_addr=None):
        '''
        Check area location (internal/external flash)
        Parameters:
        ----------
        addr : int
            Area address

        fa_size : int
            Area size

        peer_addr : bool (optional)
            Shared slot option in use

        Returns:
        ----------
        None
        '''
        if peer_addr is not None:
            self.peers[peer_addr] = addr
        fa_limit = addr + fa_size
        if self.plat['flashSize'] and \
                addr >= self.plat['flashAddr'] and \
                fa_limit <= self.plat['flashAddr'] + self.plat['flashSize']:
            # Internal flash
            self.internal_flash = True

    def add_area(self, title,
                 fa_id, addr, fa_size,
                 img_trailer_size=None, shared_slot=False):
        '''
        Add flash area to AreaList.
        Internal/external flash is detected by address.
        Parameters:
        ----------
        title : str
            Area name

        fa_id : str
            Area id

        addr : int
            Area address

        fa_size : int
            Area size

        img_trailer_size : int
            Trailer size (optional)

        shared_slot : bool
            Shared slot option in use (optional)

        Returns:
        ----------
        slot_sectors : int
            Number of sectors in a slot
        '''
        if fa_size == 0:
            print('Empty', title, file=sys.stderr)
            sys.exit(Error.CONFIG_MISMATCH)

        fa_limit = addr + fa_size
        if self.plat['flashSize'] and \
                addr >= self.plat['flashAddr'] and \
                fa_limit <= self.plat['flashAddr'] + self.plat['flashSize']:
            # Internal flash
            fa_device_id, fa_off, slot_sectors = self.process_int_area(
                title, addr, fa_size, img_trailer_size, shared_slot)
            align = self.plat['eraseSize']
        elif self.plat['smifSize'] and \
                addr >= self.plat['smifAddr'] and \
                fa_limit <= self.plat['smifAddr'] + self.plat['smifSize']:
            # External flash
            fa_device_id, fa_off, slot_sectors = self.process_ext_area(
                title, addr, fa_size, img_trailer_size, shared_slot)
            align = self.flash['eraseSize']
        else:
            print('Invalid', title, file=sys.stderr)
            sys.exit(Error.CONFIG_MISMATCH)

        if shared_slot:
            assert img_trailer_size is not None
            tr_addr = addr + fa_size - img_trailer_size
            tr_name = self.trailers.get(tr_addr)
            if tr_name is not None:
                print('Same trailer address for', title, 'and', tr_name,
                      file=sys.stderr)
                sys.exit(Error.CONFIG_MISMATCH)
            self.trailers[tr_addr] = title

        # Ensure no flash areas on this device will overlap, except the
        # shared slot
        for area in self.areas:
            if fa_device_id == area['fa_device_id']:
                over = is_overlap(fa_off, fa_size,
                                  area['fa_off'], area['fa_size'],
                                  align)
                if shared_slot and area['shared_slot']:
                    if not over:  # images in shared slot should overlap
                        print(title, 'is not shared with', area['title'],
                              file=sys.stderr)
                elif over:
                    print(title, 'overlaps with', area['title'],
                          file=sys.stderr)
                    sys.exit(Error.CONFIG_MISMATCH)

        self.areas.append({'title': title,
                           'shared_slot': shared_slot,
                           'fa_id': fa_id,
                           'fa_device_id': fa_device_id,
                           'fa_off': fa_off,
                           'fa_size': fa_size})
        return slot_sectors

    def generate_c_source(self, params, boot_and_upgrade):
        '''
        Generate C source
        Parameters:
        ----------
        params : CmdLineParams
            Application parameters

        Returns:
        ----------
        None
        '''
        c_array = 'flash_areas'

        try:
            with open(params.out_file, "w", encoding='UTF-8') as out_f:

                out_f.write(f'#include "{params.fa_file}"\n')
                out_f.write(f'#include "flash_map_backend.h"\n\n')
                out_f.write(f'#include "flash_map_backend_platform.h"\n\n')
                out_f.write(f'const struct flash_area {c_array}[] = {{\n')
                comma = len(self.areas)
                area_count = 0
                for area in self.areas:
                    comma -= 1
                    if area['fa_id'] is not None:
                        sss = ' /* Shared secondary slot */' \
                            if area['shared_slot'] else ''
                        out_f.writelines('\n'.join([
                            '    {' + sss,
                            f"        .fa_id        = {area['fa_id']},",
                            f"        .fa_device_id = {area['fa_device_id']},",
                            f"        .fa_off       = {hex(area['fa_off'])}U,",
                            f"        .fa_size      = {hex(area['fa_size'])}U",
                            '    },' if comma else '    }', '']))
                        area_count += 1
                out_f.write('};\n\n'
                            'const struct flash_area * const boot_area_descs[] = {\n')
                for area_index in range(area_count):
                    out_f.write(f'    &{c_array}[{area_index}U],\n')
                out_f.write('    NULL\n};\n')

                image_boot_mode = None

                if params.image_boot_config:
                    image_boot_mode = process_boot_type(boot_and_upgrade)

                if image_boot_mode:
                    out_f.write('\nimage_boot_config_t image_boot_config[BOOT_IMAGE_NUMBER] = {\n')
                    for mode in image_boot_mode:
                        out_f.writelines('\n'.join([
                            '\t{\n'
                            f"\t\t.mode     = {mode['mode']},",
                            f"\t\t.address  = {mode['address']},",
                            f"\t\t.size     = {mode['size']},",
                            '\t},\n']))
                    out_f.write('};\n')

                out_f.close()

        except (FileNotFoundError, OSError):
            print('Cannot create', params.out_file, file=sys.stderr)
            sys.exit(Error.IO)

    def create_flash_area_id(self, img_number, params):
        """ Get 'img_number' and generate flash_area_id.h file' """

        #check if params.fa_file already exists and it has FLASH_AREA_ID
        if os.path.exists(params.fa_file):
            with open(params.fa_file, "r", encoding='UTF-8') as fa_f:
                content = fa_f.read()
                res = content.find(f"FLASH_AREA_IMG_{img_number}_SECONDARY")
                if res != -1:
                    fa_f.close()
                    return

                fa_f.close()

        try:
            with open(params.fa_file, "w", encoding='UTF-8') as fa_f:
                fa_f.write("#pragma once\n")
                fa_f.write('/* AUTO-GENERATED FILE, DO NOT EDIT.'
                            ' ALL CHANGES WILL BE LOST! */\n')
                fa_f.write(f'#include "flash_map_backend.h"\n\n')
                fa_f.write('#include "bootutil/bootutil.h"\n')

                fa_f.write(f'extern const struct flash_area {c_array}[];\n')
                fa_f.write(f'extern const struct flash_area * const boot_area_descs[];\n')

                #we always have BOOTLOADER and IMG_1_
                fa_f.write("#define FLASH_AREA_BOOTLOADER          ( 0u)\n\n")
                fa_f.write("#define FLASH_AREA_IMG_1_PRIMARY       ( 1u)\n")
                fa_f.write("#define FLASH_AREA_IMG_1_SECONDARY     ( 2u)\n\n")

                fa_f.write("#define FLASH_AREA_IMAGE_SCRATCH       ( 3u)\n")
                fa_f.write("#define FLASH_AREA_IMAGE_SWAP_STATUS   ( 7u)\n\n")

                for img in range(2, img_number + 1):
                    """ img_id_primary and img_id_secondary must be aligned with the
                        flash_area_id, calculated in the functions
                        __STATIC_INLINE uint8_t FLASH_AREA_IMAGE_PRIMARY(uint32_t img_idx) and
                        __STATIC_INLINE uint8_t FLASH_AREA_IMAGE_SECONDARY(uint32_t img_idx),
                        in boot/cypress/platforms/memory/sysflash/sysflash.h
                    """

                    slots_for_image = 2
                    img_id_primary = None
                    img_id_secondary = None

                    if img == 2:
                        img_id_primary = int(slots_for_image * img)
                        img_id_secondary = int(slots_for_image * img + 1)

                    #number 7 is used for FLASH_AREA_IMAGE_SWAP_STATUS, so the next is 8
                    if img >= 3:
                        img_id_primary = int(slots_for_image * img + 2)
                        img_id_secondary = int(slots_for_image * img + 3)

                    fa_f.write(f"#define FLASH_AREA_IMG_{img}_PRIMARY       ( {img_id_primary}u)\n")
                    fa_f.write(f"#define FLASH_AREA_IMG_{img}_SECONDARY     ( {img_id_secondary}u)\n\n")

                if self.plat.get('bitsPerCnt'):
                    list_counters = process_policy_20829(params.policy)
                    if list_counters is not None:
                        form_max_counter_array(list_counters, fa_f)

                fa_f.writelines('\n'.join([
                    '',
                    'typedef enum',
                    '{',
                        '\tIMAGE_BOOT_MODE_FLASH = 0U,',
                        '\tIMAGE_BOOT_MODE_RAM = 1U,',
                    '} image_boot_mode_t;',
                    '',
                    'typedef struct image_boot_config_s {',
                        '\timage_boot_mode_t mode;',
                        '\tuint32_t address;',
                        '\tuint32_t size;',
                    '} image_boot_config_t;',
                    '',
                    'extern image_boot_config_t image_boot_config[BOOT_IMAGE_NUMBER];'
                ]))

                fa_f.close()

        except (FileNotFoundError, OSError):
            print('\nERROR: Cannot create ', params.fa_file, file=sys.stderr)
            sys.exit(Error.IO)


def cvt_dec_or_hex(val, desc):
    """Convert (hexa)decimal string to number"""
    try:
        return int(val, 0)
    except ValueError:
        print('Invalid value', val, 'for', desc, file=sys.stderr)
        sys.exit(Error.VALUE)


def get_val(obj, attr):
    """Get JSON 'value'"""
    obj = obj[attr]
    try:
        return cvt_dec_or_hex(obj['value'], obj['description'])
    except KeyError as key:
        print('Malformed JSON:', key,
              'is missing in', "'" + attr + "'",
              file=sys.stderr)
        sys.exit(Error.JSON)


def get_bool(obj, attr, def_val=False):
    """Get JSON boolean value (returns def_val if it is missing)"""
    ret_val = def_val
    obj = obj.get(attr)
    if obj is not None:
        try:
            val = str(obj['value']).lower()
            desc = obj['description']
            if val == 'true':
                ret_val = True
            elif val == 'false':
                ret_val = False
            else:
                print('Invalid value', val, 'for', desc, file=sys.stderr)
                sys.exit(Error.VALUE)
        except KeyError as key:
            print('Malformed JSON:', key,
                  'is missing in', "'" + attr + "'",
                  file=sys.stderr)
            sys.exit(Error.JSON)
    return ret_val


def get_str(obj, attr, def_val=None):
    """Get JSON string value (returns def_val if it is missing)"""
    ret_val = def_val
    obj = obj.get(attr)
    if obj is not None:
        try:
            ret_val = str(obj['value'])
        except KeyError as key:
            print('Malformed JSON:', key,
                  'is missing in', "'" + attr + "'",
                  file=sys.stderr)
            sys.exit(Error.JSON)
    return ret_val


class AddrSize:
    """Bootloader area"""

    def __init__(self, bootloader, addr_name, size_name):
        self.addr = get_val(bootloader, addr_name)
        self.size = get_val(bootloader, size_name)


def calc_status_size(boot_swap_status_row_sz, max_img_sectors,
                     img_number, scratch_flag=True):
    """Estimate status size, see swap_status.h"""
    boot_swap_status_cnt_sz = 4
    boot_swap_status_crc_sz = 4
    boot_swap_status_mgcrec_sz = 4
    boot_swap_status_trailer_size = 64
    boot_swap_status_payld_sz = \
        boot_swap_status_row_sz - boot_swap_status_mgcrec_sz - \
        boot_swap_status_cnt_sz - boot_swap_status_crc_sz
    boot_swap_status_sect_rows_num = \
        int((max_img_sectors - 1) //
            boot_swap_status_payld_sz) + 1
    boot_swap_status_trail_rows_num = \
        int((boot_swap_status_trailer_size - 1) //
            boot_swap_status_payld_sz) + 1
    boot_swap_status_d_size = \
        boot_swap_status_row_sz * \
        (boot_swap_status_sect_rows_num + boot_swap_status_trail_rows_num)
    boot_swap_status_mult = 2
    boot_swap_status_size = boot_swap_status_mult * boot_swap_status_d_size
    status_zone_cnt = 2 * img_number
    if scratch_flag:
        status_zone_cnt += 1
    return boot_swap_status_size * status_zone_cnt


def process_json(in_file):
    """Process JSON"""
    try:
        with open(in_file, encoding='UTF-8') as in_f:
            try:
                flash_map = json.load(in_f)
            except ValueError:
                print('Cannot parse', in_file, file=sys.stderr)
                sys.exit(Error.IO)
    except (FileNotFoundError, OSError):
        print('Cannot open', in_file, file=sys.stderr)
        sys.exit(Error.IO)
    flash = flash_map.get('external_flash')
    if flash is not None:
        flash = flash[0]
        model = flash.get('model')
        mode = flash.get('mode')
        if model is not None:
            try:
                flash = flashDict[model]
            except KeyError:
                print('Supported SPI Flash ICs are:',
                      ', '.join(flashDict.keys()),
                      file=sys.stderr)
                sys.exit(Error.FLASH)
        else:
            try:
                flash = {'flashSize': cvt_dec_or_hex(flash['flash-size'],
                                                     'flash-size'),
                         'eraseSize': cvt_dec_or_hex(flash['erase-size'],
                                                     'erase-size')}
            except KeyError as key:
                print('Malformed JSON:', key,
                      "is missing in 'external_flash'",
                      file=sys.stderr)
                sys.exit(Error.FLASH)
        flash.update({'XIP': str(mode).upper() == 'XIP'})
    return flash_map.get('boot_and_upgrade', None), flash_map.get('ram_app_staging', None), flash

def process_boot_type(boot_and_upgrade):
    image_boot_mode = []

    for app_index in range(1, 5):
        app_ident = f'application_{app_index}'
        application = boot_and_upgrade.get(app_ident)

        if application:
            mem = application.get('ram_boot')

            if mem:
                image_boot_mode.append(
                    {
                        'mode': 'IMAGE_BOOT_MODE_RAM',
                        'address': mem.get('address', {}).get('value', 0),
                        'size': mem.get('size', {}).get('value', 0),
                    }
                )
            else :
                mem = application.get('flash')
                image_boot_mode.append(
                    {
                        'mode': 'IMAGE_BOOT_MODE_FLASH',
                        'address': mem.get('address', {}).get('value', 0),
                        'size': mem.get('size', {}).get('value', 0),
                    }
                )

    return image_boot_mode

def process_images(area_list, boot_and_upgrade):
    """Process images"""
    app_count = 0
    slot_sectors_max = 0
    all_shared = get_bool(boot_and_upgrade['bootloader'], 'shared_slot')
    any_shared = all_shared
    app_core = None
    apps_flash_map = [None, ]
    apps_ram_map = [None, ]

    for stage in range(2):
        for app_index in range(1, MAX_IMAGE_NUMBERS):

            app_flash_map = {}
            app_ram_map = {}
            app_ram_boot = False

            try:
                app_ident = f'application_{app_index}'
                application = boot_and_upgrade[app_ident]

                try:
                    flash = application['flash']
                except KeyError:
                    #Backward compatibility
                    flash = application

                try:
                    config = application['config']
                except KeyError:
                    #Backward compatibility
                    config = application

                try:
                    ram = application['ram']
                except KeyError:
                    try:
                        ram = application['ram_boot']
                        app_ram_boot = True
                    except KeyError:
                        ram = None

                try:
                    try:
                        primary_addr = get_val(flash, 'primary_slot')
                        secondary_addr = get_val(flash, 'secondary_slot')
                        primary_size = get_val(flash, 'primary_slot_size')
                        secondary_size = get_val(flash, 'secondary_slot_size')

                        area_list.use_direct_xip = True

                    except KeyError:
                        primary_addr = get_val(flash, 'address')
                        secondary_addr = get_val(flash, 'upgrade_address')
                        primary_size = get_val(flash, 'size')
                        secondary_size = get_val(flash, 'upgrade_size')

                    if ram is not None:
                        app_ram_addr = get_val(ram, 'address')
                        app_ram_size = get_val(ram, 'size')
                    else:
                        app_ram_addr = None
                        app_ram_size = None

                except KeyError as key:
                    print('Malformed JSON:', key, 'is missing',
                          file=sys.stderr)
                    sys.exit(Error.JSON)
                if stage == 0:
                    if primary_size != secondary_size:
                        print('Primary and secondary slot sizes'
                              ' are different for', app_ident,
                              file=sys.stderr)
                        sys.exit(Error.VALUE)
                    area_list.chk_area(primary_addr, primary_size)
                    area_list.chk_area(secondary_addr, secondary_size,
                                       primary_addr)
                    if config is None or config.get('core') is None:
                        if app_index == 1:
                            app_core = area_list.plat['appCore']
                    elif app_index > 1:
                        print('"core" makes sense only for the 1st app',
                              file=sys.stderr)
                        sys.exit(Error.VALUE)
                    else:
                        app_core = get_str(config, 'core',
                                           area_list.plat['appCore'])
                    if app_index == 1:
                        app_core = area_list.plat['allCores'].get(app_core.lower())
                        if app_core is None:
                            print('Unknown "core"', file=sys.stderr)
                            sys.exit(Error.VALUE)
                else:
                    slot_sectors_max = max(
                        slot_sectors_max,
                        area_list.add_area(
                            f'{app_ident} (primary slot)',
                            f'FLASH_AREA_IMG_{app_index}_PRIMARY',
                            primary_addr, primary_size,
                            area_list.get_img_trailer_size()))
                    shared_slot = get_bool(flash, 'shared_slot', all_shared)
                    any_shared = any_shared or shared_slot
                    slot_sectors_max = max(
                        slot_sectors_max,
                        area_list.add_area(
                            f'{app_ident} (secondary slot)',
                            f'FLASH_AREA_IMG_{app_index}_SECONDARY',
                            secondary_addr, secondary_size,
                            area_list.get_img_trailer_size(),
                            shared_slot))

                    app_slot_prim = {"address": hex(primary_addr), "size": hex(primary_size)}
                    app_slot_sec = {"address": hex(secondary_addr), "size": hex(secondary_size)}

                    app_flash_map.update({"primary": app_slot_prim, "secondary": app_slot_sec})
                    apps_flash_map.append(app_flash_map)

                    if ram is not None:
                        app_ram_map.update({"address": app_ram_addr
                                            , "size": app_ram_size
                                            , "ram_boot": app_ram_boot})
                        apps_ram_map.append(app_ram_map)
                    else:
                        apps_ram_map = None

                app_count = app_index

            except KeyError:
                break
        if app_count == 0:
            print('Malformed JSON: no application(s) found',
                  file=sys.stderr)
            sys.exit(Error.JSON)

    return app_core, app_count, slot_sectors_max, apps_flash_map, apps_ram_map, any_shared


def process_policy_20829(in_policy):
    """Process policy file to get data of NV-counter"""
    list_counters = None

    try:
        with open(in_policy, encoding='UTF-8') as in_f:
            try:
                policy = json.load(in_f)
            except ValueError:
                print('\nERROR: Cannot parse', in_policy,'\n', file=sys.stderr)
                sys.exit(Error.IO)
            finally:
                in_f.close()
    except (FileNotFoundError, OSError):
        print('Cannot open', in_policy, file=sys.stderr)
        sys.exit(Error.IO)

    try:
        nv_cnt = policy["device_policy"]['reprovisioning']['nv_counter']
        list_values = nv_cnt["value"]
        list_counters = nv_cnt["bits_per_cnt"]
    except KeyError:
        print("\nERROR: Check path to 'nv_counter' and its correctness in policy file", in_policy,
            ".\n", file=sys.stderr)
        sys.exit(Error.POLICY)

    #Check correctness of NV-counter
    try:
        len_list_value = len(list_values)
        len_list_counters = len(list_counters)
    except TypeError:
        print("\nERROR: Fields 'value' and 'bits_per_cnt' of 'nv_counter' in policy file",
            in_policy,"must be arrays.\n", file=sys.stderr)
        sys.exit(Error.POLICY)

    if len_list_value != len_list_counters:
        print("\nERROR: Fields 'value' and 'bits_per_cnt' of 'nv_counter' in policy file",
            in_policy,"must have the same size.\n", file=sys.stderr)
        sys.exit(Error.POLICY)

    sum_all_counters = 0
    for i in range(len_list_value):
        sum_all_counters += list_counters[i]
        if list_values[i] > list_counters[i]:
            print("\nERROR: Field 'value' cannot be more then 'bits_per_cnt'.", file=sys.stderr)
            print("Check 'nv_counter' in policy file", in_policy,"\n", file=sys.stderr)
            sys.exit(Error.POLICY)

    sum_all_bit_nv_counter = 32
    if sum_all_counters != sum_all_bit_nv_counter:
        print("\nERROR: The sum of all 'bits_per_cnt' must be equal to 32.", file=sys.stderr)
        print("Check 'nv_counter' in policy file", in_policy,"\n", file=sys.stderr)
        sys.exit(Error.POLICY)

    return list_counters


def form_max_counter_array(in_list, fa_f):
    '''Write bit_per_count array to output file '''
    #ifdef here is needed to fix Rule 12.2 MISRA violation
    out_array_str = "\n#ifdef NEED_MAX_COUNTERS\nstatic const uint8_t bits_per_cnt[] = {"

    #in_list is checked in prior function 'process_policy()'
    for i, list_member in enumerate(in_list):
        out_array_str += str(list_member)
        if i < len(in_list) - 1:
            out_array_str += ", "
    out_array_str += "};\n#endif\n"

    fa_f.write(out_array_str)


def main():
    """Flash map converter"""
    params = CmdLineParams()

    try:
        plat = platDict[params.plat_id]
    except KeyError:
        print('Supported platforms are:', ', '.join(platDict.keys()),
              file=sys.stderr)
        sys.exit(Error.POLICY)

    try:
        boot_and_upgrade, ram_app_staging, flash = process_json(params.in_file)
        bootloader = boot_and_upgrade['bootloader']
        try:
            bootloader_config = bootloader['config']
        except KeyError:
            #Backward compatibility
            bootloader_config = bootloader

        if ram_app_staging is not None:
            try:
                ram_app_staging_size = get_val(ram_app_staging, 'size')
                ram_app_staging_ext_mem_addr = get_val(ram_app_staging, 'external_mememory_address')
                ram_app_staging_sram_stage_addr = get_val(ram_app_staging, 'sram_stage_address')
                ram_app_staging_reset_trigger = get_bool(ram_app_staging, 'reset_after_staging')
            except KeyError:
                ram_app_staging = None

        try:
            bootloader_flash = bootloader['flash']
        except KeyError:
            #Backward compatibility
            bootloader_flash = bootloader

        try:
            bootloader_ram = bootloader['ram']
        except KeyError:
            #Backward compatibility
            bootloader_ram = bootloader

        boot_flash_area = AddrSize(bootloader_flash, 'address', 'size')
        boot_ram_area = AddrSize(bootloader_ram, 'address', 'size')
    except KeyError as key:
        print('Malformed JSON:', key, 'is missing',
              file=sys.stderr)
        sys.exit(Error.JSON)

    try:
        scratch = AddrSize(bootloader_flash, 'scratch_address', 'scratch_size')
    except KeyError:
        scratch = None

    try:
        swap_status = AddrSize(bootloader_flash, 'status_address', 'status_size')
    except KeyError:
        swap_status = None

    try:
        bootloader_shared_data = bootloader['shared_data']
        boot_shared_data_area = AddrSize(bootloader_shared_data, 'address', 'size')
    except KeyError:
        boot_shared_data_area = None

    try:
        bootloader_startup = get_bool(bootloader_config, 'startup')
    except KeyError:
        bootloader_startup = None

    try:
        ram_app_area = AddrSize(bootloader_config['ram_boot'], 'address', 'size')
    except  KeyError:
        ram_app_area = None


    # Create flash areas
    area_list = AreaList(plat, flash, scratch is None and swap_status is None)
    area_list.add_area('bootloader', 'FLASH_AREA_BOOTLOADER',
                       boot_flash_area.addr, boot_flash_area.size)

    # Service RAM app (optional)
    service_app = boot_and_upgrade.get('service_app')
    app_binary = None
    input_params = None
    app_desc = None
    if service_app is not None:
        if plat['flashSize'] > 0:
            print('service_app is unsupported on this platform', file=sys.stderr)
            sys.exit(Error.CONFIG_MISMATCH)
        try:
            app_binary = AddrSize(service_app, 'address', 'size')
            input_params = AddrSize(service_app, 'params_address', 'params_size')
            app_desc = AddrSize(service_app, 'desc_address', 'desc_size')
            if input_params.addr != app_binary.addr + app_binary.size or \
                    app_desc.addr != input_params.addr + input_params.size or \
                    app_desc.size != SERVICE_APP_SZ:
                print('Malformed service_app definition', file=sys.stderr)
                sys.exit(Error.CONFIG_MISMATCH)
            area_list.add_area('service_app', None, app_binary.addr,
                               app_binary.size + input_params.size + app_desc.size)
        except KeyError as key:
            print('Malformed JSON:', key, 'is missing', file=sys.stderr)
            sys.exit(Error.JSON)

    # Fill flash areas
    app_core, app_count, slot_sectors_max, apps_flash_map, apps_ram_map, shared_slot = \
        process_images(area_list, boot_and_upgrade)

    cy_img_hdr_size = 0x400
    app_start = int(apps_flash_map[1].get("primary").get("address"), 0) + cy_img_hdr_size

    if app_start % plat['VTAlign'] != 0:
        print('Starting address', apps_flash_map[1].get("primary").get("address"),
              '+', hex(cy_img_hdr_size), 'must be aligned to', hex(plat['VTAlign']),
              file=sys.stderr)
        sys.exit(Error.CONFIG_MISMATCH)

    slot_sectors_max = max(slot_sectors_max, 32)

    if swap_status is not None:
        status_size_min = calc_status_size(area_list.get_min_erase_size(),
                                           slot_sectors_max,
                                           app_count,
                                           scratch is not None)

        if swap_status.size < status_size_min:
            print('Insufficient swap status area - suggested size',
                  hex(status_size_min),
                  file=sys.stderr)
            sys.exit(Error.CONFIG_MISMATCH)
        area_list.add_area('swap status partition',
                           'FLASH_AREA_IMAGE_SWAP_STATUS',
                           swap_status.addr, swap_status.size)

    if scratch is not None:
        area_list.add_area('scratch area',
                           'FLASH_AREA_IMAGE_SCRATCH',
                           scratch.addr, scratch.size)

    # Compare size 'bit_per_cnt' and number of images.
    # 'service_app' is used only when HW rollback counter exists
    if plat.get('bitsPerCnt') is not None and service_app is not None:
        plat['bitsPerCnt'] = True
        list_counters = process_policy_20829(params.policy)
        if list_counters is not None and len(list_counters) != app_count:
            print("\nERROR: 'bits_per_cnt' must be present for each image!",
                file=sys.stderr)
            print("Please, check secure provisioning and reprovisioning policies.\n",
                file=sys.stderr)
            sys.exit(Error.CONFIG_MISMATCH)

    # Image id parameter is not used for MCUBootApp
    if params.img_id is None:
        area_list.generate_c_source(params, boot_and_upgrade)

    area_list.create_flash_area_id(app_count, params)

    # Write necessary values to makefile
    try:
        mk_file = open(params.mk_file, "w")
    except (FileNotFoundError, OSError):
        print('\nERROR: Cannot create ', params.mk_file, file=sys.stderr)
        sys.exit(Error.IO)

    print('# AUTO-GENERATED FILE, DO NOT EDIT. ALL CHANGES WILL BE LOST!', file=mk_file)
    if params.set_core:
        print('CORE :=', plat['allCores'][plat['bootCore'].lower()], file=mk_file)

    if ram_app_staging is not None:
        print('USE_STAGE_RAM_APPS := 1', file=mk_file)
        print('RAM_APP_STAGING_EXT_MEM_ADDR := ', hex(ram_app_staging_ext_mem_addr), file=mk_file)
        print('RAM_APP_STAGING_SRAM_MEM_ADDR :=', hex(ram_app_staging_sram_stage_addr), file=mk_file)
        print('RAM_APP_STAGING_SIZE := ', hex(ram_app_staging_size), file=mk_file)
        if ram_app_staging_reset_trigger is True:
            print('RAM_APP_RESET_TRIGGER := 1', file=mk_file)

    if bootloader_startup is True:
        print('BOOTLOADER_STARTUP := 1', file=mk_file)

    if ram_app_area is not None:
        print('USE_MCUBOOT_RAM_LOAD := 1', file=mk_file)
        print('IMAGE_EXECUTABLE_RAM_START :=', hex(ram_app_area.addr), file=mk_file)
        print('IMAGE_EXECUTABLE_RAM_SIZE :=', hex(ram_app_area.size), file=mk_file)

    if boot_shared_data_area is not None:
        print('USE_MEASURED_BOOT := 1', file=mk_file)
        print('USE_DATA_SHARING := 1', file=mk_file)
        print('BOOT_SHARED_DATA_ADDRESS :=', hex(boot_shared_data_area.addr)+'U', file=mk_file)
        print('BOOT_SHARED_DATA_SIZE :=', hex(boot_shared_data_area.size)+'U', file=mk_file)
        print('BOOT_SHARED_DATA_RECORD_SIZE :=', hex(boot_shared_data_area.size)+'U', file=mk_file)

    print('BOOTLOADER_ORIGIN :=', hex(boot_flash_area.addr), file=mk_file)
    print('BOOTLOADER_SIZE :=', hex(boot_flash_area.size), file=mk_file)
    print('BOOTLOADER_RAM_ORIGIN :=', hex(boot_ram_area.addr), file=mk_file)
    print('BOOTLOADER_RAM_SIZE :=', hex(boot_ram_area.size), file=mk_file)
    print('APP_CORE :=', app_core, file=mk_file)

    # for blinky
    if params.img_id is not None:
        primary_img_start = apps_flash_map[int(params.img_id)].get("primary").get("address")
        secondary_img_start = apps_flash_map[int(params.img_id)].get("secondary").get("address")
        slot_size = apps_flash_map[int(params.img_id)].get("primary").get("size")

        if apps_ram_map:
            image_ram_address = apps_ram_map[int(params.img_id)].get("address")
            image_ram_size = apps_ram_map[int(params.img_id)].get("size")
            image_ram_boot = apps_ram_map[int(params.img_id)].get("ram_boot")
            if image_ram_address and image_ram_size:
                print('IMG_RAM_ORIGIN := ' + hex(image_ram_address), file=mk_file)
                print('IMG_RAM_SIZE := ' + hex(image_ram_size), file=mk_file)
                if image_ram_boot is True:
                    print('USE_MCUBOOT_RAM_LOAD := 1', file=mk_file)

        print('PRIMARY_IMG_START := ' + primary_img_start, file=mk_file)
        print('SECONDARY_IMG_START := ' + secondary_img_start, file=mk_file)
        print('SLOT_SIZE := ' + slot_size, file=mk_file)
    # for bootloader
    else:
        if apps_ram_map:
            ram_load_counter = 0
            for img in apps_ram_map:
                if img is not None and img.get("ram_boot"):
                    ram_load_counter += 1

            if ram_load_counter != 0:
                print('USE_MCUBOOT_RAM_LOAD := 1', file=mk_file)
                if ram_load_counter == 1:
                    print(f'IMAGE_EXECUTABLE_RAM_START := {hex(apps_ram_map[1].get("address"))}', file=mk_file)
                    print(f'IMAGE_EXECUTABLE_RAM_SIZE := {hex(apps_ram_map[1].get("size"))}', file=mk_file)
                else:
                    print('USE_MCUBOOT_MULTI_MEMORY_LOAD := 1', file=mk_file)

        print('MAX_IMG_SECTORS :=', slot_sectors_max, file=mk_file)

    print('MCUBOOT_IMAGE_NUMBER :=', app_count, file=mk_file)
    if area_list.external_flash:
        print('USE_EXTERNAL_FLASH := 1', file=mk_file)
    if area_list.external_flash_xip:
        print('USE_XIP := 1', file=mk_file)

    if area_list.use_direct_xip:
        print('USE_DIRECT_XIP := 1', file=mk_file)
    elif area_list.use_overwrite:
        print('USE_OVERWRITE := 1', file=mk_file)

    if shared_slot:
        print('USE_SHARED_SLOT := 1', file=mk_file)
    if service_app is not None:
        print('PLATFORM_SERVICE_APP_OFFSET :=',
              hex(app_binary.addr - plat['smifAddr']), file=mk_file)
        print('PLATFORM_SERVICE_APP_INPUT_PARAMS_OFFSET :=',
              hex(input_params.addr - plat['smifAddr']), file=mk_file)
        print('PLATFORM_SERVICE_APP_DESC_OFFSET :=',
              hex(app_desc.addr - plat['smifAddr']), file=mk_file)
        print('USE_HW_ROLLBACK_PROT := 1', file=mk_file)
    mk_file.close()

    if params.nonce_file and not os.path.isfile(params.nonce_file):
        try:
            with open(params.policy, encoding='UTF-8') as in_f:
                try:
                    policy = json.load(in_f)
                except ValueError:
                    print('\nERROR: Cannot parse', params.policy, '\n', file=sys.stderr)
                    sys.exit(Error.IO)
        except (FileNotFoundError, OSError):
            print('\nERROR: Cannot open', params.policy, file=sys.stderr)
            sys.exit(Error.IO)

        policy_key_path = policy.get('pre_build', {}).get('keys', {}).get('encrypt_key', {}).get('value', {})
        if policy_key_path:
            full_key_path = os.path.join(os.path.dirname(params.policy), policy_key_path)
            try:
                with open(full_key_path, "rb") as aes_key_file:
                    aes_key = aes_key_file.read()
            except (FileNotFoundError, OSError):
                print('Missing encryption key', full_key_path, '\nNonce file generation skipped')
                sys.exit(0)

            if len(aes_key) != AES_BLOCK_SIZE:
                print('\nERROR: Wrong AES key size in ', full_key_path, file=sys.stderr)
                sys.exit(Error.CONFIG_MISMATCH)

            for i in range(NONCE_GEN_RETRIES):
                random_bytes = os.urandom(NONCE_RAND_SIZE)
                fa_ids = [entry['fa_off'] + entry['fa_size'] for entry in area_list.areas
                          if entry['fa_id'].startswith('FLASH_AREA_IMG_')]
                for fa_end_addr in fa_ids:
                    img_ok_addr = SHAB_ADDR + fa_end_addr - IMG_OK_OFFSET
                    img_ok_block_addr = img_ok_addr & ~(AES_BLOCK_SIZE - 1)
                    nonce = img_ok_block_addr.to_bytes(AES_BLOCK_SIZE - NONCE_RAND_SIZE,
                                                         byteorder='little') + random_bytes
                    cipher = Cipher(algorithms.AES(aes_key), modes.CTR(nonce))
                    encryptor_0 = cipher.encryptor()
                    encryptor_1 = cipher.encryptor()
                    encrypted_block_0 = encryptor_0.update(b'\x00' * AES_BLOCK_SIZE)
                    encrypted_block_1 = encryptor_1.update(b'\xFF' * AES_BLOCK_SIZE)

                    if encrypted_block_0[img_ok_addr - img_ok_block_addr] == IMG_OK_VALUE or \
                       encrypted_block_1[img_ok_addr - img_ok_block_addr] == IMG_OK_VALUE:
                        break
                else:
                    break
            else:
                print("\nERROR: Can't generate valid NONCE sequence", file=sys.stderr)
                sys.exit(Error.VALUE)

            try:
                if '/' in params.nonce_file or '\\' in params.nonce_file:
                    os.makedirs(os.path.dirname(params.nonce_file), exist_ok=True)
                with open(params.nonce_file, "wb") as nonce_f:
                    nonce_f.write(random_bytes)
            except (FileNotFoundError, OSError):
                print('\nERROR: Cannot create ', params.nonce_file, file=sys.stderr)
                sys.exit(Error.IO)

if __name__ == '__main__':
    main()