Run libursa tests on Ubuntu 20.04

.github/workflows/rust.yml

@@ -40,6 +40,11 @@ jobs:
     - name: Tests
       run: cargo test --release
 
+    - name: Libursa Build
+      run: cargo build --verbose --manifest-path=libursa/Cargo.toml
+
+    - name: Libursa Tests
+      run: cargo test --release --manifest-path=libursa/Cargo.toml
 # disabled in AZP
 #
 #  Portable:

Cargo.toml

@@ -21,6 +21,10 @@ crate-type = ["cdylib", "staticlib", "rlib"]
 lto = true
 
 [workspace]
+exclude = [
+    "libursa",
+    "libzmix",
+]
 members = [
     "ursa_accumulators",
     "ursa_core",
@@ -35,4 +39,4 @@ default = ["sharing"]
 sharing = ["ursa_sharing"]
 
 [dependencies]
-ursa_sharing = { version = "0.1", path = "ursa_sharing", optional = true }
+ursa_sharing = { version = "0.1", path = "ursa_sharing", optional = true }

libursa/src/errors/mod.rs

@@ -89,7 +89,7 @@ impl fmt::Display for UrsaCryptoError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         let mut first = true;
 
-        for cause in Fail::iter_chain(&self.inner) {
+        for cause in <dyn Fail>::iter_chain(&self.inner) {
             if first {
                 first = false;
                 writeln!(f, "Error: {}", cause)?;

libursa/src/kex/secp256k1.rs

@@ -130,6 +130,7 @@ mod ecdh_secp256k1 {
     use sha2::digest::generic_array::typenum::U32;
     use sha2::Digest;
     use zeroize::Zeroize;
+    #[allow(dead_code)]
     const PUBLIC_UNCOMPRESSED_KEY_SIZE: usize = 65;
 
     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -227,20 +228,19 @@ mod tests {
 
     #[test]
     fn secp256k1_compatibility() {
-        use libsecp256k1::{
-            ecdh::SharedSecret,
-            key::{PublicKey, SecretKey},
+        use k256::{
+            {PublicKey, SecretKey},
+            elliptic_curve::ecdh::diffie_hellman,
         };
 
         let scheme = EcdhSecp256k1Sha256::new();
         let (pk, sk) = scheme.keypair(None).unwrap();
-
-        let sk1 = SecretKey::from_slice(&sk[..]).unwrap();
-        let pk1 = PublicKey::from_slice(&pk[..]).unwrap();
-        let secret = SharedSecret::new(&pk1, &sk1);
+        let sk1 = SecretKey::from_bytes(&sk[..]).unwrap();
+        let pk1 = PublicKey::from_sec1_bytes(&pk[..]).unwrap();
+        let secret = diffie_hellman(sk1.secret_scalar(), pk1.as_affine());
         assert_eq!(
-            secret.as_ref(),
-            scheme.compute_shared_secret(&sk, &pk).unwrap().as_ref()
+            secret.as_bytes().to_vec(),
+            scheme.compute_shared_secret(&sk, &pk).unwrap().as_ref().to_vec()
         );
     }
 }

libursa/src/signatures/ed25519.rs

@@ -262,7 +262,7 @@ mod test {
                 assert!(result.is_ok());
                 assert!(result.unwrap());
             }
-            Err(e) => assert!(false, e),
+            Err(e) => assert!(false, "{}", e),
         }
         let signer = Signer::new(&scheme, &s);
         match signer.sign(&MESSAGE_1) {
@@ -271,7 +271,7 @@ mod test {
                 assert!(result.is_ok());
                 assert!(result.unwrap());
             }
-            Err(er) => assert!(false, er),
+            Err(er) => assert!(false, "{}", er),
         }
     }
 

libursa/src/signatures/secp256k1.rs

@@ -472,7 +472,7 @@ mod test {
                         assert!(result.is_ok());
                         assert!(result.unwrap());
                     }
-                    Err(er) => assert!(false, er),
+                    Err(er) => assert!(false, "{}", er),
                 }
 
                 let signer = Signer::new(&scheme, &s);
@@ -482,10 +482,10 @@ mod test {
                         assert!(result.is_ok());
                         assert!(result.unwrap());
                     }
-                    Err(er) => assert!(false, er),
+                    Err(er) => assert!(false, "{}", er),
                 }
             }
-            Err(e) => assert!(false, e),
+            Err(e) => assert!(false, "{}", e),
         }
     }