def get_size(cls, curve: ec.EllipticCurve=None):
"""
Returns the size (in bytes) of a compressed Point given a curve.
If no curve is provided, it uses the default curve.
"""
curve = curve if curve is not None else default_curve()
return get_curve_keysize_bytes(curve) + 1
def expected_bytes_length(cls, curve: ec.EllipticCurve = None):
"""
Returns the size (in bytes) of a CurveBN given the curve.
If no curve is provided, it uses the default.
"""
curve = curve if curve is not None else default_curve()
return get_curve_keysize_bytes(curve)
def gen_rand(cls, curve: ec.EllipticCurve = None):
"""
Returns a BigNum object with a cryptographically secure BigNum based
on the given curve.
"""
curve = curve if curve is not None else default_curve()
curve_nid = backend._elliptic_curve_to_nid(curve)
group = backend._lib.EC_GROUP_new_by_curve_name(curve_nid)
backend.openssl_assert(group != backend._ffi.NULL)
order = backend._lib.BN_new()
backend.openssl_assert(order != backend._ffi.NULL)
order = backend._ffi.gc(order, backend._lib.BN_free)
with backend._tmp_bn_ctx() as bn_ctx:
res = backend._lib.EC_GROUP_get_order(group, order, bn_ctx)
backend.openssl_assert(res == 1)
order_int = backend._bn_to_int(order)
# Generate random number on curve
key_size = get_curve_keysize_bytes(curve)
rand_num = int.from_bytes(os.urandom(key_size), 'big')
while rand_num >= order_int or rand_num <= 0:
rand_num = int.from_bytes(os.urandom(key_size), 'big')
new_rand_bn = backend._int_to_bn(rand_num)
new_rand_bn = backend._ffi.gc(new_rand_bn, backend._lib.BN_free)
return cls(new_rand_bn, curve_nid, group, order)
def from_bytes(cls, capsule_bytes: bytes, curve: ec.EllipticCurve = None):
"""
Instantiates a Capsule object from the serialized data.
"""
curve = curve if curve is not None else default_curve()
key_size = get_curve_keysize_bytes(curve)
capsule_buff = BytesIO(capsule_bytes)
# CurveBNs are the keysize in bytes, Points are compressed and the
# keysize + 1 bytes long.
if len(capsule_bytes) == 197:
e = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
v = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
sig = CurveBN.from_bytes(capsule_buff.read(key_size), curve)
e_prime = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
v_prime = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
ni = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
else:
e = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
v = Point.from_bytes(capsule_buff.read(key_size + 1), curve)
sig = CurveBN.from_bytes(capsule_buff.read(key_size), curve)
e_prime = v_prime = ni = None
return cls(point_e=e, point_v=v, bn_sig=sig,
point_e_prime=e_prime, point_v_prime=v_prime,
point_noninteractive=ni)
def from_bytes(cls, data: bytes, curve: ec.EllipticCurve = None):
"""
Instantiate CorrectnessProof from serialized data.
"""
curve = curve if curve is not None else default_curve()
key_size = get_curve_keysize_bytes(curve)
data = BytesIO(data)
# CurveBNs are the keysize in bytes, Points are compressed and the
# keysize + 1 bytes long.
e2 = Point.from_bytes(data.read(key_size + 1), curve)
v2 = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_commitment = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_pok = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_sig1 = CurveBN.from_bytes(data.read(key_size), curve)
kfrag_sig2 = CurveBN.from_bytes(data.read(key_size), curve)
sig = CurveBN.from_bytes(data.read(key_size), curve)
metadata = data.read() or None
return cls(e2,
v2,
kfrag_commitment,
kfrag_pok,
kfrag_sig1,
kfrag_sig2,
sig,
metadata=metadata)
def from_bytes(cls, data, curve: ec.EllipticCurve = None):
"""
Returns a Point object from the given byte data on the curve provided.
"""
curve = curve if curve is not None else default_curve()
try:
curve_nid = backend._elliptic_curve_to_nid(curve)
except AttributeError:
# Presume that the user passed in the curve_nid
curve_nid = curve
# Check if compressed
if data[0] in [2, 3]:
type_y = data[0] - 2
if len(data[1:]) > get_curve_keysize_bytes(curve):
raise ValueError("X coordinate too large for curve.")
affine_x = BigNum.from_bytes(data[1:], curve)
ec_point = backend._lib.EC_POINT_new(affine_x.group)
backend.openssl_assert(ec_point != backend._ffi.NULL)
ec_point = backend._ffi.gc(ec_point,
backend._lib.EC_POINT_clear_free)
with backend._tmp_bn_ctx() as bn_ctx:
res = backend._lib.EC_POINT_set_compressed_coordinates_GFp(
affine_x.group, ec_point, affine_x.bignum, type_y, bn_ctx)
backend.openssl_assert(res == 1)
return cls(ec_point, curve_nid, affine_x.group)
# Handle uncompressed point
elif data[0] == 4:
key_size = get_curve_keysize_bytes(curve)
affine_x = int.from_bytes(data[1:key_size + 1], 'big')
affine_y = int.from_bytes(data[1 + key_size:], 'big')
return Point.from_affine((affine_x, affine_y), curve)
else:
raise ValueError("Invalid point serialization.")
def __init__(self, curve: ec.EllipticCurve):
from umbral.point import Point, unsafe_hash_to_point
from umbral.utils import get_curve_keysize_bytes
self.curve = curve
self.g = Point.get_generator_from_curve(self.curve)
self.order = Point.get_order_from_curve(self.curve)
g_bytes = self.g.to_bytes(is_compressed=True)
self.CURVE_MINVAL_SHA512 = (1 << 512) % int(self.order)
self.CURVE_KEY_SIZE_BYTES = get_curve_keysize_bytes(self.curve)
parameters_seed = b'NuCypherKMS/UmbralParameters/'
self.u = unsafe_hash_to_point(g_bytes, self, parameters_seed + b'u')
def from_bytes(data: bytes, curve: ec.EllipticCurve = None):
"""
Instantiates a CapsuleFrag object from the serialized data.
"""
curve = curve if curve is not None else default_curve()
key_size = get_curve_keysize_bytes(curve)
data = BytesIO(data)
# BigNums are the keysize in bytes, Points are compressed and the
# keysize + 1 bytes long.
e1 = Point.from_bytes(data.read(key_size + 1), curve)
v1 = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_id = BigNum.from_bytes(data.read(key_size), curve)
eph_ni = Point.from_bytes(data.read(key_size + 1), curve)
return CapsuleFrag(e1, v1, kfrag_id, eph_ni)
def __init__(self, curve: ec.EllipticCurve):
from umbral.point import Point, unsafe_hash_to_point
from umbral.utils import get_curve_keysize_bytes
self.curve = curve
curve_nid = backend._elliptic_curve_to_nid(curve)
self.g = Point.get_generator_from_curve(self.curve)
self.order = openssl._get_ec_order_by_curve_nid(curve_nid)
g_bytes = self.g.to_bytes(is_compressed=True)
self.CURVE_KEY_SIZE_BYTES = get_curve_keysize_bytes(self.curve)
parameters_seed = b'NuCypherKMS/UmbralParameters/'
self.u = unsafe_hash_to_point(g_bytes, self, parameters_seed + b'u')
def from_bytes(data: bytes, curve: ec.EllipticCurve = None):
"""
Instantiate a KFrag object from the serialized data.
"""
curve = curve if curve is not None else default_curve()
key_size = get_curve_keysize_bytes(curve)
data = BytesIO(data)
# BigNums are the keysize in bytes, Points are compressed and the
# keysize + 1 bytes long.
id = BigNum.from_bytes(data.read(key_size), curve)
key = BigNum.from_bytes(data.read(key_size), curve)
eph_ni = Point.from_bytes(data.read(key_size + 1), curve)
commitment = Point.from_bytes(data.read(key_size + 1), curve)
sig1 = BigNum.from_bytes(data.read(key_size), curve)
sig2 = BigNum.from_bytes(data.read(key_size), curve)
return KFrag(id, key, eph_ni, commitment, sig1, sig2)
def from_bytes(cls, data: bytes, curve: ec.EllipticCurve = None):
"""
Instantiates a CapsuleFrag object from the serialized data.
"""
curve = curve if curve is not None else default_curve()
key_size = get_curve_keysize_bytes(curve)
data = BytesIO(data)
# CurveBNs are the keysize in bytes, Points are compressed and the
# keysize + 1 bytes long.
e1 = Point.from_bytes(data.read(key_size + 1), curve)
v1 = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_id = CurveBN.from_bytes(data.read(key_size), curve)
ni = Point.from_bytes(data.read(key_size + 1), curve)
proof = data.read() or None
proof = CorrectnessProof.from_bytes(proof, curve) if proof else None
return cls(e1, v1, kfrag_id, ni, proof)
def from_bytes(cls, data: bytes, curve: ec.EllipticCurve = None):
"""
Instantiate ChallengeResponse from serialized data.
"""
curve = curve if curve is not None else default_curve()
key_size = get_curve_keysize_bytes(curve)
data = BytesIO(data)
# BigNums are the keysize in bytes, Points are compressed and the
# keysize + 1 bytes long.
e2 = Point.from_bytes(data.read(key_size + 1), curve)
v2 = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_commitment = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_pok = Point.from_bytes(data.read(key_size + 1), curve)
kfrag_sig1 = BigNum.from_bytes(data.read(key_size), curve)
kfrag_sig2 = BigNum.from_bytes(data.read(key_size), curve)
sig = BigNum.from_bytes(data.read(key_size), curve)
return cls(e2, v2, kfrag_commitment, kfrag_pok, kfrag_sig1, kfrag_sig2,
sig)
def expected_bytes_length(cls, curve: ec.EllipticCurve = None):
curve = curve if curve is not None else default_curve()
return get_curve_keysize_bytes(curve) * 2
