rb_mumble_protocol 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6cca0049d733675e76feeb5e9b480a5659167d2f474f199b21084f98528ab14
-  data.tar.gz: 7e4dba7a96babe8076628d53a30890629862c305630e16d02670b307cf110afb
+  metadata.gz: 53a24a4721b3a21ec02c022b203db3f44935b89e45df558711a39cf76c390d27
+  data.tar.gz: 47fac63e468a754daafe67bd1c26516e5d3f99335c5527d8881922b2a90d99f9
 SHA512:
-  metadata.gz: 28ee61c56fc114226de2f8aca41b8b8ad75fdd9d3c6bd4c2fea94e235dbc8f5d83f8dde716b113a12b5b307401d7a750c2afc3e7b0f22a834b7d347cb89a4cbb
-  data.tar.gz: b28c087c5ed16fe69d5e6b07d24bd3d0f95e7b8224974ef3c0d346ff90c9fcb8d10c8a2b53cb9559d4ce52f03a585ccc7db21183e506d660e6b0678c36597df4
+  metadata.gz: f182dc904194306a67f4d815b4373637b646b115fb5b61f2e51e2df47e8bfd6d44885e827ebbb86687b6cc81df18fc2dcb60301edd0359f49a8a30fad1c4a0cf
+  data.tar.gz: 0bcba759478da33bd4b289212c7025c6d5826f19a68eb20581c069c8ed19ace99878ce92ca5e762691d148ae1e1c71b40c25b348206399c21d4f6e85caa97140

data/ext/rb_mumble_protocol/src/lib.rs

@@ -27,9 +27,55 @@ static BASE_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
 
 pub mod crypt_state;
 
-#[magnus::wrap(class = "RbMumbleProtocol::CryptState")]
+use crypt_state::{DecryptError};
+
+impl Into<u8> for DecryptError {
+    fn into(self: DecryptError) -> u8 {
+        match self {
+            DecryptError::Repeat => 1,
+            DecryptError::Late => 2,
+            DecryptError::Mac => 3,
+            DecryptError::Eof => 4
+        }
+    }
+}
+
+#[magnus::wrap(class = "RbMumbleProtocol::CryptState", size)]
 struct CryptStateRef(RefCell<crypt_state::CryptState>);
 
+#[magnus::wrap(class = "RbMumbleProtocol::DecryptResult", free_immediately, size)]
+struct DecryptResult {
+    buffer: RefCell<Vec<u8>>,
+    reason_raw: u8
+}
+
+impl DecryptResult {
+    pub fn new(buffer: Vec<u8>, result: Result<(), DecryptError>) -> Self {
+        let reason_raw =
+            match result {
+                Ok(()) => 0,
+                Err(e) => e.into()
+            };
+
+        Self {
+            buffer: RefCell::new(buffer),
+            reason_raw: reason_raw.into()
+        }
+    }
+
+    pub fn is_success(&self) -> bool {
+        self.reason_raw == 0
+    }
+
+    pub fn data(&self) -> Vec<u8> {
+        self.buffer.borrow().to_vec()
+    }
+
+    pub fn reason_raw_value(&self) -> u8 {
+        self.reason_raw
+    }
+}
+
 impl CryptStateRef {
     pub fn new() -> Self {
         Self(RefCell::new(crypt_state::CryptState::generate_new()))
@@ -64,6 +110,23 @@ impl CryptStateRef {
         Self(RefCell::new(new_state))
     }
 
+    pub fn set_decrypt_nonce(&self, nonce: Vec<u8>) -> Result<(), Error> {
+        match self.0.try_borrow_mut() {
+            Ok(mut ref_) => {
+                match &nonce.clone().try_into() {
+                    Ok(array) => Ok(ref_.set_decrypt_nonce(array)),
+                    Err(_e) => {
+                        let msg = format!("Expected a Decrypt nonce of length {}", 16);
+                        let err = Error::new(get_ruby().get_inner(&BASE_ERROR), msg);
+
+                        Err(err)
+                    }
+                }
+            },
+            Err(_e) => { Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "borrow error")) }
+        }
+    }
+
     pub fn key(&self) -> Result<Vec<u8>, Error> {
         match self.0.try_borrow() {
             Ok(ref_) => { Ok(ref_.get_key().to_vec()) },
@@ -114,27 +177,14 @@ impl CryptStateRef {
         }
     }
 
-    pub fn decrypt(&self, encrypted: Vec<u8>) -> Result<Vec<u8>, Error> {
+    pub fn decrypt(&self, encrypted: Vec<u8>) -> Result<DecryptResult, Error> {
         match self.0.try_borrow_mut() {
             Ok(mut state) => {
                 let mut buffer = BytesMut::new();
                 buffer.extend_from_slice(&encrypted);
+                let result = state.decrypt(&mut buffer);
 
-                match state.decrypt(&mut buffer) {
-                    Ok(_) => Ok(buffer.to_vec()),
-                    Err(crypt_state::DecryptError::Repeat) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Repeat"))
-                    },
-                    Err(crypt_state::DecryptError::Late) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Late"))
-                    },
-                    Err(crypt_state::DecryptError::Mac) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Mac"))
-                    },
-                    Err(crypt_state::DecryptError::Eof) => {
-                        Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Eof"))
-                    }
-                }
+                Ok(DecryptResult::new(buffer.to_vec(), result))
             },
             Err(_e) => { Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "borrow error")) }
         }
