Skip to content

Commit

Permalink
Conversion functions for crypto parameters' enums (openfheorg#420)
Browse files Browse the repository at this point in the history 
* Added functions converting uint32_t to enum for crypto parameters

* Additional conversion functions

---------

Co-authored-by: Dmitriy Suponitskiy <dsuponitskiy@dualitytech.com>
  • Loading branch information
@dsuponitskiy @dsuponitskiy-duality
dsuponitskiy and dsuponitskiy-duality committed Jun 11, 2023
1 parent 67f4d9a commit 7aeac87
Show file tree
Hide file tree
Showing 4 changed files with 157 additions and 6 deletions.
1 change: 1 addition & 0 deletions src/core/include/lattice/stdlatticeparms.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -67,6 +67,7 @@ enum SecurityLevel {
HEStd_NotSet,
};

SecurityLevel convertToSecurityLevel(uint32_t num);
inline std::ostream& operator<<(std::ostream& s, SecurityLevel sl) {
switch (sl) {
case HEStd_128_classic:
Expand Down
16 changes: 16 additions & 0 deletions src/core/lib/lattice/stdlatticeparms.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -38,6 +38,22 @@

namespace lbcrypto {

SecurityLevel convertToSecurityLevel(uint32_t num) {
auto secLevel = static_cast<SecurityLevel>(num);
switch (secLevel) {
// case HEStd_NotSet:
case HEStd_128_classic:
case HEStd_192_classic:
case HEStd_256_classic:
return secLevel;
default:
break;
}

std::string errMsg(std::string("Unknown value for SecurityLevel ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}

std::map<usint, StdLatticeParm*> StdLatticeParm::byRing[3][3];
std::map<usint, StdLatticeParm*> StdLatticeParm::byLogQ[3][3];

Expand Down
9 changes: 9 additions & 0 deletions src/pke/include/constants.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -59,6 +59,7 @@ enum SecretKeyDist {
UNIFORM_TERNARY = 1,
SPARSE_TERNARY = 2,
};
SecretKeyDist convertToSecretKeyDist(uint32_t num);
std::ostream& operator<<(std::ostream& s, SecretKeyDist m);

enum ScalingTechnique {
Expand All @@ -69,6 +70,7 @@ enum ScalingTechnique {
NORESCALE,
INVALID_RS_TECHNIQUE, // TODO (dsuponit): make this the first value
};
ScalingTechnique convertToScalingTechnique(uint32_t num);
std::ostream& operator<<(std::ostream& s, ScalingTechnique t);

enum ProxyReEncryptionMode {
Expand All @@ -78,38 +80,44 @@ enum ProxyReEncryptionMode {
NOISE_FLOODING_HRA,
DIVIDE_AND_ROUND_HRA,
};
ProxyReEncryptionMode convertToProxyReEncryptionMode(uint32_t num);
std::ostream& operator<<(std::ostream& s, ProxyReEncryptionMode p);

enum MultipartyMode {
INVALID_MULTIPARTY_MODE = 0,
FIXED_NOISE_MULTIPARTY,
NOISE_FLOODING_MULTIPARTY,
};
MultipartyMode convertToMultipartyMode(uint32_t num);
std::ostream& operator<<(std::ostream& s, MultipartyMode t);

enum ExecutionMode {
EXEC_EVALUATION = 0,
EXEC_NOISE_ESTIMATION,
};
ExecutionMode convertToExecutionMode(uint32_t num);
std::ostream& operator<<(std::ostream& s, ExecutionMode t);

enum DecryptionNoiseMode {
FIXED_NOISE_DECRYPT = 0,
NOISE_FLOODING_DECRYPT,
};
DecryptionNoiseMode convertToDecryptionNoiseMode(uint32_t num);
std::ostream& operator<<(std::ostream& s, DecryptionNoiseMode t);

enum KeySwitchTechnique {
INVALID_KS_TECH = 0,
BV,
HYBRID,
};
KeySwitchTechnique convertToKeySwitchTechnique(uint32_t num);
std::ostream& operator<<(std::ostream& s, KeySwitchTechnique t);

enum EncryptionTechnique {
STANDARD = 0,
EXTENDED,
};
EncryptionTechnique convertToEncryptionTechnique(uint32_t num);
std::ostream& operator<<(std::ostream& s, EncryptionTechnique t);

enum MultiplicationTechnique {
Expand All @@ -118,6 +126,7 @@ enum MultiplicationTechnique {
HPSPOVERQ,
HPSPOVERQLEVELED,
};
MultiplicationTechnique convertToMultiplicationTechnique(uint32_t num);
std::ostream& operator<<(std::ostream& s, MultiplicationTechnique t);

enum PlaintextEncodings {
Expand Down
137 changes: 131 additions & 6 deletions src/pke/lib/constants-impl.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,6 +64,20 @@ std::ostream& operator<<(std::ostream& s, PKESchemeFeature f) {
return s;
}

SecretKeyDist convertToSecretKeyDist(uint32_t num) {
auto keyDist = static_cast<SecretKeyDist>(num);
switch (keyDist) {
case GAUSSIAN:
case UNIFORM_TERNARY:
case SPARSE_TERNARY:
return keyDist;
default:
break;
}

std::string errMsg(std::string("Unknown value for SecretKeyDist ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, SecretKeyDist m) {
switch (m) {
case GAUSSIAN:
Expand All @@ -82,6 +96,23 @@ std::ostream& operator<<(std::ostream& s, SecretKeyDist m) {
return s;
}

ScalingTechnique convertToScalingTechnique(uint32_t num) {
auto scTech = static_cast<ScalingTechnique>(num);
switch (scTech) {
case FIXEDMANUAL:
case FIXEDAUTO:
case FLEXIBLEAUTO:
case FLEXIBLEAUTOEXT:
case NORESCALE:
// case INVALID_RS_TECHNIQUE:
return scTech;
default:
break;
}

std::string errMsg(std::string("Unknown value for ScalingTechnique ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, ScalingTechnique t) {
switch (t) {
case FIXEDMANUAL:
Expand Down Expand Up @@ -109,6 +140,22 @@ std::ostream& operator<<(std::ostream& s, ScalingTechnique t) {
return s;
}

ProxyReEncryptionMode convertToProxyReEncryptionMode(uint32_t num) {
auto encrMode = static_cast<ProxyReEncryptionMode>(num);
switch (encrMode) {
// case NOT_SET:
case INDCPA:
case FIXED_NOISE_HRA:
case NOISE_FLOODING_HRA:
case DIVIDE_AND_ROUND_HRA:
return encrMode;
default:
break;
}

std::string errMsg(std::string("Unknown value for ProxyReEncryptionMode ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, ProxyReEncryptionMode p) {
switch (p) {
case NOT_SET:
Expand All @@ -118,12 +165,8 @@ std::ostream& operator<<(std::ostream& s, ProxyReEncryptionMode p) {
s << "INDCPA";
break;
case FIXED_NOISE_HRA:
s << "FIXED_NOISE_HRA";
break;
case NOISE_FLOODING_HRA:
s << "NOISE_FLOODING_HRA";
break;
case DIVIDE_AND_ROUND_HRA:
SecretKeyDist convertToSecretKeyDist(uint32_t num);

s << "DIVIDE_AND_ROUND_HRA";
break;
default:
Expand All @@ -133,6 +176,20 @@ std::ostream& operator<<(std::ostream& s, ProxyReEncryptionMode p) {
return s;
}

MultipartyMode convertToMultipartyMode(uint32_t num) {
auto mptyMode = static_cast<MultipartyMode>(num);
switch (mptyMode) {
// case INVALID_MULTIPARTY_MODE:
case FIXED_NOISE_MULTIPARTY:
case NOISE_FLOODING_MULTIPARTY:
return mptyMode;
default:
break;
}

std::string errMsg(std::string("Unknown value for MultipartyMode ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, MultipartyMode t) {
switch (t) {
case INVALID_MULTIPARTY_MODE:
Expand All @@ -151,6 +208,19 @@ std::ostream& operator<<(std::ostream& s, MultipartyMode t) {
return s;
}

ExecutionMode convertToExecutionMode(uint32_t num) {
auto execMode = static_cast<ExecutionMode>(num);
switch (execMode) {
case EXEC_EVALUATION:
case EXEC_NOISE_ESTIMATION:
return execMode;
default:
break;
}

std::string errMsg(std::string("Unknown value for ExecutionMode ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, ExecutionMode t) {
switch (t) {
case EXEC_EVALUATION:
Expand All @@ -166,6 +236,19 @@ std::ostream& operator<<(std::ostream& s, ExecutionMode t) {
return s;
}

DecryptionNoiseMode convertToDecryptionNoiseMode(uint32_t num) {
auto noiseMode = static_cast<DecryptionNoiseMode>(num);
switch (noiseMode) {
case FIXED_NOISE_DECRYPT:
case NOISE_FLOODING_DECRYPT:
return noiseMode;
default:
break;
}

std::string errMsg(std::string("Unknown value for DecryptionNoiseMode ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, DecryptionNoiseMode t) {
switch (t) {
case FIXED_NOISE_DECRYPT:
Expand All @@ -181,6 +264,20 @@ std::ostream& operator<<(std::ostream& s, DecryptionNoiseMode t) {
return s;
}

KeySwitchTechnique convertToKeySwitchTechnique(uint32_t num) {
auto ksTech = static_cast<KeySwitchTechnique>(num);
switch (ksTech) {
// case INVALID_KS_TECH:
case BV:
case HYBRID:
return ksTech;
default:
break;
}

std::string errMsg(std::string("Unknown value for KeySwitchTechnique ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, KeySwitchTechnique t) {
switch (t) {
case BV:
Expand All @@ -196,6 +293,19 @@ std::ostream& operator<<(std::ostream& s, KeySwitchTechnique t) {
return s;
}

EncryptionTechnique convertToEncryptionTechnique(uint32_t num) {
auto encrTech = static_cast<EncryptionTechnique>(num);
switch (encrTech) {
case STANDARD:
case EXTENDED:
return encrTech;
default:
break;
}

std::string errMsg(std::string("Unknown value for EncryptionTechnique ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, EncryptionTechnique t) {
switch (t) {
case STANDARD:
Expand All @@ -211,6 +321,21 @@ std::ostream& operator<<(std::ostream& s, EncryptionTechnique t) {
return s;
}

MultiplicationTechnique convertToMultiplicationTechnique(uint32_t num) {
auto multTech = static_cast<MultiplicationTechnique>(num);
switch (multTech) {
case BEHZ:
case HPS:
case HPSPOVERQ:
case HPSPOVERQLEVELED:
return multTech;
default:
break;
}

std::string errMsg(std::string("Unknown value for MultiplicationTechnique ") + std::to_string(num));
OPENFHE_THROW(config_error, errMsg);
}
std::ostream& operator<<(std::ostream& s, MultiplicationTechnique t) {
switch (t) {
case BEHZ:
Expand Down

0 comments on commit 7aeac87

Please # to comment.