cedros-login-server 0.0.45

Authentication server for cedros-login with email/password, Google OAuth, and Solana wallet sign-in
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

use base64::{engine::general_purpose::STANDARD as BASE64, Engine};

use crate::errors::AppError;
use crate::services::{NoteEncryptionService, NOTE_NONCE_SIZE};

pub(crate) fn decrypt_base64_payload(
    note_encryption: &NoteEncryptionService,
    encrypted: &str,
    invalid_encoding_message: &str,
    invalid_format_message: &str,
) -> Result<Vec<u8>, AppError> {
    let combined = BASE64
        .decode(encrypted)
        .map_err(|e| AppError::Internal(anyhow::anyhow!("{}: {}", invalid_encoding_message, e)))?;

    if combined.len() <= NOTE_NONCE_SIZE {
        return Err(AppError::Internal(anyhow::anyhow!(
            "{}",
            invalid_format_message
        )));
    }

    let nonce = &combined[..NOTE_NONCE_SIZE];
    let ciphertext = &combined[NOTE_NONCE_SIZE..];
    note_encryption.decrypt(ciphertext, nonce)
}

#[cfg(test)]
mod tests {
    use super::decrypt_base64_payload;
    use crate::errors::AppError;
    use crate::services::NoteEncryptionService;
    use base64::{engine::general_purpose::STANDARD as BASE64, Engine};

    fn test_note_encryption() -> NoteEncryptionService {
        NoteEncryptionService::new(&[3u8; 32], "test-key").expect("create test encryption service")
    }

    #[test]
    fn decrypt_base64_payload_round_trip() {
        let note_encryption = test_note_encryption();
        let encrypted = note_encryption
            .encrypt(b"test-private-key")
            .expect("encrypt payload");
        let mut combined = encrypted.nonce;
        combined.extend(encrypted.ciphertext);

        let decrypted = decrypt_base64_payload(
            &note_encryption,
            &BASE64.encode(combined),
            "Invalid payload encoding",
            "Invalid payload format",
        )
        .expect("decrypt payload");

        assert_eq!(decrypted, b"test-private-key");
    }

    #[test]
    fn decrypt_base64_payload_rejects_short_payload() {
        let note_encryption = test_note_encryption();
        let result = decrypt_base64_payload(
            &note_encryption,
            &BASE64.encode(vec![0u8; 12]),
            "Invalid payload encoding",
            "Invalid payload format",
        );

        assert!(matches!(result, Err(AppError::Internal(_))));
    }
}