chore: checkpoint before Python removal

vendor/p384/tests/affine.rs

@@ -0,0 +1,82 @@
+//! Affine arithmetic tests.
+
+#![cfg(all(feature = "arithmetic", feature = "test-vectors"))]
+
+use elliptic_curve::{
+    group::{prime::PrimeCurveAffine, GroupEncoding},
+    sec1::{FromEncodedPoint, ToEncodedPoint},
+};
+use hex_literal::hex;
+
+use p384::{AffinePoint, EncodedPoint};
+
+const UNCOMPRESSED_BASEPOINT: &[u8] = &hex!(
+    "04 aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98
+        59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7
+        3617de4a 96262c6f 5d9e98bf 9292dc29 f8f41dbd 289a147c
+        e9da3113 b5f0b8c0 0a60b1ce 1d7e819d 7a431d7c 90ea0e5f"
+);
+
+const COMPRESSED_BASEPOINT: &[u8] = &hex!(
+    "03 aa87ca22 be8b0537 8eb1c71e f320ad74 6e1d3b62 8ba79b98
+        59f741e0 82542a38 5502f25d bf55296c 3a545e38 72760ab7"
+);
+
+#[test]
+fn uncompressed_round_trip() {
+    let pubkey = EncodedPoint::from_bytes(UNCOMPRESSED_BASEPOINT).unwrap();
+    let point = AffinePoint::from_encoded_point(&pubkey).unwrap();
+    assert_eq!(point, AffinePoint::generator());
+
+    let res: EncodedPoint = point.into();
+    assert_eq!(res, pubkey);
+}
+
+#[test]
+fn compressed_round_trip() {
+    let pubkey = EncodedPoint::from_bytes(COMPRESSED_BASEPOINT).unwrap();
+    let point = AffinePoint::from_encoded_point(&pubkey).unwrap();
+    assert_eq!(point, AffinePoint::generator());
+
+    let res: EncodedPoint = point.to_encoded_point(true);
+    assert_eq!(res, pubkey);
+}
+
+#[test]
+fn uncompressed_to_compressed() {
+    let encoded = EncodedPoint::from_bytes(UNCOMPRESSED_BASEPOINT).unwrap();
+
+    let res = AffinePoint::from_encoded_point(&encoded)
+        .unwrap()
+        .to_encoded_point(true);
+
+    assert_eq!(res.as_bytes(), COMPRESSED_BASEPOINT);
+}
+
+#[test]
+fn compressed_to_uncompressed() {
+    let encoded = EncodedPoint::from_bytes(COMPRESSED_BASEPOINT).unwrap();
+
+    let res = AffinePoint::from_encoded_point(&encoded)
+        .unwrap()
+        .to_encoded_point(false);
+
+    assert_eq!(res.as_bytes(), UNCOMPRESSED_BASEPOINT);
+}
+
+#[test]
+fn affine_negation() {
+    let basepoint = AffinePoint::generator();
+    assert_eq!(-(-basepoint), basepoint);
+}
+
+#[test]
+fn identity_encoding() {
+    // This is technically an invalid SEC1 encoding, but is preferable to panicking.
+    assert_eq!([0; 49], AffinePoint::IDENTITY.to_bytes().as_slice());
+    assert!(bool::from(
+        AffinePoint::from_bytes(&AffinePoint::IDENTITY.to_bytes())
+            .unwrap()
+            .is_identity()
+    ))
+}

vendor/p384/tests/projective.rs

@@ -0,0 +1,143 @@
+//! Projective arithmetic tests.
+
+#![cfg(all(feature = "arithmetic", feature = "test-vectors"))]
+
+use elliptic_curve::{
+    sec1::{self, ToEncodedPoint},
+    PrimeField,
+};
+use p384::{
+    test_vectors::group::{ADD_TEST_VECTORS, MUL_TEST_VECTORS},
+    AffinePoint, ProjectivePoint, Scalar,
+};
+use primeorder::Double;
+
+/// Assert that the provided projective point matches the given test vector.
+// TODO(tarcieri): use coordinate APIs. See zkcrypto/group#30
+macro_rules! assert_point_eq {
+    ($actual:expr, $expected:expr) => {
+        let (expected_x, expected_y) = $expected;
+
+        let point = $actual.to_affine().to_encoded_point(false);
+        let (actual_x, actual_y) = match point.coordinates() {
+            sec1::Coordinates::Uncompressed { x, y } => (x, y),
+            _ => unreachable!(),
+        };
+
+        assert_eq!(&expected_x, actual_x.as_slice());
+        assert_eq!(&expected_y, actual_y.as_slice());
+    };
+}
+
+#[test]
+fn affine_to_projective() {
+    let basepoint_affine = AffinePoint::GENERATOR;
+    let basepoint_projective = ProjectivePoint::GENERATOR;
+
+    assert_eq!(
+        ProjectivePoint::from(basepoint_affine),
+        basepoint_projective,
+    );
+    assert_eq!(basepoint_projective.to_affine(), basepoint_affine);
+    assert!(!bool::from(basepoint_projective.to_affine().is_identity()));
+    assert!(bool::from(
+        ProjectivePoint::IDENTITY.to_affine().is_identity()
+    ));
+}
+
+#[test]
+fn projective_identity_addition() {
+    let identity = ProjectivePoint::IDENTITY;
+    let generator = ProjectivePoint::GENERATOR;
+
+    assert_eq!(identity + &generator, generator);
+    assert_eq!(generator + &identity, generator);
+}
+
+#[test]
+fn test_vector_repeated_add() {
+    let generator = ProjectivePoint::GENERATOR;
+    let mut p = generator;
+
+    for i in 0..ADD_TEST_VECTORS.len() {
+        assert_point_eq!(p, ADD_TEST_VECTORS[i]);
+        p += &generator;
+    }
+}
+
+#[test]
+fn test_vector_repeated_add_mixed() {
+    let generator = AffinePoint::GENERATOR;
+    let mut p = ProjectivePoint::GENERATOR;
+
+    for i in 0..ADD_TEST_VECTORS.len() {
+        assert_point_eq!(p, ADD_TEST_VECTORS[i]);
+        p += &generator;
+    }
+}
+
+#[test]
+fn test_vector_add_mixed_identity() {
+    let generator = ProjectivePoint::GENERATOR;
+    let p0 = generator + ProjectivePoint::IDENTITY;
+    let p1 = generator + AffinePoint::IDENTITY;
+    assert_eq!(p0, p1);
+}
+
+#[test]
+fn test_vector_double_generator() {
+    let generator = ProjectivePoint::GENERATOR;
+    let mut p = generator;
+
+    for i in 0..2 {
+        assert_point_eq!(p, ADD_TEST_VECTORS[i]);
+        p = p.double();
+    }
+}
+
+#[test]
+fn projective_add_vs_double() {
+    let generator = ProjectivePoint::GENERATOR;
+    assert_eq!(generator + &generator, generator.double());
+}
+
+#[test]
+fn projective_add_and_sub() {
+    let basepoint_affine = AffinePoint::GENERATOR;
+    let basepoint_projective = ProjectivePoint::GENERATOR;
+
+    assert_eq!(
+        (basepoint_projective + &basepoint_projective) - &basepoint_projective,
+        basepoint_projective
+    );
+    assert_eq!(
+        (basepoint_projective + &basepoint_affine) - &basepoint_affine,
+        basepoint_projective
+    );
+}
+
+#[test]
+fn projective_double_and_sub() {
+    let generator = ProjectivePoint::GENERATOR;
+    assert_eq!(generator.double() - &generator, generator);
+}
+
+#[test]
+fn test_vector_scalar_mult() {
+    let generator = ProjectivePoint::GENERATOR;
+
+    for (k, coords) in ADD_TEST_VECTORS
+        .iter()
+        .enumerate()
+        .map(|(k, coords)| (Scalar::from(k as u64 + 1), *coords))
+        .chain(
+            MUL_TEST_VECTORS
+                .iter()
+                .cloned()
+                .map(|(k, x, y)| (Scalar::from_repr(k.into()).unwrap(), (x, y))),
+        )
+    {
+        let p = generator * &k;
+        assert_point_eq!(p, coords);
+    }
+}