//! Certificates for short-lived keys (oxygenhub#241, docs/keyless.md,

//! Oxygen spec §14.7): the hub vouches, for ten minutes, for a fresh key

//! whose holder proves who it is with a credential the hub issued. A Flow

//! job asks with its job token; anything else with one of the hub's OIDC

//! tokens for the keyless audience. The key signs, then is thrown away:

//! nothing long-lived sits on a runner.

use crate::api::ApiError;

use crate::{db, Shared};

use axum::extract::State;

use axum::http::{HeaderMap, StatusCode};

use axum::Json;

use oxy_core::cert::{certify_challenge, Certificate, SignedCertificate};

use oxy_core::identity::{verify_challenge, Identity, Scope, Signature};

use serde::{Deserialize, Serialize};

/// How long a certificate lasts.

pub const LIFETIME_MS: i64 = 10 * 60 * 1000;

/// How far back a certificate starts, for clocks a little behind.

const SKEW_MS: i64 = 30 * 1000;

/// The OIDC audience a token must have to be exchanged here.

pub fn audience(base_url: &str) -> String {

    format!("{}/keyless", base_url.trim_end_matches('/'))

}

#[derive(Deserialize)]

pub struct CertifyRequest {

    /// The fresh key's identity object, base64.

    pub identity: String,

    /// The key's signature over `certify_challenge(credential)`, base64 CBOR.

    pub proof: String,

    /// `changes,refs` and so on.

    pub scope: String,

}

#[derive(Serialize)]

pub struct CertifyResponse {

    /// The signed certificate, base64 (`[certificate, signature]`).

    pub certificate: String,

    pub subject: String,

    pub expires_ms: i64,

}

/// Who a credential says its holder is.

struct Proven {

    subject: String,

    claims: Vec<(String, String)>,

    /// The credential's own end, which a certificate never outlives.

    until_ms: i64,

    target: String,

}

fn bad(status: StatusCode, why: impl Into<String>) -> ApiError {

    ApiError(status, why.into())

}

/// A running job's token: its repository, bookmark, run and job.

