Move iterated X25519 test to tests/agreement_tests.rs.

src/ec/curve25519/x25519.rs

@@ -120,74 +120,3 @@ extern {
     fn GFp_x25519_scalar_mult(out: &mut ops::EncodedPoint, scalar: &ops::Scalar,
                               point: &ops::EncodedPoint);
 }
-
-#[cfg(test)]
-mod tests {
-    use {agreement, error, test};
-    use std;
-    use untrusted;
-
-    #[test]
-    fn test_agreement_ecdh_x25519_rfc_iterated() {
-        let mut k =
-            h("0900000000000000000000000000000000000000000000000000000000000000");
-        let mut u = k.clone();
-
-        fn expect_iterated_x25519(expected_result: &str,
-                                  range: std::ops::Range<usize>,
-                                  k: &mut std::vec::Vec<u8>,
-                                  u: &mut std::vec::Vec<u8>) {
-            for _ in range {
-                let new_k = x25519(k, u);
-                *u = k.clone();
-                *k = new_k;
-            }
-            assert_eq!(&h(expected_result), k);
-        }
-
-        expect_iterated_x25519(
-            "422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079",
-            0..1, &mut k, &mut u);
-        expect_iterated_x25519(
-            "684cf59ba83309552800ef566f2f4d3c1c3887c49360e3875f2eb94d99532c51",
-            1..1_000, &mut k, &mut u);
-
-        // The spec gives a test vector for 1,000,000 iterations but it takes
-        // too long to do 1,000,000 iterations by default right now. This
-        // 10,000 iteration vector is self-computed.
-        expect_iterated_x25519(
-            "2c125a20f639d504a7703d2e223c79a79de48c4ee8c23379aa19a62ecd211815",
-            1_000..10_000, &mut k, &mut u);
-
-        if cfg!(feature = "slow_tests") {
-          expect_iterated_x25519(
-            "7c3911e0ab2586fd864497297e575e6f3bc601c0883c30df5f4dd2d24f665424",
-            10_000..1_000_000, &mut k, &mut u);
-        }
-    }
-
-    fn x25519(private_key: &[u8], public_key: &[u8]) -> std::vec::Vec<u8> {
-        x25519_(private_key, public_key).unwrap()
-    }
-
-    fn x25519_(private_key: &[u8], public_key: &[u8])
-               -> Result<std::vec::Vec<u8>, error::Unspecified> {
-        let rng = test::rand::FixedSliceRandom { bytes: private_key };
-        let private_key =
-            agreement::EphemeralPrivateKey::generate(&agreement::X25519, &rng)?;
-        let public_key = untrusted::Input::from(public_key);
-        agreement::agree_ephemeral(private_key, &agreement::X25519, public_key,
-                                   error::Unspecified, |agreed_value| {
-            Ok(std::vec::Vec::from(agreed_value))
-        })
-    }
-
-    fn h(s: &str) -> std::vec::Vec<u8> {
-        match test::from_hex(s) {
-            Ok(v) => v,
-            Err(msg) => {
-                panic!("{} in {}", msg, s);
-            },
-        }
-    }
-}

tests/agreement_tests.rs

@@ -15,7 +15,7 @@
 extern crate ring;
 extern crate untrusted;
 
-use ring::{agreement, rand, test};
+use ring::{agreement, error, rand, test};
 
 #[test]
 fn agreement_agree_ephemeral() {
@@ -71,6 +71,70 @@ fn agreement_agree_ephemeral() {
     });
 }
 
+#[test]
+fn test_agreement_ecdh_x25519_rfc_iterated() {
+    let mut k =
+        h("0900000000000000000000000000000000000000000000000000000000000000");
+    let mut u = k.clone();
+
+    fn expect_iterated_x25519(expected_result: &str,
+                              range: std::ops::Range<usize>,
+                              k: &mut std::vec::Vec<u8>,
+                              u: &mut std::vec::Vec<u8>) {
+        for _ in range {
+            let new_k = x25519(k, u);
+            *u = k.clone();
+            *k = new_k;
+        }
+        assert_eq!(&h(expected_result), k);
+    }
+
+    expect_iterated_x25519(
+        "422c8e7a6227d7bca1350b3e2bb7279f7897b87bb6854b783c60e80311ae3079",
+        0..1, &mut k, &mut u);
+    expect_iterated_x25519(
+        "684cf59ba83309552800ef566f2f4d3c1c3887c49360e3875f2eb94d99532c51",
+        1..1_000, &mut k, &mut u);
+
+    // The spec gives a test vector for 1,000,000 iterations but it takes
+    // too long to do 1,000,000 iterations by default right now. This
+    // 10,000 iteration vector is self-computed.
+    expect_iterated_x25519(
+        "2c125a20f639d504a7703d2e223c79a79de48c4ee8c23379aa19a62ecd211815",
+        1_000..10_000, &mut k, &mut u);
+
+    if cfg!(feature = "slow_tests") {
+      expect_iterated_x25519(
+        "7c3911e0ab2586fd864497297e575e6f3bc601c0883c30df5f4dd2d24f665424",
+        10_000..1_000_000, &mut k, &mut u);
+    }
+}
+
+fn x25519(private_key: &[u8], public_key: &[u8]) -> std::vec::Vec<u8> {
+    x25519_(private_key, public_key).unwrap()
+}
+
+fn x25519_(private_key: &[u8], public_key: &[u8])
+           -> Result<std::vec::Vec<u8>, error::Unspecified> {
+    let rng = test::rand::FixedSliceRandom { bytes: private_key };
+    let private_key =
+        agreement::EphemeralPrivateKey::generate(&agreement::X25519, &rng)?;
+    let public_key = untrusted::Input::from(public_key);
+    agreement::agree_ephemeral(private_key, &agreement::X25519, public_key,
+                               error::Unspecified, |agreed_value| {
+        Ok(std::vec::Vec::from(agreed_value))
+    })
+}
+
+fn h(s: &str) -> std::vec::Vec<u8> {
+    match test::from_hex(s) {
+        Ok(v) => v,
+        Err(msg) => {
+            panic!("{} in {}", msg, s);
+        },
+    }
+}
+
 fn alg_from_curve_name(curve_name: &str) -> &'static agreement::Algorithm {
     if curve_name == "P-256" {
         &agreement::ECDH_P256