Replace sodumoxide with rust-crypto alternatives

.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.70.0"

.github/workflows/ci.yml

@@ -4,74 +4,61 @@ on:
       - master
   pull_request:
   schedule:
-    - cron: '30 3 * * 2'
+    - cron: "30 3 * * 2"
 
 name: CI
 
-jobs:
+env:
+  RUST_VERSION: "1.70.0"
 
+jobs:
   test:
     name: run tests
     strategy:
       matrix:
-        rust: [1.72, stable]
+        rust: [$RUST_VERSION, stable]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@v1
         with:
           toolchain: ${{ matrix.rust }}
-          override: true
       - name: Build with default features
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --all-targets
+        run: cargo build --all-targets
       - name: Build with all features
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-          args: --all-targets --all-features
+        run: cargo build --all-targets --all-features
       - name: Run tests
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
-          args: --all-features
+        run: cargo test --all-features
 
   fmt:
     name: run rustfmt
     runs-on: ubuntu-latest
     steps:
-    - uses: actions/checkout@v2
-    - uses: actions-rs/toolchain@v1
-      with:
-        toolchain: 1.57
-        override: true
-    - run: rustup component add rustfmt
-    - uses: actions-rs/cargo@v1
-      with:
-        command: fmt
-        args: --all -- --check
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@v1
+        with:
+          toolchain: $RUST_VERSION
+          components: rustfmt
+      - name: Check formatting in all files
+        run: cargo fmt --all -- --check
 
   clippy:
     name: run clippy lints
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@v1
         with:
           toolchain: stable
           components: clippy
-          override: true
-      - uses: actions-rs/clippy-check@v1
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          args: --all-features
+      - name: Check if there are clippy warnings
+        run: cargo clippy --all-features -- -D warnings
 
   audit:
     name: run cargo audit
     runs-on: ubuntu-latest
     container: dbrgn/cargo-audit:latest
     steps:
-    - uses: actions/checkout@v2
-    - run: cargo audit
+      - uses: actions/checkout@v4
+      - name: Audit all used dependencies
+        run: cargo audit

CHANGELOG.md

@@ -14,6 +14,13 @@ Possible log types:
 
 ### Unreleased
 
