Fix clippy and fmt issues, update MSRV (#1039)

Fix clippy and fmt issues

Update MSRV to 1.60

Freeze test deps so they compile on Rust 1.60, with no effect on
themis itself (does not use those frozen crates)

.github/workflows/test-rust.yaml

@@ -30,7 +30,7 @@ jobs:
     runs-on: ubuntu-20.04
     strategy:
       matrix:
-        rust: [stable, '1.58']
+        rust: [stable, '1.60']
       fail-fast: false
     steps:
       - name: Install system dependencies
@@ -81,7 +81,7 @@ jobs:
     runs-on: ubuntu-20.04
     strategy:
       matrix:
-        rust: [stable, '1.58']
+        rust: [stable, '1.60']
       fail-fast: false
     steps:
       - name: Install system dependencies

CHANGELOG.md

@@ -41,7 +41,7 @@ _Code:_
 
     This is technically a breaking change, but most reasonble implementations should be `Send` already. Please raise an issue if your code fails to build.
 
-  - Minimum supported Rust version is now 1.58 ([#977](https://github.com/cossacklabs/themis/pull/977), [#984](https://github.com/cossacklabs/themis/pull/984)).
+  - Minimum supported Rust version is now 1.60 ([#977](https://github.com/cossacklabs/themis/pull/977), [#984](https://github.com/cossacklabs/themis/pull/984), [#1039](https://github.com/cossacklabs/themis/pull/1039)).
 
 - **WasmThemis**
 

benches/themis/benches/secure_message_encrypt_decrypt_ecdsa.rs

@@ -106,7 +106,7 @@ pub fn decryption(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let encrypted = SecureMessage::new(key_pair.clone())
-                    .encrypt(&message)
+                    .encrypt(message)
                     .expect("failed encryption");
 
                 let mut decrypted = vec![0; size];

benches/themis/benches/secure_message_encrypt_decrypt_rsa.rs

@@ -106,7 +106,7 @@ pub fn decryption(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let encrypted = SecureMessage::new(key_pair.clone())
-                    .encrypt(&message)
+                    .encrypt(message)
                     .expect("failed encryption");
 
                 let mut decrypted = vec![0; size];

benches/themis/benches/secure_message_sign_verify_ecdsa.rs

@@ -102,7 +102,7 @@ pub fn verification(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let signature = SecureSign::new(private.clone())
-                    .sign(&message)
+                    .sign(message)
                     .expect("failed signing");
 
                 let mut received_message = vec![0; size];

benches/themis/benches/secure_message_sign_verify_rsa.rs

@@ -102,7 +102,7 @@ pub fn verification(c: &mut Criterion) {
             |b, &size| {
                 let message = vec![0; size];
                 let signature = SecureSign::new(private.clone())
-                    .sign(&message)
+                    .sign(message)
                     .expect("failed signing");
 
                 let mut received_message = vec![0; size];

docs/examples/rust/secure_cell.rs

@@ -33,7 +33,7 @@ fn main() -> themis::Result<()> {
 
         println!("Encoded:   {}", base64::encode(&message));
 
-        let encrypted_message = scell_mk.encrypt(&message)?;
+        let encrypted_message = scell_mk.encrypt(message)?;
         println!("Encrypted: {}", base64::encode(&encrypted_message));
 
         let decrypted_message = scell_mk.decrypt(&encrypted_message)?;
@@ -44,11 +44,11 @@ fn main() -> themis::Result<()> {
 
     println!("## Passphrase API");
     {
-        let scell_pw = SecureCell::with_passphrase(&passphrase)?.seal();
+        let scell_pw = SecureCell::with_passphrase(passphrase)?.seal();
 
         println!("Encoded:   {}", base64::encode(&message));
 
-        let encrypted_message = scell_pw.encrypt(&message)?;
+        let encrypted_message = scell_pw.encrypt(message)?;
         println!("Encrypted: {}", base64::encode(&encrypted_message));
 
         let decrypted_message = scell_pw.decrypt(&encrypted_message)?;
@@ -64,7 +64,7 @@ fn main() -> themis::Result<()> {
 
         println!("Encoded:    {}", base64::encode(&message));
 
-        let (encrypted_message, auth_token) = scell_tp.encrypt(&message)?;
+        let (encrypted_message, auth_token) = scell_tp.encrypt(message)?;
         println!("Encrypted:  {}", base64::encode(&encrypted_message));
         println!("Auth token: {}", base64::encode(&auth_token));
 
@@ -81,10 +81,10 @@ fn main() -> themis::Result<()> {
 
         println!("Encoded:   {}", base64::encode(&message));
 
-        let encrypted_message = scell_ci.encrypt_with_context(&message, &context)?;
+        let encrypted_message = scell_ci.encrypt_with_context(message, context)?;
         println!("Encrypted: {}", base64::encode(&encrypted_message));
 
-        let decrypted_message = scell_ci.decrypt_with_context(&encrypted_message, &context)?;
+        let decrypted_message = scell_ci.decrypt_with_context(&encrypted_message, context)?;
         println!("Decrypted: {}", as_str(&decrypted_message));
         assert_eq!(decrypted_message, message);
     }

docs/examples/rust/secure_message_client_encrypt.rs

@@ -51,7 +51,7 @@ fn main() {
     let key_pair = KeyPair::try_join(private_key, public_key).expect("matching keys");
 
     let socket = UdpSocket::bind("localhost:0").expect("client socket");
-    socket.connect(&remote_addr).expect("client connection");
+    socket.connect(remote_addr).expect("client connection");
 
     let receive_socket = socket;
     let relay_socket = receive_socket.try_clone().unwrap();

docs/examples/rust/secure_message_client_verify.rs

@@ -49,7 +49,7 @@ fn main() {
     let public_key = PublicKey::try_from_slice(public_key).expect("parse public key");
 
     let socket = UdpSocket::bind("localhost:0").expect("client socket");
-    socket.connect(&remote_addr).expect("client connection");
+    socket.connect(remote_addr).expect("client connection");
 
     let receive_socket = socket;
     let relay_socket = receive_socket.try_clone().unwrap();

docs/examples/rust/secure_message_server.rs

@@ -36,7 +36,7 @@ fn main() {
     let port = matches.value_of("port").unwrap_or("7573").parse().unwrap();
     let listen_addr = SocketAddr::new([0; 16].into(), port);
 
-    let socket = UdpSocket::bind(&listen_addr).expect("server listen");
+    let socket = UdpSocket::bind(listen_addr).expect("server listen");
     let mut peers = HashSet::new();
     let mut process_message = || -> io::Result<()> {
         let (message, sender) = recv_from(&socket)?;

docs/examples/rust/secure_session_echo_client.rs

@@ -64,9 +64,9 @@ fn main() {
 
     info!("connecting to {:?}", remote_addr);
 
-    let mut socket = TcpStream::connect(&remote_addr).expect("client connection");
+    let mut socket = TcpStream::connect(remote_addr).expect("client connection");
 
-    let mut session = SecureSession::new(&CLIENT_ID, &CLIENT_PRIVATE, ExpectServer)
+    let mut session = SecureSession::new(CLIENT_ID, &CLIENT_PRIVATE, ExpectServer)
         .expect("Secure Session client");
     let mut buffer = [0; MAX_MESSAGE_SIZE];
 
@@ -75,7 +75,7 @@ fn main() {
 
     loop {
         let reply = read_framed(&mut socket, &mut buffer).expect("receive reply");
-        let response = session.negotiate_reply(&reply).expect("negotiate");
+        let response = session.negotiate_reply(reply).expect("negotiate");
         if session.is_established() {
             break;
         }
@@ -95,7 +95,7 @@ fn main() {
         write_framed(&mut socket, &message).expect("write to socket");
 
         let reply = read_framed(&mut socket, &mut buffer).expect("read from socket");
-        let reply = session.unwrap(&reply).expect("unwrap incoming");
+        let reply = session.unwrap(reply).expect("unwrap incoming");
 
         io::stdout().write_all(&reply).expect("write to stdout");
     }

docs/examples/rust/secure_session_echo_server.rs

@@ -105,7 +105,7 @@ fn main() {
         .expect("valid port");
 
     let listen_addr = SocketAddr::new([0; 16].into(), port);
-    let listen_socket = TcpListener::bind(&listen_addr).expect("server listen");
+    let listen_socket = TcpListener::bind(listen_addr).expect("server listen");
 
     info!("listening on port {}", port);
 
@@ -123,7 +123,7 @@ fn main() {
             info!("{:?}: connected", client_address);
 
             let transport = SocketTransport::new(client);
-            let mut session = SecureSession::new(&SERVER_ID, &SERVER_PRIVATE, transport)
+            let mut session = SecureSession::new(SERVER_ID, &SERVER_PRIVATE, transport)
                 .expect("Secure Session server");
 
             while !session.is_established() {

src/wrappers/themis/rust/Cargo.toml

@@ -2,7 +2,7 @@
 name = "themis"
 version = "0.14.0"
 edition = "2018"
-rust-version = "1.58.0"
+rust-version = "1.60.0"
 authors = ["rust-themis developers"]
 description = "High-level cryptographic services for storage and messaging"
 homepage = "https://www.cossacklabs.com/themis/"
@@ -29,11 +29,18 @@ bindings = { package = "libthemis-sys", path = "libthemis-sys", version = "0.14.
 zeroize = "1"
 
 [dev-dependencies]
-base64 = "0.10.0"
-# Freeze `log` and `byteorder` so that tests still build/run with Rust 1.58.
+# Freeze byteorder, log so that tests still build/run with Rust 1.60.
+# Other crates are frozen in hope to avoid more problems in future, where something updates
+# and requires newer toolchain version compared to what we require for RustThemis.
 # FIXME: remove/update strict version requirement after we bump minimum required Rust version
+base64 = "=0.10.1"
 byteorder = "=1.4.3"
-clap = "2.32"
-lazy_static = "1.2.0"
+clap = "=2.34.0"
+lazy_static = "=1.4.0"
 log = "=0.4.17"
-env_logger = "0.6.0"
+env_logger = "=0.6.2"
+
+# These are not used in themis tests, but are rather dependencies of dev-dependencies listed above.
+# Specifying exact versions so that tests could build/run on Rust 1.60.
+regex = "=1.9.5"
+memchr = "=2.6.1"

src/wrappers/themis/rust/libthemis-sys/Cargo.toml

@@ -2,7 +2,7 @@
 name = "libthemis-sys"
 version = "0.14.0"
 edition = "2018"
-rust-version = "1.58.0"
+rust-version = "1.60.0"
 authors = ["rust-themis developers"]
 description = "FFI binding to libthemis"
 homepage = "https://www.cossacklabs.com/themis/"

src/wrappers/themis/rust/src/secure_cell.rs

@@ -358,7 +358,7 @@ impl SecureCellSeal {
     /// # }
     /// ```
     pub fn encrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.encrypt_with_context(message, &[])
+        self.encrypt_with_context(message, [])
     }
 
     /// Encrypts the provided message with associated context.
@@ -501,7 +501,7 @@ impl SecureCellSeal {
     /// # }
     /// ```
     pub fn decrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.decrypt_with_context(message, &[])
+        self.decrypt_with_context(message, [])
     }
 
     /// Decrypts the provided message with associated context.
@@ -689,7 +689,7 @@ impl SecureCellSealWithPassphrase {
     /// # }
     /// ```
     pub fn encrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.encrypt_with_context(message, &[])
+        self.encrypt_with_context(message, [])
     }
 
     /// Encrypts the provided message with associated context.
@@ -822,7 +822,7 @@ impl SecureCellSealWithPassphrase {
     /// # }
     /// ```
     pub fn decrypt(&self, message: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.decrypt_with_context(message, &[])
+        self.decrypt_with_context(message, [])
     }
 
     /// Decrypts the provided message with associated context.
@@ -1225,7 +1225,7 @@ impl SecureCellTokenProtect {
     /// # }
     /// ```
     pub fn encrypt(&self, message: impl AsRef<[u8]>) -> Result<(Vec<u8>, Vec<u8>)> {
-        self.encrypt_with_context(message, &[])
+        self.encrypt_with_context(message, [])
     }
 
     /// Encrypts the provided message with associated context.
@@ -1393,7 +1393,7 @@ impl SecureCellTokenProtect {
     /// # }
     /// ```
     pub fn decrypt(&self, message: impl AsRef<[u8]>, token: impl AsRef<[u8]>) -> Result<Vec<u8>> {
-        self.decrypt_with_context(message, token, &[])
+        self.decrypt_with_context(message, token, [])
     }
 
     /// Decrypts the provided message with associated context.

tests/rust/keys.rs

@@ -64,10 +64,10 @@ fn parse_generated_keys_back() {
 
 #[test]
 fn parse_invalid_buffers() {
-    let error = EcdsaPublicKey::try_from_slice(&[1, 2, 3]).expect_err("parse failure");
+    let error = EcdsaPublicKey::try_from_slice([1, 2, 3]).expect_err("parse failure");
     assert_eq!(error.kind(), ErrorKind::InvalidParameter);
 
-    let error = RsaPrivateKey::try_from_slice(&[]).expect_err("parse failure");
+    let error = RsaPrivateKey::try_from_slice([]).expect_err("parse failure");
     assert_eq!(error.kind(), ErrorKind::InvalidParameter);
 }
 
@@ -105,6 +105,6 @@ fn parse_generated_symmetric_keys_back() {
 
 #[test]
 fn parse_custom_symmetric_keys() {
-    assert!(SymmetricKey::try_from_slice(&[0]).is_ok());
-    assert!(SymmetricKey::try_from_slice(&[]).is_err());
+    assert!(SymmetricKey::try_from_slice([0]).is_ok());
+    assert!(SymmetricKey::try_from_slice([]).is_err());
 }