[x509] Add base64 encode and decode helpers

Author: c-jimenez

src/tools/x509/Base64.cpp

@@ -0,0 +1,88 @@
+/*
+Copyright (c) 2020 Cedric Jimenez
+This file is part of OpenOCPP.
+
+OpenOCPP is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+OpenOCPP is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with OpenOCPP. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include "Base64.h"
+
+#include <openssl/evp.h>
+
+namespace ocpp
+{
+namespace x509
+{
+namespace base64
+{
+
+/** @brief Encode an array of bytes in Base64 */
+std::string encode(const void* data, size_t size)
+{
+    std::string b64_str;
+
+    // Check input parameters
+    if (data && (size != 0))
+    {
+        // Prepare buffer at the maximum data length
+        b64_str.resize((4u * size) / 3u + 10u);
+
+        // Encode data
+        int encoded_size = EVP_EncodeBlock(
+            reinterpret_cast<unsigned char*>(&b64_str[0]), reinterpret_cast<const unsigned char*>(data), static_cast<int>(size));
+        if (encoded_size >= 0)
+        {
+            // Resize output
+            b64_str.resize(encoded_size);
+        }
+        else
+        {
+            b64_str.clear();
+        }
+    }
+
+    return b64_str;
+}
+
+/** @brief Decode a Base64 string into an array of bytes */
+std::vector<uint8_t> decode(const std::string& b64_str)
+{
+    std::vector<uint8_t> data;
+
+    // Check input parameters
+    if (b64_str.size() != 0)
+    {
+        // Prepare buffer at the maximum data length
+        data.resize((3u * b64_str.size()) / 4u + 10u);
+
+        // Decode data
+        int decoded_size =
+            EVP_DecodeBlock(&data[0], reinterpret_cast<const unsigned char*>(b64_str.c_str()), static_cast<int>(b64_str.size()));
+        if (decoded_size >= 0)
+        {
+            // Resize output
+            data.resize(decoded_size);
+        }
+        else
+        {
+            data.clear();
+        }
+    }
+
+    return data;
+}
+
+} // namespace base64
+} // namespace x509
+} // namespace ocpp

src/tools/x509/Base64.h

@@ -0,0 +1,53 @@
+/*
+Copyright (c) 2020 Cedric Jimenez
+This file is part of OpenOCPP.
+
+OpenOCPP is free software: you can redistribute it and/or modify
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+OpenOCPP is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License
+along with OpenOCPP. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef BASE64_H
+#define BASE64_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace ocpp
+{
+namespace x509
+{
+namespace base64
+{
+
+/** 
+ * @brief Encode an array of bytes in Base64
+ * @param data Data to encode
+ * @param size Size in bytes of the data to encode
+ * @return Base64 representation of the input array
+ */
+std::string encode(const void* data, size_t size);
+
+/** 
+ * @brief Decode a Base64 string into an array of bytes
+ * @param b64_str  Base64 string to decode
+ * @return Corresponding array of bytes or empty array if the string
+ *         format is invalid
+ */
+std::vector<uint8_t> decode(const std::string& b64_str);
+
+} // namespace base64
+} // namespace x509
+} // namespace ocpp
+
+#endif // BASE64_H

src/tools/x509/CMakeLists.txt

@@ -2,6 +2,7 @@
 # X509 library
 include_directories(impl)
 add_library(x509 STATIC
+    Base64.cpp
     Certificate.cpp
     CertificateRequest.cpp
     PrivateKey.cpp

tests/tools/test_x509.cpp

@@ -16,6 +16,7 @@ You should have received a copy of the GNU Lesser General Public License
 along with OpenOCPP. If not, see <http://www.gnu.org/licenses/>.
 */
 
+#include "Base64.h"
 #include "Certificate.h"
 #include "CertificateRequest.h"
 #include "PrivateKey.h"
@@ -717,3 +718,44 @@ TEST_SUITE("Certificate generation")
         CHECK(cert.verify(data_signature, data.c_str(), data.size()));
     }
 }
+
+TEST_SUITE("Base64")
+{
+    TEST_CASE("Encode/Decode nominal")
+    {
+        // Data to encode
+        const std::string input_data =
+            "This string could have been some binary data but it is way more easier to do it with human readable data instead :) !";
+
+        // Expected result
+        const std::string expected_result = "VGhpcyBzdHJpbmcgY291bGQgaGF2ZSBiZWVuIHNvbWUgYmluYXJ5IGRhdGEgYnV0IGl0IGlzIHdheSBtb3JlIGVhc2llci"
+                                            "B0byBkbyBpdCB3aXRoIGh1bWFuIHJlYWRhYmxlIGRhdGEgaW5zdGVhZCA6KSAh";
+
+        // Check encoding
+        CHECK_EQ(ocpp::x509::base64::encode(input_data.c_str(), input_data.size()), expected_result);
+
+        // Check decoding
+        std::vector<uint8_t> decoded_data = ocpp::x509::base64::decode(expected_result);
+        std::string          decoded_data_str(reinterpret_cast<char*>(&decoded_data[0]), decoded_data.size());
+        CHECK_EQ(decoded_data_str, input_data);
+    }
+
+    TEST_CASE("Encode/Decode limits")
+    {
+        // Empty buffer to encode
+        std::string encoded_null = ocpp::x509::base64::encode("hjkl", 0u);
+        CHECK(encoded_null.empty());
+
+        // NULL buffer to encode
+        encoded_null = ocpp::x509::base64::encode(nullptr, 10u);
+        CHECK(encoded_null.empty());
+
+        // Empty buffer to decode
+        std::vector<uint8_t> decoded_null = ocpp::x509::base64::decode("");
+        CHECK(decoded_null.empty());
+
+        // Invalid input data to decode
+        decoded_null = ocpp::x509::base64::decode("VGh");
+        CHECK(decoded_null.empty());
+    }
+}