+- [added] Re-export `crypto_secretbox::Nonce`
+- [changed] Replace `sodiumoxide` with `crypto_box` and `crypto_secretbox`
+- [changed] Replace re-exports of `PublicKey`, `SecretKey` and `Key`
+- [changed] Use dedicated `Nonce` type instead of `&[u8; 24]`
+- [changed] Return result in `encrypt_*` functions
+- [changed] Use `hmac` and `sha2` crates for calculating MAC
+
 ### v0.16.0 (2023-09-04)
 
 - [added] Expose encryption functions: `encrypt` and `encrypt_raw` (#59)

Cargo.toml

@@ -24,15 +24,20 @@ receive = ["form_urlencoded", "serde_urlencoded"] # Support for receiving and de
 
 [dependencies]
 byteorder = "1.0"
+crypto_box = "0.9.1"
+crypto_secretbox = "0.1.1"
 data-encoding = "2.1"
 form_urlencoded = { version = "1", optional = true }
+hmac = "0.12.1"
 log = "0.4"
-thiserror = "1"
 reqwest = { version = "0.11", features = ["rustls-tls-native-roots", "multipart"], default-features = false }
+rand = "0.8.5"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 serde_urlencoded = { version = "0.7", optional = true }
-sodiumoxide = "0.2.0"
+sha2 = "0.10.8"
+thiserror = "1"
+zeroize = { version = "1", features = ["zeroize_derive"], default-features = false }
 
 [dev-dependencies]
 docopt = "1.1.0"

examples/download_blob.rs

@@ -33,7 +33,8 @@ async fn main() {
         let bytes = HEXLOWER_PERMISSIVE
             .decode(blob_key_raw.as_bytes())
             .expect("Invalid blob key");
-        Some(Key::from_slice(&bytes).expect("Invalid blob key bytes"))
+        let key = Key::try_from(bytes).expect("Invalid size of blob key");
+        Some(key)
     } else {
         None
     };

examples/generate_keypair.rs

@@ -1,10 +1,11 @@
+use crypto_secretbox::aead::OsRng;
 use data_encoding::HEXLOWER;
-use sodiumoxide::crypto::box_;
 
 fn main() {
     println!("Generating new random nacl/libsodium crypto box keypair:\n");
-    let (pk, sk) = box_::gen_keypair();
-    println!("   Public: {}", HEXLOWER.encode(&pk.0));
-    println!("  Private: {}", HEXLOWER.encode(&sk.0));
+    let sk = crypto_box::SecretKey::generate(&mut OsRng);
+    let pk = sk.public_key();
+    println!("   Public: {}", HEXLOWER.encode(pk.as_bytes()));
+    println!("  Private: {}", HEXLOWER.encode(&sk.to_bytes()));
     println!("\nKeep the private key safe, and don't share it with anybody!");
 }

examples/receive.rs

@@ -18,20 +18,22 @@ async fn main() {
     // Command line arguments
     let our_id = args.get_str("<our-id>");
     let secret = args.get_str("<secret>");
-    let private_key = HEXLOWER_PERMISSIVE
+    let key_bytes = HEXLOWER_PERMISSIVE
         .decode(args.get_str("<private-key>").as_bytes())
-        .ok()
-        .and_then(|bytes| SecretKey::from_slice(&bytes))
-        .unwrap_or_else(|| {
-            eprintln!("Invalid private key");
+        .unwrap_or_else(|_| {
+            eprintln!("No private key provided");
             std::process::exit(1);
         });
+    let private_key = SecretKey::from_slice(&key_bytes).unwrap_or_else(|_| {
+        eprintln!("Invalid private key");
+        std::process::exit(1);
+    });
     let request_body = args.get_str("<request-body>");
 
     // Create E2eApi instance
     let api = ApiBuilder::new(our_id, secret)
-        .with_private_key_bytes(private_key.as_ref())
-        .and_then(|builder| builder.into_e2e())
+        .with_private_key(private_key)
+        .into_e2e()
         .unwrap();
 
     // Parse request body

examples/send_e2e_file.rs

@@ -93,7 +93,7 @@ async fn main() {
         file: file_bytes,
         thumbnail: thumbnail_bytes,
     };
-    let (encrypted, key) = encrypt_file_data(&file_data);
+    let (encrypted, key) = etry!(encrypt_file_data(&file_data), "Could not encrypt file");
 
     // Upload files to blob server
     let file_blob_id = etry!(
@@ -126,7 +126,10 @@ async fn main() {
         .rendering_type(rendering_type)
         .build()
         .expect("Could not build FileMessage");
-    let encrypted = api.encrypt_file_msg(&msg, &public_key.into());
+    let encrypted = etry!(
+        api.encrypt_file_msg(&msg, &public_key.into()),
+        "Could not encrypt file msg"
+    );
 
     // Send
     let msg_id = api.send(to, &encrypted, false).await;

examples/send_e2e_image.rs

@@ -61,7 +61,12 @@ async fn main() {
         println!("Could not read file: {}", e);
         process::exit(1);
     });
-    let encrypted_image = api.encrypt_raw(&img_data, &recipient_key);
+    let encrypted_image = api
+        .encrypt_raw(&img_data, &recipient_key)
+        .unwrap_or_else(|_| {
+            println!("Could encrypt raw msg");
+            process::exit(1);
+        });
 
     // Upload image to blob server
     let blob_id = api
@@ -73,15 +78,20 @@ async fn main() {
         });
 
     // Create image message
-    let msg = api.encrypt_image_msg(
-        &blob_id,
-        img_data.len() as u32,
-        &encrypted_image.nonce,
-        &recipient_key,
-    );
+    let msg = api
+        .encrypt_image_msg(
+            &blob_id,
+            img_data.len() as u32,
+            &encrypted_image.nonce,
+            &recipient_key,
+        )
+        .unwrap_or_else(|e| {
+            println!("Could not encrypt image msg: {e}");
+            process::exit(1);
+        });
 
     // Send
-    let msg_id = api.send(&to, &msg, false).await;
+    let msg_id = api.send(to, &msg, false).await;
     match msg_id {
         Ok(id) => println!("Sent. Message id is {}.", id),
         Err(e) => println!("Could not send message: {}", e),

examples/send_e2e_text.rs

@@ -37,8 +37,13 @@ async fn main() {
     });
 
     // Encrypt and send
-    let encrypted = api.encrypt_text_msg(&text, &public_key.into());
-    let msg_id = api.send(&to, &encrypted, false).await;
+    let encrypted = api
+        .encrypt_text_msg(&text, &public_key.into())
+        .unwrap_or_else(|e| {
+            println!("Could not encrypt text msg: {e}");
+            process::exit(1);
+        });
+    let msg_id = api.send(to, &encrypted, false).await;
 
     match msg_id {
         Ok(id) => println!("Sent. Message id is {}.", id),

src/api.rs

@@ -4,9 +4,10 @@ use std::{
     time::Duration,
 };
 
+use crypto_box::{PublicKey, SecretKey};
+use crypto_secretbox::Nonce;
 use data_encoding::HEXLOWER_PERMISSIVE;
 use reqwest::Client;
-use sodiumoxide::crypto::box_::PublicKey;
 
 use crate::{
     connection::{blob_download, blob_upload, send_e2e, send_simple, Recipient},
@@ -20,7 +21,7 @@ use crate::{
     },
     receive::IncomingMessage,
     types::{BlobId, FileMessage, MessageType},
-    SecretKey, MSGAPI_URL,
+    MSGAPI_URL,
 };
 
 fn make_reqwest_client() -> Client {
@@ -173,7 +174,11 @@ impl E2eApi {
     }
 
     /// Encrypt a text message for the specified recipient public key.
-    pub fn encrypt_text_msg(&self, text: &str, recipient_key: &RecipientKey) -> EncryptedMessage {
+    pub fn encrypt_text_msg(
+        &self,
+        text: &str,
+        recipient_key: &RecipientKey,
+    ) -> Result<EncryptedMessage, CryptoError> {
         let data = text.as_bytes();
         let msgtype = MessageType::Text;
         encrypt(data, msgtype, &recipient_key.0, &self.private_key)
@@ -192,9 +197,9 @@ impl E2eApi {
         &self,
         blob_id: &BlobId,
         img_size_bytes: u32,
-        image_data_nonce: &[u8; 24],
+        image_data_nonce: &Nonce,
         recipient_key: &RecipientKey,
-    ) -> EncryptedMessage {
+    ) -> Result<EncryptedMessage, CryptoError> {
         encrypt_image_msg(
             blob_id,
             img_size_bytes,
@@ -214,7 +219,7 @@ impl E2eApi {
         &self,
         msg: &FileMessage,
         recipient_key: &RecipientKey,
-    ) -> EncryptedMessage {
+    ) -> Result<EncryptedMessage, CryptoError> {
         encrypt_file_msg(msg, &recipient_key.0, &self.private_key)
     }
 
@@ -233,12 +238,16 @@ impl E2eApi {
         raw_data: &[u8],
         msgtype: MessageType,
         recipient_key: &RecipientKey,
-    ) -> EncryptedMessage {
+    ) -> Result<EncryptedMessage, CryptoError> {
         encrypt(raw_data, msgtype, &recipient_key.0, &self.private_key)
     }
 
     /// Encrypt raw bytes for the specified recipient public key.
-    pub fn encrypt_raw(&self, raw_data: &[u8], recipient_key: &RecipientKey) -> EncryptedMessage {
+    pub fn encrypt_raw(
+        &self,
+        raw_data: &[u8],
+        recipient_key: &RecipientKey,
+    ) -> Result<EncryptedMessage, CryptoError> {
         encrypt_raw(raw_data, &recipient_key.0, &self.private_key)
     }
 
@@ -507,8 +516,9 @@ impl ApiBuilder {
 
     /// Set the private key from a byte slice. Only needed for E2e mode.
     pub fn with_private_key_bytes(mut self, private_key: &[u8]) -> Result<Self, ApiBuilderError> {
-        let private_key = SecretKey::from_slice(private_key)
-            .ok_or_else(|| ApiBuilderError::InvalidKey("Invalid libsodium private key".into()))?;
+        let private_key = SecretKey::from_slice(private_key).map_err(|e| {
+            ApiBuilderError::InvalidKey(format!("Invalid libsodium private key: {e}"))
+        })?;
         self.private_key = Some(private_key);
         Ok(self)
     }

src/connection.rs

@@ -223,13 +223,11 @@ pub(crate) async fn blob_download(
 mod tests {
     use super::*;
 
-    use std::iter::repeat;
-
     use crate::{errors::ApiError, MSGAPI_URL};
 
     #[tokio::test]
     async fn test_simple_max_length_ok() {
-        let text: String = repeat("à").take(3500 / 2).collect();
+        let text: String = "à".repeat(3500 / 2);
         let client = Client::new();
         let result = send_simple(
             &client,
@@ -247,7 +245,7 @@ mod tests {
 
     #[tokio::test]
     async fn test_simple_max_length_too_long() {
-        let mut text: String = repeat("à").take(3500 / 2).collect();
+        let mut text: String = "à".repeat(3500 / 2);
         text.push('x');
         let client = Client::new();
         let result = send_simple(