def __init__(self,
log2_n: int,
r: int,
p: int,
salt: Optional[bytes] = None):
self.log2_n, self.r, self.p = log2_n, r, p
self.salt = salt if salt is not None else rand_unique_bytes(32)
def __parse_scrypt(name: str, params: List[Tuple[str, Optional[str]]]) -> ScryptKdf:
ret = ScryptKdf.sensitive()
if name != "scrypt":
raise ValueError(f"Name must be 'scrypt'. Was '{name}'")
for key, value in params:
if key == "fast":
ret = ScryptKdf.fast()
elif key == "sensitive":
ret = ScryptKdf.sensitive()
elif value is None:
log.warning(f"Key '{key}' is unrecognized for scrypt and/or needs an associated value.")
elif key in {"log2n", "log2_n"}:
ret.log2_n = int(value)
elif key in {"n"}:
ret.log2_n = int(floor(log2(float(value))))
elif key in {"r"}:
ret.r = int(value)
elif key in {"p"}:
ret.p = int(value)
elif key in {"salt", "s"}:
ret.salt = b64.decode(value)
elif key in {"salt-len", "sl"}:
sint = int(value)
ret.salt = rand_unique_bytes(sint)
else:
log.warning(f"Unrecognized key '{key}' in params string.")
return ret
def __parse_argon2(name: str, params: List[Tuple[str, Optional[str]]]) -> Argon2Kdf:
ret = Argon2Kdf.sensitive()
if name == "argon2":
name = "argon2id"
ret.type = Argon2Kdf.str_to_type(name)
for key, value in params:
if key == "fast":
ret = Argon2Kdf.fast()
elif key == "sensitive":
ret = Argon2Kdf.sensitive()
elif value is None:
log.warning(f"Key '{key}' is unrecognized for argon2 and/or needs an associated value.")
elif key in {"time_cost", "n", "n_iterations"}:
vint = int(value)
ret.time_cost = vint
elif key in {"mem_cost", "mem", "m", "memory"}:
mint = __parse_memory_unit(value) // 1024
ret.memory_cost = mint
elif key in {"salt", "s"}:
ret.salt = b64.decode(value)
elif key in {"salt-len", "sl"}:
sint = int(value)
ret.salt = rand_unique_bytes(sint)
elif key in {"parallelism", "para", "p"}:
pint = int(value)
ret.parallelism = pint
else:
log.warning(f"Unrecognized key '{key}' in params string.")
return ret
def __parse_aes256gcm(
name: str, params: List[Tuple[str, Optional[str]]]) -> Aes256GcmCipher:
ret = Aes256GcmCipher()
if name not in {
"aes256", "aes256gcm", "aes-256", "aes-256-gcm", "aes256-gcm"
}:
raise ValueError(f"Given name '{name}' is not aes-256-gcm")
for key, value in params:
if key in {"iv", "nonce"}:
if value is None:
value = ''
ret.nonce = b64.decode(value)
if key in {"iv-len", "nonce-len"}:
if value is None:
log.warning(f"No value given for key '{key}'.")
iint = int(value)
ret.nonce = rand_unique_bytes(iint)
else:
log.warning(f"Unrecognized key '{key}' in params string.")
return ret
def __init__(self, nonce: Optional[bytes] = None):
if nonce is None:
nonce = rand_unique_bytes(32)
self.nonce = nonce
def __init__(self, nonce: Optional[bytes] = None):
if nonce is None:
nonce = rand_unique_bytes(12)
if len(nonce) != 12:
raise ValueError("Nonce must be 12 bytes.")
self.nonce = nonce