@@ -149,18 +199,24 @@ fn get_ruby() -> Ruby {
 #[magnus::init]
 fn init() -> Result<(), Error> {
     let module = define_module("RbMumbleProtocol")?;
-    let class = module.define_class("CryptState", class::object())?;
+    let class1 = module.define_class("CryptState", class::object())?;
+
+    class1.define_singleton_method("new", function!(CryptStateRef::new, 0))?;
+    class1.define_singleton_method("new_from", function!(CryptStateRef::new_from, 3))?;
 
-    class.define_singleton_method("new", function!(CryptStateRef::new, 0))?;
-    class.define_singleton_method("new_from", function!(CryptStateRef::new_from, 3))?;
+    class1.define_method("key", method!(CryptStateRef::key, 0))?;
+    class1.define_method("encrypt_nonce", method!(CryptStateRef::encrypt_nonce, 0))?;
+    class1.define_method("decrypt_nonce", method!(CryptStateRef::decrypt_nonce, 0))?;
+    class1.define_method("stats", method!(CryptStateRef::stats, 0))?;
+    class1.define_method("set_decrypt_nonce", method!(CryptStateRef::set_decrypt_nonce, 1))?;
 
-    class.define_method("key", method!(CryptStateRef::key, 0))?;
-    class.define_method("encrypt_nonce", method!(CryptStateRef::encrypt_nonce, 0))?;
-    class.define_method("decrypt_nonce", method!(CryptStateRef::decrypt_nonce, 0))?;
-    class.define_method("stats", method!(CryptStateRef::stats, 0))?;
+    class1.define_method("encrypt", method!(CryptStateRef::encrypt, 1))?;
+    class1.define_method("decrypt", method!(CryptStateRef::decrypt, 1))?;
 
-    class.define_method("encrypt", method!(CryptStateRef::encrypt, 1))?;
-    class.define_method("decrypt", method!(CryptStateRef::decrypt, 1))?;
+    let class2 = module.define_class("DecryptResult", class::object())?;
+    class2.define_method("success?", method!(DecryptResult::is_success, 0))?;
+    class2.define_method("data", method!(DecryptResult::data, 0))?;
+    class2.define_method("reason_raw_value", method!(DecryptResult::reason_raw_value, 0))?;
 
     Ok(())
 }

data/lib/rb_mumble_protocol/crypt_state.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
 module RbMumbleProtocol
-  class Error < StandardError
+  class CryptState
   end
 
-  class CryptState
+  class DecryptResult
+    REASONS = {
+      0 => :ok,
+      1 => :repeat,
+      2 => :late,
+      3 => :mac,
+      4 => :eof
+    }.freeze
+
+    def reason
+      REASONS[reason_raw_value]
+    end
   end
 end

data/lib/rb_mumble_protocol/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RbMumbleProtocol
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rb_mumble_protocol
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Mikhail Odebe
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-02-09 00:00:00.000000000 Z
+date: 2024-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec