Lines Matching refs:backend
42 def _skip_ecdsa_vector(backend, curve_type, hash_type): argument
43 if not backend.elliptic_curve_signature_algorithm_supported(
54 def _skip_curve_unsupported(backend, curve): argument
55 if not backend.elliptic_curve_supported(curve):
58 curve.name, backend
63 def _skip_exchange_algorithm_unsupported(backend, algorithm, curve): argument
64 if not backend.elliptic_curve_exchange_algorithm_supported(
69 curve.name, backend
86 def test_skip_curve_unsupported(backend): argument
88 _skip_curve_unsupported(backend, DummyCurve())
92 def test_skip_exchange_algorithm_unsupported(backend): argument
94 _skip_exchange_algorithm_unsupported(backend, ec.ECDH(), DummyCurve())
98 def test_skip_ecdsa_vector(backend): argument
100 _skip_ecdsa_vector(backend, DummyCurve, hashes.SHA256)
104 def test_derive_private_key_success(backend): argument
106 _skip_curve_unsupported(backend, curve)
108 private_numbers = ec.generate_private_key(curve, backend).private_numbers()
111 private_numbers.private_value, curve, backend
118 def test_derive_private_key_errors(backend): argument
120 _skip_curve_unsupported(backend, curve)
123 ec.derive_private_key('one', curve, backend)
126 ec.derive_private_key(10, 'five', backend)
129 ec.derive_private_key(-7, curve, backend)
268 def test_ec_key_key_size(backend): argument
270 _skip_curve_unsupported(backend, curve)
271 key = ec.generate_private_key(curve, backend)
289 def test_with_numbers(self, backend, vector, hash_type): argument
292 _skip_ecdsa_vector(backend, curve_type, hash_type)
301 ).private_key(backend)
324 def test_signing_with_example_keys(self, backend, vector, hash_type): argument
327 _skip_ecdsa_vector(backend, curve_type, hash_type)
336 ).private_key(backend)
355 def test_generate_vector_curves(self, backend, curve): argument
356 _skip_curve_unsupported(backend, curve())
358 key = ec.generate_private_key(curve(), backend)
368 def test_generate_unknown_curve(self, backend): argument
372 ec.generate_private_key(DummyCurve(), backend)
374 assert backend.elliptic_curve_signature_algorithm_supported(
379 def test_unknown_signature_algoritm(self, backend): argument
380 _skip_curve_unsupported(backend, ec.SECP192R1())
382 key = ec.generate_private_key(ec.SECP192R1(), backend)
406 assert backend.elliptic_curve_signature_algorithm_supported(
411 def test_load_invalid_ec_key_from_numbers(self, backend): argument
412 _skip_curve_unsupported(backend, ec.SECP256R1())
423 numbers.private_key(backend)
434 numbers.private_key(backend)
445 numbers.private_key(backend)
447 def test_load_invalid_public_ec_key_from_numbers(self, backend): argument
448 _skip_curve_unsupported(backend, ec.SECP521R1())
461 numbers.public_key(backend)
474 numbers.public_key(backend)
491 def test_signatures(self, backend, vector): argument
495 _skip_ecdsa_vector(backend, curve_type, hash_type)
501 ).public_key(backend)
519 def test_signature_failures(self, backend, vector): argument
523 _skip_ecdsa_vector(backend, curve_type, hash_type)
529 ).public_key(backend)
547 def test_sign(self, backend): argument
548 _skip_curve_unsupported(backend, ec.SECP256R1())
551 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
556 def test_sign_prehashed(self, backend): argument
557 _skip_curve_unsupported(backend, ec.SECP256R1())
559 h = hashes.Hash(hashes.SHA1(), backend)
563 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
568 def test_sign_prehashed_digest_mismatch(self, backend): argument
569 _skip_curve_unsupported(backend, ec.SECP256R1())
571 h = hashes.Hash(hashes.SHA1(), backend)
575 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
579 def test_verify(self, backend): argument
580 _skip_curve_unsupported(backend, ec.SECP256R1())
583 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
588 def test_verify_prehashed(self, backend): argument
589 _skip_curve_unsupported(backend, ec.SECP256R1())
592 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
594 h = hashes.Hash(hashes.SHA1(), backend)
602 def test_verify_prehashed_digest_mismatch(self, backend): argument
603 _skip_curve_unsupported(backend, ec.SECP256R1())
605 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
606 h = hashes.Hash(hashes.SHA1(), backend)
615 def test_prehashed_unsupported_in_signer_ctx(self, backend): argument
616 _skip_curve_unsupported(backend, ec.SECP256R1())
617 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
622 def test_prehashed_unsupported_in_verifier_ctx(self, backend): argument
623 _skip_curve_unsupported(backend, ec.SECP256R1())
624 private_key = ec.generate_private_key(ec.SECP256R1(), backend)
689 def test_private_bytes_encrypted_pem(self, backend, fmt, password): argument
690 _skip_curve_unsupported(backend, ec.SECP256R1())
696 key = serialization.load_pem_private_key(key_bytes, None, backend)
703 serialized, password, backend
718 def test_private_bytes_rejects_invalid(self, encoding, fmt, backend): argument
719 _skip_curve_unsupported(backend, ec.SECP256R1())
720 key = ec.generate_private_key(ec.SECP256R1(), backend)
733 def test_private_bytes_encrypted_der(self, backend, fmt, password): argument
734 _skip_curve_unsupported(backend, ec.SECP256R1())
740 key = serialization.load_pem_private_key(key_bytes, None, backend)
747 serialized, password, backend
778 def test_private_bytes_unencrypted(self, backend, encoding, fmt, argument
780 _skip_curve_unsupported(backend, ec.SECP256R1())
786 key = serialization.load_pem_private_key(key_bytes, None, backend)
790 loaded_key = loader_func(serialized, None, backend)
815 self, backend, key_path, encoding, loader_func argument
817 _skip_curve_unsupported(backend, ec.SECP256R1())
821 key = loader_func(key_bytes, None, backend)
829 def test_private_bytes_traditional_der_encrypted_invalid(self, backend): argument
830 _skip_curve_unsupported(backend, ec.SECP256R1())
835 pemfile.read().encode(), None, backend
845 def test_private_bytes_invalid_encoding(self, backend): argument
846 _skip_curve_unsupported(backend, ec.SECP256R1())
851 pemfile.read().encode(), None, backend
861 def test_private_bytes_invalid_format(self, backend): argument
862 _skip_curve_unsupported(backend, ec.SECP256R1())
867 pemfile.read().encode(), None, backend
877 def test_private_bytes_invalid_encryption_algorithm(self, backend): argument
878 _skip_curve_unsupported(backend, ec.SECP256R1())
883 pemfile.read().encode(), None, backend
893 def test_private_bytes_unsupported_encryption_type(self, backend): argument
894 _skip_curve_unsupported(backend, ec.SECP256R1())
899 pemfile.read().encode(), None, backend
909 def test_public_bytes_from_derived_public_key(self, backend): argument
910 _skip_curve_unsupported(backend, ec.SECP256R1())
915 pemfile.read().encode(), None, backend
923 parsed_public = serialization.load_pem_public_key(pem, backend)
949 backend): argument
950 _skip_curve_unsupported(backend, ec.SECP256R1())
954 key = loader_func(key_bytes, backend)
960 def test_public_bytes_openssh(self, backend): argument
961 _skip_curve_unsupported(backend, ec.SECP192R1())
962 _skip_curve_unsupported(backend, ec.SECP256R1())
970 key = serialization.load_pem_public_key(key_bytes, backend)
981 key = ec.generate_private_key(ec.SECP192R1(), backend).public_key()
988 def test_public_bytes_invalid_encoding(self, backend): argument
989 _skip_curve_unsupported(backend, ec.SECP256R1())
995 pemfile.read().encode(), backend
1026 def test_public_bytes_rejects_invalid(self, encoding, fmt, backend): argument
1027 _skip_curve_unsupported(backend, ec.SECP256R1())
1028 key = ec.generate_private_key(ec.SECP256R1(), backend).public_key()
1032 def test_public_bytes_invalid_format(self, backend): argument
1033 _skip_curve_unsupported(backend, ec.SECP256R1())
1039 pemfile.read().encode(), backend
1045 def test_public_bytes_pkcs1_unsupported(self, backend): argument
1046 _skip_curve_unsupported(backend, ec.SECP256R1())
1052 pemfile.read().encode(), backend
1147 def test_serialize_point(self, vector, backend): argument
1173 def test_signature_not_bytes(self, backend): argument
1174 _skip_curve_unsupported(backend, ec.SECP256R1())
1175 key = ec.generate_private_key(ec.SECP256R1(), backend)
1193 def test_key_exchange_with_vectors(self, backend, vector): argument
1195 backend, ec.ECDH(), ec._CURVE_TYPES[vector['curve']]
1211 private_numbers.private_key(backend)
1214 private_key = private_numbers.private_key(backend)
1226 public_numbers.public_key(backend)
1229 peer_pubkey = public_numbers.public_key(backend)
1249 def test_brainpool_kex(self, backend, vector): argument
1251 _skip_exchange_algorithm_unsupported(backend, ec.ECDH(), curve)
1257 ).private_key(backend)
1263 ).private_key(backend)
1269 def test_exchange_unsupported_algorithm(self, backend): argument
1270 _skip_curve_unsupported(backend, ec.SECP256R1())
1276 pemfile.read().encode(), None, backend
1285 def test_exchange_non_matching_curve(self, backend): argument
1286 _skip_curve_unsupported(backend, ec.SECP256R1())
1287 _skip_curve_unsupported(backend, ec.SECP384R1())
1293 pemfile.read().encode(), None, backend
1296 public_key = EC_KEY_SECP384R1.public_numbers.public_key(backend)