perf: batch decrypt

src/bin/rbw-agent/actions.rs

@@ -688,6 +688,38 @@ pub async fn decrypt(
     Ok(())
 }
 
+pub async fn decrypt_batch(
+    sock: &mut crate::sock::Sock,
+    state: std::sync::Arc<tokio::sync::Mutex<crate::state::State>>,
+    environment: &rbw::protocol::Environment,
+    entries: &[rbw::protocol::DecryptRequest],
+) -> anyhow::Result<()> {
+    let mut results = Vec::with_capacity(entries.len());
+    for entry in entries {
+        let result = decrypt_cipher(
+            state.clone(),
+            environment,
+            &entry.cipherstring,
+            entry.entry_key.as_deref(),
+            entry.org_id.as_deref(),
+        )
+        .await;
+        results.push(match result {
+            Ok(plaintext) => {
+                rbw::protocol::DecryptResult::Success { plaintext }
+            }
+            Err(e) => rbw::protocol::DecryptResult::Failure {
+                error: format!("{e:#}"),
+            },
+        });
+    }
+
+    sock.send(&rbw::protocol::Response::DecryptBatch { results })
+        .await?;
+
+    Ok(())
+}
+
 pub async fn encrypt(
     sock: &mut crate::sock::Sock,
     state: std::sync::Arc<tokio::sync::Mutex<crate::state::State>>,

src/bin/rbw-agent/agent.rs

@@ -162,6 +162,16 @@ async fn handle_request(
             .await?;
             true
         }
+        rbw::protocol::Action::DecryptBatch { entries } => {
+            crate::actions::decrypt_batch(
+                sock,
+                state.clone(),
+                &environment,
+                entries,
+            )
+            .await?;
+            true
+        }
         rbw::protocol::Action::Encrypt { plaintext, org_id } => {
             crate::actions::encrypt(
                 sock,

src/bin/rbw/actions.rs

@@ -105,6 +105,25 @@ pub fn decrypt(
     }
 }
 
+pub fn decrypt_batch(
+    requests: Vec<rbw::protocol::DecryptRequest>,
+) -> anyhow::Result<Vec<rbw::protocol::DecryptResult>> {
+    let mut sock = connect()?;
+    sock.send(&rbw::protocol::Request::new(
+        get_environment(),
+        rbw::protocol::Action::DecryptBatch { entries: requests },
+    ))?;
+
+    let res = sock.recv()?;
+    match res {
+        rbw::protocol::Response::DecryptBatch { results } => Ok(results),
+        rbw::protocol::Response::Error { error } => {
+            Err(anyhow::anyhow!("failed to decrypt: {error}"))
+        }
+        _ => Err(anyhow::anyhow!("unexpected message: {res:?}")),
+    }
+}
+
 pub fn encrypt(
     plaintext: &str,
     org_id: Option<&str>,