digest.hpp

Go to the documentation of this file.

 
#ifndef __JOIN_DIGEST_HPP__
#define __JOIN_DIGEST_HPP__
 
// libjoin.
#include <join/openssl.hpp>
#include <join/base64.hpp>
 
namespace join
{
    enum class DigestErrc
    {
        InvalidAlgorithm = 1,   
        InvalidKey,             
        InvalidSignature        
    };
 
    class DigestCategory : public std::error_category
    {
    public:
        virtual const char* name () const noexcept;
 
        virtual std::string message (int code) const;
    };
 
    const std::error_category& getDigestCategory ();
 
    std::error_code make_error_code (DigestErrc code);
 
    std::error_condition make_error_condition (DigestErrc code);
 
    class Digest;
 
    class Digestbuf : public std::streambuf
    {
    public:
        Digestbuf (const std::string& algo);
 
        Digestbuf (const Digestbuf& other) = delete;
 
        Digestbuf& operator= (const Digestbuf& other) = delete;
 
        Digestbuf (Digestbuf&& other);
 
        Digestbuf& operator= (Digestbuf&& other);
 
        virtual ~Digestbuf () = default;
 
        BytesArray finalize ();
 
    protected:
        virtual int_type overflow (int_type c = traits_type::eof ()) override;
 
        static const std::streamsize _bufsize = 256;
 
        std::unique_ptr <char []> _buf;
 
        const EVP_MD* _md;
 
        EvpMdCtxPtr _ctx;
    };
 
    class Digest : public std::ostream
    {
    public:
        enum Algorithm
        {
            MD5 = 1,    
            SHA1,       
            SHA224,     
            SHA256,     
            SHA384,     
            SHA512,     
            SM3,        
        };
 
        Digest (Algorithm algo);
 
        Digest (const Digest& other) = delete;
 
        Digest& operator=(const Digest& other) = delete;
 
        Digest (Digest&& other);
 
        Digest& operator=(Digest&& other);
 
        virtual ~Digest () = default;
 
        BytesArray finalize ();
 
        static BytesArray md5bin (const char* data, std::streamsize size);
 
        static BytesArray md5bin (const BytesArray& data);
 
        static BytesArray md5bin (const std::string& data);
 
        static std::string md5hex (const char* data, std::streamsize size);
 
        static std::string md5hex (const BytesArray& data);
 
        static std::string md5hex (const std::string& data);
 
        static BytesArray sha1bin (const char* data, std::streamsize size);
 
        static BytesArray sha1bin (const BytesArray& data);
 
        static BytesArray sha1bin (const std::string& data);
 
        static std::string sha1hex (const char* data, std::streamsize size);
 
        static std::string sha1hex (const BytesArray& data);
 
        static std::string sha1hex (const std::string& data);
 
        static BytesArray sha224bin (const char* data, std::streamsize size);
 
        static BytesArray sha224bin (const BytesArray& data);
 
        static BytesArray sha224bin (const std::string& data);
 
        static std::string sha224hex (const char* data, std::streamsize size);
 
        static std::string sha224hex (const BytesArray& data);
 
        static std::string sha224hex (const std::string& data);
 
        static BytesArray sha256bin (const char* data, std::streamsize size);
 
        static BytesArray sha256bin (const BytesArray& data);
 
        static BytesArray sha256bin (const std::string& data);
 
        static std::string sha256hex (const char* data, std::streamsize size);
 
        static std::string sha256hex (const BytesArray& data);
 
        static std::string sha256hex (const std::string& data);
 
        static BytesArray sha384bin (const char* data, std::streamsize size);
 
        static BytesArray sha384bin (const BytesArray& data);
 
        static BytesArray sha384bin (const std::string& data);
 
        static std::string sha384hex (const char* data, std::streamsize size);
 
        static std::string sha384hex (const BytesArray& data);
 
        static std::string sha384hex (const std::string& data);
 
        static BytesArray sha512bin (const char* data, std::streamsize size);
 
        static BytesArray sha512bin (const BytesArray& data);
 
        static BytesArray sha512bin (const std::string& data);
 
        static std::string sha512hex (const char* data, std::streamsize size);
 
        static std::string sha512hex (const BytesArray& data);
 
        static std::string sha512hex (const std::string& data);
 
        static BytesArray sm3bin (const char* data, std::streamsize size);
 
        static BytesArray sm3bin (const BytesArray& data);
 
        static BytesArray sm3bin (const std::string& data);
 
        static std::string sm3hex (const char* data, std::streamsize size);
 
        static std::string sm3hex (const BytesArray& data);
 
        static std::string sm3hex (const std::string& data);
 
    protected:
        static const char* algorithm (Algorithm algo);
 
        Digestbuf _digestbuf;
 
        friend class Signature;
 
        friend class Hmac;
    };
}
 
namespace std
{
    template <> struct is_error_condition_enum <join::DigestErrc> : public true_type {};
}
 
#endif