Crypto.h

#ifndef TENDUKE_CRYPTO_CRYPTO_H
#define TENDUKE_CRYPTO_CRYPTO_H
 
#include <memory>
 
#include "./Ciphers.h"
#include "./asymmetric/PublicKeyFactory.h"
#include "./kdf/KDFProvider.h"
#include "./msgauthn/HashFactory.h"
#include "../utl/random/RandomBytes.h"
 
namespace tenduke { namespace crypto {

class Crypto
{
public:
    virtual ~Crypto() = default;

    explicit Crypto(
        const std::shared_ptr<::tenduke::crypto::Ciphers> &ciphersService,
        const std::shared_ptr<::tenduke::crypto::HashFactory> &hashFactory,
        const std::shared_ptr<::tenduke::crypto::KDFProvider> &kdf,
        const std::shared_ptr<::tenduke::crypto::PublicKeyFactory> &publicKeyFactory,
        const std::shared_ptr<::tenduke::utl::random::RandomBytes> &randomBytes
    )
    : ciphersService(ciphersService)
    , hashFactory_(hashFactory)
    , kdf_(kdf)
    , publicKeyFactory(publicKeyFactory)
    , randomBytes_(randomBytes)
    {
    }

    virtual std::shared_ptr<const ::tenduke::crypto::Ciphers> ciphers() const { return ciphersService; }

    virtual std::shared_ptr<const ::tenduke::crypto::KDFProvider> kdf() const { return kdf_; }

    virtual std::shared_ptr<const ::tenduke::crypto::HashFactory> hash() const { return hashFactory_; }

    virtual std::shared_ptr<const ::tenduke::crypto::PublicKeyFactory> publicKeys() const { return publicKeyFactory; }
 

    virtual std::shared_ptr<::tenduke::utl::random::RandomBytes> randomBytes() {return randomBytes_;}
 
private:
    std::shared_ptr<const ::tenduke::crypto::Ciphers> ciphersService;
    std::shared_ptr<const ::tenduke::crypto::HashFactory> hashFactory_;
    std::shared_ptr<const ::tenduke::crypto::PublicKeyFactory> publicKeyFactory;
    std::shared_ptr<const ::tenduke::crypto::KDFProvider> kdf_;
    std::shared_ptr<::tenduke::utl::random::RandomBytes> randomBytes_;
};
 
 
}}
 
#endif //TENDUKE_CRYPTO_CRYPTO_H