hdicoreCrypt.h

Go to the documentation of this file.

 
#ifndef __HDI_CORE_CRYPT__
#define __HDI_CORE_CRYPT__
 
#include <vector>
 
#include "hdicoreTypes.h"
 
namespace hdi
{
    namespace plat
    {
        class AESKey;
        class AESInitializationVector;
        class PublicRSAKey;
        class PrivateRSAKey;
    }
 
    namespace core
    {
        namespace crypt
        {
            std::string rot13(const std::string& str_);
 
            std::string md5(const std::string& str_);
 
            std::string sha1(const std::string& str_);
 
            std::string sha2_256(const std::string& str_);
 
            std::string sha2_512(const std::string& str_);
 
            std::string base64Encode(const std::string& plain_);
 
            std::string base64Decode(const std::string& cipher_);
            
            namespace aes
            {
                class Key;
                class InitVector;
            }
                
            namespace aes
            {
                typedef std::vector<byte> ByteVector;
 
                bool encrypt(const Key& key_, const InitVector& iv_, const std::string& data_, std::string& b64Cipher__);
                
                bool decrypt(const Key& key_, const InitVector& iv_, const std::string& b64Cipher_, std::string& data__);
                
                class Key
                {
                    public:
                        Key(const Key& key_);
                        
                        Key(const std::string& serializedKey_);
                    
                        Key(const int32_t size_);
 
                        Key(const int32_t size_, const ByteVector& bytes_);
 
                        virtual ~Key();
                        
                        Key& operator=(const Key& rhs_);
                        
                        bool valid() const;
                        
                        int32_t length() const;
                        
                        ByteVector bytes() const;
                        
                        std::string serialize() const;
                        
                        bool operator==(const Key& rhs_) const;
                        
                        bool operator!=(const Key& rhs_) const;
 
 
                    private:
                        friend plat::AESKey* __accessImpl(const Key&);
 
                        friend bool encrypt(const Key&, const InitVector&, const std::string&, std::string&);
                        friend bool decrypt(const Key&, const InitVector&, const std::string&, std::string&);
                    
                        plat::AESKey* __impl;
 
                        Key();
                };
        
                typedef std::unique_ptr<Key> KeyUP;
                typedef std::shared_ptr<Key> KeySP;
                typedef std::weak_ptr<Key> KeyWP;
                
                class InitVector
                {
                    public:
                        InitVector();
                        
                        InitVector(const InitVector& iv_);
                        
                        InitVector(const std::string& serializedIV_);
                        
                        virtual ~InitVector();
                        
                        InitVector& operator=(const InitVector& rhs_);
                        
                        ByteVector bytes() const;
                        
                        std::string serialize() const;
                        
                        bool operator==(const InitVector& rhs_) const;
                        
                        bool operator!=(const InitVector& rhs_) const;
 
 
                    private:
                        friend plat::AESInitializationVector* __accessImpl(const InitVector&);
 
                        friend bool encrypt(const Key&, const InitVector&, const std::string&, std::string&);
                        friend bool decrypt(const Key&, const InitVector&, const std::string&, std::string&);
 
                        plat::AESInitializationVector* __impl;
                };
        
                typedef std::unique_ptr<InitVector> InitVectorUP;
                typedef std::shared_ptr<InitVector> InitVectorSP;
                typedef std::weak_ptr<InitVector> InitVectorWP;
 
                extern plat::AESKey* __accessImpl(const Key&);
                extern plat::AESInitializationVector* __accessImpl(const InitVector&);
            }
            
            namespace rsa
            {
                class PublicKey;
                class PrivateKey;
            }
 
            namespace rsa
            {
                bool generateKeyPair(const int32_t size_, PrivateKey& privKey__, PublicKey& pubKey__);
 
                bool encryptWithPublicKey(const PublicKey& key_, const std::string& data_, std::string& b64Cipher__);
 
                bool decryptWithPrivateKey(const PrivateKey& key_, const std::string& b64Cipher_, std::string& data__);
 
                bool encryptWithPrivateKey(const PrivateKey& key_, const std::string& data_, std::string& b64Cipher__);
 
                bool decryptWithPublicKey(const PublicKey& key_, const std::string& b64Cipher_, std::string& data__);
            
                class PublicKey
                {
                    public:
                        PublicKey();
                        
                        PublicKey(const PublicKey& key_);
                        
                        PublicKey(const std::string& serializedKey_);
 
                        virtual ~PublicKey();
                        
                        PublicKey& operator=(const PublicKey& rhs_);
                        
                        bool valid() const;
 
                        int32_t length() const;
 
                        std::string serialize() const;
                        
                        bool operator==(const PublicKey& rhs_) const;
                        
                        bool operator!=(const PublicKey& rhs_) const;
 
 
                    private:
                        friend bool generateKeyPair(const int32_t, PrivateKey&, PublicKey&);
                        friend bool encryptWithPublicKey(const PublicKey&, const std::string&, std::string&);
                        friend bool decryptWithPrivateKey(const PrivateKey&, const std::string&, std::string&);
                        friend bool encryptWithPrivateKey(const PrivateKey&, const std::string&, std::string&);
                        friend bool decryptWithPublicKey(const PublicKey&, const std::string&, std::string&);
                    
                        plat::PublicRSAKey* __impl;
                };
        
                typedef std::unique_ptr<PublicKey> PublicKeyUP;
                typedef std::shared_ptr<PublicKey> PublicKeySP;
                typedef std::weak_ptr<PublicKey> PublicKeyWP;
                
                class PrivateKey
                {
                    public:
                        PrivateKey();
                        
                        PrivateKey(const PrivateKey& key_);
                        
                        PrivateKey(const std::string& serializedKey_);
 
                        virtual ~PrivateKey();
                        
                        PrivateKey& operator=(const PrivateKey& rhs_);
                        
                        bool valid() const;
 
                        int32_t length() const;
 
                        std::string serialize() const;
                        
                        bool operator==(const PrivateKey& rhs_) const;
                        
                        bool operator!=(const PrivateKey& rhs_) const;
 
 
                    private:
                        friend bool generateKeyPair(const int32_t, PrivateKey&, PublicKey&);
                        friend bool encryptWithPublicKey(const PublicKey&, const std::string&, std::string&);
                        friend bool decryptWithPrivateKey(const PrivateKey&, const std::string&, std::string&);
                        friend bool encryptWithPrivateKey(const PrivateKey&, const std::string&, std::string&);
                        friend bool decryptWithPublicKey(const PublicKey&, const std::string&, std::string&);
 
                        plat::PrivateRSAKey* __impl;
                };
        
                typedef std::unique_ptr<PrivateKey> PrivateKeyUP;
                typedef std::shared_ptr<PrivateKey> PrivateKeySP;
                typedef std::weak_ptr<PrivateKey> PrivateKeyWP;
            }
        }
    }
}
 
#endif
// __HDI_CORE_CRYPT__