Keep the colleague's microbu-esp32c5 tree in this repository

obu-firmware builds against vanetza-idf from microbu-esp32c5/external, but
that tree was gitignored, so a clone of this repository could not build the
firmware it ships. It is now committed here as ordinary files in its own
folder, microbu-esp32c5/: the colleague's commit cf4b99f plus the V2X2MAP
bridge's signature verification (--trust) used on the bench. Nothing is
fetched from or pushed to the colleague's repository; this repository and
its remotes carry everything. The folder's own .gitignore keeps build output,
downloaded components and private key material out, as it did there; the
committed file set is identical to that repository's tracked files.

The ESP32-C5 is still flashed from obu-firmware/, which only takes
vanetza-idf from microbu-esp32c5/, so the two stay separate folders.
FLASHING.md says how to take a newer version of the colleague's tree (copy
it over the folder, rebuild, test, commit).

microbu-esp32c5/external/vanetza-idf/vanetza/security/v2/header_field.cpp

@@ -0,0 +1,290 @@
+#include <vanetza/security/exception.hpp>
+#include <vanetza/security/v2/header_field.hpp>
+#include <boost/optional.hpp>
+#include <boost/variant/apply_visitor.hpp>
+#include <boost/variant/static_visitor.hpp>
+
+namespace vanetza
+{
+namespace security
+{
+namespace v2
+{
+
+HeaderFieldType get_type(const HeaderField& field)
+{
+    struct HeaderFieldVisitor : public boost::static_visitor<HeaderFieldType>
+    {
+        HeaderFieldType operator()(const Time64&)
+        {
+            return HeaderFieldType::Generation_Time;
+        }
+        HeaderFieldType operator()(const Time64WithStandardDeviation&)
+        {
+            return HeaderFieldType::Generation_Time_Confidence;
+        }
+        HeaderFieldType operator()(const Time32&)
+        {
+            return HeaderFieldType::Expiration;
+        }
+        HeaderFieldType operator()(const ThreeDLocation&)
+        {
+            return HeaderFieldType::Generation_Location;
+        }
+        HeaderFieldType operator()(const std::list<HashedId3>&)
+        {
+            return HeaderFieldType::Request_Unrecognized_Certificate;
+        }
+        HeaderFieldType operator()(const IntX&)
+        {
+            return HeaderFieldType::Its_Aid;
+        }
+        HeaderFieldType operator()(const SignerInfo&)
+        {
+            return HeaderFieldType::Signer_Info;
+        }
+        HeaderFieldType operator()(const std::list<RecipientInfo>&)
+        {
+            return HeaderFieldType::Recipient_Info;
+        }
+        HeaderFieldType operator()(const EncryptionParameter&)
+        {
+            return HeaderFieldType::Encryption_Parameters;
+        }
+    };
+
+    HeaderFieldVisitor visit;
+    return boost::apply_visitor(visit, field);
+}
+
+size_t get_size(const HeaderField& field)
+{
+    size_t size = sizeof(HeaderFieldType);
+    struct HeaderFieldVisitor : public boost::static_visitor<>
+    {
+        void operator()(const Time64&)
+        {
+            m_size = sizeof(Time64);
+        }
+        void operator()(const Time64WithStandardDeviation& time)
+        {
+            m_size = sizeof(time.time64);
+            m_size += sizeof(time.log_std_dev);
+        }
+        void operator()(const Time32&)
+        {
+            m_size = sizeof(Time32);
+        }
+        void operator()(const ThreeDLocation& loc)
+        {
+            m_size = get_size(loc);
+        }
+        void operator()(const std::list<HashedId3>& list)
+        {
+            m_size = 0;
+            for (auto& elem : list) {
+                m_size += elem.size();
+            }
+            m_size += length_coding_size(m_size);
+        }
+        void operator()(const IntX& itsAid)
+        {
+            m_size = get_size(itsAid);
+        }
+        void operator()(const SignerInfo& info)
+        {
+            m_size = get_size(info);
+        }
+        void operator()(const std::list<RecipientInfo>& list)
+        {
+            m_size = get_size(list);
+            m_size += length_coding_size(m_size);
+        }
+        void operator()(const EncryptionParameter& enc)
+        {
+            m_size = get_size(enc);
+        }
+        size_t m_size;
+    };
+
+    HeaderFieldVisitor visit;
+    boost::apply_visitor(visit, field);
+    size += visit.m_size;
+    return size;
+}
+
+void serialize(OutputArchive& ar, const HeaderField& field)
+{
+    struct HeaderFieldVisitor : public boost::static_visitor<>
+    {
+        HeaderFieldVisitor(OutputArchive& ar) :
+            m_archive(ar)
+        {
+        }
+        void operator()(const Time64& time)
+        {
+            serialize(m_archive, host_cast(time));
+        }
+        void operator()(const Time64WithStandardDeviation& time)
+        {
+            serialize(m_archive, host_cast(time.time64));
+            serialize(m_archive, host_cast(time.log_std_dev));
+        }
+        void operator()(const Time32& time)
+        {
+            serialize(m_archive, host_cast(time));
+        }
+        void operator()(const ThreeDLocation& loc)
+        {
+            serialize(m_archive, loc);
+        }
+        void operator()(const std::list<HashedId3>& list)
+        {
+            size_t size = 0;
+            for (auto& elem : list) {
+                size += elem.size();
+            }
+            serialize_length(m_archive, size);
+            for (auto& elem : list) {
+                m_archive << elem[0];
+                m_archive << elem[1];
+                m_archive << elem[2];
+            }
+        }
+        void operator()(const IntX& itsAid)
+        {
+            serialize(m_archive, itsAid);
+        }
+        void operator()(const SignerInfo& info)
+        {
+            serialize(m_archive, info);
+        }
+        void operator()(const std::list<RecipientInfo>& list)
+        {
+            // TODO: only works until further symmetric algorithms are introduced
+            serialize(m_archive, list, SymmetricAlgorithm::AES128_CCM);
+        }
+        void operator()(const EncryptionParameter& param)
+        {
+            serialize(m_archive, param);
+        }
+
+        OutputArchive& m_archive;
+    };
+    HeaderFieldType type = get_type(field);
+    serialize(ar, type);
+    HeaderFieldVisitor visit(ar);
+    boost::apply_visitor(visit, field);
+}
+
+std::size_t deserialize(InputArchive& ar, std::list<HeaderField>& list)
+{
+    static const std::size_t size_limit = 1024;
+    const std::size_t size = trim_size(deserialize_length(ar));
+    if (size > size_limit) {
+        ar.fail(InputArchive::ErrorCode::ExcessiveLength);
+    }
+
+    std::size_t read = 0;
+    boost::optional<SymmetricAlgorithm> sym_algo;
+    while (read < size && ar.is_good()) {
+        HeaderField field;
+        HeaderFieldType type;
+        deserialize(ar, type);
+        read += sizeof(HeaderFieldType);
+        switch (type) {
+            case HeaderFieldType::Generation_Time: {
+                Time64 time;
+                deserialize(ar, time);
+                field = time;
+                list.push_back(field);
+                read += sizeof(Time64);
+                break;
+            }
+            case HeaderFieldType::Generation_Time_Confidence: {
+                Time64WithStandardDeviation time;
+                deserialize(ar, time.time64);
+                deserialize(ar, time.log_std_dev);
+                field = time;
+                list.push_back(field);
+                read += sizeof(Time64);
+                read += sizeof(uint8_t);
+                break;
+            }
+            case HeaderFieldType::Expiration: {
+                Time32 time;
+                deserialize(ar, time);
+                field = time;
+                list.push_back(field);
+                read += sizeof(Time32);
+                break;
+            }
+            case HeaderFieldType::Generation_Location: {
+                ThreeDLocation loc;
+                read += deserialize(ar, loc);
+                field = loc;
+                list.push_back(field);
+                break;
+            }
+            case HeaderFieldType::Request_Unrecognized_Certificate: {
+                const std::size_t tmp_size = trim_size(deserialize_length(ar));
+                read += tmp_size;
+                std::list<HashedId3> hashedList;
+                for (std::size_t c = 0; c < tmp_size; c += 3) {
+                    HashedId3 id;
+                    ar >> id[0];
+                    ar >> id[1];
+                    ar >> id[2];
+                    hashedList.push_back(id);
+                }
+                field = hashedList;
+                read += length_coding_size(tmp_size);
+                list.push_back(field);
+                break;
+            }
+            case HeaderFieldType::Its_Aid: {
+                IntX its_aid;
+                read += deserialize(ar, its_aid);
+                field = its_aid;
+                list.push_back(field);
+                break;
+            }
+            case HeaderFieldType::Signer_Info: {
+                SignerInfo info;
+                read += deserialize(ar, info);
+                field = info;
+                list.push_back(field);
+                break;
+            }
+            case HeaderFieldType::Recipient_Info: {
+                std::list<RecipientInfo> recipientList;
+                if (sym_algo) {
+                    const size_t tmp_size = deserialize(ar, recipientList, sym_algo.get());
+                    read += tmp_size;
+                    read += length_coding_size(tmp_size);
+                    field = recipientList;
+                    list.push_back(field);
+                } else {
+                    throw deserialization_error("HeaderFields: RecipientInfo read before EncryptionParameters: SymmetricAlgorithm still unknown");
+                }
+                break;
+            }
+            case HeaderFieldType::Encryption_Parameters: {
+                EncryptionParameter param;
+                read += deserialize(ar, param);
+                field = param;
+                sym_algo = get_type(param);
+                list.push_back(field);
+                break;
+            }
+            default:
+                throw deserialization_error("Unknown HeaderFieldType");
+                break;
+        }
+    }
+    return read;
+}
+
+} // namespace v2
+} // namespace security
+} // namespace vanetza