def test_ed448_unsupported(backend): with raises_unsupported_algorithm( _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM): Ed448PublicKey.from_public_bytes(b"0" * 57) with raises_unsupported_algorithm( _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM): Ed448PrivateKey.from_private_bytes(b"0" * 57) with raises_unsupported_algorithm( _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM): Ed448PrivateKey.generate()
def test_ed448_unsupported(backend): with raises_unsupported_algorithm( _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM ): Ed448PublicKey.from_public_bytes(b"0" * 57) with raises_unsupported_algorithm( _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM ): Ed448PrivateKey.from_private_bytes(b"0" * 57) with raises_unsupported_algorithm( _Reasons.UNSUPPORTED_PUBLIC_KEY_ALGORITHM ): Ed448PrivateKey.generate()
def test_pub_priv_bytes_raw(self, vector, backend): sk = binascii.unhexlify(vector["secret"]) pk = binascii.unhexlify(vector["public"]) private_key = Ed448PrivateKey.from_private_bytes(sk) assert ( private_key.private_bytes( serialization.Encoding.Raw, serialization.PrivateFormat.Raw, serialization.NoEncryption(), ) == sk ) assert ( private_key.public_key().public_bytes( serialization.Encoding.Raw, serialization.PublicFormat.Raw ) == pk ) public_key = Ed448PublicKey.from_public_bytes(pk) assert ( public_key.public_bytes( serialization.Encoding.Raw, serialization.PublicFormat.Raw ) == pk )
def sign(self, to_be_signed: bytes, alg: Optional[CoseAlgorithms] = None, curve: CoseEllipticCurves = None) -> bytes: """ Computes a digital signature over 'to_be_signed'. The parameter 'alg' and 'curve' parameters are optional in case they are already provided by the key object self. :param to_be_signed: Data over which the signature is calculated. :param alg: An optional algorithm parameter. :param curve: An optional curve parameter. :return: the signature over the COSE object. """ self._check_key_conf(algorithm=alg, key_operation=KeyOps.SIGN, curve=curve) if self.crv == CoseEllipticCurves.ED25519: sk = Ed25519PrivateKey.from_private_bytes(self.d) elif self._crv == CoseEllipticCurves.ED448: sk = Ed448PrivateKey.from_private_bytes(self.d) else: raise CoseIllegalCurve( f"Illegal curve for OKP singing: {self.crv}") return sk.sign(to_be_signed)
def from_jwk(jwk): try: if isinstance(jwk, str): obj = json.loads(jwk) elif isinstance(jwk, dict): obj = jwk else: raise ValueError except ValueError: raise InvalidKeyError("Key is not valid JSON") if obj.get("kty") != "OKP": raise InvalidKeyError("Not an Octet Key Pair") curve = obj.get("crv") if curve != "Ed25519" and curve != "Ed448": raise InvalidKeyError(f"Invalid curve: {curve}") if "x" not in obj: raise InvalidKeyError('OKP should have "x" parameter') x = base64url_decode(obj.get("x")) try: if "d" not in obj: if curve == "Ed25519": return Ed25519PublicKey.from_public_bytes(x) return Ed448PublicKey.from_public_bytes(x) d = base64url_decode(obj.get("d")) if curve == "Ed25519": return Ed25519PrivateKey.from_private_bytes(d) return Ed448PrivateKey.from_private_bytes(d) except ValueError as err: raise InvalidKeyError("Invalid key parameter") from err
def test_buffer_protocol(self, backend): private_bytes = os.urandom(57) key = Ed448PrivateKey.from_private_bytes(bytearray(private_bytes)) assert (key.private_bytes( serialization.Encoding.Raw, serialization.PrivateFormat.Raw, serialization.NoEncryption(), ) == private_bytes)
def test_buffer_protocol(self, backend): private_bytes = os.urandom(57) key = Ed448PrivateKey.from_private_bytes(bytearray(private_bytes)) assert key.private_bytes( serialization.Encoding.Raw, serialization.PrivateFormat.Raw, serialization.NoEncryption() ) == private_bytes
def sign(cls, key: 'OKP', data: bytes) -> bytes: if key.crv.fullname == 'ED25519': sk = Ed25519PrivateKey.from_private_bytes(key.d) elif key.crv.fullname == 'ED448': sk = Ed448PrivateKey.from_private_bytes(key.d) else: raise CoseException(f"Illegal curve for OKP singing: {key.crv}") return sk.sign(data)
def test_sign_input(self, vector, backend): if vector.get("context") is not None: pytest.skip("ed448 contexts are not currently supported") sk = binascii.unhexlify(vector["secret"]) pk = binascii.unhexlify(vector["public"]) message = binascii.unhexlify(vector["message"]) signature = binascii.unhexlify(vector["signature"]) private_key = Ed448PrivateKey.from_private_bytes(sk) computed_sig = private_key.sign(message) assert computed_sig == signature public_key = private_key.public_key() assert (public_key.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw) == pk) public_key.verify(signature, message)
def test_pub_priv_bytes_raw(self, vector, backend): sk = binascii.unhexlify(vector["secret"]) pk = binascii.unhexlify(vector["public"]) private_key = Ed448PrivateKey.from_private_bytes(sk) assert private_key.private_bytes( serialization.Encoding.Raw, serialization.PrivateFormat.Raw, serialization.NoEncryption() ) == sk assert private_key.public_key().public_bytes( serialization.Encoding.Raw, serialization.PublicFormat.Raw ) == pk public_key = Ed448PublicKey.from_public_bytes(pk) assert public_key.public_bytes( serialization.Encoding.Raw, serialization.PublicFormat.Raw ) == pk
def test_sign_input(self, vector, backend): if vector.get("context") is not None: pytest.skip("ed448 contexts are not currently supported") sk = binascii.unhexlify(vector["secret"]) pk = binascii.unhexlify(vector["public"]) message = binascii.unhexlify(vector["message"]) signature = binascii.unhexlify(vector["signature"]) private_key = Ed448PrivateKey.from_private_bytes(sk) computed_sig = private_key.sign(message) assert computed_sig == signature public_key = private_key.public_key() assert public_key.public_bytes( serialization.Encoding.Raw, serialization.PublicFormat.Raw ) == pk public_key.verify(signature, message)
def test_invalid_length_from_private_bytes(self, backend): with pytest.raises(ValueError): Ed448PrivateKey.from_private_bytes(b"a" * 56) with pytest.raises(ValueError): Ed448PrivateKey.from_private_bytes(b"a" * 58)
def test_invalid_type_private_bytes(self, backend): with pytest.raises(TypeError): Ed448PrivateKey.from_private_bytes(object())
def __init__(self, params: Dict[int, Any]): super().__init__(params) self._public_key: Any = None self._private_key: Any = None self._hash_alg: Any = None self._x = None self._d = None # Validate kty. if params[1] != 1: raise ValueError("kty(1) should be OKP(1).") # Validate crv. if -1 not in params: raise ValueError("crv(-1) not found.") self._crv = params[-1] if not isinstance(self._crv, int): raise ValueError("crv(-1) should be int.") if self._crv not in [4, 5, 6, 7]: raise ValueError( f"Unsupported or unknown crv(-1) for OKP: {self._crv}.") if self._crv in [4, 5]: if not self._alg: raise ValueError("X25519/X448 needs alg explicitly.") if self._alg in [-25, -27]: self._hash_alg = hashes.SHA256 elif self._alg in [-26, -28]: self._hash_alg = hashes.SHA512 else: raise ValueError( f"Unsupported or unknown alg used with X25519/X448: {self._alg}." ) # Validate alg and key_ops. if self._key_ops: if set(self._key_ops) & set([3, 4, 5, 6, 9, 10]): raise ValueError( "Unknown or not permissible key_ops(4) for OKP.") else: if self._crv in [4, 5]: self._key_ops = [7, 8] if -4 in params else [] else: # self._crv in [6, 7] self._key_ops = [1, 2] if -4 in params else [2] if self._alg: if self._alg in COSE_ALGORITHMS_SIG_OKP.values(): if -4 in params: # private key for signing. if not (set(self._key_ops) & set([1, 2])): raise ValueError("Invalid key_ops for signing key.") if set(self._key_ops) & set([7, 8]): raise ValueError( "Signing key should not be used for key derivation." ) else: # public key for signing. if 2 not in self._key_ops or len(self._key_ops) != 1: raise ValueError("Invalid key_ops for public key.") elif self._alg in COSE_ALGORITHMS_CKDM_KEY_AGREEMENT.values(): if -4 in params: # private key for key derivation. if not (set(self._key_ops) & set([7, 8])): raise ValueError("Invalid key_ops for key derivation.") if set(self._key_ops) & set([1, 2]): raise ValueError( "Private key for ECDHE should not be used for signing." ) else: # public key for key derivation. if self._key_ops: raise ValueError( "Public key for ECDHE should not have key_ops.") else: raise ValueError( f"Unsupported or unknown alg(3) for OKP: {self._alg}.") else: if -4 in params: # private key. if set(self._key_ops) & set([1, 2]): # private key for signing. if set(self._key_ops) & set([7, 8]): raise ValueError( "OKP private key should not be used for both signing and key derivation." ) self._alg = -8 # EdDSA else: # public key. if 2 in self._key_ops: if len(self._key_ops) > 1: raise ValueError("Invalid key_ops for public key.") else: raise ValueError("Invalid key_ops for public key.") if self._alg in COSE_ALGORITHMS_CKDM_KEY_AGREEMENT_ES.values(): if -2 not in params: return # Validate x. if -2 not in params: raise ValueError("x(-2) not found.") if not isinstance(params[-2], bytes): raise ValueError("x(-2) should be bytes(bstr).") self._x = params[-2] try: if -4 not in params: if self._crv == 4: # X25519 self._public_key = X25519PublicKey.from_public_bytes( self._x) elif self._crv == 5: # X448 self._public_key = X448PublicKey.from_public_bytes(self._x) elif self._crv == 6: # Ed25519 self._public_key = Ed25519PublicKey.from_public_bytes( self._x) else: # self._crv == 7 (Ed448) self._public_key = Ed448PublicKey.from_public_bytes( self._x) self._key = self._public_key return except ValueError as err: raise ValueError("Invalid key parameter.") from err if not isinstance(params[-4], bytes): raise ValueError("d(-4) should be bytes(bstr).") try: self._d = params[-4] if self._crv == 4: # X25519 self._private_key = X25519PrivateKey.from_private_bytes( self._d) elif self._crv == 5: # X448 self._private_key = X448PrivateKey.from_private_bytes(self._d) elif self._crv == 6: # Ed25519 self._private_key = Ed25519PrivateKey.from_private_bytes( self._d) else: # self._crv == 7 (Ed448) self._private_key = Ed448PrivateKey.from_private_bytes(self._d) self._key = self._private_key except ValueError as err: raise ValueError("Invalid key parameter.") from err return