encryption.hpp

Go to the documentation of this file.

#ifndef LIBFILEZILLA_ENCRYPTION_HEADER
#define LIBFILEZILLA_ENCRYPTION_HEADER
 
#include "libfilezilla.hpp"
 
#include <vector>
#include <string>
 
namespace fz {
 
class FZ_PUBLIC_SYMBOL public_key
{
public:
    enum {
        key_size = 32,
        salt_size = 32
    };
 
    explicit operator bool() const {
        return key_.size() == key_size && salt_.size() == salt_size;
    }
 
    bool operator==(public_key const& rhs) const {
        return key_ == rhs.key_ && salt_ == rhs.salt_;
    }
 
    bool operator!=(public_key const& rhs) const {
        return !(*this == rhs);
    }
 
    bool operator<(public_key const& rhs) const {
        return key_ < rhs.key_ || (key_ == rhs.key_ && salt_ < rhs.salt_);
    }
 
    std::string to_base64(bool pad = true) const;
    static public_key from_base64(std::string_view const& base64);
    static public_key from_base64(std::wstring_view const& base64);
 
    std::vector<uint8_t> key_;
    std::vector<uint8_t> salt_;
};
 
class FZ_PUBLIC_SYMBOL private_key
{
public:
    enum {
        key_size = 32,
        salt_size = 32
    };
 
    static private_key generate();
 
    enum {
        min_iterations = 100000
    };
 
    static private_key from_password(std::vector<uint8_t> const& password, std::vector<uint8_t> const& salt, unsigned int iterations = min_iterations);
    static private_key from_password(std::string_view const& password, std::vector<uint8_t> const& salt, unsigned int iterations = min_iterations)
    {
        return from_password(std::vector<uint8_t>(password.begin(), password.end()), salt, iterations);
    }
 
    explicit operator bool() const {
        return key_.size() == key_size && salt_.size() == salt_size;
    }
 
    std::vector<uint8_t> const& salt() const {
        return salt_;
    }
 
    public_key pubkey() const;
 
    std::vector<uint8_t> shared_secret(public_key const& pub) const;
 
    std::string to_base64(bool pad = true) const;
    static private_key from_base64(std::string_view const& base64);
 
private:
    std::vector<uint8_t> key_;
    std::vector<uint8_t> salt_;
};
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::vector<uint8_t> const& plain, public_key const& pub, bool authenticated = true);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::string_view const& plain, public_key const& pub, bool authenticated = true);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(uint8_t const* plain, size_t size, public_key const& pub, bool authenticated = true);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::vector<uint8_t> const& plain, public_key const& pub, std::vector<uint8_t> const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::string_view const& plain, public_key const& pub, std::string_view const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(uint8_t const* plain, size_t size, public_key const& pub, uint8_t const* authenticated_data, size_t authenticated_data_size);
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::vector<uint8_t> const& chiper, private_key const& priv, bool authenticated = true);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::string_view const& chiper, private_key const& priv, bool authenticated = true);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(uint8_t const* cipher, size_t size, private_key const& priv, bool authenticated = true);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::vector<uint8_t> const& cipher, private_key const& priv, std::vector<uint8_t> const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::string_view const& cipher, private_key const& priv, std::string_view const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(uint8_t const* cipher, size_t size, private_key const& priv, uint8_t const* authenticated_data, size_t authenticated_data_size);
 
class FZ_PUBLIC_SYMBOL symmetric_key
{
public:
    enum {
        key_size = 32,
        salt_size = 32
    };
 
    static symmetric_key generate();
 
    enum {
        min_iterations = 100000
    };
 
    static symmetric_key from_password(std::vector<uint8_t> const& password, std::vector<uint8_t> const& salt, unsigned int iterations = min_iterations);
    static symmetric_key from_password(std::string_view const& password, std::vector<uint8_t> const& salt, unsigned int iterations = min_iterations)
    {
        return from_password(std::vector<uint8_t>(password.begin(), password.end()), salt, iterations);
    }
 
    explicit operator bool() const {
        return key_.size() == key_size && salt_.size() == salt_size;
    }
 
    std::vector<uint8_t> const& salt() const {
        return salt_;
    }
 
    std::string to_base64(bool pad = true) const;
    static symmetric_key from_base64(std::string_view const& base64);
    static symmetric_key from_base64(std::wstring_view const& base64);
 
    std::vector<uint8_t> encrypt_key(fz::public_key const& kek);
    static symmetric_key decrypt_key(std::vector<uint8_t> const& encrypted, fz::private_key const& kek);
 
    std::vector<uint8_t> const& key() const;
 
    static size_t encryption_overhead();
private:
    std::vector<uint8_t> key_;
    std::vector<uint8_t> salt_;
};
 
bool FZ_PUBLIC_SYMBOL operator==(symmetric_key const& lhs, symmetric_key const& rhs);
inline bool FZ_PUBLIC_SYMBOL operator!=(symmetric_key const& lhs, symmetric_key const& rhs) {
    return !(lhs == rhs);
}
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::vector<uint8_t> const& plain, symmetric_key const& key);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::string_view const& plain, symmetric_key const& key);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(uint8_t const* plain, size_t size, symmetric_key const& key);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::vector<uint8_t> const& plain, symmetric_key const& key, std::vector<uint8_t> const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(std::string_view const& plain, symmetric_key const& key, std::string_view const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL encrypt(uint8_t const* plain, size_t size, symmetric_key const& key, uint8_t const* authenticated_data, size_t authenticated_data_size);
 
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::vector<uint8_t> const& chiper, symmetric_key const& key);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::string_view const& chiper, symmetric_key const& key);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(uint8_t const* cipher, size_t size, symmetric_key const& key);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::vector<uint8_t> const& cipher, symmetric_key const& key, std::vector<uint8_t> const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(std::string_view const& cipher, symmetric_key const& key, std::string_view const& authenticated_data);
std::vector<uint8_t> FZ_PUBLIC_SYMBOL decrypt(uint8_t const* cipher, size_t size, symmetric_key const& key, uint8_t const* authenticated_data, size_t authenticated_data_size);
 
}
#endif