Add extracted tools: CitrineOS, OpenOCPP, ShapeShifter

- CitrineOS core extracted (CSMS OCPP 2.0.1)
- OpenOCPP extracted (firmware OCPP 1.6J/2.0.1)
- ShapeShifter library installed (pip install -e)
- ShapeShifter specification extracted
- EVerest extracted

TODO updated with progress

tools/EVerest-main/modules/EVSE/EvseSecurity/main/evse_securityImpl.cpp

@@ -0,0 +1,290 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+
+#include "evse_securityImpl.hpp"
+#include <everest/conversions/evse_security/conversions.hpp>
+
+namespace module {
+namespace main {
+
+void evse_securityImpl::init() {
+
+    const auto certs_path = this->mod->info.paths.etc / "certs";
+    evse_security::FilePaths file_paths = {certs_path / this->mod->config.csms_ca_bundle,
+                                           certs_path / this->mod->config.mf_ca_bundle,
+                                           certs_path / this->mod->config.mo_ca_bundle,
+                                           certs_path / this->mod->config.v2g_ca_bundle,
+                                           certs_path / this->mod->config.csms_leaf_cert_directory,
+                                           certs_path / this->mod->config.csms_leaf_key_directory,
+                                           certs_path / this->mod->config.secc_leaf_cert_directory,
+                                           certs_path / this->mod->config.secc_leaf_key_directory};
+
+    std::optional<std::string> private_key_password = std::nullopt;
+    if (!this->mod->config.private_key_password.empty()) {
+        private_key_password = this->mod->config.private_key_password;
+    }
+
+    this->evse_security = std::make_unique<evse_security::EvseSecurity>(file_paths, private_key_password);
+}
+
+void evse_securityImpl::ready() {
+}
+
+types::evse_security::InstallCertificateResult
+evse_securityImpl::handle_install_ca_certificate(std::string& certificate,
+                                                 types::evse_security::CaCertificateType& certificate_type) {
+    try {
+        const auto response = conversions::to_everest(
+            this->evse_security->install_ca_certificate(certificate, conversions::from_everest(certificate_type)));
+        if (response == types::evse_security::InstallCertificateResult::Accepted) {
+            types::evse_security::CertificateStoreUpdate update;
+            update.operation = types::evse_security::CertificateStoreUpdateOperation::Installed;
+            update.ca_certificate_type = certificate_type;
+            this->publish_certificate_store_update(update);
+        }
+        return response;
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return types::evse_security::InstallCertificateResult::WriteError;
+    }
+}
+
+types::evse_security::DeleteCertificateResult
+evse_securityImpl::handle_delete_certificate(types::evse_security::CertificateHashData& certificate_hash_data) {
+    try {
+        const auto response = this->evse_security->delete_certificate(conversions::from_everest(certificate_hash_data));
+        const auto result = conversions::to_everest(response.result);
+
+        if (result == types::evse_security::DeleteCertificateResult::Accepted) {
+            types::evse_security::CertificateStoreUpdate update;
+
+            update.operation = types::evse_security::CertificateStoreUpdateOperation::Deleted;
+
+            if (response.ca_certificate_type.has_value()) {
+                update.ca_certificate_type = conversions::to_everest(response.ca_certificate_type.value());
+            }
+            if (response.leaf_certificate_type.has_value()) {
+                update.leaf_certificate_type = conversions::to_everest(response.leaf_certificate_type.value());
+            }
+
+            this->publish_certificate_store_update(update);
+        }
+
+        return result;
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return types::evse_security::DeleteCertificateResult::Failed;
+    }
+}
+
+types::evse_security::InstallCertificateResult
+evse_securityImpl::handle_update_leaf_certificate(std::string& certificate_chain,
+                                                  types::evse_security::LeafCertificateType& certificate_type) {
+    try {
+        const auto response = conversions::to_everest(this->evse_security->update_leaf_certificate(
+            certificate_chain, conversions::from_everest(certificate_type)));
+        if (response == types::evse_security::InstallCertificateResult::Accepted) {
+            types::evse_security::CertificateStoreUpdate update;
+            update.operation = types::evse_security::CertificateStoreUpdateOperation::Installed;
+            update.leaf_certificate_type = certificate_type;
+            this->publish_certificate_store_update(update);
+        }
+        return response;
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return types::evse_security::InstallCertificateResult::WriteError;
+    }
+}
+
+types::evse_security::CertificateValidationResult evse_securityImpl::handle_verify_certificate(
+    std::string& certificate_chain, std::vector<types::evse_security::LeafCertificateType>& certificate_types) {
+
+    std::vector<evse_security::LeafCertificateType> _certificate_types;
+
+    for (const auto& certificate_type : certificate_types) {
+        try {
+            _certificate_types.push_back(conversions::from_everest(certificate_type));
+        } catch (const std::out_of_range& e) {
+            EVLOG_warning << e.what();
+        }
+    }
+
+    try {
+        return conversions::to_everest(this->evse_security->verify_certificate(certificate_chain, _certificate_types));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return types::evse_security::CertificateValidationResult::Unknown;
+    }
+}
+
+types::evse_security::GetInstalledCertificatesResult evse_securityImpl::handle_get_installed_certificates(
+    std::vector<types::evse_security::CertificateType>& certificate_types) {
+    std::vector<evse_security::CertificateType> _certificate_types;
+
+    for (const auto& certificate_type : certificate_types) {
+        try {
+            _certificate_types.push_back(conversions::from_everest(certificate_type));
+        } catch (const std::out_of_range& e) {
+            EVLOG_warning << e.what();
+        }
+    }
+
+    try {
+        return conversions::to_everest(this->evse_security->get_installed_certificates(_certificate_types));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return {types::evse_security::GetInstalledCertificatesStatus::NotFound, {}};
+    }
+}
+
+types::evse_security::OCSPRequestDataList evse_securityImpl::handle_get_v2g_ocsp_request_data() {
+    try {
+        return conversions::to_everest(this->evse_security->get_v2g_ocsp_request_data());
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return {};
+    }
+}
+
+types::evse_security::OCSPRequestDataList
+evse_securityImpl::handle_get_mo_ocsp_request_data(std::string& certificate_chain) {
+    try {
+        return conversions::to_everest(this->evse_security->get_mo_ocsp_request_data(certificate_chain));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return {};
+    }
+}
+
+void evse_securityImpl::handle_update_ocsp_cache(types::evse_security::CertificateHashData& certificate_hash_data,
+                                                 std::string& ocsp_response) {
+    try {
+        this->evse_security->update_ocsp_cache(conversions::from_everest(certificate_hash_data), ocsp_response);
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+    }
+}
+
+bool evse_securityImpl::handle_is_ca_certificate_installed(types::evse_security::CaCertificateType& certificate_type) {
+    try {
+        return this->evse_security->is_ca_certificate_installed(conversions::from_everest(certificate_type));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return false;
+    }
+}
+
+types::evse_security::GetCertificateSignRequestResult evse_securityImpl::handle_generate_certificate_signing_request(
+    types::evse_security::LeafCertificateType& certificate_type, std::string& country, std::string& organization,
+    std::string& common, bool& use_tpm) {
+    types::evse_security::GetCertificateSignRequestResult response;
+
+    try {
+        auto csr_response = this->evse_security->generate_certificate_signing_request(
+            conversions::from_everest(certificate_type), country, organization, common, use_tpm);
+
+        response.status = conversions::to_everest(csr_response.status);
+
+        if (csr_response.status == evse_security::GetCertificateSignRequestStatus::Accepted &&
+            csr_response.csr.has_value()) {
+            response.csr = csr_response.csr;
+        }
+
+        return response;
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        response.status = types::evse_security::GetCertificateSignRequestStatus::GenerationError;
+        return response;
+    }
+}
+
+types::evse_security::GetCertificateInfoResult
+evse_securityImpl::handle_get_leaf_certificate_info(types::evse_security::LeafCertificateType& certificate_type,
+                                                    types::evse_security::EncodingFormat& encoding,
+                                                    bool& include_ocsp) {
+    types::evse_security::GetCertificateInfoResult response;
+
+    try {
+        const auto leaf_info = this->evse_security->get_leaf_certificate_info(
+            conversions::from_everest(certificate_type), conversions::from_everest(encoding), include_ocsp);
+
+        response.status = conversions::to_everest(leaf_info.status);
+
+        if (leaf_info.status == evse_security::GetCertificateInfoStatus::Accepted && leaf_info.info.has_value()) {
+            response.info = conversions::to_everest(leaf_info.info.value());
+        }
+
+        return response;
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        response.status = types::evse_security::GetCertificateInfoStatus::Rejected;
+        return response;
+    }
+}
+
+types::evse_security::GetCertificateFullInfoResult
+evse_securityImpl::handle_get_all_valid_certificates_info(types::evse_security::LeafCertificateType& certificate_type,
+                                                          types::evse_security::EncodingFormat& encoding,
+                                                          bool& include_ocsp) {
+    types::evse_security::GetCertificateFullInfoResult response;
+
+    try {
+        const auto full_leaf_info = this->evse_security->get_all_valid_certificates_info(
+            conversions::from_everest(certificate_type), conversions::from_everest(encoding), include_ocsp);
+
+        response.status = conversions::to_everest(full_leaf_info.status);
+
+        if (full_leaf_info.status == evse_security::GetCertificateInfoStatus::Accepted) {
+            for (const auto& info : full_leaf_info.info) {
+                response.info.push_back(conversions::to_everest(info));
+            }
+        }
+
+        return response;
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        response.status = types::evse_security::GetCertificateInfoStatus::Rejected;
+        return response;
+    }
+}
+
+std::string evse_securityImpl::handle_get_verify_file(types::evse_security::CaCertificateType& certificate_type) {
+    try {
+        return this->evse_security->get_verify_file(conversions::from_everest(certificate_type));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return {};
+    }
+}
+
+std::string evse_securityImpl::handle_get_verify_location(types::evse_security::CaCertificateType& certificate_type) {
+    try {
+        return this->evse_security->get_verify_location(conversions::from_everest(certificate_type));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return {};
+    }
+}
+
+int evse_securityImpl::handle_get_leaf_expiry_days_count(types::evse_security::LeafCertificateType& certificate_type) {
+    try {
+        return this->evse_security->get_leaf_expiry_days_count(conversions::from_everest(certificate_type));
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return 0;
+    }
+}
+
+bool evse_securityImpl::handle_verify_file_signature(std::string& file_path, std::string& signing_certificate,
+                                                     std::string& signature) {
+    try {
+        return evse_security::EvseSecurity::verify_file_signature(std::filesystem::path(file_path), signing_certificate,
+                                                                  signature);
+    } catch (const std::out_of_range& e) {
+        EVLOG_warning << e.what();
+        return false;
+    }
+}
+
+} // namespace main
+} // namespace module

