mirror of https://github.com/nucypher/pyUmbral.git
136 lines
3.9 KiB
Python
136 lines
3.9 KiB
Python
"""
|
|
This file is part of pyUmbral.
|
|
|
|
pyUmbral is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
pyUmbral is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with pyUmbral. If not, see <https://www.gnu.org/licenses/>.
|
|
"""
|
|
|
|
from cryptography.hazmat.backends import default_backend
|
|
|
|
from umbral import openssl
|
|
|
|
|
|
class Curve:
|
|
"""
|
|
Acts as a container to store constant variables such as the OpenSSL
|
|
curve_nid, the EC_GROUP struct, and the order of the curve.
|
|
|
|
Contains a whitelist of supported elliptic curves used in pyUmbral.
|
|
|
|
"""
|
|
|
|
_supported_curves = {
|
|
415: 'secp256r1',
|
|
714: 'secp256k1',
|
|
715: 'secp384r1'
|
|
}
|
|
|
|
def __init__(self, nid: int) -> None:
|
|
"""
|
|
Instantiates an OpenSSL curve with the provided curve_nid and derives
|
|
the proper EC_GROUP struct and order. You can _only_ instantiate curves
|
|
with supported nids (see `Curve.supported_curves`).
|
|
"""
|
|
|
|
try:
|
|
self.__curve_name = self._supported_curves[nid]
|
|
except KeyError:
|
|
raise NotImplementedError("Curve NID {} is not supported.".format(nid))
|
|
|
|
# set only once
|
|
self.__curve_nid = nid
|
|
self.__ec_group = openssl._get_ec_group_by_curve_nid(self.__curve_nid)
|
|
self.__order = openssl._get_ec_order_by_group(self.ec_group)
|
|
self.__generator = openssl._get_ec_generator_by_group(self.ec_group)
|
|
|
|
# Init cache
|
|
self.__field_order_size_in_bytes = 0
|
|
self.__group_order_size_in_bytes = 0
|
|
|
|
@classmethod
|
|
def from_name(cls, name: str) -> 'Curve':
|
|
"""
|
|
Alternate constructor to generate a curve instance by its name.
|
|
|
|
Raises NotImplementedError if the name cannot be mapped to a known
|
|
supported curve NID.
|
|
|
|
"""
|
|
|
|
name = name.casefold() # normalize
|
|
|
|
for supported_nid, supported_name in cls._supported_curves.items():
|
|
if name == supported_name:
|
|
instance = cls(nid=supported_nid)
|
|
break
|
|
else:
|
|
message = "{} is not supported curve name.".format(name)
|
|
raise NotImplementedError(message)
|
|
|
|
return instance
|
|
|
|
def __eq__(self, other):
|
|
return self.__curve_nid == other.curve_nid
|
|
|
|
def __repr__(self):
|
|
return "<OpenSSL Curve(nid={}, name={})>".format(self.__curve_nid, self.__curve_name)
|
|
|
|
#
|
|
# Immutable Curve Data
|
|
#
|
|
|
|
@property
|
|
def field_order_size_in_bytes(self) -> int:
|
|
if not self.__field_order_size_in_bytes:
|
|
size_in_bits = openssl._get_ec_group_degree(self.__ec_group)
|
|
self.__field_order_size_in_bytes = (size_in_bits + 7) // 8
|
|
return self.__field_order_size_in_bytes
|
|
|
|
@property
|
|
def group_order_size_in_bytes(self) -> int:
|
|
if not self.__group_order_size_in_bytes:
|
|
BN_num_bytes = default_backend()._lib.BN_num_bytes
|
|
self.__group_order_size_in_bytes = BN_num_bytes(self.order)
|
|
return self.__group_order_size_in_bytes
|
|
|
|
@property
|
|
def curve_nid(self) -> int:
|
|
return self.__curve_nid
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
return self.__curve_name
|
|
|
|
@property
|
|
def ec_group(self):
|
|
return self.__ec_group
|
|
|
|
@property
|
|
def order(self):
|
|
return self.__order
|
|
|
|
@property
|
|
def generator(self):
|
|
return self.__generator
|
|
|
|
|
|
#
|
|
# Global Curve Instances
|
|
#
|
|
|
|
SECP256R1 = Curve.from_name('secp256r1')
|
|
SECP256K1 = Curve.from_name('secp256k1')
|
|
SECP384R1 = Curve.from_name('secp384r1')
|
|
|
|
CURVES = (SECP256K1, SECP256R1, SECP384R1)
|