memberlist_types/
secret.rs

1use std::{iter::once, sync::Arc};
2
3use async_lock::RwLock;
4use byteorder::{ByteOrder, NetworkEndian};
5use indexmap::IndexSet;
6use transformable::Transformable;
7
8/// Unknown secret key kind error
9#[derive(Debug, thiserror::Error)]
10#[error("unknown secret key kind: {0}")]
11pub struct UnknownSecretKeyKind(u8);
12
13/// The key used while attempting to encrypt/decrypt a message
14#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
15pub enum SecretKey {
16  /// secret key for AES128
17  Aes128([u8; 16]),
18  /// secret key for AES192
19  Aes192([u8; 24]),
20  /// secret key for AES256
21  Aes256([u8; 32]),
22}
23
24/// Error occurred while transforming the [`SecretKey`].
25#[derive(Debug, thiserror::Error)]
26pub enum SecretKeyTransformError {
27  /// Returned when the buffer is too small to encode the key
28  #[error("encode buffer is too small")]
29  BufferTooSmall,
30  /// Returned when the buffer is too small to decode the key
31  #[error("not enough bytes to decode")]
32  NotEnoughBytes,
33
34  /// Returned when the key is not a valid length
35  #[error("invalid key length")]
36  UnknownSecretKeyKind(#[from] UnknownSecretKeyKind),
37}
38
39impl Transformable for SecretKey {
40  type Error = SecretKeyTransformError;
41
42  fn encode(&self, dst: &mut [u8]) -> Result<usize, Self::Error> {
43    let encoded_len = self.encoded_len();
44    if dst.len() < encoded_len {
45      return Err(Self::Error::BufferTooSmall);
46    }
47
48    let len = match self {
49      Self::Aes128(_) => 16,
50      Self::Aes192(_) => 24,
51      Self::Aes256(_) => 32,
52    };
53    dst[0] = len as u8;
54
55    match self {
56      Self::Aes128(k) => dst[1..17].copy_from_slice(k),
57      Self::Aes192(k) => dst[1..25].copy_from_slice(k),
58      Self::Aes256(k) => dst[1..33].copy_from_slice(k),
59    }
60
61    Ok(len + 1)
62  }
63
64  fn encoded_len(&self) -> usize {
65    self.len() + 1
66  }
67
68  fn encode_to_writer<W: std::io::Write>(&self, writer: &mut W) -> std::io::Result<usize> {
69    match self {
70      Self::Aes128(k) => {
71        let mut buf = [0; 17];
72        buf[0] = 16;
73        buf[1..17].copy_from_slice(k);
74        writer.write_all(&buf).map(|_| 17)
75      }
76      Self::Aes192(k) => {
77        let mut buf = [0; 25];
78        buf[0] = 24;
79        buf[1..25].copy_from_slice(k);
80        writer.write_all(&buf).map(|_| 25)
81      }
82      Self::Aes256(k) => {
83        let mut buf = [0; 33];
84        buf[0] = 32;
85        buf[1..33].copy_from_slice(k);
86        writer.write_all(&buf).map(|_| 33)
87      }
88    }
89  }
90
91  async fn encode_to_async_writer<W: futures::io::AsyncWrite + Send + Unpin>(
92    &self,
93    writer: &mut W,
94  ) -> std::io::Result<usize> {
95    use futures::io::AsyncWriteExt;
96
97    match self {
98      Self::Aes128(k) => {
99        let mut buf = [0; 17];
100        buf[0] = 16;
101        buf[1..17].copy_from_slice(k);
102        writer.write_all(&buf).await.map(|_| 17)
103      }
104      Self::Aes192(k) => {
105        let mut buf = [0; 25];
106        buf[0] = 24;
107        buf[1..25].copy_from_slice(k);
108        writer.write_all(&buf).await.map(|_| 25)
109      }
110      Self::Aes256(k) => {
111        let mut buf = [0; 33];
112        buf[0] = 32;
113        buf[1..33].copy_from_slice(k);
114        writer.write_all(&buf).await.map(|_| 33)
115      }
116    }
117  }
118
119  fn decode(src: &[u8]) -> Result<(usize, Self), Self::Error>
120  where
121    Self: Sized,
122  {
123    if src.len() < 17 {
124      return Err(Self::Error::NotEnoughBytes);
125    }
126
127    let len = src[0];
128    let key = match len {
129      16 => Self::Aes128(src[1..17].try_into().unwrap()),
130      24 => Self::Aes192(src[1..25].try_into().unwrap()),
131      32 => Self::Aes256(src[1..33].try_into().unwrap()),
132      x => return Err(Self::Error::UnknownSecretKeyKind(UnknownSecretKeyKind(x))),
133    };
134
135    Ok((len as usize + 1, key))
136  }
137
138  fn decode_from_reader<R: std::io::Read>(reader: &mut R) -> std::io::Result<(usize, Self)>
139  where
140    Self: Sized,
141  {
142    let mut buf = [0; 17];
143    reader.read_exact(&mut buf)?;
144    let len = buf[0] as usize;
145    match len {
146      16 => Ok((17, Self::Aes128(buf[1..17].try_into().unwrap()))),
147      24 => {
148        let mut key = [0; 24];
149        key[..16].copy_from_slice(&buf[1..]);
150        reader.read_exact(&mut key[16..])?;
151        Ok((25, Self::Aes192(key)))
152      }
153      32 => {
154        let mut key = [0; 32];
155        key[..16].copy_from_slice(&buf[1..]);
156        reader.read_exact(&mut key[16..])?;
157        Ok((33, Self::Aes256(key)))
158      }
159      x => Err(std::io::Error::new(
160        std::io::ErrorKind::InvalidData,
161        Self::Error::UnknownSecretKeyKind(UnknownSecretKeyKind(x as u8)),
162      )),
163    }
164  }
165
166  async fn decode_from_async_reader<R: futures::io::AsyncRead + Send + Unpin>(
167    reader: &mut R,
168  ) -> std::io::Result<(usize, Self)>
169  where
170    Self: Sized,
171  {
172    use futures::io::AsyncReadExt;
173
174    let mut buf = [0; 17];
175    reader.read_exact(&mut buf).await?;
176    let len = buf[0] as usize;
177    match len {
178      16 => Ok((17, Self::Aes128(buf[1..17].try_into().unwrap()))),
179      24 => {
180        let mut key = [0; 24];
181        key[..16].copy_from_slice(&buf[1..]);
182        reader.read_exact(&mut key[16..]).await?;
183        Ok((25, Self::Aes192(key)))
184      }
185      32 => {
186        let mut key = [0; 32];
187        key[..16].copy_from_slice(&buf[1..]);
188        reader.read_exact(&mut key[16..]).await?;
189        Ok((33, Self::Aes256(key)))
190      }
191      x => Err(std::io::Error::new(
192        std::io::ErrorKind::InvalidData,
193        Self::Error::UnknownSecretKeyKind(UnknownSecretKeyKind(x as u8)),
194      )),
195    }
196  }
197}
198
199#[cfg(feature = "serde")]
200const _: () = {
201  use base64::Engine;
202  use serde::{Deserialize, Serialize};
203
204  impl Serialize for SecretKey {
205    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
206    where
207      S: serde::Serializer,
208    {
209      if serializer.is_human_readable() {
210        base64::engine::general_purpose::STANDARD
211          .encode(self)
212          .serialize(serializer)
213      } else {
214        serializer.serialize_bytes(self)
215      }
216    }
217  }
218
219  impl<'de> Deserialize<'de> for SecretKey {
220    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
221    where
222      D: serde::Deserializer<'de>,
223    {
224      macro_rules! parse {
225        ($key:ident) => {{
226          match $key.len() {
227            16 => Ok(Self::Aes128($key.try_into().unwrap())),
228            24 => Ok(Self::Aes192($key.try_into().unwrap())),
229            32 => Ok(Self::Aes256($key.try_into().unwrap())),
230            _ => Err(<D::Error as serde::de::Error>::custom(
231              "invalid secret key length",
232            )),
233          }
234        }};
235      }
236
237      if deserializer.is_human_readable() {
238        <String as Deserialize<'de>>::deserialize(deserializer).and_then(|val| {
239          base64::engine::general_purpose::STANDARD
240            .decode(val)
241            .map_err(serde::de::Error::custom)
242            .and_then(|key| parse!(key))
243        })
244      } else {
245        <Vec<u8> as Deserialize<'de>>::deserialize(deserializer).and_then(|val| parse!(val))
246      }
247    }
248  }
249};
250
251impl core::hash::Hash for SecretKey {
252  fn hash<H: core::hash::Hasher>(&self, state: &mut H) {
253    self.as_ref().hash(state);
254  }
255}
256
257impl core::borrow::Borrow<[u8]> for SecretKey {
258  fn borrow(&self) -> &[u8] {
259    self.as_ref()
260  }
261}
262
263impl PartialEq<[u8]> for SecretKey {
264  fn eq(&self, other: &[u8]) -> bool {
265    self.as_ref() == other
266  }
267}
268
269impl core::ops::Deref for SecretKey {
270  type Target = [u8];
271
272  fn deref(&self) -> &Self::Target {
273    match self {
274      Self::Aes128(k) => k,
275      Self::Aes192(k) => k,
276      Self::Aes256(k) => k,
277    }
278  }
279}
280
281impl core::ops::DerefMut for SecretKey {
282  fn deref_mut(&mut self) -> &mut Self::Target {
283    match self {
284      Self::Aes128(k) => k,
285      Self::Aes192(k) => k,
286      Self::Aes256(k) => k,
287    }
288  }
289}
290
291impl From<[u8; 16]> for SecretKey {
292  fn from(k: [u8; 16]) -> Self {
293    Self::Aes128(k)
294  }
295}
296
297impl From<[u8; 24]> for SecretKey {
298  fn from(k: [u8; 24]) -> Self {
299    Self::Aes192(k)
300  }
301}
302
303impl From<[u8; 32]> for SecretKey {
304  fn from(k: [u8; 32]) -> Self {
305    Self::Aes256(k)
306  }
307}
308
309impl TryFrom<&[u8]> for SecretKey {
310  type Error = String;
311
312  fn try_from(k: &[u8]) -> Result<Self, Self::Error> {
313    match k.len() {
314      16 => Ok(Self::Aes128(k.try_into().unwrap())),
315      24 => Ok(Self::Aes192(k.try_into().unwrap())),
316      32 => Ok(Self::Aes256(k.try_into().unwrap())),
317      x => Err(format!(
318        "invalid key size: {}, secret key size must be 16, 24 or 32 bytes",
319        x
320      )),
321    }
322  }
323}
324
325impl AsRef<[u8]> for SecretKey {
326  fn as_ref(&self) -> &[u8] {
327    match self {
328      Self::Aes128(k) => k,
329      Self::Aes192(k) => k,
330      Self::Aes256(k) => k,
331    }
332  }
333}
334
335impl AsMut<[u8]> for SecretKey {
336  fn as_mut(&mut self) -> &mut [u8] {
337    match self {
338      Self::Aes128(k) => k,
339      Self::Aes192(k) => k,
340      Self::Aes256(k) => k,
341    }
342  }
343}
344
345smallvec_wrapper::smallvec_wrapper!(
346  /// A collection of secret keys, you can just treat it as a `Vec<SecretKey>`.
347  #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
348  #[repr(transparent)]
349  #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
350  #[cfg_attr(feature = "serde", serde(transparent))]
351  pub SecretKeys([SecretKey; 3]);
352);
353
354/// Error occurred while transforming the [`SecretKeys`].
355#[derive(Debug, thiserror::Error)]
356pub enum SecretKeysTransformError {
357  /// Returned when the buffer is too small to encode the keys
358  #[error("encode buffer is too small")]
359  BufferTooSmall,
360  /// Returned when the buffer is too small to decode the keys
361  #[error("not enough bytes to decode")]
362  NotEnoughBytes,
363
364  /// Returned when transforming the secret key
365  #[error(transparent)]
366  SecretKey(#[from] SecretKeyTransformError),
367
368  /// Returned when missing keys
369  #[error("expect {expected} keys, but actual decode {actual} keys")]
370  MissingKeys {
371    /// Expected number of keys
372    expected: usize,
373    /// Actual number of keys
374    actual: usize,
375  },
376}
377
378impl Transformable for SecretKeys {
379  type Error = SecretKeysTransformError;
380
381  fn encode(&self, dst: &mut [u8]) -> Result<usize, Self::Error> {
382    let encoded_len = self.encoded_len();
383    if dst.len() < encoded_len {
384      return Err(Self::Error::BufferTooSmall);
385    }
386
387    let mut offset = 0;
388    NetworkEndian::write_u32(&mut dst[offset..], encoded_len as u32);
389    offset += 4;
390
391    let num_keys = self.len();
392    NetworkEndian::write_u32(&mut dst[offset..], num_keys as u32);
393    offset += 4;
394
395    for key in self.iter() {
396      let len = key.encode(&mut dst[offset..])?;
397      offset += len;
398    }
399
400    debug_assert_eq!(
401      offset, encoded_len,
402      "expect write {} bytes, but actual write {} bytes",
403      encoded_len, offset
404    );
405
406    Ok(encoded_len)
407  }
408
409  fn encoded_len(&self) -> usize {
410    4 + 4 + self.iter().map(SecretKey::encoded_len).sum::<usize>()
411  }
412
413  fn decode(src: &[u8]) -> Result<(usize, Self), Self::Error>
414  where
415    Self: Sized,
416  {
417    if src.len() < 4 {
418      return Err(Self::Error::NotEnoughBytes);
419    }
420
421    let len = NetworkEndian::read_u32(&src[0..4]) as usize;
422    if src.len() < len {
423      return Err(Self::Error::NotEnoughBytes);
424    }
425
426    let mut offset = 4;
427    let keys_len = NetworkEndian::read_u32(&src[offset..]) as usize;
428    offset += 4;
429
430    let mut keys = SecretKeys::with_capacity(keys_len);
431    for _ in 0..keys_len {
432      let (len, key) = SecretKey::decode(&src[offset..])?;
433      offset += len;
434      keys.push(key);
435    }
436
437    debug_assert_eq!(
438      offset, len,
439      "expect read {} bytes, but actual read {} bytes",
440      len, offset
441    );
442
443    Ok((offset, keys))
444  }
445}
446
447/// Error for [`SecretKeyring`]
448#[derive(Debug, Clone, thiserror::Error, PartialEq, Eq)]
449pub enum SecretKeyringError {
450  /// Secret key is not in the keyring
451  #[error("secret key is not in the keyring")]
452  SecretKeyNotFound,
453  /// Removing the primary key is not allowed
454  #[error("removing the primary key is not allowed")]
455  RemovePrimaryKey,
456}
457
458#[derive(Debug)]
459pub(super) struct SecretKeyringInner {
460  pub(super) primary_key: SecretKey,
461  pub(super) keys: IndexSet<SecretKey>,
462}
463
464/// A lock-free and thread-safe container for a set of encryption keys.
465/// The keyring contains all key data used internally by memberlist.
466///
467/// If creating a keyring with multiple keys, one key must be designated
468/// primary by passing it as the primaryKey. If the primaryKey does not exist in
469/// the list of secondary keys, it will be automatically added at position 0.
470#[derive(Debug, Clone)]
471#[repr(transparent)]
472pub struct SecretKeyring {
473  pub(super) inner: Arc<RwLock<SecretKeyringInner>>,
474}
475
476impl SecretKeyring {
477  /// Constructs a new container for a primary key. The
478  /// keyring contains all key data used internally by memberlist.
479  ///
480  /// If only a primary key is passed, then it will be automatically added to the
481  /// keyring.
482  ///
483  /// A key should be either 16, 24, or 32 bytes to select AES-128,
484  /// AES-192, or AES-256.
485  #[inline]
486  pub fn new(primary_key: SecretKey) -> Self {
487    Self {
488      inner: Arc::new(RwLock::new(SecretKeyringInner {
489        primary_key,
490        keys: IndexSet::new(),
491      })),
492    }
493  }
494
495  /// Constructs a new container for a set of encryption keys. The
496  /// keyring contains all key data used internally by memberlist.
497  ///
498  /// If only a primary key is passed, then it will be automatically added to the
499  /// keyring. If creating a keyring with multiple keys, one key must be designated
500  /// primary by passing it as the primaryKey. If the primaryKey does not exist in
501  /// the list of secondary keys, it will be automatically added.
502  ///
503  /// A key should be either 16, 24, or 32 bytes to select AES-128,
504  /// AES-192, or AES-256.
505  #[inline]
506  pub fn with_keys(
507    primary_key: SecretKey,
508    keys: impl Iterator<Item = impl Into<SecretKey>>,
509  ) -> Self {
510    if keys.size_hint().0 != 0 {
511      return Self {
512        inner: Arc::new(RwLock::new(SecretKeyringInner {
513          primary_key,
514          keys: keys
515            .filter_map(|k| {
516              let k = k.into();
517              if k == primary_key {
518                None
519              } else {
520                Some(k)
521              }
522            })
523            .collect(),
524        })),
525      };
526    }
527
528    Self::new(primary_key)
529  }
530
531  /// Returns the key on the ring at position 0. This is the key used
532  /// for encrypting messages, and is the first key tried for decrypting messages.
533  #[inline]
534  pub async fn primary_key(&self) -> SecretKey {
535    self.inner.read().await.primary_key
536  }
537
538  /// Drops a key from the keyring. This will return an error if the key
539  /// requested for removal is currently at position 0 (primary key).
540  #[inline]
541  pub async fn remove(&self, key: &[u8]) -> Result<(), SecretKeyringError> {
542    let mut inner = self.inner.write().await;
543    if &inner.primary_key == key {
544      return Err(SecretKeyringError::RemovePrimaryKey);
545    }
546    inner.keys.shift_remove(key);
547    Ok(())
548  }
549
550  /// Install a new key on the ring. Adding a key to the ring will make
551  /// it available for use in decryption. If the key already exists on the ring,
552  /// this function will just return noop.
553  ///
554  /// key should be either 16, 24, or 32 bytes to select AES-128,
555  /// AES-192, or AES-256.
556  #[inline]
557  pub async fn insert(&self, key: SecretKey) {
558    self.inner.write().await.keys.insert(key);
559  }
560
561  /// Changes the key used to encrypt messages. This is the only key used to
562  /// encrypt messages, so peers should know this key before this method is called.
563  #[inline]
564  pub async fn use_key(&self, key_data: &[u8]) -> Result<(), SecretKeyringError> {
565    let mut inner = self.inner.write().await;
566    if key_data == inner.primary_key.as_ref() {
567      return Ok(());
568    }
569
570    // Try to find the key to set as primary
571    let Some(&key) = inner.keys.get(key_data) else {
572      return Err(SecretKeyringError::SecretKeyNotFound);
573    };
574
575    let old_pk = inner.primary_key;
576    inner.keys.insert(old_pk);
577    inner.primary_key = key;
578    inner.keys.swap_remove(key_data);
579    Ok(())
580  }
581
582  /// Returns the current set of keys on the ring.
583  #[inline]
584  pub async fn keys(&self) -> impl Iterator<Item = SecretKey> + 'static {
585    let inner = self.inner.read().await;
586
587    // we must promise the first key is the primary key
588    // so that when decrypt messages, we can try the primary key first
589    once(inner.primary_key).chain(inner.keys.clone().into_iter())
590  }
591}
592
593#[cfg(test)]
594mod tests {
595  use std::ops::{Deref, DerefMut};
596
597  use super::*;
598
599  impl SecretKey {
600    fn random(kind: u8) -> Self {
601      match kind {
602        16 => Self::Aes128(rand::random()),
603        24 => Self::Aes192(rand::random()),
604        32 => Self::Aes256(rand::random()),
605        x => panic!("invalid key kind: {}", x),
606      }
607    }
608  }
609
610  impl SecretKeys {
611    fn random(num_keys: usize) -> Self {
612      let mut keys = SecretKeys::new();
613      for i in 0..num_keys {
614        let kind = match i % 3 {
615          0 => 16,
616          1 => 24,
617          2 => 32,
618          _ => unreachable!(),
619        };
620        keys.push(SecretKey::random(kind));
621      }
622      keys
623    }
624  }
625
626  #[test]
627  fn test_secret_key() {
628    let mut key = SecretKey::from([0; 16]);
629    assert_eq!(key.deref(), &[0; 16]);
630    assert_eq!(key.deref_mut(), &mut [0; 16]);
631    assert_eq!(key.as_ref(), &[0; 16]);
632    assert_eq!(key.as_mut(), &mut [0; 16]);
633    assert_eq!(key.len(), 16);
634    assert!(!key.is_empty());
635    assert_eq!(key.to_vec(), vec![0; 16]);
636
637    let mut key = SecretKey::from([0; 24]);
638    assert_eq!(key.deref(), &[0; 24]);
639    assert_eq!(key.deref_mut(), &mut [0; 24]);
640    assert_eq!(key.as_ref(), &[0; 24]);
641    assert_eq!(key.as_mut(), &mut [0; 24]);
642    assert_eq!(key.len(), 24);
643    assert!(!key.is_empty());
644    assert_eq!(key.to_vec(), vec![0; 24]);
645
646    let mut key = SecretKey::from([0; 32]);
647    assert_eq!(key.deref(), &[0; 32]);
648    assert_eq!(key.deref_mut(), &mut [0; 32]);
649    assert_eq!(key.as_ref(), &[0; 32]);
650    assert_eq!(key.as_mut(), &mut [0; 32]);
651    assert_eq!(key.len(), 32);
652    assert!(!key.is_empty());
653    assert_eq!(key.to_vec(), vec![0; 32]);
654
655    let mut key = SecretKey::from([0; 16]);
656    assert_eq!(key.as_ref(), &[0; 16]);
657    assert_eq!(key.as_mut(), &mut [0; 16]);
658
659    let mut key = SecretKey::from([0; 24]);
660    assert_eq!(key.as_ref(), &[0; 24]);
661    assert_eq!(key.as_mut(), &mut [0; 24]);
662
663    let mut key = SecretKey::from([0; 32]);
664    assert_eq!(key.as_ref(), &[0; 32]);
665    assert_eq!(key.as_mut(), &mut [0; 32]);
666
667    let key = SecretKey::Aes128([0; 16]);
668    assert_eq!(key.to_vec(), vec![0; 16]);
669
670    let key = SecretKey::Aes192([0; 24]);
671    assert_eq!(key.to_vec(), vec![0; 24]);
672
673    let key = SecretKey::Aes256([0; 32]);
674    assert_eq!(key.to_vec(), vec![0; 32]);
675  }
676
677  #[test]
678  fn test_try_from() {
679    assert!(SecretKey::try_from([0; 15].as_slice()).is_err());
680    assert!(SecretKey::try_from([0; 16].as_slice()).is_ok());
681    assert!(SecretKey::try_from([0; 23].as_slice()).is_err());
682    assert!(SecretKey::try_from([0; 24].as_slice()).is_ok());
683    assert!(SecretKey::try_from([0; 31].as_slice()).is_err());
684    assert!(SecretKey::try_from([0; 32].as_slice()).is_ok());
685  }
686
687  const TEST_KEYS: &[SecretKey] = &[
688    SecretKey::Aes128([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]),
689    SecretKey::Aes128([15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]),
690    SecretKey::Aes128([8, 9, 10, 11, 12, 13, 14, 15, 0, 1, 2, 3, 4, 5, 6, 7]),
691  ];
692
693  #[tokio::test]
694  async fn test_primary_only() {
695    let keyring = SecretKeyring::new(TEST_KEYS[1]);
696    assert_eq!(keyring.keys().await.collect::<Vec<_>>().len(), 1);
697  }
698
699  #[tokio::test]
700  async fn test_get_primary_key() {
701    let keyring = SecretKeyring::with_keys(TEST_KEYS[1], TEST_KEYS.iter().copied());
702    assert_eq!(keyring.primary_key().await.as_ref(), TEST_KEYS[1].as_ref());
703  }
704
705  #[tokio::test]
706  async fn test_insert_remove_use() {
707    let keyring = SecretKeyring::new(TEST_KEYS[1]);
708
709    // Use non-existent key throws error
710    keyring.use_key(&TEST_KEYS[2]).await.unwrap_err();
711
712    // Add key to ring
713    keyring.insert(TEST_KEYS[2]).await;
714    assert_eq!(keyring.inner.read().await.keys.len() + 1, 2);
715    assert_eq!(keyring.keys().await.next().unwrap(), TEST_KEYS[1]);
716
717    // Use key that exists should succeed
718    keyring.use_key(&TEST_KEYS[2]).await.unwrap();
719    assert_eq!(keyring.keys().await.next().unwrap(), TEST_KEYS[2]);
720
721    let primary_key = keyring.primary_key().await;
722    assert_eq!(primary_key.as_ref(), TEST_KEYS[2].as_ref());
723
724    // Removing primary key should fail
725    keyring.remove(&TEST_KEYS[2]).await.unwrap_err();
726
727    // Removing non-primary key should succeed
728    keyring.remove(&TEST_KEYS[1]).await.unwrap();
729    assert_eq!(keyring.inner.read().await.keys.len() + 1, 1);
730  }
731
732  #[tokio::test]
733  async fn test_secret_key_transform() {
734    for i in 0..100 {
735      let kind = match i % 3 {
736        0 => 16,
737        1 => 24,
738        2 => 32,
739        _ => unreachable!(),
740      };
741      let key = SecretKey::random(kind);
742      let mut buf = vec![0; key.encoded_len()];
743      let encoded_len = key.encode(&mut buf).unwrap();
744      assert_eq!(encoded_len, key.encoded_len());
745      let mut buf1 = vec![];
746      let encoded_len1 = key.encode_to_writer(&mut buf1).unwrap();
747      assert_eq!(encoded_len1, key.encoded_len());
748      let mut buf2 = vec![];
749      let encoded_len2 = key.encode_to_async_writer(&mut buf2).await.unwrap();
750      assert_eq!(encoded_len2, key.encoded_len());
751
752      let (decoded_len, decoded) = SecretKey::decode(&buf).unwrap();
753      assert_eq!(decoded_len, encoded_len);
754      assert_eq!(decoded, key);
755      let (decoded_len, decoded) = SecretKey::decode(&buf1).unwrap();
756      assert_eq!(decoded_len, encoded_len);
757      assert_eq!(decoded, key);
758      let (decoded_len, decoded) = SecretKey::decode(&buf2).unwrap();
759      assert_eq!(decoded_len, encoded_len);
760      assert_eq!(decoded, key);
761
762      let (decoded_len, decoded) =
763        SecretKey::decode_from_reader(&mut std::io::Cursor::new(&buf)).unwrap();
764      assert_eq!(decoded_len, encoded_len);
765      assert_eq!(decoded, key);
766      let (decoded_len, decoded) =
767        SecretKey::decode_from_reader(&mut std::io::Cursor::new(&buf1)).unwrap();
768      assert_eq!(decoded_len, encoded_len);
769      assert_eq!(decoded, key);
770      let (decoded_len, decoded) =
771        SecretKey::decode_from_reader(&mut std::io::Cursor::new(&buf2)).unwrap();
772      assert_eq!(decoded_len, encoded_len);
773      assert_eq!(decoded, key);
774
775      let (decoded_len, decoded) =
776        SecretKey::decode_from_async_reader(&mut futures::io::Cursor::new(&buf))
777          .await
778          .unwrap();
779      assert_eq!(decoded_len, encoded_len);
780      assert_eq!(decoded, key);
781      let (decoded_len, decoded) =
782        SecretKey::decode_from_async_reader(&mut futures::io::Cursor::new(&buf1))
783          .await
784          .unwrap();
785      assert_eq!(decoded_len, encoded_len);
786      assert_eq!(decoded, key);
787      let (decoded_len, decoded) =
788        SecretKey::decode_from_async_reader(&mut futures::io::Cursor::new(&buf2))
789          .await
790          .unwrap();
791      assert_eq!(decoded_len, encoded_len);
792      assert_eq!(decoded, key);
793    }
794  }
795
796  #[tokio::test]
797  async fn test_secret_keys_transform() {
798    for i in 0..100 {
799      let keys = SecretKeys::random(i);
800      let mut buf = vec![0; keys.encoded_len()];
801      let encoded_len = keys.encode(&mut buf).unwrap();
802      assert_eq!(encoded_len, keys.encoded_len());
803
804      let (decoded_len, decoded) = SecretKeys::decode(&buf).unwrap();
805      assert_eq!(decoded_len, encoded_len);
806      assert_eq!(decoded, keys);
807
808      let (decoded_len, decoded) =
809        SecretKeys::decode_from_reader(&mut std::io::Cursor::new(&buf)).unwrap();
810      assert_eq!(decoded_len, encoded_len);
811      assert_eq!(decoded, keys);
812
813      let (decoded_len, decoded) =
814        SecretKeys::decode_from_async_reader(&mut futures::io::Cursor::new(&buf))
815          .await
816          .unwrap();
817      assert_eq!(decoded_len, encoded_len);
818      assert_eq!(decoded, keys);
819    }
820  }
821}
memberlist_types/secret.rs

memberlist_types/
secret.rs