tools/EVerest-main/modules/EVSE/EvseSecurity/main/evse_securityImpl.hpp

@@ -0,0 +1,96 @@
+// SPDX-License-Identifier: Apache-2.0
+// Copyright Pionix GmbH and Contributors to EVerest
+#ifndef MAIN_EVSE_SECURITY_IMPL_HPP
+#define MAIN_EVSE_SECURITY_IMPL_HPP
+
+//
+// AUTO GENERATED - MARKED REGIONS WILL BE KEPT
+// template version 3
+//
+
+#include <generated/interfaces/evse_security/Implementation.hpp>
+
+#include "../EvseSecurity.hpp"
+
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+// insert your custom include headers here
+#include <evse_security/evse_security.hpp>
+// ev@75ac1216-19eb-4182-a85c-820f1fc2c091:v1
+
+namespace module {
+namespace main {
+
+struct Conf {};
+
+class evse_securityImpl : public evse_securityImplBase {
+public:
+    evse_securityImpl() = delete;
+    evse_securityImpl(Everest::ModuleAdapter* ev, const Everest::PtrContainer<EvseSecurity>& mod, Conf& config) :
+        evse_securityImplBase(ev, "main"), mod(mod), config(config){};
+
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+    // insert your public definitions here
+    // ev@8ea32d28-373f-4c90-ae5e-b4fcc74e2a61:v1
+
+protected:
+    // command handler functions (virtual)
+    virtual types::evse_security::InstallCertificateResult
+    handle_install_ca_certificate(std::string& certificate,
+                                  types::evse_security::CaCertificateType& certificate_type) override;
+    virtual types::evse_security::DeleteCertificateResult
+    handle_delete_certificate(types::evse_security::CertificateHashData& certificate_hash_data) override;
+    virtual types::evse_security::InstallCertificateResult
+    handle_update_leaf_certificate(std::string& certificate_chain,
+                                   types::evse_security::LeafCertificateType& certificate_type) override;
+    virtual types::evse_security::CertificateValidationResult
+    handle_verify_certificate(std::string& certificate_chain,
+                              std::vector<types::evse_security::LeafCertificateType>& certificate_types) override;
+    virtual types::evse_security::GetInstalledCertificatesResult
+    handle_get_installed_certificates(std::vector<types::evse_security::CertificateType>& certificate_types) override;
+    virtual types::evse_security::OCSPRequestDataList handle_get_v2g_ocsp_request_data() override;
+    virtual types::evse_security::OCSPRequestDataList
+    handle_get_mo_ocsp_request_data(std::string& certificate_chain) override;
+    virtual void handle_update_ocsp_cache(types::evse_security::CertificateHashData& certificate_hash_data,
+                                          std::string& ocsp_response) override;
+    virtual bool handle_is_ca_certificate_installed(types::evse_security::CaCertificateType& certificate_type) override;
+    virtual types::evse_security::GetCertificateSignRequestResult
+    handle_generate_certificate_signing_request(types::evse_security::LeafCertificateType& certificate_type,
+                                                std::string& country, std::string& organization, std::string& common,
+                                                bool& use_tpm) override;
+    virtual types::evse_security::GetCertificateInfoResult
+    handle_get_leaf_certificate_info(types::evse_security::LeafCertificateType& certificate_type,
+                                     types::evse_security::EncodingFormat& encoding, bool& include_ocsp) override;
+    virtual types::evse_security::GetCertificateFullInfoResult
+    handle_get_all_valid_certificates_info(types::evse_security::LeafCertificateType& certificate_type,
+                                           types::evse_security::EncodingFormat& encoding, bool& include_ocsp) override;
+    virtual std::string handle_get_verify_file(types::evse_security::CaCertificateType& certificate_type) override;
+    virtual std::string handle_get_verify_location(types::evse_security::CaCertificateType& certificate_type) override;
+    virtual int handle_get_leaf_expiry_days_count(types::evse_security::LeafCertificateType& certificate_type) override;
+    virtual bool handle_verify_file_signature(std::string& file_path, std::string& signing_certificate,
+                                              std::string& signature) override;
+
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+    // insert your protected definitions here
+    // ev@d2d1847a-7b88-41dd-ad07-92785f06f5c4:v1
+
+private:
+    const Everest::PtrContainer<EvseSecurity>& mod;
+    const Conf& config;
+
+    virtual void init() override;
+    virtual void ready() override;
+
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+    // insert your private definitions here
+    std::unique_ptr<evse_security::EvseSecurity> evse_security;
+    // ev@3370e4dd-95f4-47a9-aaec-ea76f34a66c9:v1
+};
+
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+// insert other definitions here
+// ev@3d7da0ad-02c2-493d-9920-0bbbd56b9876:v1
+
+} // namespace main
+} // namespace module
+
+#endif // MAIN_EVSE_SECURITY_IMPL_HPP