| #pragma once | |
| #include <memory> | |
| #include <iterator> | |
| #include "boot/picobin.h" | |
| #include <map> | |
| #include <cassert> | |
| #include "elf_file.h" | |
| #if ENABLE_DEBUG_LOG | |
| #define DEBUG_LOG(...) printf(__VA_ARGS__) | |
| #else | |
| #define DEBUG_LOG(...) ((void)0) | |
| #endif | |
| // Support for SDK 2.1.0 & SDK 2.1.1 ----- | |
| #ifndef PICOBIN_IMAGE_TYPE_EXE_EXTRA_SECURITY_BITS | |
| #define PICOBIN_IMAGE_TYPE_EXE_EXTRA_SECURITY_BITS _u(0x0800) | |
| #endif | |
| // ------ | |
| struct item; | |
| template<typename InputIterator> std::vector<uint32_t> lsb_bytes_to_words(InputIterator begin, InputIterator end) { | |
| using InputType = typename std::iterator_traits<InputIterator>::value_type; | |
| static_assert(sizeof(InputType) == 1, ""); | |
| std::vector<uint32_t> rc; | |
| size_t size = end - begin; | |
| assert(!(size & 3)); | |
| if (size) { | |
| rc.reserve(size / 4); | |
| for(auto it = begin; it < end; ) { | |
| uint32_t word = *it++; | |
| word |= (*it++) << 8; | |
| word |= (*it++) << 16; | |
| word |= (*it++) << 24; | |
| rc.push_back(word); | |
| } | |
| } | |
| return rc; | |
| } | |
| template<typename InputIterator, typename OutputType = std::uint8_t> std::vector<OutputType> words_to_lsb_bytes(InputIterator begin, InputIterator end) { | |
| static_assert(sizeof(OutputType) == 1, ""); | |
| std::vector<OutputType> rc; | |
| size_t size = end - begin; | |
| if (size) { | |
| rc.reserve(size * 4); | |
| for(auto it = begin; it < end; ) { | |
| uint32_t word = *it++; | |
| rc.push_back(word & 0xff); | |
| rc.push_back((word >> 8) & 0xff); | |
| rc.push_back((word >> 16) & 0xff); | |
| rc.push_back((word >> 24) & 0xff); | |
| } | |
| } | |
| return rc; | |
| } | |
| struct item_writer_context { | |
| item_writer_context(uint32_t base_addr) : base_addr(base_addr), word_offset(0) {} | |
| std::map<std::shared_ptr<item>, uint32_t> item_word_offsets; | |
| uint32_t base_addr; | |
| uint32_t word_offset; | |
| }; | |
| struct item { | |
| explicit item() {}; | |
| virtual ~item() = default; | |
| virtual uint8_t type() const = 0; | |
| static uint32_t decode_size(uint32_t item_header) { | |
| uint32_t size; | |
| if (item_header & 0x80) { | |
| size = (uint16_t)(item_header >> 8); | |
| } else { | |
| size = (uint8_t)(item_header >> 8); | |
| } | |
| return size; | |
| } | |
| virtual std::vector<uint32_t> to_words(item_writer_context &ctx) const = 0; | |
| virtual uint32_t encode_type_and_size(unsigned int size) const { | |
| assert(size < PICOBIN_MAX_BLOCK_SIZE); | |
| if (size < 256) { | |
| return (size << 8u) | type(); | |
| } else { | |
| // todo byte order | |
| return (size << 8u) | 0x80 | type(); | |
| } | |
| } | |
| }; | |
| // always use single byte size | |
| struct single_byte_size_item : public item { | |
| virtual uint32_t encode_type_and_size(unsigned int size) const override { | |
| assert(size < PICOBIN_MAX_BLOCK_SIZE); | |
| assert(size < 128); | |
| assert(!(type() & 128)); | |
| return (size << 8u) | type(); | |
| } | |
| }; | |
| // always use double byte size | |
| struct double_byte_size_item : public item { | |
| virtual uint32_t encode_type_and_size(unsigned int size) const override { | |
| assert(size < PICOBIN_MAX_BLOCK_SIZE); | |
| assert(type() & 128); | |
| // todo byte order | |
| return (size << 8u) | 0x80 | type(); | |
| } | |
| }; | |
| struct ignored_item : public double_byte_size_item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_2BS_IGNORED; } | |
| ignored_item() = default; | |
| explicit ignored_item(uint32_t size, std::vector<uint32_t> data) : size(size), data(data) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| uint32_t size = item::decode_size(header); | |
| std::vector<uint32_t> data; | |
| for (unsigned int i=1; i < size; i++) { | |
| data.push_back(*it++); | |
| } | |
| return std::make_shared<ignored_item>(size, data); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| std::vector<uint32_t> ret; | |
| ret.push_back(encode_type_and_size(size)); | |
| ret.insert(ret.end(), data.begin(), data.end()); | |
| return ret; | |
| } | |
| uint32_t size; | |
| std::vector<uint32_t> data; | |
| }; | |
| enum image_type_image_type { | |
| type_invalid=PICOBIN_IMAGE_TYPE_IMAGE_TYPE_INVALID, | |
| type_exe=PICOBIN_IMAGE_TYPE_IMAGE_TYPE_EXE, | |
| type_data=PICOBIN_IMAGE_TYPE_IMAGE_TYPE_DATA | |
| }; | |
| enum image_type_exe_security { | |
| sec_unspecified=PICOBIN_IMAGE_TYPE_EXE_SECURITY_UNSPECIFIED, | |
| sec_ns=PICOBIN_IMAGE_TYPE_EXE_SECURITY_NS, | |
| sec_s=PICOBIN_IMAGE_TYPE_EXE_SECURITY_S | |
| }; | |
| enum image_type_exe_cpu { | |
| cpu_arm=PICOBIN_IMAGE_TYPE_EXE_CPU_ARM, | |
| cpu_riscv=PICOBIN_IMAGE_TYPE_EXE_CPU_RISCV, | |
| cpu_varmulet=PICOBIN_IMAGE_TYPE_EXE_CPU_VARMULET | |
| }; | |
| enum image_type_exe_chip { | |
| chip_rp2040=PICOBIN_IMAGE_TYPE_EXE_CHIP_RP2040, | |
| chip_rp2350=PICOBIN_IMAGE_TYPE_EXE_CHIP_RP2350 | |
| }; | |
| struct image_type_item : public single_byte_size_item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_1BS_IMAGE_TYPE; } | |
| image_type_item() = default; | |
| explicit image_type_item(uint16_t flags) : flags(flags) {} | |
| template <typename I> static std::shared_ptr<item> parse(I it, I end, uint32_t header) { | |
| return std::make_shared<image_type_item>(header >> 16); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| return {encode_type_and_size(1) | (flags << 16)}; | |
| } | |
| image_type_image_type image_type() const { return static_cast<image_type_image_type>((flags & PICOBIN_IMAGE_TYPE_IMAGE_TYPE_BITS) >> PICOBIN_IMAGE_TYPE_IMAGE_TYPE_LSB); } | |
| image_type_exe_security security() const { return static_cast<image_type_exe_security>((flags & PICOBIN_IMAGE_TYPE_EXE_SECURITY_BITS) >> PICOBIN_IMAGE_TYPE_EXE_SECURITY_LSB); } | |
| image_type_exe_cpu cpu() const { return static_cast<image_type_exe_cpu>((flags & PICOBIN_IMAGE_TYPE_EXE_CPU_BITS) >> PICOBIN_IMAGE_TYPE_EXE_CPU_LSB); } | |
| image_type_exe_chip chip() const { return static_cast<image_type_exe_chip>((flags & PICOBIN_IMAGE_TYPE_EXE_CHIP_BITS) >> PICOBIN_IMAGE_TYPE_EXE_CHIP_LSB); } | |
| bool tbyb() const { return flags & PICOBIN_IMAGE_TYPE_EXE_TBYB_BITS; } | |
| bool extra_security() const { return flags & PICOBIN_IMAGE_TYPE_EXE_EXTRA_SECURITY_BITS; } | |
| uint16_t flags; | |
| }; | |
| struct partition_table_item : public single_byte_size_item { | |
| struct partition { | |
| uint8_t permissions = 0; | |
| uint16_t first_sector = 0; | |
| uint16_t last_sector = 0; | |
| uint32_t flags = 0; | |
| uint64_t id; | |
| std::string name; | |
| std::vector<uint32_t> extra_families; | |
| std::vector<uint32_t> to_words() const { | |
| std::vector<uint32_t> ret = { | |
| ((permissions << PICOBIN_PARTITION_PERMISSIONS_LSB) & PICOBIN_PARTITION_PERMISSIONS_BITS) | |
| | ((first_sector << PICOBIN_PARTITION_LOCATION_FIRST_SECTOR_LSB) & PICOBIN_PARTITION_LOCATION_FIRST_SECTOR_BITS) | |
| | ((last_sector << PICOBIN_PARTITION_LOCATION_LAST_SECTOR_LSB) & PICOBIN_PARTITION_LOCATION_LAST_SECTOR_BITS), | |
| ((permissions << PICOBIN_PARTITION_PERMISSIONS_LSB) & PICOBIN_PARTITION_PERMISSIONS_BITS) | |
| | flags, | |
| }; | |
| if (flags & PICOBIN_PARTITION_FLAGS_HAS_ID_BITS) { | |
| ret.push_back((uint32_t)id); | |
| ret.push_back((uint32_t)(id >> 32)); | |
| } | |
| if (extra_families.size() > 0) { | |
| assert(extra_families.size() == (flags & PICOBIN_PARTITION_FLAGS_ACCEPTS_NUM_EXTRA_FAMILIES_BITS) >> PICOBIN_PARTITION_FLAGS_ACCEPTS_NUM_EXTRA_FAMILIES_LSB); | |
| ret.insert(ret.end(), extra_families.begin(), extra_families.end()); | |
| } | |
| if (name.size() > 0) { | |
| char size = name.size(); | |
| assert((size & 0x7f) == size); | |
| std::vector<char> name_vec = {size}; | |
| for (char c : name) { | |
| name_vec.push_back(c); | |
| } | |
| while (name_vec.size() % 4 != 0) name_vec.push_back(0); | |
| while (name_vec.size() > 0) { | |
| ret.push_back(*(uint32_t*)name_vec.data()); | |
| name_vec.erase(name_vec.begin(), name_vec.begin() + 4); | |
| } | |
| } | |
| return ret; | |
| } | |
| }; | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_PARTITION_TABLE; } | |
| partition_table_item() = default; | |
| explicit partition_table_item(uint32_t unpartitioned_flags, bool singleton) : unpartitioned_flags(unpartitioned_flags), singleton(singleton) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| uint32_t size = decode_size(header); | |
| uint8_t singleton_count = header >> 24; | |
| bool singleton = singleton_count & 0x80; | |
| uint8_t partition_count = singleton_count & 0x0f; | |
| uint32_t unpartitioned_flags = *it++; | |
| auto pt = std::make_shared<partition_table_item>(unpartitioned_flags, singleton); | |
| std::vector<uint32_t> data; | |
| for (unsigned int i=2; i < size; i++) { | |
| data.push_back(*it++); | |
| } | |
| size_t i=0; | |
| while (i < data.size()) { | |
| partition new_p; | |
| uint32_t permissions_locations = data[i++]; | |
| new_p.permissions = (permissions_locations & PICOBIN_PARTITION_PERMISSIONS_BITS) >> PICOBIN_PARTITION_PERMISSIONS_LSB; | |
| new_p.first_sector = (permissions_locations & PICOBIN_PARTITION_LOCATION_FIRST_SECTOR_BITS) >> PICOBIN_PARTITION_LOCATION_FIRST_SECTOR_LSB; | |
| new_p.last_sector = (permissions_locations & PICOBIN_PARTITION_LOCATION_LAST_SECTOR_BITS) >> PICOBIN_PARTITION_LOCATION_LAST_SECTOR_LSB; | |
| uint32_t permissions_flags = data[i++]; | |
| uint8_t permissions2 = (permissions_flags & PICOBIN_PARTITION_PERMISSIONS_BITS) >> PICOBIN_PARTITION_PERMISSIONS_LSB; | |
| if (new_p.permissions != permissions2) { | |
| printf("Permissions mismatch %02x %02x\n", new_p.permissions, permissions2); | |
| assert(false); | |
| } | |
| new_p.flags = permissions_flags & (~PICOBIN_PARTITION_PERMISSIONS_BITS); | |
| if (new_p.flags & PICOBIN_PARTITION_FLAGS_HAS_ID_BITS) { | |
| uint32_t low = data[i++]; | |
| uint32_t high = data[i++]; | |
| new_p.id = (uint64_t)low | ((uint64_t)high << 32); | |
| } | |
| uint8_t num_extra_families = (new_p.flags & PICOBIN_PARTITION_FLAGS_ACCEPTS_NUM_EXTRA_FAMILIES_BITS) >> PICOBIN_PARTITION_FLAGS_ACCEPTS_NUM_EXTRA_FAMILIES_LSB; | |
| for (int fam=0; fam < num_extra_families; fam++) { | |
| new_p.extra_families.push_back(data[i++]); | |
| } | |
| if (new_p.flags & PICOBIN_PARTITION_FLAGS_HAS_NAME_BITS) { | |
| auto bytes = words_to_lsb_bytes(data.begin() + i++, data.end()); | |
| int name_size = bytes[0]; | |
| // This works neatly - accounts for the size byte at the start | |
| i += name_size / 4; | |
| new_p.name = std::string((char*)(bytes.data() + 1), name_size); | |
| } | |
| pt->partitions.push_back(new_p); | |
| } | |
| return pt; | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| std::vector<uint32_t> partition_words; | |
| for (auto p : partitions) { | |
| auto words = p.to_words(); | |
| partition_words.insert(partition_words.end(), words.begin(), words.end()); | |
| } | |
| std::vector<uint32_t> ret = { | |
| encode_type_and_size(2 + partition_words.size()) | (singleton << 31) | ((uint8_t)partitions.size() << 24), | |
| unpartitioned_flags | |
| }; | |
| ret.insert(ret.end(), partition_words.begin(), partition_words.end()); | |
| return ret; | |
| } | |
| uint32_t unpartitioned_flags; | |
| bool singleton; | |
| std::vector<partition> partitions; | |
| }; | |
| struct vector_table_item : public single_byte_size_item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_1BS_VECTOR_TABLE; } | |
| vector_table_item() = default; | |
| explicit vector_table_item(uint32_t addr) : addr(addr) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| if (decode_size(header) != 2) { | |
| printf("Bad block size %d for vector table item\n", decode_size(header)); | |
| assert(false); | |
| } | |
| return std::make_shared<vector_table_item>(*it++); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| return {encode_type_and_size(2), addr}; | |
| } | |
| uint32_t addr; | |
| }; | |
| struct rolling_window_delta_item : public single_byte_size_item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_1BS_ROLLING_WINDOW_DELTA; } | |
| rolling_window_delta_item() = default; | |
| explicit rolling_window_delta_item(uint32_t addr) : addr(addr) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| if (decode_size(header) != 2) { | |
| printf("Bad block size %d for rolling window delta item\n", decode_size(header)); | |
| assert(false); | |
| } | |
| return std::make_shared<rolling_window_delta_item>(*it++); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| return {encode_type_and_size(2), (uint32_t)addr}; | |
| } | |
| int32_t addr; | |
| }; | |
| struct entry_point_item : public single_byte_size_item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_1BS_ENTRY_POINT; } | |
| entry_point_item() = default; | |
| explicit entry_point_item(uint32_t ep, uint32_t sp) : ep(ep), sp(sp) {} | |
| explicit entry_point_item(uint32_t ep, uint32_t sp, uint32_t splim) : ep(ep), sp(sp), splim(splim), splim_set(true) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| uint32_t size = decode_size(header); | |
| uint32_t ep = *it++; | |
| uint32_t sp = *it++; | |
| if (size == 3) { | |
| return std::make_shared<entry_point_item>(ep, sp); | |
| } else if (size == 4) { | |
| uint32_t splim = *it++; | |
| return std::make_shared<entry_point_item>(ep, sp, splim); | |
| } else { | |
| printf("Bad block size %d for entry point item\n", size); | |
| assert(false); | |
| return nullptr; | |
| } | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| std::vector<uint32_t> ret = {encode_type_and_size(splim_set ? 4 : 3), ep, sp}; | |
| if (splim_set) ret.push_back(splim); | |
| return ret; | |
| } | |
| uint32_t ep; | |
| uint32_t sp; | |
| uint32_t splim; | |
| bool splim_set = false; | |
| }; | |
| struct load_map_item : public item { | |
| struct entry { | |
| uint32_t storage_address; | |
| uint32_t runtime_address; | |
| uint32_t size; | |
| }; | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_LOAD_MAP; } | |
| load_map_item() = default; | |
| explicit load_map_item(bool absolute, std::vector<entry> entries) : absolute(absolute), entries(entries) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header, uint32_t current_addr) { | |
| uint8_t num_entries = (header >> 24) & 0x7f; | |
| bool absolute = (header >> 24) & 0x80; | |
| std::vector<entry> entries; | |
| for (int i=0; i < num_entries; i++) { | |
| uint32_t storage_address = (uint32_t)*it++; | |
| uint32_t runtime_address = (uint32_t)*it++; | |
| uint32_t size = (uint32_t)*it++; | |
| if (storage_address != 0) { | |
| if (absolute) { | |
| size -= runtime_address; | |
| } else { | |
| storage_address += current_addr; | |
| } | |
| } | |
| entries.push_back({ | |
| storage_address, | |
| runtime_address, | |
| size | |
| }); | |
| } | |
| return std::make_shared<load_map_item>(absolute, entries); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| assert(entries.size() < 256); | |
| std::vector<uint32_t> rc = { | |
| encode_type_and_size(1 + 3 * entries.size()) | (((uint8_t)entries.size())<<24) | (absolute ? 1 << 31 : 0) | |
| }; | |
| for(const auto &entry : entries) { | |
| // todo byte order | |
| if (absolute) { | |
| rc.push_back(entry.storage_address); | |
| rc.push_back(entry.runtime_address); | |
| if (entry.storage_address != 0) { | |
| rc.push_back(entry.runtime_address + entry.size); | |
| } else { | |
| rc.push_back(entry.size); | |
| } | |
| } else { | |
| if (entry.storage_address != 0) { | |
| rc.push_back(entry.storage_address - ctx.base_addr - ctx.word_offset * 4); | |
| } else { | |
| rc.push_back(entry.storage_address); | |
| } | |
| rc.push_back(entry.runtime_address); | |
| rc.push_back(entry.size); | |
| } | |
| } | |
| return rc; | |
| } | |
| bool absolute; | |
| std::vector<entry> entries; | |
| }; | |
| struct version_item : public item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_1BS_VERSION; } | |
| version_item() = default; | |
| explicit version_item(uint16_t major, uint16_t minor) : version_item(major, minor, 0, {}) {} | |
| version_item(uint16_t major, uint16_t minor, uint16_t rollback, std::vector<uint16_t> otp_rows) : | |
| rollback(rollback), otp_rows(std::move(otp_rows)) { | |
| // NOTE: A linux sysroot might define `major` and `minor` as macros so we | |
| // can't use regular initialization in the form `major(major)` since we woudn't | |
| // be able to tell if we're calling a macro or not. | |
| this->major = major; | |
| this->minor = minor; | |
| } | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| // todo validate | |
| uint32_t major_minor = *it++; | |
| uint16_t major = major_minor >> 16; | |
| uint16_t minor = major_minor & 0xffff; | |
| unsigned int otp_row_count = header >> 24; | |
| uint16_t rollback = 0; | |
| std::vector<uint16_t> otp_rows; | |
| if (otp_row_count) { | |
| unsigned int pair = *it++; | |
| // todo endian | |
| rollback = (uint16_t) pair; | |
| for(unsigned int i=0;i<otp_row_count;i++) { | |
| if (i&1) pair = *it++; | |
| otp_rows.push_back((uint16_t)(pair >> ((1^(i&1))*16))); | |
| } | |
| } | |
| return std::make_shared<version_item>(major, minor, rollback, otp_rows); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| assert(otp_rows.size() < 256); | |
| unsigned int size = 2 + (!otp_rows.empty() + otp_rows.size() + 1) / 2; | |
| std::vector<uint32_t> rc = { | |
| (uint32_t)(encode_type_and_size(size) | (otp_rows.size() << 24)) | |
| }; | |
| uint32_t major_minor = (uint16_t)major << 16 | (uint16_t)minor; | |
| rc.push_back(major_minor); | |
| if (!otp_rows.empty()) { | |
| rc.push_back(rollback); | |
| for(unsigned int i=0;i<otp_rows.size();i++) { | |
| if (i&1) { | |
| rc.push_back(otp_rows[i]); | |
| } else { | |
| rc[rc.size()-1] |= otp_rows[i] << 16; | |
| } | |
| } | |
| } | |
| return rc; | |
| } | |
| uint16_t major; | |
| uint16_t minor; | |
| uint16_t rollback; | |
| std::vector<uint16_t> otp_rows; | |
| }; | |
| struct hash_def_item : public single_byte_size_item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_1BS_HASH_DEF; } | |
| hash_def_item() = default; | |
| explicit hash_def_item(uint8_t hash_type) : hash_type(hash_type) {} | |
| explicit hash_def_item(uint8_t hash_type, uint16_t block_words_to_hash) : hash_type(hash_type), block_words_to_hash(block_words_to_hash) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| uint8_t hash_type = (header & 0xff000000) >> 24; | |
| uint16_t block_words_to_hash = *it++; | |
| return std::make_shared<hash_def_item>(hash_type, block_words_to_hash); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| return { | |
| encode_type_and_size(2) | (hash_type << 24), | |
| block_words_to_hash == 0 ? (ctx.word_offset + 2) : block_words_to_hash | |
| }; | |
| } | |
| uint8_t hash_type; | |
| uint16_t block_words_to_hash = 0; | |
| }; | |
| struct signature_item : public item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_SIGNATURE; } | |
| signature_item() = default; | |
| explicit signature_item(uint8_t sig_type) : sig_type(sig_type) {} | |
| explicit signature_item(uint8_t sig_type, std::vector<uint8_t> signature_bytes, std::vector<uint8_t> public_key_bytes) : sig_type(sig_type), signature_bytes(signature_bytes), public_key_bytes(public_key_bytes) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| auto sig_block_size = decode_size(header); | |
| uint8_t sig_type = (header & 0xff000000) >> 24; | |
| assert(sig_block_size == 0x21); | |
| std::vector<uint8_t> signature_bytes; | |
| std::vector<uint8_t> public_key_bytes; | |
| { | |
| std::vector<uint32_t> words; | |
| for (int i=0; i < 16; i++) { | |
| words.push_back(*it++); | |
| } | |
| auto bytes = words_to_lsb_bytes(words.begin(), words.end()); | |
| std::copy(bytes.begin(), bytes.end(), std::back_inserter(public_key_bytes)); | |
| } | |
| { | |
| std::vector<uint32_t> words; | |
| for (int i=0; i < 16; i++) { | |
| words.push_back(*it++); | |
| } | |
| auto bytes = words_to_lsb_bytes(words.begin(), words.end()); | |
| std::copy(bytes.begin(), bytes.end(), std::back_inserter(signature_bytes)); | |
| } | |
| return std::make_shared<signature_item>(sig_type, signature_bytes, public_key_bytes); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| assert(signature_bytes.size() % 4 == 0); | |
| assert(public_key_bytes.size() % 4 == 0); | |
| std::vector<uint32_t> rc = { | |
| encode_type_and_size(1 + public_key_bytes.size()/4 + signature_bytes.size()/4) | (sig_type << 24), | |
| }; | |
| auto words = lsb_bytes_to_words(public_key_bytes.begin(), public_key_bytes.end()); | |
| std::copy(words.begin(), words.end(), std::back_inserter(rc)); | |
| words = lsb_bytes_to_words(signature_bytes.begin(), signature_bytes.end()); | |
| std::copy(words.begin(), words.end(), std::back_inserter(rc)); | |
| return rc; | |
| } | |
| uint8_t sig_type; | |
| std::vector<uint8_t> signature_bytes; | |
| std::vector<uint8_t> public_key_bytes; | |
| }; | |
| struct hash_value_item : public item { | |
| uint8_t type() const override { return PICOBIN_BLOCK_ITEM_HASH_VALUE; } | |
| hash_value_item() = default; | |
| explicit hash_value_item(std::vector<uint8_t> hash_bytes) : hash_bytes(hash_bytes) {} | |
| template <typename I> static std::shared_ptr<item> parse(I& it, I end, uint32_t header) { | |
| auto hash_size = decode_size(header) - 1; | |
| std::vector<uint32_t> hash_words; | |
| for (unsigned int i=0; i < hash_size; i++) { | |
| hash_words.push_back(*it++); | |
| } | |
| return std::make_shared<hash_value_item>(words_to_lsb_bytes(hash_words.begin(), hash_words.end())); | |
| } | |
| std::vector<uint32_t> to_words(item_writer_context& ctx) const override { | |
| assert(hash_bytes.size() % 4 == 0); | |
| std::vector<uint32_t> rc = { | |
| encode_type_and_size(1 + hash_bytes.size()/4), | |
| }; | |
| auto words = lsb_bytes_to_words(hash_bytes.begin(), hash_bytes.end()); | |
| std::copy(words.begin(), words.end(), std::back_inserter(rc)); | |
| return rc; | |
| } | |
| std::vector<uint8_t> hash_bytes; | |
| }; | |
| struct block { | |
| explicit block(uint32_t physical_addr, uint32_t next_block_rel=0, uint32_t next_block_rel_index=0, std::vector<std::shared_ptr<item>> items = {}) | |
| : physical_addr(physical_addr), | |
| next_block_rel(next_block_rel), | |
| next_block_rel_index(next_block_rel_index), | |
| items( std::move(items)) {} | |
| template <typename I> static std::unique_ptr<block> parse(uint32_t physical_addr, I next_block_rel_loc, I it, I end) { | |
| I block_base = it; | |
| uint32_t current_addr = physical_addr + 4; // for the ffffded3 | |
| std::vector<std::shared_ptr<item>> items; | |
| while (it < end) { | |
| auto item_base = it; | |
| uint32_t header = *it++; | |
| uint32_t size = item::decode_size(header); | |
| std::shared_ptr<item> i; | |
| switch ((uint8_t)header) { | |
| case PICOBIN_BLOCK_ITEM_1BS_IMAGE_TYPE: | |
| i = image_type_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_PARTITION_TABLE: | |
| i = partition_table_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_1BS_VECTOR_TABLE: | |
| i = vector_table_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_1BS_ROLLING_WINDOW_DELTA: | |
| i = rolling_window_delta_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_1BS_VERSION: | |
| i = version_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_1BS_ENTRY_POINT: | |
| i = entry_point_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_LOAD_MAP: | |
| i = load_map_item::parse(it, end, header, current_addr); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_1BS_HASH_DEF: | |
| i = hash_def_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_HASH_VALUE: | |
| i = hash_value_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_SIGNATURE: | |
| i = signature_item::parse(it, end, header); | |
| break; | |
| case PICOBIN_BLOCK_ITEM_2BS_IGNORED: | |
| i = ignored_item::parse(it, end, header); | |
| break; | |
| default: | |
| DEBUG_LOG("Ignoring block type: %02x\n", (uint8_t)header); | |
| i = ignored_item::parse(it, end, header); | |
| break; | |
| } | |
| if (i) { | |
| items.push_back(i); | |
| } | |
| current_addr += (size*4); | |
| if (it != item_base + size) { | |
| printf("WARNING: item at %08x had wrong size %x (expected %x)\n", (unsigned int)(physical_addr + (item_base - block_base) * 4), (int)(it - item_base), (int)size); | |
| it = item_base + size; | |
| assert(false); | |
| } | |
| } | |
| uint32_t next_block_rel = *next_block_rel_loc; | |
| uint32_t next_block_rel_index = next_block_rel_loc - block_base + 1; | |
| return std::make_unique<block>(physical_addr, next_block_rel, next_block_rel_index, items); | |
| } | |
| std::vector<uint32_t> to_words() { | |
| std::vector<uint32_t> words; | |
| words.push_back(PICOBIN_BLOCK_MARKER_START); | |
| item_writer_context ctx(physical_addr); | |
| for(const auto &item : items) { | |
| ctx.word_offset = words.size(); | |
| ctx.item_word_offsets[item] = ctx.word_offset; | |
| const auto item_words = item->to_words(ctx); | |
| std::copy(item_words.begin(), item_words.end(), std::back_inserter(words)); | |
| } | |
| // todo should use a real item struct | |
| assert(words.size() <= PICOBIN_MAX_BLOCK_SIZE - 3); | |
| // todo byte order | |
| words.push_back(PICOBIN_BLOCK_ITEM_2BS_LAST | (words.size() - 1) << 8); | |
| words.push_back(next_block_rel); | |
| words.push_back(PICOBIN_BLOCK_MARKER_END); | |
| return words; | |
| } | |
| template <typename I> std::shared_ptr<I> get_item() { | |
| I tmp = I(); | |
| uint8_t type = tmp.type(); | |
| auto it = std::find_if(items.begin(), items.end(), [type](std::shared_ptr<item> i) { return i->type() == type; }); | |
| if (it != std::end(items)) { | |
| return std::dynamic_pointer_cast<I>(*it); | |
| } else { | |
| return nullptr; | |
| } | |
| } | |
| uint32_t physical_addr; | |
| uint32_t next_block_rel; | |
| uint32_t next_block_rel_index; | |
| std::vector<std::shared_ptr<item>> items; | |
| }; |