OPENSSL Hash 추출하기

namespace util {
	class CryptoUtil
	{
		DECLARE_NO_COPY_CLASS( CryptoUtil );
	public:
		CryptoUtil() = default;
		~CryptoUtil() = default;

		static std::string GetMD5Hash( const std::string& _ssInput );
		static std::string GetSHA256Hash( const std::string& _ssInput );
		static std::string GetSHA512Hash( const std::string& _ssInput );
		static std::string GetSHA1Hash( const std::string& _ssInput );

		static bool VerifyMD5Hash( const std::string& _ssInput, const std::string& _ssHash );
		static bool VerifySHA256Hash( const std::string& _ssInput, const std::string& _ssHash );
		static bool VerifySHA512Hash( const std::string& _ssInput, const std::string& _ssHash );
		static bool VerifySHA1Hash( const std::string& _ssInput, const std::string& _ssHash );

		static std::string GetMD5FileHash( const std::string& _ssFilePath );
		static std::string GetSHA1FileHash( const std::string& _ssFilePath );
		static std::string GetSHA256FileHash( const std::string& _ssFilePath );
		static std::string GetSHA512FileHash( const std::string& _ssFilePath );

	};
}

#include "CryptoUtil.h"
#include <openssl/sha.h>
namespace
{
    std::string BytesToHexString( const unsigned char* data, size_t len )
    {
        std::ostringstream oss;
        for( size_t i = 0; i < len; ++i )
            oss << std::hex << std::setw( 2 ) << std::setfill( '0' ) << (int)data[i];
        return oss.str();
    }
	std::string CalcDigest( const std::string & input, const EVP_MD * (*digestFunc)(), unsigned int digestLen )
	{
		unsigned char hash[EVP_MAX_MD_SIZE];
		unsigned int hashLen = 0;

		EVP_MD_CTX* ctx = EVP_MD_CTX_new();
		if( !ctx )
			return "";

		if( EVP_DigestInit_ex( ctx, digestFunc(), nullptr ) != 1 ||
			EVP_DigestUpdate( ctx, input.data(), input.size() ) != 1 ||
			EVP_DigestFinal_ex( ctx, hash, &hashLen ) != 1 )
		{
			EVP_MD_CTX_free( ctx );
			return "";
		}

		EVP_MD_CTX_free( ctx );
		return BytesToHexString( hash, hashLen );
	}
    std::string CalcFileDigest( const std::string& filePath, const EVP_MD* (*digestFunc)() )
    {
        constexpr size_t BUFFER_SIZE = 4096;
        unsigned char buffer[BUFFER_SIZE];
        unsigned char hash[EVP_MAX_MD_SIZE];
        unsigned int hashLen = 0;

        std::ifstream file( filePath, std::ios::binary );
        if( !file.is_open() )
            return "";

        EVP_MD_CTX* ctx = EVP_MD_CTX_new();
        if( !ctx )
            return "";

        if( EVP_DigestInit_ex( ctx, digestFunc(), nullptr ) != 1 ) {
            EVP_MD_CTX_free( ctx );
            return "";
        }

        while( file.good() ) {
            file.read( reinterpret_cast<char*>(buffer), BUFFER_SIZE );
            std::streamsize bytesRead = file.gcount();
            if( bytesRead > 0 ) {
                if( EVP_DigestUpdate( ctx, buffer, bytesRead ) != 1 ) {
                    EVP_MD_CTX_free( ctx );
                    return "";
                }
            }
        }

        if( EVP_DigestFinal_ex( ctx, hash, &hashLen ) != 1 ) {
            EVP_MD_CTX_free( ctx );
            return "";
        }

        EVP_MD_CTX_free( ctx );
        return BytesToHexString( hash, hashLen );
    }

}
std::string CryptoUtil::GetMD5Hash( const std::string& _ssInput )
{
	return CalcDigest( _ssInput, EVP_md5, 16 );
}

std::string CryptoUtil::GetSHA1Hash( const std::string& _ssInput )
{
	return CalcDigest( _ssInput, EVP_sha1, 20 );
}

std::string CryptoUtil::GetSHA256Hash( const std::string& _ssInput )
{
	return CalcDigest( _ssInput, EVP_sha256, 32 );
}

std::string CryptoUtil::GetSHA512Hash( const std::string& _ssInput )
{
	return CalcDigest( _ssInput, EVP_sha512, 64 );
}

bool CryptoUtil::VerifyMD5Hash( const std::string& _ssInput, const std::string& _ssHash )
{
	return GetMD5Hash( _ssInput ) == _ssHash;
}

bool CryptoUtil::VerifySHA1Hash( const std::string& _ssInput, const std::string& _ssHash )
{
	return GetSHA1Hash( _ssInput ) == _ssHash;
}

bool CryptoUtil::VerifySHA256Hash( const std::string& _ssInput, const std::string& _ssHash )
{
	return GetSHA256Hash( _ssInput ) == _ssHash;
}

bool CryptoUtil::VerifySHA512Hash( const std::string& _ssInput, const std::string& _ssHash )
{
	return GetSHA512Hash( _ssInput ) == _ssHash;
}

std::string CryptoUtil::GetMD5FileHash( const std::string& _ssFilePath )
{
    return CalcFileDigest( _ssFilePath, EVP_md5 );
}

std::string CryptoUtil::GetSHA1FileHash( const std::string& _ssFilePath )
{
    return CalcFileDigest( _ssFilePath, EVP_sha1 );
}

std::string CryptoUtil::GetSHA256FileHash( const std::string& _ssFilePath )
{
    return CalcFileDigest( _ssFilePath, EVP_sha256 );
}

std::string CryptoUtil::GetSHA512FileHash( const std::string& _ssFilePath )
{
    return CalcFileDigest( _ssFilePath, EVP_sha512 );
}