rb_mumble_protocol 0.2.1 → 0.3.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: e6cca0049d733675e76feeb5e9b480a5659167d2f474f199b21084f98528ab14
4
- data.tar.gz: 7e4dba7a96babe8076628d53a30890629862c305630e16d02670b307cf110afb
3
+ metadata.gz: 7389a940b90f092d9f0b0450ed5ae3237e93f3c6d9400a799e6f6221a63e330a
4
+ data.tar.gz: 7332e0fec01c75d7845ac315d05a0b018fbadbb248b3553aa1b12ff2cf3a70eb
5
5
  SHA512:
6
- metadata.gz: 28ee61c56fc114226de2f8aca41b8b8ad75fdd9d3c6bd4c2fea94e235dbc8f5d83f8dde716b113a12b5b307401d7a750c2afc3e7b0f22a834b7d347cb89a4cbb
7
- data.tar.gz: b28c087c5ed16fe69d5e6b07d24bd3d0f95e7b8224974ef3c0d346ff90c9fcb8d10c8a2b53cb9559d4ce52f03a585ccc7db21183e506d660e6b0678c36597df4
6
+ metadata.gz: '09a342f7767ac3e1410bbb05c4bf38b6450052d6656c64697d49e1b1b980e426263c899247c3c6364a60ce4bdd61e758a290fa3d640c7c39a6b95a724ac0488d'
7
+ data.tar.gz: 43b4a05ac99e5ef55db0c7c53e723fe40ee22ba2a7e69b86cf373435b6785cf30a089e17a33ebcecde6eac314448b0ae84b4161eba1a9cb219533da6b2f32461
@@ -27,9 +27,55 @@ static BASE_ERROR: Lazy<ExceptionClass> = Lazy::new(|ruby| {
27
27
 
28
28
  pub mod crypt_state;
29
29
 
30
- #[magnus::wrap(class = "RbMumbleProtocol::CryptState")]
30
+ use crypt_state::{DecryptError};
31
+
32
+ impl Into<u8> for DecryptError {
33
+ fn into(self: DecryptError) -> u8 {
34
+ match self {
35
+ DecryptError::Repeat => 1,
36
+ DecryptError::Late => 2,
37
+ DecryptError::Mac => 3,
38
+ DecryptError::Eof => 4
39
+ }
40
+ }
41
+ }
42
+
43
+ #[magnus::wrap(class = "RbMumbleProtocol::CryptState", size)]
31
44
  struct CryptStateRef(RefCell<crypt_state::CryptState>);
32
45
 
46
+ #[magnus::wrap(class = "RbMumbleProtocol::DecryptResult", free_immediately, size)]
47
+ struct DecryptResult {
48
+ buffer: RefCell<Vec<u8>>,
49
+ reason_raw: u8
50
+ }
51
+
52
+ impl DecryptResult {
53
+ pub fn new(buffer: Vec<u8>, result: Result<(), DecryptError>) -> Self {
54
+ let reason_raw =
55
+ match result {
56
+ Ok(()) => 0,
57
+ Err(e) => e.into()
58
+ };
59
+
60
+ Self {
61
+ buffer: RefCell::new(buffer),
62
+ reason_raw: reason_raw.into()
63
+ }
64
+ }
65
+
66
+ pub fn is_success(&self) -> bool {
67
+ self.reason_raw == 0
68
+ }
69
+
70
+ pub fn data(&self) -> Vec<u8> {
71
+ self.buffer.borrow().to_vec()
72
+ }
73
+
74
+ pub fn reason_raw_value(&self) -> u8 {
75
+ self.reason_raw
76
+ }
77
+ }
78
+
33
79
  impl CryptStateRef {
34
80
  pub fn new() -> Self {
35
81
  Self(RefCell::new(crypt_state::CryptState::generate_new()))
@@ -114,27 +160,14 @@ impl CryptStateRef {
114
160
  }
115
161
  }
116
162
 
117
- pub fn decrypt(&self, encrypted: Vec<u8>) -> Result<Vec<u8>, Error> {
163
+ pub fn decrypt(&self, encrypted: Vec<u8>) -> Result<DecryptResult, Error> {
118
164
  match self.0.try_borrow_mut() {
119
165
  Ok(mut state) => {
120
166
  let mut buffer = BytesMut::new();
121
167
  buffer.extend_from_slice(&encrypted);
168
+ let result = state.decrypt(&mut buffer);
122
169
 
123
- match state.decrypt(&mut buffer) {
124
- Ok(_) => Ok(buffer.to_vec()),
125
- Err(crypt_state::DecryptError::Repeat) => {
126
- Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Repeat"))
127
- },
128
- Err(crypt_state::DecryptError::Late) => {
129
- Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Late"))
130
- },
131
- Err(crypt_state::DecryptError::Mac) => {
132
- Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Mac"))
133
- },
134
- Err(crypt_state::DecryptError::Eof) => {
135
- Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "DecryptError::Eof"))
136
- }
137
- }
170
+ Ok(DecryptResult::new(buffer.to_vec(), result))
138
171
  },
139
172
  Err(_e) => { Err(Error::new(get_ruby().get_inner(&BASE_ERROR), "borrow error")) }
140
173
  }
@@ -149,18 +182,23 @@ fn get_ruby() -> Ruby {
149
182
  #[magnus::init]
150
183
  fn init() -> Result<(), Error> {
151
184
  let module = define_module("RbMumbleProtocol")?;
152
- let class = module.define_class("CryptState", class::object())?;
185
+ let class1 = module.define_class("CryptState", class::object())?;
186
+
187
+ class1.define_singleton_method("new", function!(CryptStateRef::new, 0))?;
188
+ class1.define_singleton_method("new_from", function!(CryptStateRef::new_from, 3))?;
153
189
 
154
- class.define_singleton_method("new", function!(CryptStateRef::new, 0))?;
155
- class.define_singleton_method("new_from", function!(CryptStateRef::new_from, 3))?;
190
+ class1.define_method("key", method!(CryptStateRef::key, 0))?;
191
+ class1.define_method("encrypt_nonce", method!(CryptStateRef::encrypt_nonce, 0))?;
192
+ class1.define_method("decrypt_nonce", method!(CryptStateRef::decrypt_nonce, 0))?;
193
+ class1.define_method("stats", method!(CryptStateRef::stats, 0))?;
156
194
 
157
- class.define_method("key", method!(CryptStateRef::key, 0))?;
158
- class.define_method("encrypt_nonce", method!(CryptStateRef::encrypt_nonce, 0))?;
159
- class.define_method("decrypt_nonce", method!(CryptStateRef::decrypt_nonce, 0))?;
160
- class.define_method("stats", method!(CryptStateRef::stats, 0))?;
195
+ class1.define_method("encrypt", method!(CryptStateRef::encrypt, 1))?;
196
+ class1.define_method("decrypt", method!(CryptStateRef::decrypt, 1))?;
161
197
 
162
- class.define_method("encrypt", method!(CryptStateRef::encrypt, 1))?;
163
- class.define_method("decrypt", method!(CryptStateRef::decrypt, 1))?;
198
+ let class2 = module.define_class("DecryptResult", class::object())?;
199
+ class2.define_method("success?", method!(DecryptResult::is_success, 0))?;
200
+ class2.define_method("data", method!(DecryptResult::data, 0))?;
201
+ class2.define_method("reason_raw_value", method!(DecryptResult::reason_raw_value, 0))?;
164
202
 
165
203
  Ok(())
166
204
  }
@@ -1,9 +1,20 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module RbMumbleProtocol
4
- class Error < StandardError
4
+ class CryptState
5
5
  end
6
6
 
7
- class CryptState
7
+ class DecryptResult
8
+ REASONS = {
9
+ 0 => :ok,
10
+ 1 => :repeat,
11
+ 2 => :late,
12
+ 3 => :mac,
13
+ 4 => :eof
14
+ }.freeze
15
+
16
+ def reason
17
+ REASONS[reason_raw_value]
18
+ end
8
19
  end
9
20
  end
@@ -1,5 +1,5 @@
1
1
  # frozen_string_literal: true
2
2
 
3
3
  module RbMumbleProtocol
4
- VERSION = "0.2.1"
4
+ VERSION = "0.3.0"
5
5
  end
metadata CHANGED
@@ -1,14 +1,14 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: rb_mumble_protocol
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.2.1
4
+ version: 0.3.0
5
5
  platform: ruby
6
6
  authors:
7
7
  - Mikhail Odebe
8
8
  autorequire:
9
9
  bindir: bin
10
10
  cert_chain: []
11
- date: 2024-02-09 00:00:00.000000000 Z
11
+ date: 2024-02-11 00:00:00.000000000 Z
12
12
  dependencies:
13
13
  - !ruby/object:Gem::Dependency
14
14
  name: rspec