Cryptography.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
 
#include "../Common/CompilerMacrosExport.h"
#ifndef SC_EXPORT_LIBRARY_CRYPTOGRAPHY
#define SC_EXPORT_LIBRARY_CRYPTOGRAPHY 0
#endif
#define SC_CRYPTOGRAPHY_EXPORT SC_COMPILER_LIBRARY_EXPORT(SC_EXPORT_LIBRARY_CRYPTOGRAPHY)
 
#include "../Common/CompilerMacrosLifetimeBound.h"
#include "../Common/CompilerMove.h"
#include "../Common/OpaqueObject.h"
#include "../Common/Result.h"
#include "../Common/Span.h"
 
namespace SC
{
 
 
struct SC_CRYPTOGRAPHY_EXPORT Cryptography
{
    enum class Backend : uint8_t
    {
        Native,
        OpenSSL,
    };
 
    struct Features
    {
        Backend backend = Backend::Native;
 
        bool secureRandom   = false;
        bool aes128Gcm      = false;
        bool aes256Gcm      = false;
        bool aes128CbcPkcs7 = false;
        bool aes256CbcPkcs7 = false;
        bool hmacSha256     = false;
        bool hmacSha384     = false;
        bool hkdfSha256     = false;
        bool hkdfSha384     = false;
 
        size_t maximumAeadAssociatedDataSize = 0;
    };
 
    enum class HashType : uint8_t
    {
        SHA256,
        SHA384,
    };
 
    enum class AeadType : uint8_t
    {
        AES128GCM,
        AES256GCM,
    };
 
    enum class CipherType : uint8_t
    {
        AES128CBCPKCS7,
        AES256CBCPKCS7,
    };
 
    struct MacResult
    {
        uint8_t bytes[48] = {0};
        size_t  size      = 0;
 
        Span<const uint8_t> toBytesSpan() const SC_LANGUAGE_LIFETIME_BOUND { return {bytes, size}; }
    };
 
    static Result queryFeatures(Features& outFeatures);
 
    static Result queryFeatures(Backend backend, Features& outFeatures);
 
    struct SC_CRYPTOGRAPHY_EXPORT Random
    {
        static Result fill(Span<uint8_t> output);
    };
 
    struct SC_CRYPTOGRAPHY_EXPORT Aead
    {
      private:
        struct Internal;
        struct InternalDefinition
        {
            static constexpr int Windows = 4600;
            static constexpr int Apple   = 128;
            static constexpr int Linux   = 96;
            static constexpr int Default = Linux;
 
            static constexpr size_t Alignment = alignof(void*);
 
            using Object = Internal;
        };
 
      public:
        using InternalOpaque = OpaqueObject<InternalDefinition>;
 
      private:
        InternalOpaque internal;
 
      public:
        Aead();
        explicit Aead(Backend backend);
        ~Aead();
        Aead(const Aead&)            = delete;
        Aead(Aead&&)                 = delete;
        Aead& operator=(const Aead&) = delete;
        Aead& operator=(Aead&&)      = delete;
 
        Result init(AeadType type, Span<const uint8_t> key);
 
        Result seal(Span<const uint8_t> nonce, Span<const uint8_t> aad, Span<const uint8_t> plaintext,
                    Span<uint8_t> ciphertext, Span<uint8_t> tag, size_t& bytesWritten);
 
        Result open(Span<const uint8_t> nonce, Span<const uint8_t> aad, Span<const uint8_t> ciphertext,
                    Span<const uint8_t> tag, Span<uint8_t> plaintext, size_t& bytesWritten);
 
      private:
        friend decltype(internal);
    };
 
    struct SC_CRYPTOGRAPHY_EXPORT Cipher
    {
        enum class Operation : uint8_t
        {
            Encrypt,
            Decrypt,
        };
 
      private:
        struct Internal;
        struct InternalDefinition
        {
            static constexpr int Windows = 4600;
            static constexpr int Apple   = 512;
            static constexpr int Linux   = 128;
            static constexpr int Default = Linux;
 
            static constexpr size_t Alignment = alignof(void*);
 
            using Object = Internal;
        };
 
      public:
        using InternalOpaque = OpaqueObject<InternalDefinition>;
 
      private:
        InternalOpaque internal;
 
      public:
        Cipher();
        explicit Cipher(Backend backend);
        ~Cipher();
        Cipher(const Cipher&)            = delete;
        Cipher(Cipher&&)                 = delete;
        Cipher& operator=(const Cipher&) = delete;
        Cipher& operator=(Cipher&&)      = delete;
 
        Result start(CipherType type, Operation operation, Span<const uint8_t> key, Span<const uint8_t> iv);
 
        Result update(Span<const uint8_t> input, Span<uint8_t> output, size_t& bytesWritten);
 
        Result finish(Span<uint8_t> output, size_t& bytesWritten);
 
        void reset();
 
      private:
        friend decltype(internal);
    };
 
    struct SC_CRYPTOGRAPHY_EXPORT Hmac
    {
      private:
        struct Internal;
        struct InternalDefinition
        {
            static constexpr int Windows = 2600;
            static constexpr int Apple   = 512;
            static constexpr int Linux   = 64;
            static constexpr int Default = Linux;
 
            static constexpr size_t Alignment = alignof(void*);
 
            using Object = Internal;
        };
 
      public:
        using InternalOpaque = OpaqueObject<InternalDefinition>;
 
      private:
        InternalOpaque internal;
 
      public:
        Hmac();
        explicit Hmac(Backend backend);
        ~Hmac();
        Hmac(const Hmac&)            = delete;
        Hmac(Hmac&&)                 = delete;
        Hmac& operator=(const Hmac&) = delete;
        Hmac& operator=(Hmac&&)      = delete;
 
        Result setType(HashType type);
 
        Result setKey(Span<const uint8_t> key);
 
        Result add(Span<const uint8_t> data);
 
        Result getMac(MacResult& result);
 
        void reset();
 
      private:
        friend decltype(internal);
    };
 
    struct SC_CRYPTOGRAPHY_EXPORT Hkdf
    {
        static Result derive(HashType type, Span<const uint8_t> salt, Span<const uint8_t> ikm, Span<const uint8_t> info,
                             Span<uint8_t> output);
 
        static Result derive(Backend backend, HashType type, Span<const uint8_t> salt, Span<const uint8_t> ikm,
                             Span<const uint8_t> info, Span<uint8_t> output);
    };
};
 
} // namespace SC