Deps updated

Cargo.toml

@@ -27,7 +27,7 @@ serde_json = "1"
 serde_bytes = "0.11"
 bytes = "1"
 chrono = "0.4"
-orion = "0.17"
+orion = "0.18"
 smallvec = "1"
 bincode = "1"
 futures = "0.3"

crates/hyperqueue/Cargo.toml

@@ -37,7 +37,7 @@ itertools = { workspace = true }
 humantime = "2"
 clap_complete = "4"
 cli-table = { version = "0.5", default-features = false }
-dirs = "6"
+dirs = "7"
 nom = "7"
 nom-supreme = { version = "0.8" }
 colored = "3"

crates/hyperqueue/src/transfer/auth.rs

@@ -1,18 +1,16 @@
 use anyhow::Context;
 use orion::kdf::SecretKey;
 
-const KEY_SIZE: usize = 32;
-
 pub fn generate_key() -> SecretKey {
-    SecretKey::generate(KEY_SIZE).unwrap()
+    SecretKey::generate().unwrap()
 }
 pub fn serialize_key(key: &SecretKey) -> String {
-    let bytes = key.unprotected_as_bytes();
+    let bytes = key.unprotected_as_ref::<[u8]>();
     hex::encode(bytes)
 }
 pub fn deserialize_key(key: &str) -> anyhow::Result<SecretKey> {
     let data = hex::decode(key).context("Could not deserialize secret key")?;
-    let key = SecretKey::from_slice(&data).context("Could not create secret key from slice")?;
+    let key = SecretKey::try_from(&data).context("Could not create secret key from slice")?;
     Ok(key)
 }
 
@@ -24,7 +22,7 @@ mod tests {
 
     #[test]
     fn test_roundtrip() {
-        let key = SecretKey::default();
+        let key = SecretKey::generate().unwrap();
         let str = serialize_key(&key);
         let deserialized = deserialize_key(&str).unwrap();
         assert_eq!(key, deserialized);

crates/tako/src/internal/tests/integration/test_secret.rs

@@ -2,7 +2,7 @@ use crate::internal::tests::integration::utils::server::ServerConfigBuilder;
 use crate::internal::tests::integration::utils::server::{ServerSecretKey, run_server_test};
 use crate::internal::tests::integration::utils::worker::{WorkerConfigBuilder, WorkerSecretKey};
 use crate::internal::tests::utils::expect_error_message;
-use orion::auth::SecretKey;
+use orion::aead::SecretKey;
 
 #[tokio::test]
 async fn test_no_auth() {
@@ -31,8 +31,9 @@ async fn test_server_auth_worker_no_auth() {
 async fn test_server_no_auth_worker_auth() {
     let config = ServerConfigBuilder::default().secret_key(ServerSecretKey::Custom(None));
     run_server_test(config, |mut handler| async move {
-        let config = WorkerConfigBuilder::default()
-            .secret_key(WorkerSecretKey::Custom(Some(Default::default())));
+        let config = WorkerConfigBuilder::default().secret_key(WorkerSecretKey::Custom(Some(
+            SecretKey::generate().unwrap(),
+        )));
         expect_error_message(
             handler.start_worker(config).await,
             "Authentication failed: Peer does not support authentication",
@@ -45,11 +46,11 @@ async fn test_server_no_auth_worker_auth() {
 async fn test_auth_same_key() {
     let key_bytes: Vec<_> = (0u8..32u8).collect();
     let config = ServerConfigBuilder::default().secret_key(ServerSecretKey::Custom(Some(
-        SecretKey::from_slice(&key_bytes).unwrap(),
+        SecretKey::try_from(&key_bytes).unwrap(),
     )));
     run_server_test(config, |mut handler| async move {
         let config = WorkerConfigBuilder::default().secret_key(WorkerSecretKey::Custom(Some(
-            SecretKey::from_slice(&key_bytes).unwrap(),
+            SecretKey::try_from(&key_bytes).unwrap(),
         )));
         handler.start_worker(config).await.unwrap();
     })
@@ -60,14 +61,14 @@ async fn test_auth_same_key() {
 async fn test_auth_different_key() {
     let mut key_bytes: Vec<_> = (0u8..32u8).collect();
     let config = ServerConfigBuilder::default().secret_key(ServerSecretKey::Custom(Some(
-        SecretKey::from_slice(&key_bytes).unwrap(),
+        SecretKey::try_from(&key_bytes).unwrap(),
     )));
 
     key_bytes[0] = 100;
 
     run_server_test(config, |mut handler| async move {
         let config = WorkerConfigBuilder::default().secret_key(WorkerSecretKey::Custom(Some(
-            SecretKey::from_slice(&key_bytes).unwrap(),
+            SecretKey::try_from(&key_bytes).unwrap(),
         )));
         expect_error_message(
             handler.start_worker(config).await,

crates/tako/src/internal/tests/integration/utils/server.rs

@@ -1,5 +1,5 @@
 use derive_builder::Builder;
-use orion::auth::SecretKey;
+use orion::aead::SecretKey;
 use std::future::Future;
 use std::net::{Ipv4Addr, SocketAddr};
 use std::rc::Rc;
@@ -265,7 +265,7 @@ async fn create_handle(
     let listener = TcpListener::bind(listen_address).await.unwrap();
 
     let secret_key = match config.secret_key {
-        ServerSecretKey::AutoGenerate => Some(Arc::new(Default::default())),
+        ServerSecretKey::AutoGenerate => Some(Arc::new(SecretKey::generate().unwrap())),
         ServerSecretKey::Custom(key) => key.map(Arc::new),
     };
 

crates/tako/src/internal/tests/integration/utils/worker.rs

@@ -12,7 +12,7 @@ use crate::launcher::{StopReason, TaskBuildContext, TaskResult};
 use crate::program::ProgramDefinition;
 use crate::worker::WorkerConfiguration;
 use derive_builder::Builder;
-use orion::auth::SecretKey;
+use orion::aead::SecretKey;
 use tempfile::TempDir;
 use tokio::io::AsyncWriteExt;
 use tokio::sync::Notify;

crates/tako/src/internal/transfer/auth.rs

@@ -154,7 +154,7 @@ impl Authenticator {
             }
             (AuthenticationResponse::Encryption(response), Some(key)) => {
                 log::trace!("Challenge verification started");
-                let remote_nonce = &Nonce::from_slice(&response.nonce)
+                let remote_nonce = &Nonce::try_from(&response.nonce)
                     .map_err(|_| DsError::AuthenticationRejected("Invalid nonce".to_string()))?;
                 let mut opener = StreamOpener::new(key, remote_nonce).map_err(|_| {
                     DsError::AuthenticationRejected("Failed to create opener".to_string())
@@ -334,7 +334,7 @@ mod tests {
 
     #[test]
     fn test_auth_ok() {
-        let secret_key = Some(Arc::new(SecretKey::generate(32).unwrap()));
+        let secret_key = Some(Arc::new(SecretKey::generate().unwrap()));
         let mut a1 = Authenticator::new(0, "a", "b", secret_key.clone());
         let mut a2 = Authenticator::new(0, "b", "a", secret_key);
 
@@ -358,8 +358,8 @@ mod tests {
 
     #[test]
     fn test_auth_different_keys() {
-        let secret_key1 = Some(Arc::new(SecretKey::generate(32).unwrap()));
-        let secret_key2 = Some(Arc::new(SecretKey::generate(32).unwrap()));
+        let secret_key1 = Some(Arc::new(SecretKey::generate().unwrap()));
+        let secret_key2 = Some(Arc::new(SecretKey::generate().unwrap()));
         let mut a1 = Authenticator::new(0, "a", "b", secret_key1);
         let mut a2 = Authenticator::new(0, "b", "a", secret_key2);
 
@@ -378,7 +378,7 @@ mod tests {
 
     #[test]
     fn test_auth_and_no_auth() {
-        let secret_key = Some(Arc::new(SecretKey::generate(32).unwrap()));
+        let secret_key = Some(Arc::new(SecretKey::generate().unwrap()));
         let mut a1 = Authenticator::new(0, "a", "b", secret_key);
         let mut a2 = Authenticator::new(0, "b", "a", None);
 
@@ -397,7 +397,7 @@ mod tests {
 
     #[test]
     fn test_mirror_attack() {
-        let secret_key = Some(Arc::new(SecretKey::generate(32).unwrap()));
+        let secret_key = Some(Arc::new(SecretKey::generate().unwrap()));
         let mut a1 = Authenticator::new(0, "a", "b", secret_key);
 
         let mut q1 = a1.make_auth_request().unwrap();

crates/tako/src/internal/worker/localclient.rs

@@ -2,6 +2,7 @@ use crate::comm::{deserialize, serialize};
 use crate::internal::common::error::DsError;
 use crate::internal::worker::localcomm::IntroMessage;
 use bstr::BStr;
+use bytes::Bytes;
 use futures::{SinkExt, StreamExt};
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
@@ -32,13 +33,13 @@ impl LocalClientConnection {
             token: token.into(),
             connection_type,
         })?;
-        stream.send(data.into()).await?;
+        stream.send(Bytes::from(data)).await?;
         Ok(LocalClientConnection { stream })
     }
 
     pub async fn send_message<T: Serialize>(&mut self, message: T) -> crate::Result<()> {
         let data = serialize(&message)?;
-        self.stream.send(data.into()).await?;
+        self.stream.send(Bytes::from(data)).await?;
         Ok(())
     }