use std::fmt;
use std::marker::PhantomData;
use std::sync::Arc;
use lambda_http::RequestExt as _;
use lambda_http::request::RequestContext;
use serde_json::{Map, Value};
use super::StatusCode;
use super::codes;
use super::failure::{ErrorDefinition, Failure, FailureKind};
use super::policy::Policy;
use super::request::Request;
use crate::Invocation;
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct Claims(Map<String, Value>);
impl Claims {
#[must_use]
pub fn new(claims: Map<String, Value>) -> Self {
Self(claims)
}
#[must_use]
pub fn get(&self, name: &str) -> Option<&Value> {
self.0.get(name)
}
#[must_use]
pub fn string(&self, name: &str) -> Option<&str> {
self.0.get(name).and_then(Value::as_str)
}
#[must_use]
pub fn subject(&self) -> Option<&str> {
self.string("sub")
}
#[must_use]
pub fn list(&self, name: &str) -> Vec<String> {
match self.0.get(name) {
Some(Value::Array(items)) => items.iter().filter_map(item_text).collect(),
Some(Value::String(text)) => split_list(text),
_ => Vec::new(),
}
}
#[must_use]
pub fn contains(&self, name: &str, value: &str) -> bool {
self.list(name).iter().any(|item| item == value)
}
#[must_use]
pub fn all(&self) -> &Map<String, Value> {
&self.0
}
#[must_use]
pub fn from_gateway(request: &Request<'_>) -> Option<Self> {
match request.native().request_context_ref()? {
RequestContext::ApiGatewayV2(context) => {
let authorizer = context.authorizer.clone()?;
if let Some(jwt) = authorizer.jwt.filter(|jwt| !jwt.claims.is_empty()) {
return Some(Self::new(
jwt.claims
.into_iter()
.map(|(name, value)| (name, Value::String(value)))
.collect(),
));
}
(!authorizer.fields.is_empty())
.then(|| Self::new(authorizer.fields.into_iter().collect()))
}
#[cfg(feature = "apigw-rest")]
RequestContext::ApiGatewayV1(context) => {
let mut fields = context.authorizer.fields.clone();
if let Some(Value::Object(claims)) = fields.remove("claims") {
return Some(Self::new(claims));
}
(!fields.is_empty()).then(|| Self::new(fields.into_iter().collect()))
}
#[allow(unreachable_patterns)]
_ => None,
}
}
}
impl Claims {
#[must_use]
pub fn from_gateway_token(request: &Request<'_>) -> Option<Self> {
let gateway = Self::from_gateway(request)?;
let issuer = gateway.string("iss")?;
let token = request.header("authorization").and_then(bearer_token)?;
let claims = unverified_payload(token)?;
let agrees = claims.get("iss").and_then(Value::as_str) == Some(issuer)
&& claims
.iter()
.all(|(name, value)| match (value, gateway.string(name)) {
(Value::String(own), Some(verified)) => own == verified,
_ => true,
});
agrees.then(|| Self::new(claims))
}
}
const MAX_GATEWAY_TOKEN_BYTES: usize = 8 * 1024;
fn unverified_payload(token: &str) -> Option<Map<String, Value>> {
use base64::Engine as _;
if token.len() > MAX_GATEWAY_TOKEN_BYTES {
return None;
}
let mut parts = token.split('.');
let (_header, payload, _signature) = (parts.next()?, parts.next()?, parts.next()?);
if parts.next().is_some() {
return None;
}
let bytes = base64::engine::general_purpose::URL_SAFE_NO_PAD
.decode(payload)
.ok()?;
serde_json::from_slice(&bytes).ok()
}
impl From<Map<String, Value>> for Claims {
fn from(claims: Map<String, Value>) -> Self {
Self(claims)
}
}
fn item_text(item: &Value) -> Option<String> {
match item {
Value::String(text) => Some(text.clone()),
Value::Number(number) => Some(number.to_string()),
Value::Bool(flag) => Some(flag.to_string()),
_ => None,
}
}
fn split_list(text: &str) -> Vec<String> {
let text = text.trim();
if let Ok(Value::Array(items)) = serde_json::from_str::<Value>(text) {
return items.iter().filter_map(item_text).collect();
}
let inner = text
.strip_prefix('[')
.and_then(|rest| rest.strip_suffix(']'))
.unwrap_or(text);
inner
.split(|c: char| c.is_whitespace() || c == ',')
.filter(|part| !part.is_empty())
.map(str::to_owned)
.collect()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct Refusals {
pub invalid_token: ErrorDefinition,
pub unauthenticated: ErrorDefinition,
pub forbidden: ErrorDefinition,
pub tenant_required: ErrorDefinition,
}
impl Default for Refusals {
fn default() -> Self {
Self {
invalid_token: ErrorDefinition::new(
codes::INVALID_TOKEN,
StatusCode::UNAUTHORIZED,
"The access token is invalid or expired",
),
unauthenticated: ErrorDefinition::new(
codes::UNAUTHENTICATED,
StatusCode::UNAUTHORIZED,
"Authentication is required",
),
forbidden: ErrorDefinition::new(
codes::FORBIDDEN,
StatusCode::FORBIDDEN,
"Access denied",
),
tenant_required: ErrorDefinition::new(
codes::TENANT_REQUIRED,
StatusCode::BAD_REQUEST,
"A tenant must be selected",
),
}
}
}
type Member<C> = Arc<dyn Fn(&C, &str) -> bool + Send + Sync>;
type Fallback<C> = Arc<dyn Fn(&C) -> Option<String> + Send + Sync>;
pub struct Tenancy<C> {
header: String,
member: Member<C>,
fallback: Option<Fallback<C>>,
public: bool,
}
impl<C> Tenancy<C> {
#[must_use]
pub fn header(
name: impl Into<String>,
member: impl Fn(&C, &str) -> bool + Send + Sync + 'static,
) -> Self {
Self {
header: name.into(),
member: Arc::new(member),
fallback: None,
public: false,
}
}
#[must_use]
pub fn public(mut self) -> Self {
self.public = true;
self
}
#[must_use]
pub fn or_else(
mut self,
fallback: impl Fn(&C) -> Option<String> + Send + Sync + 'static,
) -> Self {
self.fallback = Some(Arc::new(fallback));
self
}
fn select(
&self,
request: &Request<'_>,
caller: Option<&C>,
forbidden: ErrorDefinition,
) -> Result<Option<String>, Failure> {
let requested = request
.header(&self.header)
.map(str::trim)
.filter(|value| !value.is_empty());
match (requested, caller) {
(Some(tenant), Some(caller)) if !(self.member)(caller, tenant) => {
Err(refusal(forbidden))
}
(Some(_), None) if !self.public => Err(refusal(forbidden)),
(Some(tenant), _) => Ok(Some(tenant.to_owned())),
(None, Some(caller)) => {
let tenant = self.fallback.as_ref().and_then(|fallback| fallback(caller));
if tenant
.as_deref()
.is_some_and(|tenant| !(self.member)(caller, tenant))
{
return Err(refusal(forbidden));
}
Ok(tenant)
}
(None, None) => Ok(None),
}
}
}
impl<C> fmt::Debug for Tenancy<C> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Tenancy")
.field("header", &self.header)
.field("fallback", &self.fallback.is_some())
.field("public", &self.public)
.finish_non_exhaustive()
}
}
pub trait Requirement<T>: sealed::Sealed<T> + Sized {
const REQUIRED: bool;
fn fulfill(found: Option<T>) -> Option<Self>;
}
impl<T> Requirement<T> for Option<T> {
const REQUIRED: bool = false;
fn fulfill(found: Option<T>) -> Option<Self> {
Some(found)
}
}
impl<T> Requirement<T> for T {
const REQUIRED: bool = true;
fn fulfill(found: Option<T>) -> Option<Self> {
found
}
}
impl Requirement<String> for () {
const REQUIRED: bool = false;
fn fulfill(_found: Option<String>) -> Option<Self> {
Some(())
}
}
mod sealed {
pub trait Sealed<T> {}
impl<T> Sealed<T> for Option<T> {}
impl<T> Sealed<T> for T {}
impl Sealed<String> for () {}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Grant<Who, Where> {
caller: Who,
tenant: Where,
}
impl<Who, Where> Grant<Who, Where> {
pub fn caller(&self) -> &Who {
&self.caller
}
pub fn tenant(&self) -> &Where {
&self.tenant
}
pub fn into_parts(self) -> (Who, Where) {
(self.caller, self.tenant)
}
}
type Identify<C> = Arc<dyn Fn(&Claims) -> Option<C> + Send + Sync>;
type Permit<C> = Arc<dyn Fn(Option<&C>, Option<&str>) -> bool + Send + Sync>;
pub struct Access<C, Who = Option<C>, Where = ()> {
identify: Identify<C>,
gateway: bool,
gateway_token: bool,
#[cfg(feature = "auth")]
verifier: Option<Arc<crate::auth::Verifier>>,
tenancy: Option<Tenancy<C>>,
permit: Option<Permit<C>>,
refusals: Refusals,
guarantees: PhantomData<fn() -> (Who, Where)>,
}
impl<C> Access<C> {
#[must_use]
pub fn new(identify: impl Fn(&Claims) -> Option<C> + Send + Sync + 'static) -> Self {
Self {
identify: Arc::new(identify),
gateway: true,
gateway_token: false,
#[cfg(feature = "auth")]
verifier: None,
tenancy: None,
permit: None,
refusals: Refusals::default(),
guarantees: PhantomData,
}
}
}
impl<C, Who, Where> Access<C, Who, Where> {
#[must_use]
pub fn gateway_claims(mut self, trust: bool) -> Self {
self.gateway = trust;
self
}
#[must_use]
pub fn gateway_token_claims(mut self, read: bool) -> Self {
self.gateway_token = read;
self
}
#[cfg(feature = "auth")]
#[must_use]
pub fn verify_bearer(mut self, verifier: Arc<crate::auth::Verifier>) -> Self {
self.verifier = Some(verifier);
self
}
#[must_use]
pub fn permit(
mut self,
rule: impl Fn(Option<&C>, Option<&str>) -> bool + Send + Sync + 'static,
) -> Self {
self.permit = Some(Arc::new(rule));
self
}
#[must_use]
pub fn refusals(mut self, refusals: Refusals) -> Self {
self.refusals = refusals;
self
}
fn guarantee<W, T>(self) -> Access<C, W, T> {
Access {
identify: self.identify,
gateway: self.gateway,
gateway_token: self.gateway_token,
#[cfg(feature = "auth")]
verifier: self.verifier,
tenancy: self.tenancy,
permit: self.permit,
refusals: self.refusals,
guarantees: PhantomData,
}
}
}
impl<C, Where> Access<C, Option<C>, Where> {
#[must_use]
pub fn require_caller(self) -> Access<C, C, Where> {
self.guarantee()
}
}
impl<C, Who> Access<C, Who, ()> {
#[must_use]
pub fn tenancy(mut self, tenancy: Tenancy<C>) -> Access<C, Who, Option<String>> {
self.tenancy = Some(tenancy);
self.guarantee()
}
}
impl<C, Who> Access<C, Who, Option<String>> {
#[must_use]
pub fn require_tenant(self) -> Access<C, Who, String> {
self.guarantee()
}
}
impl<C, Who, Where> Access<C, Who, Where> {
async fn identify(&self, request: &Request<'_>) -> Result<Option<C>, Failure> {
if self.gateway {
let claims = self
.gateway_token
.then(|| Claims::from_gateway_token(request))
.flatten()
.or_else(|| Claims::from_gateway(request));
if let Some(caller) = claims.and_then(|claims| (self.identify)(&claims)) {
return Ok(Some(caller));
}
}
#[cfg(feature = "auth")]
if let Some(verifier) = &self.verifier
&& let Some(token) = request.header("authorization").and_then(bearer_token)
{
let verified = verifier
.verify(token)
.await
.map_err(|_| refusal(self.refusals.invalid_token))?;
let claims = Claims::new(verified.all().clone());
return (self.identify)(&claims)
.map(Some)
.ok_or_else(|| refusal(self.refusals.invalid_token));
}
Ok(None)
}
}
impl<C, Who, Where> Policy for Access<C, Who, Where>
where
C: Send + 'static,
Who: Requirement<C> + Send + 'static,
Where: Requirement<String> + Send + 'static,
{
type Scope = Grant<Who, Where>;
async fn authorize(
&self,
request: &Request<'_>,
_invocation: &Invocation,
) -> Result<Self::Scope, Failure> {
let caller = self.identify(request).await?;
if Who::REQUIRED && caller.is_none() {
return Err(refusal(self.refusals.unauthenticated));
}
let tenant = match &self.tenancy {
Some(tenancy) => tenancy.select(request, caller.as_ref(), self.refusals.forbidden)?,
None => None,
};
if Where::REQUIRED && tenant.is_none() {
return Err(refusal(self.refusals.tenant_required));
}
if let Some(permit) = &self.permit
&& !permit(caller.as_ref(), tenant.as_deref())
{
return Err(refusal(self.refusals.forbidden));
}
let caller = Who::fulfill(caller).ok_or_else(|| refusal(self.refusals.unauthenticated))?;
let tenant =
Where::fulfill(tenant).ok_or_else(|| refusal(self.refusals.tenant_required))?;
Ok(Grant { caller, tenant })
}
}
impl<C, Who, Where> fmt::Debug for Access<C, Who, Where> {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
let mut debug = f.debug_struct("Access");
debug
.field("gateway_claims", &self.gateway)
.field("gateway_token_claims", &self.gateway_token);
#[cfg(feature = "auth")]
debug.field("verify_bearer", &self.verifier.is_some());
debug
.field("tenancy", &self.tenancy)
.field("permit", &self.permit.is_some())
.field("refusals", &self.refusals)
.finish_non_exhaustive()
}
}
fn refusal(definition: ErrorDefinition) -> Failure {
definition.failure().with_kind(FailureKind::Policy)
}
fn bearer_token(value: &str) -> Option<&str> {
let value = value.trim();
match value.split_once(char::is_whitespace) {
Some((scheme, token)) if scheme.eq_ignore_ascii_case("bearer") => {
Some(token.trim()).filter(|token| !token.is_empty())
}
Some(_) => None,
None => Some(value).filter(|token| token.contains('.')),
}
}