CryptoDataReader.h

Go to the documentation of this file.

#pragma once
 
 
#include "GeneralUtils.h"
#include "PemCodec.h"
#include <string>
#include <memory>
#include <fstream>
 
namespace pcpp
{
    namespace internal
    {
        template <typename CryptoDecoder> class CryptoDataReader
        {
        public:
            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));
            }
 
            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));
            }
 
            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));
            }
 
            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()));
            }
 
            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