Add cryptograhpic key decoders (#1936)

Author: seladb

Packet++/CMakeLists.txt

@@ -6,6 +6,7 @@ add_library(
   src/BgpLayer.cpp
   src/CiscoHdlcLayer.cpp
   src/CotpLayer.cpp
+  src/CryptoKeyDecoder.cpp
   src/DhcpLayer.cpp
   src/DhcpV6Layer.cpp
   src/DnsLayer.cpp
@@ -82,6 +83,8 @@ set(
   header/BgpLayer.h
   header/CiscoHdlcLayer.h
   header/CotpLayer.h
+  header/CryptoDataReader.h
+  header/CryptoKeyDecoder.h
   header/DhcpLayer.h
   header/DhcpV6Layer.h
   header/DnsLayerEnums.h

Packet++/header/Asn1Codec.h

@@ -434,11 +434,13 @@ namespace pcpp
 			return getIntValue<uint32_t>();
 		}
 
+		/// Get the integer value of this record as a hex string
+		/// @param removeLeadingZeros If true, leading zeros will be removed
 		/// @return A hex string representation of the record value
-		std::string getValueAsString() const
+		std::string getValueAsString(bool removeLeadingZeros = false) const
 		{
 			decodeValueIfNeeded();
-			return m_Value.toString();
+			return m_Value.toString(removeLeadingZeros);
 		}
 
 	protected:
@@ -491,7 +493,7 @@ namespace pcpp
 				return sizeof(T) >= (m_Value.size() + 1) / 2;
 			}
 
-			std::string toString() const;
+			std::string toString(bool removeLeadingZeros = false) const;
 			std::vector<uint8_t> toBytes() const;
 
 		private:

Packet++/header/CryptoDataReader.h

@@ -0,0 +1,125 @@
+#pragma once
+
+/// @file
+
+#include "GeneralUtils.h"
+#include "PemCodec.h"
+#include <string>
+#include <memory>
+#include <fstream>
+
+/// @namespace pcpp
+/// @brief The main namespace for the PcapPlusPlus lib
+namespace pcpp
+{
+	namespace internal
+	{
+		/// @class CryptoDataReader
+		/// @brief A template helper class for reading and decoding cryptographic data in different formats (DER/PEM)
+		/// @tparam CryptoDecoder The decoder type that will be used to process the cryptographic data.
+		/// Must be a class that can be constructed with a byte array and a length, or a unique pointer to a byte array
+		/// and a length
+		template <typename CryptoDecoder> class CryptoDataReader
+		{
+		public:
+			/// Creates a decoder from DER-encoded data
+			/// @param[in] derData Pointer to the DER-encoded data
+			/// @param[in] derDataLen Length of the DER-encoded data
+			/// @param[in] ownDerData If true, the decoder will take ownership of the data and free it when the
+			/// decoder class is destructed
+			/// @return A unique pointer to the created decoder
+			/// @throws An exception if the data is not a valid ASN.1 record
+			static std::unique_ptr<CryptoDecoder> fromDER(uint8_t* derData, size_t derDataLen, bool ownDerData = false)
+			{
+				return std::unique_ptr<CryptoDecoder>(new CryptoDecoder(derData, derDataLen, ownDerData));
+			}
+
+			/// Creates a decoder from a hex string containing DER-encoded data
+			/// @param[in] derData Hex string containing DER-encoded data
+			/// @return A unique pointer to the created decoder
+			/// @throws An exception if the data is not a valid ASN.1 record
+			static std::unique_ptr<CryptoDecoder> fromDER(const std::string& derData)
+			{
+				size_t derDataBufferLen = derData.length() / 2;
+				auto derDataBuffer = std::make_unique<uint8_t[]>(derDataBufferLen);
+				hexStringToByteArray(derData, derDataBuffer.get(), derDataBufferLen);
+				return std::unique_ptr<CryptoDecoder>(new CryptoDecoder(std::move(derDataBuffer), derDataBufferLen));
+			}
+
+			/// Creates a decoder from a file containing DER-encoded data
+			/// @param[in] derFileName Path to the file containing DER-encoded data
+			/// @return A unique pointer to the created decoder
+			/// @throws An exception if the file doesn't exist, cannot be read or contains invalid data
+			static std::unique_ptr<CryptoDecoder> fromDERFile(const std::string& derFileName)
+			{
+				std::ifstream derFile(derFileName, std::ios::binary);
+				if (!derFile.good())
+				{
+					throw std::runtime_error("DER file doesn't exist or cannot be opened");
+				}
+
+				derFile.seekg(0, std::ios::end);
+				std::streamsize derDataLen = derFile.tellg();
+				if (derDataLen < 0)
+				{
+					throw std::runtime_error("Failed to determine DER file size");
+				}
+				derFile.seekg(0, std::ios::beg);
+
+				auto derData = std::make_unique<uint8_t[]>(derDataLen);
+
+				if (!derFile.read(reinterpret_cast<char*>(derData.get()), derDataLen))
+				{
+					throw std::runtime_error("Failed to read DER file");
+				}
+				return std::unique_ptr<CryptoDecoder>(new CryptoDecoder(std::move(derData), derDataLen));
+			}
+
+			/// Creates a decoder from PEM-encoded data
+			/// @param[in] pemData PEM-encoded data
+			/// @return A unique pointer to the created decoder
+			/// @throws std::invalid_argument exception if the data is not a valid PEM-encoded data
+			static std::unique_ptr<CryptoDecoder> fromPEM(const std::string& pemData)
+			{
+				auto derData = PemCodec::decode(pemData, CryptoDecoder::pemLabel);
+				auto derDataBuffer = std::make_unique<uint8_t[]>(derData.size());
+				std::copy(derData.begin(), derData.end(), derDataBuffer.get());
+				return std::unique_ptr<CryptoDecoder>(new CryptoDecoder(std::move(derDataBuffer), derData.size()));
+			}
+
+			/// Creates a decoder from a file containing PEM-encoded data
+			/// @param[in] pemFileName Path to the file containing PEM-encoded data
+			/// @return A unique pointer to the created decoder
+			/// @throws std::runtime_error exception if the file doesn't exist or cannot be read
+			/// @throws std::invalid_argument exception if the data is not a valid PEM-encoded data
+			static std::unique_ptr<CryptoDecoder> fromPEMFile(const std::string& pemFileName)
+			{
+				std::ifstream pemFile(pemFileName, std::ios::in | std::ios::binary);
+				if (!pemFile.good())
+				{
+					throw std::runtime_error("PEM file doesn't exist or cannot be opened");
+				}
+
+				pemFile.seekg(0, std::ios::end);
+				std::streamsize pemContentLen = pemFile.tellg();
+				if (pemContentLen < 0)
+				{
+					throw std::runtime_error("Failed to determine PEM file size");
+				}
+				pemFile.seekg(0, std::ios::beg);
+
+				std::string pemContent;
+				pemContent.resize(static_cast<std::size_t>(pemContentLen));
+				if (!pemFile.read(&pemContent[0], pemContentLen))
+				{
+					throw std::runtime_error("Failed to read PEM file");
+				}
+
+				return fromPEM(pemContent);
+			}
+
+		protected:
+			~CryptoDataReader() = default;
+		};
+	}  // namespace internal
+}  // namespace pcpp