use base64::{engine::general_purpose::URL_SAFE, Engine as _};
use hmac::{Hmac, Mac as _};
use serde::Serialize;
use sha1::Sha1;
use crate::error::Result;
type HmacSha1 = Hmac<Sha1>;
pub(crate) fn urlsafe_b64(data: &[u8]) -> String {
URL_SAFE.encode(data)
}
#[derive(Clone)]
pub struct Mac {
access_key: String,
secret_key: String,
}
impl std::fmt::Debug for Mac {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("Mac")
.field("access_key", &self.access_key)
.field("secret_key", &"[redacted]")
.finish()
}
}
impl Mac {
pub fn new(access_key: impl Into<String>, secret_key: impl Into<String>) -> Self {
Mac {
access_key: access_key.into(),
secret_key: secret_key.into(),
}
}
fn hmac_raw(&self, data: &[u8]) -> Vec<u8> {
let mut mac = HmacSha1::new_from_slice(self.secret_key.as_bytes())
.expect("HMAC accepts any key length");
mac.update(data);
mac.finalize().into_bytes().to_vec()
}
fn sign(&self, data: &str) -> String {
format!(
"{}:{}",
self.access_key,
urlsafe_b64(&self.hmac_raw(data.as_bytes()))
)
}
pub fn access_key(&self) -> &str {
&self.access_key
}
pub fn upload_token(&self, policy: &PutPolicy) -> Result<String> {
let json = serde_json::to_vec(policy)?;
let encoded_policy = urlsafe_b64(&json);
let encoded_sign = urlsafe_b64(&self.hmac_raw(encoded_policy.as_bytes()));
Ok(format!(
"{}:{}:{}",
self.access_key, encoded_sign, encoded_policy
))
}
pub fn qbox_authorization(&self, signing_str: &str) -> String {
format!("QBox {}", self.sign(signing_str))
}
pub fn up_authorization(upload_token: &str) -> String {
format!("UpToken {upload_token}")
}
pub fn private_download_url(
&self,
base_url: &str,
encoded_path: &str,
deadline: i64,
) -> String {
let sign_data = format!("{encoded_path}?e={deadline}");
let token = self.sign(&sign_data);
let sep = if base_url.contains('?') { '&' } else { '?' };
format!("{base_url}{sep}e={deadline}&token={token}")
}
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct PutPolicy {
pub scope: String,
pub deadline: i64,
#[serde(skip_serializing_if = "Option::is_none")]
pub insert_only: Option<u8>,
#[serde(skip_serializing_if = "Option::is_none")]
pub save_key: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mime_types: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub fsize_limit: Option<u64>,
#[serde(skip_serializing_if = "Option::is_none")]
pub return_body: Option<String>,
}
impl PutPolicy {
pub fn for_bucket(bucket: &str, deadline: i64) -> Self {
PutPolicy {
scope: bucket.to_string(),
deadline,
insert_only: None,
save_key: None,
mime_types: None,
fsize_limit: None,
return_body: None,
}
}
pub fn for_key(bucket: &str, key: &str, deadline: i64) -> Self {
PutPolicy {
scope: format!("{bucket}:{key}"),
..Self::for_bucket(bucket, deadline)
}
}
pub fn insert_only(mut self, on: bool) -> Self {
self.insert_only = if on { Some(1) } else { None };
self
}
}