use std::{fmt, future::Future, sync::Arc, time::Duration};
use axum::{
http::{self, HeaderMap, HeaderValue, Method, StatusCode, Uri},
response::Response,
};
use chrono::{DateTime, Utc};
use futures_util::future::BoxFuture;
use crate::{
config::{AccessKeyId, S3Action},
error::S3Error,
s3::types::{BucketName, ObjectKey, PartNumber, RequestId, S3Operation, UploadId},
};
pub type SharedRequestObserver = Arc<dyn RequestObserver>;
pub type SharedErrorMapper = Arc<dyn ErrorMapper>;
pub type SharedRequestIdFactory = Arc<dyn RequestIdFactory>;
pub type SharedAuthorizationPolicy = Arc<dyn AuthorizationPolicy>;
pub type SharedAuthenticationProvider = Arc<dyn AuthenticationProvider>;
pub type SharedOperationPolicy = Arc<dyn OperationPolicy>;
pub type SharedTargetPolicy = Arc<dyn TargetPolicy>;
pub type SharedUploadPolicy = Arc<dyn UploadPolicy>;
pub type SharedResponseMapper = Arc<dyn ResponseMapper>;
pub type SharedClock = Arc<dyn Clock>;
pub type SharedTenantLimitsProvider = Arc<dyn TenantLimitsProvider>;
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum RequestPrincipal {
Anonymous,
AccessKey {
access_key_id: AccessKeyId,
},
Custom {
id: String,
},
}
const MAX_TENANT_ID_LEN: usize = 256;
#[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
pub struct TenantId(String);
impl TenantId {
pub fn new(value: impl Into<String>) -> Self {
Self(value.into())
}
pub fn parse(value: impl Into<String>) -> Result<Self, TenantIdError> {
let value = value.into();
validate_tenant_id(&value)?;
Ok(Self(value))
}
pub fn as_str(&self) -> &str {
&self.0
}
pub(crate) fn from_principal(principal: &RequestPrincipal) -> Result<Self, TenantIdError> {
match principal {
RequestPrincipal::Anonymous => Self::parse("anonymous"),
RequestPrincipal::AccessKey { access_key_id } => Self::parse(access_key_id.as_str()),
RequestPrincipal::Custom { id } => Self::parse(id.clone()),
}
}
}
impl From<&RequestPrincipal> for TenantId {
fn from(principal: &RequestPrincipal) -> Self {
match principal {
RequestPrincipal::Anonymous => Self::new("anonymous"),
RequestPrincipal::AccessKey { access_key_id } => {
Self::new(access_key_id.as_str().to_owned())
}
RequestPrincipal::Custom { id } => Self::new(id.clone()),
}
}
}
impl fmt::Display for TenantId {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
formatter.write_str(&self.0)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum TenantIdError {
Empty,
TooLong {
max_len: usize,
},
ControlCharacter,
}
impl fmt::Display for TenantIdError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Empty => formatter.write_str("tenant ID must not be empty"),
Self::TooLong { max_len } => {
write!(formatter, "tenant ID must be at most {max_len} bytes")
}
Self::ControlCharacter => {
formatter.write_str("tenant ID must not contain control characters")
}
}
}
}
impl std::error::Error for TenantIdError {}
fn validate_tenant_id(value: &str) -> Result<(), TenantIdError> {
if value.is_empty() {
return Err(TenantIdError::Empty);
}
if value.len() > MAX_TENANT_ID_LEN {
return Err(TenantIdError::TooLong {
max_len: MAX_TENANT_ID_LEN,
});
}
if value.chars().any(char::is_control) {
return Err(TenantIdError::ControlCharacter);
}
Ok(())
}
#[derive(Clone, Debug)]
pub struct AuthenticationRequest {
pub method: Method,
pub uri: Uri,
pub headers: HeaderMap,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AuthenticationResult {
principal: RequestPrincipal,
access_key_id: Option<AccessKeyId>,
}
impl AuthenticationResult {
pub fn anonymous() -> Self {
Self {
principal: RequestPrincipal::Anonymous,
access_key_id: None,
}
}
pub fn access_key(access_key_id: AccessKeyId) -> Self {
Self {
principal: RequestPrincipal::AccessKey {
access_key_id: access_key_id.clone(),
},
access_key_id: Some(access_key_id),
}
}
pub fn custom(id: impl Into<String>) -> Self {
Self {
principal: RequestPrincipal::Custom { id: id.into() },
access_key_id: None,
}
}
pub fn try_custom(id: impl Into<String>) -> Result<Self, TenantIdError> {
let tenant = TenantId::parse(id)?;
Ok(Self::custom(tenant.as_str().to_owned()))
}
pub fn principal(&self) -> &RequestPrincipal {
&self.principal
}
pub(crate) fn into_parts(self) -> (RequestPrincipal, Option<AccessKeyId>) {
(self.principal, self.access_key_id)
}
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct S3RequestContext {
pub request_id: RequestId,
pub method: Method,
pub operation: String,
pub bucket: Option<BucketName>,
pub key: Option<ObjectKey>,
pub upload_id: Option<UploadId>,
pub part_number: Option<PartNumber>,
pub content_length: Option<u64>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct S3ErrorContext {
pub request_id: RequestId,
pub operation: String,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct S3ResponseContext {
pub request_id: RequestId,
pub operation: String,
pub bucket: Option<BucketName>,
pub key: Option<ObjectKey>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct AuthorizationContext {
pub principal: RequestPrincipal,
pub bucket: BucketName,
pub key: Option<ObjectKey>,
pub action: S3Action,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct OperationContext {
pub operation: S3Operation,
pub action: S3Action,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TargetContext {
pub bucket: BucketName,
pub key: Option<ObjectKey>,
pub action: S3Action,
}
#[derive(Clone, Debug)]
pub struct UploadPolicyContext {
pub request_id: RequestId,
pub bucket: BucketName,
pub key: ObjectKey,
pub action: S3Action,
pub headers: HeaderMap,
}
pub fn redacted_headers(headers: &HeaderMap) -> HeaderMap {
let mut redacted = headers.clone();
for name in [
http::header::AUTHORIZATION.as_str(),
"proxy-authorization",
"x-api-key",
"x-auth-token",
"x-amz-security-token",
"x-amz-server-side-encryption-customer-key",
"x-amz-server-side-encryption-customer-key-md5",
"x-amz-server-side-encryption-context",
] {
if redacted.contains_key(name) {
redacted.insert(name, HeaderValue::from_static("<redacted>"));
}
}
redacted
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TenantLimitContext {
pub request_id: RequestId,
pub tenant: TenantId,
pub principal: RequestPrincipal,
pub method: Method,
pub operation: S3Operation,
pub action: S3Action,
pub bucket: Option<BucketName>,
pub key: Option<ObjectKey>,
pub upload_id: Option<UploadId>,
pub part_number: Option<PartNumber>,
pub content_length: Option<u64>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct TenantOperationOutcome {
pub status: StatusCode,
pub timed_out: bool,
pub error_code: Option<String>,
pub error_message: Option<String>,
pub decoded_bytes: Option<u64>,
}
impl TenantOperationOutcome {
pub fn success(status: StatusCode, decoded_bytes: Option<u64>) -> Self {
Self {
status,
timed_out: false,
error_code: None,
error_message: None,
decoded_bytes,
}
}
pub fn error(error: &S3Error, decoded_bytes: Option<u64>) -> Self {
Self {
status: error.status(),
timed_out: false,
error_code: Some(error.code().to_owned()),
error_message: Some(error.message().to_owned()),
decoded_bytes,
}
}
pub fn timed_out(error: &S3Error) -> Self {
Self {
status: error.status(),
timed_out: true,
error_code: Some(error.code().to_owned()),
error_message: Some(error.message().to_owned()),
decoded_bytes: None,
}
}
}
pub struct TenantOperationLease {
timeout: Option<Duration>,
_permit: Option<Box<dyn Send + Sync>>,
}
impl TenantOperationLease {
pub fn new() -> Self {
Self {
timeout: None,
_permit: None,
}
}
pub fn with_timeout(timeout: Duration) -> Self {
Self::new().timeout(timeout)
}
pub fn timeout(mut self, timeout: Duration) -> Self {
self.timeout = Some(timeout);
self
}
pub fn permit<P>(mut self, permit: P) -> Self
where
P: Send + Sync + 'static,
{
self._permit = Some(Box::new(permit));
self
}
pub fn timeout_duration(&self) -> Option<Duration> {
self.timeout
}
}
impl Default for TenantOperationLease {
fn default() -> Self {
Self::new()
}
}
pub trait RequestObserver: Send + Sync + 'static {
fn observe<'a>(&'a self, context: S3RequestContext) -> BoxFuture<'a, ()>;
}
pub trait AuthenticationProvider: Send + Sync + 'static {
fn authenticate<'a>(
&'a self,
request: AuthenticationRequest,
) -> BoxFuture<'a, Result<AuthenticationResult, S3Error>>;
}
impl<F, Fut> AuthenticationProvider for F
where
F: Fn(AuthenticationRequest) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Result<AuthenticationResult, S3Error>> + Send + 'static,
{
fn authenticate<'a>(
&'a self,
request: AuthenticationRequest,
) -> BoxFuture<'a, Result<AuthenticationResult, S3Error>> {
Box::pin((self)(request))
}
}
impl<F, Fut> RequestObserver for F
where
F: Fn(S3RequestContext) -> Fut + Send + Sync + 'static,
Fut: Future<Output = ()> + Send + 'static,
{
fn observe<'a>(&'a self, context: S3RequestContext) -> BoxFuture<'a, ()> {
Box::pin((self)(context))
}
}
pub trait ErrorMapper: Send + Sync + 'static {
fn map_error<'a>(&'a self, context: S3ErrorContext, error: S3Error) -> BoxFuture<'a, S3Error>;
}
impl<F, Fut> ErrorMapper for F
where
F: Fn(S3ErrorContext, S3Error) -> Fut + Send + Sync + 'static,
Fut: Future<Output = S3Error> + Send + 'static,
{
fn map_error<'a>(&'a self, context: S3ErrorContext, error: S3Error) -> BoxFuture<'a, S3Error> {
Box::pin((self)(context, error))
}
}
pub trait ResponseMapper: Send + Sync + 'static {
fn map_response<'a>(
&'a self,
context: S3ResponseContext,
response: Response,
) -> BoxFuture<'a, Response>;
}
pub trait TenantLimitsProvider: Send + Sync + 'static {
fn begin_operation<'a>(
&'a self,
context: TenantLimitContext,
) -> BoxFuture<'a, Result<TenantOperationLease, S3Error>>;
fn finish_operation<'a>(
&'a self,
context: TenantLimitContext,
outcome: TenantOperationOutcome,
) -> BoxFuture<'a, ()>;
}
#[derive(Clone, Copy, Debug, Default)]
pub struct NoopTenantLimitsProvider;
impl TenantLimitsProvider for NoopTenantLimitsProvider {
fn begin_operation<'a>(
&'a self,
_context: TenantLimitContext,
) -> BoxFuture<'a, Result<TenantOperationLease, S3Error>> {
Box::pin(async { Ok(TenantOperationLease::new()) })
}
fn finish_operation<'a>(
&'a self,
_context: TenantLimitContext,
_outcome: TenantOperationOutcome,
) -> BoxFuture<'a, ()> {
Box::pin(async {})
}
}
impl<F, Fut> ResponseMapper for F
where
F: Fn(S3ResponseContext, Response) -> Fut + Send + Sync + 'static,
Fut: Future<Output = Response> + Send + 'static,
{
fn map_response<'a>(
&'a self,
context: S3ResponseContext,
response: Response,
) -> BoxFuture<'a, Response> {
Box::pin((self)(context, response))
}
}
pub trait RequestIdFactory: Send + Sync + 'static {
fn request_id(&self) -> RequestId;
}
impl<F> RequestIdFactory for F
where
F: Fn() -> RequestId + Send + Sync + 'static,
{
fn request_id(&self) -> RequestId {
(self)()
}
}
pub trait OperationPolicy: Send + Sync + 'static {
fn allow_operation(&self, context: OperationContext) -> Result<(), S3Error>;
}
impl<F> OperationPolicy for F
where
F: Fn(OperationContext) -> Result<(), S3Error> + Send + Sync + 'static,
{
fn allow_operation(&self, context: OperationContext) -> Result<(), S3Error> {
(self)(context)
}
}
pub trait TargetPolicy: Send + Sync + 'static {
fn allow_target(&self, context: TargetContext) -> Result<(), S3Error>;
}
impl<F> TargetPolicy for F
where
F: Fn(TargetContext) -> Result<(), S3Error> + Send + Sync + 'static,
{
fn allow_target(&self, context: TargetContext) -> Result<(), S3Error> {
(self)(context)
}
}
pub trait UploadPolicy: Send + Sync + 'static {
fn allow_upload(&self, context: UploadPolicyContext) -> Result<(), S3Error>;
}
impl<F> UploadPolicy for F
where
F: Fn(UploadPolicyContext) -> Result<(), S3Error> + Send + Sync + 'static,
{
fn allow_upload(&self, context: UploadPolicyContext) -> Result<(), S3Error> {
(self)(context)
}
}
pub trait AuthorizationPolicy: Send + Sync + 'static {
fn authorize(&self, context: AuthorizationContext) -> Result<(), S3Error>;
}
impl<F> AuthorizationPolicy for F
where
F: Fn(AuthorizationContext) -> Result<(), S3Error> + Send + Sync + 'static,
{
fn authorize(&self, context: AuthorizationContext) -> Result<(), S3Error> {
(self)(context)
}
}
pub trait Clock: Send + Sync + 'static {
fn now(&self) -> DateTime<Utc>;
}
impl<F> Clock for F
where
F: Fn() -> DateTime<Utc> + Send + Sync + 'static,
{
fn now(&self) -> DateTime<Utc> {
(self)()
}
}
#[derive(Clone, Copy, Debug, Default)]
pub struct SystemClock;
impl Clock for SystemClock {
fn now(&self) -> DateTime<Utc> {
Utc::now()
}
}
impl fmt::Display for RequestPrincipal {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
Self::Anonymous => formatter.write_str("anonymous"),
Self::AccessKey { access_key_id } => write!(formatter, "{access_key_id}"),
Self::Custom { id } => formatter.write_str(id),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::AccessKeyId;
#[test]
fn tenant_id_is_derived_from_request_principal() {
assert_eq!(
TenantId::from(&RequestPrincipal::Anonymous).as_str(),
"anonymous"
);
assert_eq!(
TenantId::from(&RequestPrincipal::AccessKey {
access_key_id: AccessKeyId::parse("client-a").expect("access key")
})
.as_str(),
"client-a"
);
assert_eq!(
TenantId::from(&RequestPrincipal::Custom {
id: "tenant-a".to_owned()
})
.as_str(),
"tenant-a"
);
}
#[test]
fn tenant_id_parse_rejects_unsafe_values() {
assert_eq!(TenantId::parse("").unwrap_err(), TenantIdError::Empty);
assert_eq!(
TenantId::parse("tenant\nid").unwrap_err(),
TenantIdError::ControlCharacter
);
assert_eq!(
TenantId::parse("x".repeat(MAX_TENANT_ID_LEN + 1)).unwrap_err(),
TenantIdError::TooLong {
max_len: MAX_TENANT_ID_LEN
}
);
}
#[test]
fn authentication_result_try_custom_validates_id() {
let result = AuthenticationResult::try_custom("tenant-a").expect("custom auth");
assert_eq!(
result.principal(),
&RequestPrincipal::Custom {
id: "tenant-a".to_owned()
}
);
assert_eq!(
AuthenticationResult::try_custom("tenant\rid").unwrap_err(),
TenantIdError::ControlCharacter
);
}
#[test]
fn redacted_headers_masks_sensitive_values() {
let mut headers = HeaderMap::new();
headers.insert(
http::header::AUTHORIZATION,
HeaderValue::from_static("secret"),
);
headers.insert("x-api-key", HeaderValue::from_static("api-secret"));
headers.insert(
http::header::CONTENT_TYPE,
HeaderValue::from_static("text/plain"),
);
let redacted = redacted_headers(&headers);
assert_eq!(
redacted.get(http::header::AUTHORIZATION),
Some(&HeaderValue::from_static("<redacted>"))
);
assert_eq!(
redacted.get("x-api-key"),
Some(&HeaderValue::from_static("<redacted>"))
);
assert_eq!(
redacted.get(http::header::CONTENT_TYPE),
Some(&HeaderValue::from_static("text/plain"))
);
}
}