def _create_v3_keyfile_json(hrp,private_key, password, kdf,
work_factor=None, salt_size=16):
salt = Random.get_random_bytes(salt_size)
if work_factor is None:
work_factor = get_default_work_factor_for_kdf(kdf)
if kdf == 'pbkdf2':
derived_key = _pbkdf2_hash(
password,
hash_name='sha256',
salt=salt,
iterations=work_factor,
dklen=DKLEN,
)
kdfparams = {
'c': work_factor,
'dklen': DKLEN,
'prf': 'hmac-sha256',
'salt': encode_hex_no_prefix(salt),
}
elif kdf == 'scrypt':
derived_key = _scrypt_hash(
password,
salt=salt,
buflen=DKLEN,
r=SCRYPT_R,
p=SCRYPT_P,
n=work_factor,
)
kdfparams = {
'dklen': DKLEN,
'n': work_factor,
'r': SCRYPT_R,
'p': SCRYPT_P,
'salt': encode_hex_no_prefix(salt),
}
else:
raise NotImplementedError("KDF not implemented: {0}".format(kdf))
iv = big_endian_to_int(Random.get_random_bytes(16))
encrypt_key = derived_key[:16]
ciphertext = encrypt_aes_ctr(private_key, encrypt_key, iv)
mac = keccak(derived_key[16:32] + ciphertext)
pub = keys.PrivateKey(private_key).public_key
return {
'address': pub.to_bech32_address(hrp),
'crypto': {
'cipher': 'aes-128-ctr',
'cipherparams': {
'iv': encode_hex_no_prefix(int_to_big_endian(iv)),
},
'ciphertext': encode_hex_no_prefix(ciphertext),
'kdf': kdf,
'kdfparams': kdfparams,
'mac': encode_hex_no_prefix(mac),
},
'id': str(uuid.uuid4()),
'version': 3,
}
def encode_fn(self, value):
scaled_value = value * 2**self.low_bit_size
integer_value = int(scaled_value)
unsigned_integer_value = integer_value % (2**(self.high_bit_size +
self.low_bit_size))
return int_to_big_endian(unsigned_integer_value)
def compress_public_key(uncompressed_public_key_bytes: bytes) -> bytes:
x, y = decode_public_key(uncompressed_public_key_bytes)
if y % 2 == 0:
prefix = b"\x02"
else:
prefix = b"\x03"
return prefix + pad32(int_to_big_endian(x))
def encode_fn(self, value):
with decimal.localcontext(abi_decimal_context):
scaled_value = value * TEN**self.frac_places
integer_value = int(scaled_value)
unsigned_integer_value = integer_value % (2**self.value_bit_size)
return int_to_big_endian(unsigned_integer_value)
def to_text(primitive=None, hexstr=None, text=None):
assert_one_val(primitive, hexstr=hexstr, text=text)
if hexstr is not None:
return to_bytes(hexstr=hexstr).decode('utf-8')
elif text is not None:
return text
elif isinstance(primitive, str):
return to_text(hexstr=primitive)
elif isinstance(primitive, bytes):
return primitive.decode('utf-8')
elif is_integer(primitive):
byte_encoding = int_to_big_endian(primitive)
return to_text(byte_encoding)
raise TypeError("Expected an int, bytes or hexstr.")
def encode_raw_public_key(raw_public_key: Tuple[int, int]) -> bytes:
left, right = raw_public_key
return b''.join((
pad32(int_to_big_endian(left)),
pad32(int_to_big_endian(right)),
))
def to_bytes(self):
return b''.join(
pad32(int_to_big_endian(value))
for value in self.rs
)
def to_bytes(self) -> bytes:
vb = int_to_byte(self.v)
rb = pad32(int_to_big_endian(self.r))
sb = pad32(int_to_big_endian(self.s))
return b''.join((rb, sb, vb))
def encode_fn(self, value):
scaled_value = value * 2**self.low_bit_size
integer_value = int(scaled_value)
return int_to_big_endian(integer_value)
def encode_fn(self, value):
return int_to_big_endian(value % (2**self.value_bit_size))