async fn job_proof(app: &Shared, token: &str) -> Result<Proven, ApiError> {

    let invalid = || bad(StatusCode::UNAUTHORIZED, "this job token is not valid (the job must be running)");

    let hash = crate::auth::token_hash(token);

    let job = db::flow::job_by_token(&app.db, &hash, crate::flow::JOB_TOKEN_MAX_AGE_MS)

        .await

        .map_err(|e| bad(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?

        .ok_or_else(invalid)?;

    let run = db::flow::run_by_id(&app.db, job.run_id)

        .await

        .map_err(|e| bad(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?

        .ok_or_else(invalid)?;

    let repo = db::repos::get_by_id(&app.db, run.repo_id)

        .await

        .map_err(|e| bad(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?

        .ok_or_else(invalid)?;

    let mut claims = vec![

        ("repository".to_string(), format!("{}/{}", repo.owner, repo.name)),

        ("bookmark".to_string(), run.bookmark.clone()),

        ("run".to_string(), run.number.to_string()),

        ("job".to_string(), job.name.clone()),

        ("runner".to_string(), job.runner.clone()),

    ];

    if !job.environment.is_empty() && !job.approved_by.is_empty() {

        claims.push(("environment".to_string(), job.environment.clone()));

        claims.push(("approved_by".to_string(), job.approved_by.clone()));

    }

    Ok(Proven {

        subject: format!("repo:{}/{}:bookmark:{}", repo.owner, repo.name, run.bookmark),

        claims,

        until_ms: job.started_ms.unwrap_or(0) + crate::flow::JOB_TOKEN_MAX_AGE_MS,

        target: format!("{}/{}", repo.owner, repo.name),

    })

}

/// One of this hub's OIDC tokens for the keyless audience.

async fn oidc_proof(app: &Shared, token: &str, now: i64) -> Result<Proven, ApiError> {

    let issuer = app.oidc().await.map_err(|e| bad(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let aud = audience(app.config.base_url());

    let claims = issuer

        .verify(token, &aud, now)

        .ok_or_else(|| bad(StatusCode::UNAUTHORIZED, format!("the token is not one of this hub's, for audience {aud}, still valid")))?;

    let subject = claims["sub"].as_str().unwrap_or("").to_string();

    if subject.is_empty() {

        return Err(bad(StatusCode::UNAUTHORIZED, "the token names no subject"));

    }

    let keep = ["repository", "bookmark", "run_number", "job", "runner", "environment", "approved_by"];

    let mut out = Vec::new();

    for k in keep {

        match &claims[k] {

            serde_json::Value::String(s) => out.push((k.to_string(), s.clone())),

            serde_json::Value::Number(n) => out.push((k.to_string(), n.to_string())),

            _ => {}

        }

    }

    Ok(Proven {

        target: claims["repository"].as_str().unwrap_or(&subject).to_string(),

        subject,

        claims: out,

        until_ms: claims["exp"].as_i64().unwrap_or(0) * 1000,

    })

}

/// `POST /api/v1/keyless/certify`: a ten-minute certificate for a fresh

/// key, for whoever the bearer credential proves.

pub async fn certify(

    State(app): State<Shared>,

    headers: HeaderMap,

    Json(req): Json<CertifyRequest>,

) -> Result<Json<CertifyResponse>, ApiError> {

    let token = oxy_server::bearer_token(&headers)

        .ok_or_else(|| bad(StatusCode::UNAUTHORIZED, "ask with a job token or one of this hub's OIDC tokens as the bearer"))?

        .to_string();

    let now = db::now_ms();

    let proven = if token.starts_with(crate::flow::JOB_TOKEN_PREFIX) {

        job_proof(&app, &token).await?

    } else {

        oidc_proof(&app, &token, now).await?

    };

    let decode = |what: &str, b64: &str| {

        oxy_core::dsse::base64_decode(b64.trim()).ok_or_else(|| bad(StatusCode::BAD_REQUEST, format!("{what} is not base64")))

    };

    let identity =

        Identity::decode(&decode("identity", &req.identity)?).map_err(|e| bad(StatusCode::BAD_REQUEST, format!("identity: {e}")))?;

    let proof = oxy_core::cbor::decode(&decode("proof", &req.proof)?)

        .map_err(|e| e.to_string())

        .and_then(|v| Signature::from_value(&v).map_err(|e| e.to_string()))

        .map_err(|e| bad(StatusCode::BAD_REQUEST, format!("proof: {e}")))?;

    verify_challenge(&identity, &proof, &certify_challenge(&token))

        .map_err(|e| bad(StatusCode::UNAUTHORIZED, format!("the proof does not show this key's holder asked: {e}")))?;

    let scope = Scope::parse(&req.scope).map_err(|e| bad(StatusCode::BAD_REQUEST, e))?;

    let expires = (now + LIFETIME_MS).min(proven.until_ms);

    if expires <= now {

        return Err(bad(StatusCode::UNAUTHORIZED, "the credential is about to expire: ask with a fresh one"));

    }

    let (key, secret) =

        crate::keys::load_secret(&app.config.keys_dir()).map_err(|e| bad(StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;

    let cert = Certificate {

        key: identity,

        issuer: key,

        subject: proven.subject.clone(),

        claims: proven.claims,

        scope,

        not_before: (now - SKEW_MS) as u64,

        expires: expires as u64,

    };

    let signed = SignedCertificate::sign(cert, &app.hub_key.identity, &secret);

    let detail = format!("{} for {} until {}", signed.cert.key_id().short(12), proven.subject, expires);

    db::accounts::audit(&app.db, None, "keyless.certified", &proven.target, &detail).await.ok();

    Ok(Json(CertifyResponse { certificate: oxy_core::dsse::base64(&signed.encode()), subject: proven.subject, expires_ms: expires }))

}