Add SLIC pubkey and marker parsers

common/generated/apple_sysf.cpp

@@ -1,7 +1,6 @@
 // This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
 
 #include "apple_sysf.h"
-#include "../kaitai/exceptions.h"
 
 apple_sysf_t::apple_sysf_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, apple_sysf_t* p__root) : kaitai::kstruct(p__io) {
     m__parent = p__parent;
@@ -14,12 +13,6 @@ apple_sysf_t::apple_sysf_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, a
 
 void apple_sysf_t::_read() {
     m_signature = m__io->read_u4le();
-    {
-        uint32_t _ = signature();
-        if (!( ((_ == 1937339206) || (_ == 1684627783)) )) {
-            throw kaitai::validation_expr_error<uint32_t>(signature(), _io(), std::string("/seq/0"));
-        }
-    }
     m_unknown = m__io->read_u1();
     m_unknown1 = m__io->read_u4le();
     m_sysf_size = m__io->read_u2le();

common/generated/edk2_ftw.cpp

@@ -1,7 +1,6 @@
 // This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
 
 #include "edk2_ftw.h"
-#include "../kaitai/exceptions.h"
 
 edk2_ftw_t::edk2_ftw_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, edk2_ftw_t* p__root) : kaitai::kstruct(p__io) {
     m__parent = p__parent;
@@ -13,12 +12,6 @@ edk2_ftw_t::edk2_ftw_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, edk2_
 
 void edk2_ftw_t::_read() {
     m_signature = m__io->read_bytes(16);
-    {
-        std::string _ = signature();
-        if (!( ((_ == std::string("\x8D\x2B\xF1\xFF\x96\x76\x8B\x4C\xA9\x85\x27\x47\x07\x5B\x4F\x50", 16)) || (_ == std::string("\x2B\x29\x58\x9E\x68\x7C\x7D\x49\x0A\xCE\x65\x00\xFD\x9F\x1B\x95", 16)) || (_ == std::string("\x2B\x29\x58\x9E\x68\x7C\x7D\x49\xA0\xCE\x65\x00\xFD\x9F\x1B\x95", 16))) )) {
-            throw kaitai::validation_expr_error<std::string>(signature(), _io(), std::string("/seq/0"));
-        }
-    }
     m_crc = m__io->read_u4le();
     m_state = m__io->read_u1();
     m_reserved = m__io->read_bytes(3);

common/generated/edk2_vss.cpp

@@ -14,12 +14,6 @@ edk2_vss_t::edk2_vss_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, edk2_
 
 void edk2_vss_t::_read() {
     m_signature = m__io->read_u4le();
-    {
-        uint32_t _ = signature();
-        if (!( ((_ == 1397970468) || (_ == 1398166308) || (_ == 1397968420)) )) {
-            throw kaitai::validation_expr_error<uint32_t>(signature(), _io(), std::string("/seq/0"));
-        }
-    }
     m_vss_size = m__io->read_u4le();
     {
         uint32_t _ = vss_size();
@@ -28,12 +22,6 @@ void edk2_vss_t::_read() {
         }
     }
     m_format = m__io->read_u1();
-    {
-        uint8_t _ = format();
-        if (!(_ == 90)) {
-            throw kaitai::validation_expr_error<uint8_t>(format(), _io(), std::string("/seq/2"));
-        }
-    }
     m_state = m__io->read_u1();
     m_reserved = m__io->read_u2le();
     m_reserved1 = m__io->read_u4le();

common/generated/edk2_vss2.cpp

@@ -13,51 +13,15 @@ edk2_vss2_t::edk2_vss2_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, edk
 }
 
 void edk2_vss2_t::_read() {
-    m_signature = m__io->read_u4le();
-    {
-        uint32_t _ = signature();
-        if (!( ((_ == 3721344534UL) || (_ == 3721344535UL) || (_ == 2868063352UL)) )) {
-            throw kaitai::validation_expr_error<uint32_t>(signature(), _io(), std::string("/seq/0"));
-        }
-    }
-    n_signature_auth_var_key_db = true;
-    if (signature() == 2868063352UL) {
-        n_signature_auth_var_key_db = false;
-        m_signature_auth_var_key_db = m__io->read_bytes(12);
-        if (!(signature_auth_var_key_db() == std::string("\x7B\x94\x9A\x43\xA1\x80\x2E\x14\x4E\xC3\x77\x92", 12))) {
-            throw kaitai::validation_not_equal_error<std::string>(std::string("\x7B\x94\x9A\x43\xA1\x80\x2E\x14\x4E\xC3\x77\x92", 12), signature_auth_var_key_db(), _io(), std::string("/seq/1"));
-        }
-    }
-    n_signature_vss2_store = true;
-    if (signature() == 3721344535UL) {
-        n_signature_vss2_store = false;
-        m_signature_vss2_store = m__io->read_bytes(12);
-        if (!(signature_vss2_store() == std::string("\x75\x32\x64\x41\x98\xB6\xFE\x85\x70\x7F\xFE\x7D", 12))) {
-            throw kaitai::validation_not_equal_error<std::string>(std::string("\x75\x32\x64\x41\x98\xB6\xFE\x85\x70\x7F\xFE\x7D", 12), signature_vss2_store(), _io(), std::string("/seq/2"));
-        }
-    }
-    n_signature_fdc_store = true;
-    if (signature() == 3721344534UL) {
-        n_signature_fdc_store = false;
-        m_signature_fdc_store = m__io->read_bytes(12);
-        if (!(signature_fdc_store() == std::string("\x75\x32\x64\x41\x98\xB6\xFE\x85\x70\x7F\xFE\x7D", 12))) {
-            throw kaitai::validation_not_equal_error<std::string>(std::string("\x75\x32\x64\x41\x98\xB6\xFE\x85\x70\x7F\xFE\x7D", 12), signature_fdc_store(), _io(), std::string("/seq/3"));
-        }
-    }
+    m_signature = m__io->read_bytes(16);
     m_vss2_size = m__io->read_u4le();
     {
         uint32_t _ = vss2_size();
         if (!( ((_ > static_cast<uint32_t>(len_vss2_store_header())) && (_ < 4294967295UL)) )) {
-            throw kaitai::validation_expr_error<uint32_t>(vss2_size(), _io(), std::string("/seq/4"));
+            throw kaitai::validation_expr_error<uint32_t>(vss2_size(), _io(), std::string("/seq/1"));
         }
     }
     m_format = m__io->read_u1();
-    {
-        uint8_t _ = format();
-        if (!(_ == 90)) {
-            throw kaitai::validation_expr_error<uint8_t>(format(), _io(), std::string("/seq/5"));
-        }
-    }
     m_state = m__io->read_u1();
     m_reserved = m__io->read_u2le();
     m_reserved1 = m__io->read_u4le();
@@ -71,12 +35,6 @@ edk2_vss2_t::~edk2_vss2_t() {
 }
 
 void edk2_vss2_t::_clean_up() {
-    if (!n_signature_auth_var_key_db) {
-    }
-    if (!n_signature_vss2_store) {
-    }
-    if (!n_signature_fdc_store) {
-    }
 }
 
 edk2_vss2_t::vss2_store_body_t::vss2_store_body_t(kaitai::kstream* p__io, edk2_vss2_t* p__parent, edk2_vss2_t* p__root) : kaitai::kstruct(p__io) {

common/generated/edk2_vss2.h

@@ -344,28 +344,7 @@ public:
     int32_t len_vss2_store_header();
 
 private:
-    uint32_t m_signature;
-    std::string m_signature_auth_var_key_db;
-    bool n_signature_auth_var_key_db;
-
-public:
-    bool _is_null_signature_auth_var_key_db() { signature_auth_var_key_db(); return n_signature_auth_var_key_db; };
-
-private:
-    std::string m_signature_vss2_store;
-    bool n_signature_vss2_store;
-
-public:
-    bool _is_null_signature_vss2_store() { signature_vss2_store(); return n_signature_vss2_store; };
-
-private:
-    std::string m_signature_fdc_store;
-    bool n_signature_fdc_store;
-
-public:
-    bool _is_null_signature_fdc_store() { signature_fdc_store(); return n_signature_fdc_store; };
-
-private:
+    std::string m_signature;
     uint32_t m_vss2_size;
     uint8_t m_format;
     uint8_t m_state;
@@ -378,10 +357,7 @@ private:
     std::unique_ptr<kaitai::kstream> m__io__raw_body;
 
 public:
-    uint32_t signature() const { return m_signature; }
-    std::string signature_auth_var_key_db() const { return m_signature_auth_var_key_db; }
-    std::string signature_vss2_store() const { return m_signature_vss2_store; }
-    std::string signature_fdc_store() const { return m_signature_fdc_store; }
+    std::string signature() const { return m_signature; }
     uint32_t vss2_size() const { return m_vss2_size; }
     uint8_t format() const { return m_format; }
     uint8_t state() const { return m_state; }

common/generated/insyde_fdc.cpp

@@ -12,12 +12,6 @@ insyde_fdc_t::insyde_fdc_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, i
 
 void insyde_fdc_t::_read() {
     m_signature = m__io->read_u4le();
-    {
-        uint32_t _ = signature();
-        if (!(_ == 1128547935)) {
-            throw kaitai::validation_expr_error<uint32_t>(signature(), _io(), std::string("/seq/0"));
-        }
-    }
     m_fdc_size = m__io->read_u4le();
     {
         uint32_t _ = fdc_size();

common/generated/insyde_fdm.cpp

@@ -24,6 +24,9 @@ void insyde_fdm_t::_read() {
     m_entry_size = m__io->read_u4le();
     m_entry_format = m__io->read_u1();
     m_revision = m__io->read_u1();
+    if (!( ((revision() == 1) || (revision() == 2) || (revision() == 3)) )) {
+        throw kaitai::validation_not_any_of_error<uint8_t>(revision(), _io(), std::string("/seq/5"));
+    }
     m_num_extensions = m__io->read_u1();
     m_checksum = m__io->read_u1();
     m_fd_base_address = m__io->read_u8le();
@@ -35,7 +38,7 @@ void insyde_fdm_t::_read() {
         m_extensions = std::unique_ptr<fdm_extensions_t>(new fdm_extensions_t(m__io__raw_extensions.get(), this, m__root));
     }
     n_board_ids = true;
-    if (revision() == 3) {
+    if ( ((revision() == 3) && (extensions()->extensions()->at(1)->count() > 0)) ) {
         n_board_ids = false;
         m_board_ids = std::unique_ptr<fdm_board_ids_t>(new fdm_board_ids_t(m__io, this, m__root));
     }

common/generated/ms_slic_marker.cpp

@@ -0,0 +1,28 @@
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+#include "ms_slic_marker.h"
+
+ms_slic_marker_t::ms_slic_marker_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, ms_slic_marker_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = this; (void)p__root;
+    _read();
+}
+
+void ms_slic_marker_t::_read() {
+    m_type = m__io->read_u4le();
+    m_len_marker = m__io->read_u4le();
+    m_version = m__io->read_u4le();
+    m_oem_id = m__io->read_bytes(6);
+    m_oem_table_id = m__io->read_bytes(8);
+    m_windows_flag = m__io->read_u8le();
+    m_slic_version = m__io->read_u4le();
+    m_reserved = m__io->read_bytes(16);
+    m_signature = m__io->read_bytes(128);
+}
+
+ms_slic_marker_t::~ms_slic_marker_t() {
+    _clean_up();
+}
+
+void ms_slic_marker_t::_clean_up() {
+}

common/generated/ms_slic_marker.h

@@ -0,0 +1,51 @@
+#pragma once
+
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+#include "../kaitai/kaitaistruct.h"
+#include <stdint.h>
+#include <memory>
+
+#if KAITAI_STRUCT_VERSION < 9000L
+#error "Incompatible Kaitai Struct C++/STL API: version 0.9 or later is required"
+#endif
+
+class ms_slic_marker_t : public kaitai::kstruct {
+
+public:
+
+    ms_slic_marker_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = nullptr, ms_slic_marker_t* p__root = nullptr);
+
+private:
+    void _read();
+    void _clean_up();
+
+public:
+    ~ms_slic_marker_t();
+
+private:
+    uint32_t m_type;
+    uint32_t m_len_marker;
+    uint32_t m_version;
+    std::string m_oem_id;
+    std::string m_oem_table_id;
+    uint64_t m_windows_flag;
+    uint32_t m_slic_version;
+    std::string m_reserved;
+    std::string m_signature;
+    ms_slic_marker_t* m__root;
+    kaitai::kstruct* m__parent;
+
+public:
+    uint32_t type() const { return m_type; }
+    uint32_t len_marker() const { return m_len_marker; }
+    uint32_t version() const { return m_version; }
+    std::string oem_id() const { return m_oem_id; }
+    std::string oem_table_id() const { return m_oem_table_id; }
+    uint64_t windows_flag() const { return m_windows_flag; }
+    uint32_t slic_version() const { return m_slic_version; }
+    std::string reserved() const { return m_reserved; }
+    std::string signature() const { return m_signature; }
+    ms_slic_marker_t* _root() const { return m__root; }
+    kaitai::kstruct* _parent() const { return m__parent; }
+};

common/generated/ms_slic_pubkey.cpp

@@ -0,0 +1,29 @@
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+#include "ms_slic_pubkey.h"
+
+ms_slic_pubkey_t::ms_slic_pubkey_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, ms_slic_pubkey_t* p__root) : kaitai::kstruct(p__io) {
+    m__parent = p__parent;
+    m__root = this; (void)p__root;
+    _read();
+}
+
+void ms_slic_pubkey_t::_read() {
+    m_type = m__io->read_u4le();
+    m_len_pubkey = m__io->read_u4le();
+    m_key_type = m__io->read_u1();
+    m_version = m__io->read_u1();
+    m_reserved = m__io->read_u2le();
+    m_algorithm = m__io->read_u4le();
+    m_magic = m__io->read_u4le();
+    m_bit_length = m__io->read_u4le();
+    m_exponent = m__io->read_u4le();
+    m_modulus = m__io->read_bytes(128);
+}
+
+ms_slic_pubkey_t::~ms_slic_pubkey_t() {
+    _clean_up();
+}
+
+void ms_slic_pubkey_t::_clean_up() {
+}

common/generated/ms_slic_pubkey.h

@@ -0,0 +1,53 @@
+#pragma once
+
+// This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
+
+#include "../kaitai/kaitaistruct.h"
+#include <stdint.h>
+#include <memory>
+
+#if KAITAI_STRUCT_VERSION < 9000L
+#error "Incompatible Kaitai Struct C++/STL API: version 0.9 or later is required"
+#endif
+
+class ms_slic_pubkey_t : public kaitai::kstruct {
+
+public:
+
+    ms_slic_pubkey_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent = nullptr, ms_slic_pubkey_t* p__root = nullptr);
+
+private:
+    void _read();
+    void _clean_up();
+
+public:
+    ~ms_slic_pubkey_t();
+
+private:
+    uint32_t m_type;
+    uint32_t m_len_pubkey;
+    uint8_t m_key_type;
+    uint8_t m_version;
+    uint16_t m_reserved;
+    uint32_t m_algorithm;
+    uint32_t m_magic;
+    uint32_t m_bit_length;
+    uint32_t m_exponent;
+    std::string m_modulus;
+    ms_slic_pubkey_t* m__root;
+    kaitai::kstruct* m__parent;
+
+public:
+    uint32_t type() const { return m_type; }
+    uint32_t len_pubkey() const { return m_len_pubkey; }
+    uint8_t key_type() const { return m_key_type; }
+    uint8_t version() const { return m_version; }
+    uint16_t reserved() const { return m_reserved; }
+    uint32_t algorithm() const { return m_algorithm; }
+    uint32_t magic() const { return m_magic; }
+    uint32_t bit_length() const { return m_bit_length; }
+    uint32_t exponent() const { return m_exponent; }
+    std::string modulus() const { return m_modulus; }
+    ms_slic_pubkey_t* _root() const { return m__root; }
+    kaitai::kstruct* _parent() const { return m__parent; }
+};

common/generated/phoenix_evsa.cpp

@@ -13,18 +13,9 @@ phoenix_evsa_t::phoenix_evsa_t(kaitai::kstream* p__io, kaitai::kstruct* p__paren
 
 void phoenix_evsa_t::_read() {
     m_type = m__io->read_u1();
-    if (!(type() == 236)) {
-        throw kaitai::validation_not_equal_error<uint8_t>(236, type(), _io(), std::string("/seq/0"));
-    }
     m_checksum = m__io->read_u1();
     m_len_evsa_store_header = m__io->read_u2le();
-    if (!(len_evsa_store_header() == 20)) {
-        throw kaitai::validation_not_equal_error<uint16_t>(20, len_evsa_store_header(), _io(), std::string("/seq/2"));
-    }
     m_signature = m__io->read_u4le();
-    if (!(signature() == 1095980613)) {
-        throw kaitai::validation_not_equal_error<uint32_t>(1095980613, signature(), _io(), std::string("/seq/3"));
-    }
     m_attributes = m__io->read_u4le();
     m_len_evsa_store = m__io->read_u4le();
     m_reserved = m__io->read_u4le();

common/generated/phoenix_flm.cpp

@@ -1,14 +1,11 @@
 // This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
 
 #include "phoenix_flm.h"
-#include "../kaitai/exceptions.h"
 
 phoenix_flm_t::phoenix_flm_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent, phoenix_flm_t* p__root) : kaitai::kstruct(p__io) {
     m__parent = p__parent;
     m__root = this; (void)p__root;
     m_entries = nullptr;
-    m_free_space = nullptr;
-    f_len_flm_store = false;
     f_len_flm_store_header = false;
     f_len_flm_entry = false;
     _read();
@@ -16,27 +13,13 @@ phoenix_flm_t::phoenix_flm_t(kaitai::kstream* p__io, kaitai::kstruct* p__parent,
 
 void phoenix_flm_t::_read() {
     m_signature = m__io->read_bytes(10);
-    if (!(signature() == std::string("\x5F\x46\x4C\x41\x53\x48\x5F\x4D\x41\x50", 10))) {
-        throw kaitai::validation_not_equal_error<std::string>(std::string("\x5F\x46\x4C\x41\x53\x48\x5F\x4D\x41\x50", 10), signature(), _io(), std::string("/seq/0"));
-    }
     m_num_entries = m__io->read_u2le();
-    {
-        uint16_t _ = num_entries();
-        if (!(_ <= 113)) {
-            throw kaitai::validation_expr_error<uint16_t>(num_entries(), _io(), std::string("/seq/1"));
-        }
-    }
     m_reserved = m__io->read_u4le();
     m_entries = std::unique_ptr<std::vector<std::unique_ptr<flm_entry_t>>>(new std::vector<std::unique_ptr<flm_entry_t>>());
     const int l_entries = num_entries();
     for (int i = 0; i < l_entries; i++) {
         m_entries->push_back(std::move(std::unique_ptr<flm_entry_t>(new flm_entry_t(m__io, this, m__root))));
     }
-    m_free_space = std::unique_ptr<std::vector<uint8_t>>(new std::vector<uint8_t>());
-    const int l_free_space = ((len_flm_store() - len_flm_store_header()) - (len_flm_entry() * num_entries()));
-    for (int i = 0; i < l_free_space; i++) {
-        m_free_space->push_back(std::move(m__io->read_u1()));
-    }
 }
 
 phoenix_flm_t::~phoenix_flm_t() {
@@ -68,14 +51,6 @@ phoenix_flm_t::flm_entry_t::~flm_entry_t() {
 void phoenix_flm_t::flm_entry_t::_clean_up() {
 }
 
-int32_t phoenix_flm_t::len_flm_store() {
-    if (f_len_flm_store)
-        return m_len_flm_store;
-    m_len_flm_store = 4096;
-    f_len_flm_store = true;
-    return m_len_flm_store;
-}
-
 int8_t phoenix_flm_t::len_flm_store_header() {
     if (f_len_flm_store_header)
         return m_len_flm_store_header;

common/generated/phoenix_flm.h

@@ -59,13 +59,6 @@ public:
         phoenix_flm_t* _parent() const { return m__parent; }
     };
 
-private:
-    bool f_len_flm_store;
-    int32_t m_len_flm_store;
-
-public:
-    int32_t len_flm_store();
-
 private:
     bool f_len_flm_store_header;
     int8_t m_len_flm_store_header;
@@ -85,7 +78,6 @@ private:
     uint16_t m_num_entries;
     uint32_t m_reserved;
     std::unique_ptr<std::vector<std::unique_ptr<flm_entry_t>>> m_entries;
-    std::unique_ptr<std::vector<uint8_t>> m_free_space;
     phoenix_flm_t* m__root;
     kaitai::kstruct* m__parent;
 
@@ -94,7 +86,6 @@ public:
     uint16_t num_entries() const { return m_num_entries; }
     uint32_t reserved() const { return m_reserved; }
     std::vector<std::unique_ptr<flm_entry_t>>* entries() const { return m_entries.get(); }
-    std::vector<uint8_t>* free_space() const { return m_free_space.get(); }
     phoenix_flm_t* _root() const { return m__root; }
     kaitai::kstruct* _parent() const { return m__parent; }
 };