akas 2.4.18

AKAS: API Key Authorization Server
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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use crate::utils::{is_key_valid, sha256_hex};
use actix_multipart::form::{json::Json as MPJson, tempfile::TempFile, MultipartForm};
use serde::{Deserialize, Serialize};
use std::sync::Arc;

pub const FORMAT_SHA256: &str = "sha256";
pub const FORMAT_PLAIN: &str = "plain";

#[derive(Debug)]
pub struct AppConfig {
    pub admin_key: String,
    pub no_admin_key: bool,
    pub local: bool,
    pub enable_metrics: bool,
    pub port: u16,
    pub log_level: String,
    pub original_length: u16,
    pub metadata_length: u16,
    pub key_length: u16,
    pub key_prefix: String,
    pub auth_counter: Arc<prometheus::IntCounterVec>,
}

#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ApiKey(String);

impl ApiKey {
    /// Create a new ApiKey instance if the key is valid.
    pub fn new(raw: &str, length: u16, prefix: &str) -> Option<Self> {
        if is_key_valid(raw, length, prefix) {
            Some(ApiKey(raw.to_string()))
        } else {
            None
        }
    }

    pub fn hash(&self) -> String {
        sha256_hex(&self.0)
    }
}

#[derive(Debug, Serialize)]
pub struct Headers {
    pub forwarded_for: String,
    pub original_host: String,
    pub original_uri: String,
    pub metadata: String,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum KeyFormat {
    Sha256,
    Plain,
}

impl KeyFormat {
    /// Convert from string
    pub fn from_str(s: &str) -> Option<Self> {
        match s {
            FORMAT_SHA256 => Some(KeyFormat::Sha256),
            FORMAT_PLAIN => Some(KeyFormat::Plain),
            _ => None,
        }
    }

    /// Convert enum -> &str
    pub fn as_str(&self) -> &'static str {
        match self {
            KeyFormat::Sha256 => FORMAT_SHA256,
            KeyFormat::Plain => FORMAT_PLAIN,
        }
    }
}

#[derive(Debug, MultipartForm)]
pub struct LoadForm {
    pub file: TempFile,
    pub json: Option<MPJson<LoadMetadata>>,
}

#[derive(Debug, Deserialize)]
pub struct LoadMetadata {
    pub format: Option<String>,
    pub hash_input_file: Option<String>,
}

#[derive(Debug, Serialize)]
pub struct StatusResponse {
    pub log_level: String,
    pub no_admin_key: bool,
    pub local: bool,
    pub enable_metrics: bool,
    pub original_length: u16,
    pub metadata_length: u16,
    pub file_hash: String,
    pub file_date: String,
    pub file_key_count: u32,
    pub key_length: u16,
    pub key_prefix: String,
}

#[cfg(test)]
mod api_key_tests {
    use super::*;
    use crate::utils;

    #[test]
    fn test_api_key_new_valid() {
        let key = "prefix12345";
        let api_key = ApiKey::new(key, 11, "prefix");
        assert!(api_key.is_some());
    }

    #[test]
    fn test_api_key_new_invalid_length() {
        let key = "prefix1";
        let api_key = ApiKey::new(key, 10, "prefix");
        assert!(api_key.is_none());
    }

    #[test]
    fn test_api_key_new_invalid_prefix() {
        let key = "noprefix123";
        let api_key = ApiKey::new(key, 11, "prefix");
        assert!(api_key.is_none());
    }

    #[test]
    fn test_api_key_hash() {
        let key = "testkey";
        let api_key = ApiKey::new(key, 7, "test").unwrap();
        assert_eq!(api_key.hash(), utils::sha256_hex(key));
    }
}

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

    #[test]
    fn test_key_format_from_str() {
        assert_eq!(KeyFormat::from_str("sha256"), Some(KeyFormat::Sha256));
        assert_eq!(KeyFormat::from_str("plain"), Some(KeyFormat::Plain));
        assert_eq!(KeyFormat::from_str("unknown"), None);
    }

    #[test]
    fn test_key_format_as_str() {
        assert_eq!(KeyFormat::Sha256.as_str(), "sha256");
        assert_eq!(KeyFormat::Plain.as_str(), "plain");
    }
}