msf-srtp 0.3.0

Secure Real-time Transport Protocol (SRTP) for Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use openssl::symm::{Cipher, Crypter, Mode};

use crate::Error;

/// Key stream.
pub trait KeyStream {
    /// Fill a given buffer with key-stream data.
    fn take(&mut self, output: &mut [u8]) -> Result<(), Error>;

    /// Skip a given number of bytes in the key-stream.
    fn skip(&mut self, mut len: usize) -> Result<(), Error> {
        let mut buf = [0u8; 128];

        while len > 0 {
            let take = len.min(buf.len());

            self.take(&mut buf[..take])?;

            len -= take;
        }

        Ok(())
    }

    /// XOR key-stream data onto given input data and write the result into a
    /// given output buffer.
    ///
    /// # Panics
    /// The method panics if the output buffer is shorter than the input
    /// buffer.
    fn xor(&mut self, input: &[u8], output: &mut [u8]) -> Result<(), Error> {
        let len = input.len();

        debug_assert!(output.len() >= len);

        self.take(&mut output[..len])?;

        for i in 0..len {
            output[i] ^= input[i];
        }

        Ok(())
    }
}

/// AES 128 CM key-stream.
pub struct AES128CM {
    crypter: Crypter,
    input: [u8; 128],
    buffer: [u8; 144],
    available: usize,
    offset: usize,
}

impl AES128CM {
    /// Create a new AES 128 CM key-stream.
    pub fn new(key: &[u8], iv: &[u8]) -> Result<Self, Error> {
        let crypter = Crypter::new(Cipher::aes_128_ctr(), Mode::Encrypt, key, Some(iv))?;

        let res = Self {
            crypter,
            input: [0u8; 128],
            buffer: [0u8; 144],
            available: 0,
            offset: 0,
        };

        Ok(res)
    }
}

impl KeyStream for AES128CM {
    fn take(&mut self, output: &mut [u8]) -> Result<(), Error> {
        let output_len = output.len();

        let mut output_offset = 0;

        while output_offset < output_len {
            let remaining = output_len - output_offset;

            if self.available == 0 {
                let max = self.input.len();
                let len = max.min((remaining + 15) & !15);

                let len = self.crypter.update(&self.input[..len], &mut self.buffer)?;

                self.offset = 0;
                self.available = len;
            }

            let take = self.available.min(remaining);

            let buffer_start = self.offset;
            let buffer_end = self.offset + take;
            let output_start = output_offset;
            let output_end = output_offset + take;

            let src = &self.buffer[buffer_start..buffer_end];
            let dst = &mut output[output_start..output_end];

            dst.copy_from_slice(src);

            output_offset += take;

            self.available -= take;
            self.offset += take;
        }

        Ok(())
    }
}