duckdb::EncryptionTypes Class Reference

Public Types
enum	CipherType : uint8_t { INVALID = 0 , GCM = 1 , CTR = 2 , CBC = 3 }
enum	KeyDerivationFunction : uint8_t { DEFAULT = 0 , SHA256 = 1 , PBKDF2 = 2 }
enum	Mode { ENCRYPT , DECRYPT }
enum	EncryptionVersion : uint8_t { V0_0 = 0 , V0_1 = 1 , NONE = 127 }

Static Public Member Functions
static string	CipherToString (CipherType cipher_p)
static CipherType	StringToCipher (const string &encryption_cipher_p)
static string	KDFToString (KeyDerivationFunction kdf_p)
static KeyDerivationFunction	StringToKDF (const string &key_derivation_function_p)
static EncryptionVersion	StringToVersion (const string &encryption_version_p)

Member Enumeration Documentation

CipherType

enum duckdb::EncryptionTypes::CipherType : uint8_t

: uint8_t { INVALID = 0, GCM = 1, CTR = 2, CBC = 3 };

KeyDerivationFunction

enum duckdb::EncryptionTypes::KeyDerivationFunction : uint8_t

: uint8_t { DEFAULT = 0, SHA256 = 1, PBKDF2 = 2 };

Mode

enum duckdb::EncryptionTypes::Mode

{ ENCRYPT, DECRYPT };

EncryptionVersion

enum duckdb::EncryptionTypes::EncryptionVersion : uint8_t

: uint8_t { V0_0 = 0, V0_1 = 1, NONE = 127 };

Member Function Documentation

CipherToString()

string duckdb::EncryptionTypes::CipherToString ( CipherType  cipher_p )

static

                                                          {
    switch (cipher_p) {
    case GCM:
        return "GCM";
    case CTR:
        return "CTR";
    case CBC:
        return "CBC";
    default:
        return "INVALID";
    }
}

StringToCipher()

EncryptionTypes::CipherType duckdb::EncryptionTypes::StringToCipher ( const string &  encryption_cipher_p )

static

                                                                                           {
    auto encryption_cipher = StringUtil::Upper(encryption_cipher_p);
    if (encryption_cipher == "GCM") {
        return GCM;
    }
    if (encryption_cipher == "CTR") {
        return CTR;
    }
    if (encryption_cipher == "CBC") {
        throw NotImplementedException("CBC encryption is disabled");
    }
    return INVALID;
}

KDFToString()

string duckdb::EncryptionTypes::KDFToString ( KeyDerivationFunction  kdf_p )

static

                                                               {
    switch (kdf_p) {
    case SHA256:
        return "SHA256";
    case PBKDF2:
        return "PBKDF2";
    default:
        return "DEFAULT";
    }
}

StringToKDF()

EncryptionTypes::KeyDerivationFunction duckdb::EncryptionTypes::StringToKDF ( const string &  key_derivation_function_p )

static

                                                                                                         {
    auto key_derivation_function = StringUtil::Upper(key_derivation_function_p);
    if (key_derivation_function == "SHA256") {
        return SHA256;
    }
    if (key_derivation_function == "PBKDF2") {
        return PBKDF2;
    }
    return DEFAULT;
}

StringToVersion()

EncryptionTypes::EncryptionVersion duckdb::EncryptionTypes::StringToVersion ( const string &  encryption_version_p )

static

                                                                                                    {
    if (encryption_version_p == "v0") {
        return V0_0;
    } else if (encryption_version_p == "v1") {
        return V0_1;
    } else {
        throw NotImplementedException("No encryption version higher then v%d is supported yet in this DuckDB version",
                                      MAX_VERSION);
    }
}

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp