caido-convert 1.2.1

Encoding library for web security applications
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

use data_encoding;
#[cfg(target_family = "wasm")]
use serde::{Deserialize, Serialize};

use crate::Operation;
use crate::OperationError;

#[derive(Clone, Copy)]
#[cfg_attr(target_family = "wasm", derive(Serialize, Deserialize))]
#[cfg_attr(target_family = "wasm", serde(rename_all = "snake_case"))]
pub enum Base64Format {
    Standard,
    Url,
    Mime,
}

#[derive(Clone)]
#[cfg_attr(target_family = "wasm", derive(Serialize, Deserialize))]
pub struct Base64Decode {
    format: Base64Format,
    pad: bool,
}

impl Operation for Base64Decode {
    fn execute(&self, input: &[u8]) -> Result<Vec<u8>, OperationError> {
        match (&self.format, self.pad) {
            (Base64Format::Standard, false) => data_encoding::BASE64_NOPAD.decode(input),
            (Base64Format::Standard, true) => data_encoding::BASE64.decode(input),
            (Base64Format::Url, false) => data_encoding::BASE64URL_NOPAD.decode(input),
            (Base64Format::Url, true) => data_encoding::BASE64URL.decode(input),
            (Base64Format::Mime, _) => data_encoding::BASE64_MIME.decode(input),
        }
        .map_err(|_| OperationError::DecodeError("Invalid base64 input".to_string()))
    }
}

impl Base64Decode {
    pub const fn new(format: Base64Format, pad: bool) -> Self {
        Base64Decode { format, pad }
    }
}

#[derive(Clone)]
#[cfg_attr(target_family = "wasm", derive(Serialize, Deserialize))]
pub struct Base64Encode {
    format: Base64Format,
    pad: bool,
}

impl Operation for Base64Encode {
    fn execute(&self, input: &[u8]) -> Result<Vec<u8>, OperationError> {
        let encoded = match (&self.format, self.pad) {
            (Base64Format::Standard, false) => data_encoding::BASE64_NOPAD.encode(input),
            (Base64Format::Standard, true) => data_encoding::BASE64.encode(input),
            (Base64Format::Url, false) => data_encoding::BASE64URL_NOPAD.encode(input),
            (Base64Format::Url, true) => data_encoding::BASE64URL.encode(input),
            (Base64Format::Mime, _) => data_encoding::BASE64_MIME.encode(input),
        };
        Ok(encoded.into())
    }
}

impl Base64Encode {
    pub const fn new(format: Base64Format, pad: bool) -> Self {
        Base64Encode { format, pad }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn base64_decode() {
        let encoder = Base64Decode::new(Base64Format::Standard, true);
        let actual = encoder.execute("Y2FpZG8=".as_bytes()).unwrap();
        let expected = "caido".as_bytes().to_vec();
        assert_eq!(actual, expected);
    }

    #[test]
    fn base64_encode() {
        let encoder = Base64Encode::new(Base64Format::Standard, true);
        let actual = encoder.execute("caido".as_bytes()).unwrap();
        let expected = "Y2FpZG8=".as_bytes().to_vec();
        assert_eq!(actual, expected);
    }
}