megalib 0.7.0

Rust client library for Mega.nz cloud storage
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

//! MEGA-style URL-safe base64 encoding/decoding.
//!
//! MEGA uses a variant of base64 that:
//! - Replaces `+` with `-`
//! - Replaces `/` with `_`
//! - Removes padding `=` characters

use base64::{Engine, engine::general_purpose};

/// Encode bytes to MEGA's URL-safe base64 (no padding).
///
/// # Example
/// ```
/// use megalib::base64::base64url_encode;
/// let encoded = base64url_encode(b"hello");
/// assert!(!encoded.contains('='));
/// assert!(!encoded.contains('+'));
/// assert!(!encoded.contains('/'));
/// ```
pub fn base64url_encode(data: &[u8]) -> String {
    let encoded = general_purpose::STANDARD.encode(data);
    encoded
        .replace('+', "-")
        .replace('/', "_")
        .trim_end_matches('=')
        .to_string()
}

/// Decode MEGA's URL-safe base64 to bytes.
///
/// # Example
/// ```
/// use megalib::base64::{base64url_encode, base64url_decode};
/// let original = b"hello world";
/// let encoded = base64url_encode(original);
/// let decoded = base64url_decode(&encoded).unwrap();
/// assert_eq!(decoded, original);
/// ```
pub fn base64url_decode(s: &str) -> Result<Vec<u8>, base64::DecodeError> {
    // Replace URL-safe chars back to standard base64
    let standard = s.replace('-', "+").replace('_', "/");

    // Add padding if needed (base64 requires length to be multiple of 4)
    let padding = (4 - (standard.len() % 4)) % 4;
    let padded = format!("{}{}", standard, "=".repeat(padding));

    general_purpose::STANDARD.decode(&padded)
}

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

    #[test]
    fn test_roundtrip() {
        let original = b"Hello, MEGA!";
        let encoded = base64url_encode(original);
        let decoded = base64url_decode(&encoded).unwrap();
        assert_eq!(decoded, original);
    }

    #[test]
    fn test_no_padding() {
        let encoded = base64url_encode(b"test");
        assert!(!encoded.contains('='));
    }

    #[test]
    fn test_url_safe_chars() {
        // Create data that would normally produce + and / in base64
        let data: Vec<u8> = (0..255).collect();
        let encoded = base64url_encode(&data);
        assert!(!encoded.contains('+'));
        assert!(!encoded.contains('/'));
    }

    #[test]
    fn test_decode_with_url_safe_chars() {
        // Manually create a URL-safe encoded string
        let encoded = "SGVsbG8tV29ybGRf"; // Contains - and _
        let decoded = base64url_decode(encoded);
        assert!(decoded.is_ok());
    }
}