,
35 | }
36 |
37 | #[derive(Deserialize)]
38 | #[serde(rename_all = "kebab-case")]
39 | /// Struct holding the jaeger specific configuration values
40 | pub struct ConfigurationJaeger {
41 | pub active: bool,
42 | pub host: String,
43 | pub port: u16,
44 | }
45 |
46 | #[derive(Deserialize)]
47 | #[serde(rename_all = "kebab-case")]
48 | /// Struct holding the ratelimit specific configuration values
49 | pub struct ConfigurationRatelimit {
50 | pub active: bool,
51 |
52 | pub authentication_quota: u32,
53 | pub registration_quota: u32,
54 | }
55 |
56 | #[derive(Deserialize)]
57 | #[serde(rename_all = "kebab-case")]
58 | /// Struct holding the HTTP server specific configuration values
59 | pub struct ConfigurationServer {
60 | pub interface: String,
61 | pub port: u16,
62 |
63 | pub database_url: String,
64 | }
65 |
66 | #[derive(Deserialize)]
67 | #[serde(rename_all = "kebab-case")]
68 | /// Struct holding the TLS specific configuration values
69 | pub struct ConfigurationTls {
70 | pub serve_tls_directly: bool,
71 |
72 | pub certificate: String,
73 | pub secret_key: String,
74 | }
75 |
76 | #[derive(Deserialize)]
77 | #[serde(rename_all = "kebab-case")]
78 | /// Struct holding the configuration values
79 | pub struct Configuration {
80 | pub email: ConfigurationEmail,
81 | pub instance: ConfigurationInstance,
82 | pub jaeger: ConfigurationJaeger,
83 | pub ratelimit: ConfigurationRatelimit,
84 | pub server: ConfigurationServer,
85 | pub tls: ConfigurationTls,
86 | }
87 |
88 | /// Load the configuration from the path
89 | pub async fn load(config_path: P) -> Configuration
90 | where
91 | P: AsRef,
92 | {
93 | let config_file = File::open(config_path)
94 | .await
95 | .expect("Couldn't open configuration file");
96 | let mut config_file = BufReader::new(config_file);
97 |
98 | let mut data = Vec::new();
99 | config_file
100 | .read_to_end(&mut data)
101 | .await
102 | .expect("Couldn't read configuration file");
103 |
104 | toml::from_slice(data.as_slice()).expect("Invalid TOML")
105 | }
106 |
--------------------------------------------------------------------------------
/tranquility/src/consts.rs:
--------------------------------------------------------------------------------
1 | pub mod activitypub {
2 | pub const ACTIVITIES_PER_PAGE: i64 = 10;
3 | }
4 |
5 | pub mod cors {
6 | use http::Method;
7 |
8 | pub const API_ALLOWED_METHODS: &[Method] = &[
9 | Method::POST,
10 | Method::PUT,
11 | Method::DELETE,
12 | Method::GET,
13 | Method::PATCH,
14 | Method::OPTIONS,
15 | ];
16 | pub const GENERAL_ALLOWED_METHODS: &[Method] = &[Method::GET];
17 | pub const OAUTH_TOKEN_ALLOWED_METHODS: &[Method] = &[Method::POST];
18 | }
19 |
20 | pub mod crypto {
21 | pub const KEY_SIZE: usize = 2048;
22 | pub const TOKEN_LENGTH: usize = 40;
23 | }
24 |
25 | pub mod daemon {
26 | use std::time::Duration;
27 |
28 | pub const DELETE_INTERVAL: Duration = Duration::from_secs(60);
29 | }
30 |
31 | pub mod regex {
32 | use crate::r#const;
33 |
34 | r#const!(USERNAME_BASE: &str = r#"[\w]+"#);
35 |
36 | pub const USERNAME: &str = concat!("^", USERNAME_BASE!(), "$");
37 | // Regex101 link (for explaination of the regex): https://regex101.com/r/pyTTsW/1
38 | pub const MENTION: &str = concat!(
39 | r#"(?:^|\W)@(?P"#,
40 | USERNAME_BASE!(),
41 | r#")(?:@(?P[\w\.\-]+[[:alnum:]]+))?"#
42 | );
43 | }
44 |
45 | // Default to 5MB
46 | pub const MAX_BODY_SIZE: u64 = 5 * MB_BYTES;
47 | pub const MB_BYTES: u64 = 1024_u64.pow(2);
48 |
49 | pub const SOFTWARE_NAME: &str = env!("CARGO_PKG_NAME");
50 |
51 | pub const USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
52 | pub const PROPER_VERSION: &str = concat!(
53 | "v",
54 | env!("CARGO_PKG_VERSION"),
55 | "-",
56 | env!("GIT_BRANCH"),
57 | "-",
58 | env!("GIT_COMMIT")
59 | );
60 | pub const VERSION: &str = env!("CARGO_PKG_VERSION");
61 |
--------------------------------------------------------------------------------
/tranquility/src/crypto.rs:
--------------------------------------------------------------------------------
1 | use rand::{
2 | distributions::{Distribution, Standard},
3 | rngs::OsRng,
4 | Rng,
5 | };
6 |
7 | /// Generate a type that supports being generated via `rand::Rng::gen()` using `OsRng`
8 | #[inline]
9 | pub fn gen_secure_rand() -> T
10 | where
11 | Standard: Distribution,
12 | {
13 | OsRng.gen::()
14 | }
15 |
16 | pub mod digest {
17 | use crate::{error::Error, util::cpu_intensive_task};
18 | use reqwest::header::HeaderValue;
19 | use sha2::{Digest, Sha256};
20 |
21 | /// Calculate the digest HTTP header
22 | pub async fn http_header(data: Vec) -> Result {
23 | cpu_intensive_task(move || {
24 | let sha_hash = Sha256::digest(&data);
25 | let base64_encoded_hash = base64::encode(&sha_hash);
26 |
27 | Ok(HeaderValue::from_str(&format!(
28 | "SHA-256={}",
29 | base64_encoded_hash
30 | ))?)
31 | })
32 | .await
33 | }
34 | }
35 |
36 | pub mod password {
37 | use crate::{error::Error, util::cpu_intensive_task};
38 | use argon2::Config;
39 |
40 | /// Hash the password using the standard rust-argon2 config
41 | pub async fn hash(password: String) -> Result {
42 | cpu_intensive_task(move || {
43 | let salt = crate::crypto::gen_secure_rand::<[u8; 32]>();
44 | let config = Config::default();
45 |
46 | Ok(argon2::hash_encoded(password.as_bytes(), &salt, &config)?)
47 | })
48 | .await
49 | }
50 |
51 | /// Verify an encoded password
52 | pub async fn verify(password: String, hash: String) -> bool {
53 | cpu_intensive_task(move || {
54 | argon2::verify_encoded(hash.as_str(), password.as_bytes()).unwrap_or(false)
55 | })
56 | .await
57 | }
58 | }
59 |
60 | pub mod rsa {
61 | use crate::{consts::crypto::KEY_SIZE, error::Error, util::cpu_intensive_task};
62 | use rand::rngs::OsRng;
63 | use rsa::{
64 | pkcs8::{EncodePrivateKey, EncodePublicKey, LineEnding},
65 | RsaPrivateKey,
66 | };
67 |
68 | /// Generate an RSA key pair (key size defined in the `consts` file)
69 | pub async fn generate() -> Result {
70 | cpu_intensive_task(|| Ok(RsaPrivateKey::new(&mut OsRng, KEY_SIZE)?)).await
71 | }
72 |
73 | /// Get the public key from the private key and encode both in the PKCS#8 PEM format
74 | pub fn to_pem(rsa_key: &RsaPrivateKey) -> Result<(String, String), Error> {
75 | let public_key = rsa_key.to_public_key_pem(LineEnding::LF)?;
76 | let private_key = rsa_key.to_pkcs8_pem(LineEnding::LF)?.to_string(); // Having this zeroised would be nice but SQLx has no support at the moment. Maybe there's some workaround?
77 |
78 | Ok((public_key, private_key))
79 | }
80 | }
81 |
82 | pub mod token {
83 | use crate::consts::crypto::TOKEN_LENGTH;
84 |
85 | /// Generate a cryptographically random token (length defined in the `consts` file)
86 | pub fn generate() -> String {
87 | // Two characters are needed to encode one byte as hex
88 | let token = crate::crypto::gen_secure_rand::<[u8; TOKEN_LENGTH / 2]>();
89 |
90 | hex::encode(token)
91 | }
92 | }
93 |
94 | pub mod request {
95 | use crate::{error::Error, util::cpu_intensive_task};
96 | use http::{
97 | self,
98 | header::{HeaderName, HeaderValue},
99 | HeaderMap,
100 | };
101 | use std::future::Future;
102 | use tranquility_http_signatures::Request;
103 |
104 | /// Sign a reqwest HTTP request
105 | pub fn sign(
106 | request: reqwest::Request,
107 | key_id: String,
108 | // The public key is provided in the PEM format
109 | // That's why the function takes a `String`
110 | private_key: String,
111 | ) -> impl Future