use chrono::Utc; use serde::{Deserialize, Serialize}; use serde_json::json; use worker::*; use crate::claim::{self, ClaimError, SitesStore}; use crate::kvmap; use crate::serviceauth::{self, XrpcError}; use crate::sites; fn render_error(e: XrpcError) -> Result { if e.name == "Internal" { console_warn!("xrpc {} error: {}", e.status, e.message); return Response::from_json(&json!({ "error": "Internal", "message": "Internal error" })) .map(|r| r.with_status(500)); } Response::from_json(&json!({ "error": e.name, "message": e.message })) .map(|r| r.with_status(e.status)) } fn ok_json(value: serde_json::Value) -> Result { Response::from_json(&value) .map_err(|e| XrpcError::internal(format!("failed to encode response: {}", e))) } fn internal(msg: String) -> XrpcError { XrpcError::internal(msg) } fn claim_error_to_xrpc(err: ClaimError) -> XrpcError { match err { ClaimError::DomainTaken => XrpcError::new( "DomainTaken", "That domain is already claimed by another user.", 409, ), ClaimError::DomainCooldown => XrpcError::new( "DomainCooldown", "That domain was recently released and is in a 30-day cooldown period.", 409, ), ClaimError::AlreadyClaimed => XrpcError::new( "AlreadyClaimed", "You already have an active domain claim; release it before claiming a new one.", 409, ), ClaimError::InvalidSubdomain => XrpcError::new( "InvalidSubdomain", "Invalid or reserved subdomain. Use a lowercase letter/digit label (1-63 chars, no leading or trailing hyphen) under a supported TLD.", 400, ), ClaimError::DomainPermanent => XrpcError::new( "DomainPermanent", "Your tngl.sh domain is tied to your handle and cannot be released.", 409, ), ClaimError::HandleNotOwned => XrpcError::new( "HandleNotOwned", "That handle belongs to another account.", 403, ), ClaimError::HandleUnknown => XrpcError::new( "HandleUnknown", "No account holds that handle yet. tngl.sh handles are assigned at signup.", 404, ), ClaimError::Store(msg) => internal(format!("database error: {}", msg)), } } fn store(env: &Env) -> Result { let db = env .d1("SITES_DB") .map_err(|_| XrpcError::internal("SITES_DB is not configured"))?; Ok(SitesStore::d1(db)) } fn allowed_tlds(env: &Env) -> Result, XrpcError> { let raw = env .var("SITES_ALLOWED_TLDS") .map_err(|_| XrpcError::internal("SITES_ALLOWED_TLDS is not configured"))? .to_string(); Ok(raw.split(',').map(|s| s.to_string()).collect()) } fn reserved_labels(env: &Env) -> Vec { let audience = env .var("SITES_AUDIENCE_DID") .map(|v| v.to_string()) .unwrap_or_default(); let configured = env .var("SITES_RESERVED_LABELS") .ok() .map(|v| v.to_string()) .filter(|v| !v.is_empty()); claim::reserved_labels(&audience, configured.as_deref()) } fn refs(values: &[String]) -> Vec<&str> { values.iter().map(|s| s.as_str()).collect() } fn query_param(url: &Url, name: &str) -> Option { url.query_pairs() .find(|(k, _)| k == name) .map(|(_, v)| v.into_owned()) } fn require_non_empty(field: &str, value: &str) -> Result { let trimmed = value.trim(); if trimmed.is_empty() { return Err(XrpcError::new( "InvalidRequest", format!("'{}' must not be empty", field), 400, )); } Ok(trimmed.to_string()) } async fn verify_caller(req: &Request, env: &Env, nsid: &str) -> Result { let did = serviceauth::verify(req, env, nsid).await?; if !serviceauth::is_account_did(&did) { return Err(XrpcError::auth( "service auth issuer must be an atproto account DID", )); } Ok(did) } async fn verify_sd(req: &Request, env: &Env, nsid: &str) -> Result { let did = serviceauth::verify(req, env, nsid).await?; let sd = env .var("SITES_SD_DID") .map_err(|_| XrpcError::internal("SITES_SD_DID is not configured"))? .to_string(); if did != sd { return Err(XrpcError::auth("issuer is not the sites deploy service")); } Ok(did) } #[derive(Deserialize)] struct ClaimDomainBody { domain: String, } #[derive(Deserialize)] struct ReleaseDomainBody { domain: String, } #[derive(Deserialize)] struct UpdateSiteConfigBody { #[serde(rename = "repoDid")] repo_did: String, name: String, rkey: String, knot: String, branch: String, dir: String, #[serde(default, rename = "isIndex")] is_index: bool, } #[derive(Deserialize)] struct RepoDidBody { #[serde(rename = "repoDid")] repo_did: String, } #[derive(Deserialize)] struct RecordDeployBody { #[serde(rename = "repoDid")] repo_did: String, branch: String, dir: String, #[serde(rename = "commitSha")] commit_sha: String, status: String, trigger: String, #[serde(default)] error: String, } async fn handle_claim_domain(mut req: Request, env: &Env) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.site.claimDomain").await?; let body: ClaimDomainBody = req .json() .await .map_err(|_| XrpcError::new("InvalidRequest", "request body must be JSON", 400))?; let domain = body.domain.trim().to_string(); let allowed = allowed_tlds(env)?; let reserved = reserved_labels(env); let store = store(env)?; claim::claim_vouched( &store, Utc::now(), &did, &domain, &refs(&allowed), &refs(&reserved), claim::resolve_handle, ) .await .map_err(claim_error_to_xrpc)?; ok_json(json!({ "domain": domain })) } async fn handle_get_domain_claim(req: Request, env: &Env) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.site.getDomainClaim").await?; let store = store(env)?; let Some(domain) = store.active_domain_for_did(&did).await.map_err(internal)? else { return match verified_signup_handle(env, &did).await? { Some(handle) => ok_json(json!({ "domain": handle })), None => ok_json(json!({})), }; }; // only report handle claims the zone still gives this account if !claim::is_handle_domain(&domain) { return ok_json(json!({ "domain": domain })); } let title = claim::handle_title(&domain, &did).await; if title.holds() { return ok_json(json!({ "domain": domain })); } match title { claim::Title::Unverifiable => Err(XrpcError::new( "ClaimUnverifiable", format!( "the zone that owns {} could not be asked, so this claim cannot be shown", domain ), 503, )), _ => ok_json(json!({})), } } async fn handle_release_domain(mut req: Request, env: &Env) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.site.releaseDomain").await?; let body: ReleaseDomainBody = req .json() .await .map_err(|_| XrpcError::new("InvalidRequest", "request body must be JSON", 400))?; let domain = body.domain.trim().to_string(); let store = store(env)?; let active = match store.active_domain_for_did(&did).await { Ok(Some(d)) => d, Ok(None) => { return Err(XrpcError::new( "DomainNotFound", "No active claim on this domain for this account.", 404, )); } Err(e) => return Err(internal(e)), }; if active != domain { return Err(XrpcError::new( "DomainNotFound", "No active claim on this domain for this account.", 404, )); } if claim::is_handle_domain(&domain) { return Err(claim_error_to_xrpc(ClaimError::DomainPermanent)); } match claim::release(&store, Utc::now(), &did, &domain).await { Err(e) => return Err(claim_error_to_xrpc(e)), Ok(false) => { return Err(XrpcError::new( "DomainNotFound", "No active claim on this domain for this account.", 404, )); } Ok(true) => {} } let kv = env .kv("SITES") .map_err(|_| XrpcError::internal("SITES KV is not configured"))?; kv.put(&domain, "") .map_err(|e| internal(e.to_string()))? .execute() .await .map_err(|e| XrpcError::internal(format!("failed to invalidate serving mapping: {}", e)))?; let rows = match store.delete_repos_for_owner(&did).await { Ok(rows) => rows, Err(e) => { console_warn!("releaseDomain: removing site rows failed: {}", e); Vec::new() } }; if let Ok(bucket) = env.bucket("SITES_BUCKET") { for row in &rows { if let Err(e) = kvmap::delete_r2_prefix(&bucket, &format!("{}/{}/", row.owner_did, row.rkey)).await { console_warn!( "releaseDomain: R2 cleanup for {} failed: {}", row.repo_did, e ); } } } ok_json(json!({})) } async fn handle_get_domain_claim_for_did(req: Request, env: &Env) -> Result { let _did = verify_sd(&req, env, "org.tangled.temp.site.getDomainClaimForDid").await?; let url = req.url().map_err(|e| internal(e.to_string()))?; let Some(target) = query_param(&url, "did") else { return Err(XrpcError::new( "InvalidRequest", "missing 'did' query parameter", 400, )); }; let store = store(env)?; match store .active_domain_for_did(&target) .await .map_err(|e| internal(e))? { Some(domain) => ok_json(json!({ "domain": domain })), None => ok_json(json!({})), } } async fn handle_update_site_config( mut req: Request, env: &Env, ctx: &Context, ) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.repo.updateSiteConfig").await?; let body: UpdateSiteConfigBody = req .json() .await .map_err(|_| XrpcError::new("InvalidRequest", "request body must be JSON", 400))?; let branch = require_non_empty("branch", &body.branch)?; require_non_empty("rkey", &body.rkey)?; require_non_empty("knot", &body.knot)?; let store = store(env)?; let Some(domain) = usable_claim(env, &store, &did).await? else { return Err(XrpcError::new( "NoDomainClaim", "This account has no active domain claim.", 403, )); }; let Some(dir) = sites::normalize_dir(&body.dir) else { return Err(XrpcError::new( "InvalidDirectory", "Invalid directory path.", 400, )); }; // the knot hosting the repo is the authority on who owns it, not d1 let (access, _, proof) = repo_scope(env, &store, &did, &body.repo_did).await?; // don't let the client redirect the knot or rkey away from the proof if let Err(e) = config_identity(&proof, &body.name, &body.rkey, &body.knot) { console_warn!("updateSiteConfig for {}: {}", body.repo_did, e.message); return Err(e); } let Some(name) = site_name(&proof.name) else { return Err(XrpcError::new( "InvalidRequest", "the repository's name must be a single path segment of letters, digits, '-', '_' or '.' to be served", 400, )); }; let (rkey, knot) = (proof.rkey.clone(), proof.knot.clone()); store .update_site_config( &body.repo_did, &did, &name, &rkey, &knot, &branch, &dir, body.is_index, access == RepoAccess::Disputed, ) .await .map_err(|e| { if e == sites::ERR_NOT_OWNER { XrpcError::new( "NotOwner", "This repository's site config belongs to another account.", 403, ) } else if e == sites::ERR_INDEX_TAKEN { XrpcError::new( "IndexSiteTaken", "Another repository is already the index site of this domain; save this one as a sub-path site.", 409, ) } else { internal(e) } })?; let kv = env .kv("SITES") .map_err(|_| XrpcError::internal("SITES KV is not configured"))?; let mut rebuild_err = None; for _ in 0..2 { match kvmap::rebuild_for_domain(&kv, &store, &domain).await { Ok(()) => { rebuild_err = None; break; } Err(e) => rebuild_err = Some(e), } } if let Some(e) = rebuild_err { return Err(internal(format!( "config saved but the serving mapping update failed: {}", e ))); } match trigger_deploy( env, ctx, db_handle(env)?, DeployTarget { repo_did: body.repo_did, branch, dir, }, None, ) { DeployTrigger::Dispatched => ok_json(json!({})), DeployTrigger::Disabled => Err(XrpcError::new( "WorkerUnavailable", "The config was saved, but site deploys are disabled on this deployment.", 503, )), } } #[derive(PartialEq, Debug)] enum DeployTrigger { Dispatched, Disabled, } #[derive(Clone, Copy, Debug, PartialEq)] enum TriggerAnswer { Accepted, Refused, } fn trigger_answer(status: u16) -> TriggerAnswer { if (200..300).contains(&status) { TriggerAnswer::Accepted } else { TriggerAnswer::Refused } } struct DeployTarget { repo_did: String, branch: String, dir: String, } // detached task outlives borrowed store, needs its own d1 handle fn db_handle(env: &Env) -> Result { env.d1("SITES_DB") .map_err(|_| XrpcError::internal("SITES_DB is not configured")) } /// an omitted trigger is sitesd's config-change deploy fn trigger_deploy( env: &Env, ctx: &Context, db: D1Database, target: DeployTarget, trigger: Option<&'static str>, ) -> DeployTrigger { let url = env .var("SITES_SD_URL") .ok() .map(|v| v.to_string()) .filter(|v| !v.is_empty()); // the vpc binding ignores the host in the url, so any name works let sitesd = env.service("SITES_SD").ok(); let Some(aud) = url.or_else(|| sitesd.as_ref().map(|_| "http://sitesd".to_string())) else { console_warn!("deploy triggers are disabled: neither SITES_SD_URL nor SITES_SD is set"); return DeployTrigger::Disabled; }; let url = format!("{}/deploy", aud.trim_end_matches('/')); ctx.wait_until(async move { let store = SitesStore::d1(db); let mut payload = json!({ "repoDid": target.repo_did }); if let Some(trigger) = trigger { payload["trigger"] = json!(trigger); } let payload = payload.to_string(); let mut headers = Headers::new(); if headers.set("content-type", "application/json").is_err() { return; } let mut init = RequestInit::new(); init.with_method(Method::Post) .with_headers(headers) .with_body(Some(wasm_bindgen::JsValue::from_str(&payload))); let Ok(request) = Request::new_with_init(&url, &init) else { record_unreached( &store, &target, trigger, "the deploy service address is not a URL", ) .await; return; }; let sent = match &sitesd { Some(sitesd) => sitesd.fetch_request(request).await, None => Fetch::Request(request).send().await, }; match sent { Ok(res) => { if trigger_answer(res.status_code()) == TriggerAnswer::Refused { let status = res.status_code(); record_unreached( &store, &target, trigger, &format!( "the deploy service rejected the trigger before accepting it: HTTP {}", status ), ) .await; } } Err(e) => { record_unreached( &store, &target, trigger, &format!("the deploy service was not reached: {}", e), ) .await; } } }); DeployTrigger::Dispatched } async fn record_unreached( store: &SitesStore, target: &DeployTarget, trigger: Option<&str>, reason: &str, ) { let trigger = trigger.unwrap_or("config_change"); if let Err(e) = store .insert_deploy( &target.repo_did, &target.branch, &target.dir, "", "failure", trigger, reason, ) .await { console_warn!( "recording the failed deploy trigger for {} failed: {}", target.repo_did, e ); } } async fn handle_deploy_site( mut req: Request, env: &Env, ctx: &Context, ) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.repo.deploySite").await?; let body: RepoDidBody = req .json() .await .map_err(|_| XrpcError::new("InvalidRequest", "request body must be JSON", 400))?; let store = store(env)?; let _ = verified_repo(env, &store, &did, &body.repo_did).await?; let Some(dc) = store .deploy_context(&body.repo_did) .await .map_err(internal)? else { return Err(XrpcError::new( "SiteNotFound", "no site configuration for this repository", 404, )); }; match trigger_deploy( env, ctx, db_handle(env)?, DeployTarget { repo_did: body.repo_did, branch: dc.branch, dir: dc.dir, }, Some("manual"), ) { DeployTrigger::Dispatched => ok_json(json!({})), DeployTrigger::Disabled => Err(XrpcError::new( "WorkerUnavailable", "site deploys are disabled on this deployment", 503, )), } } async fn usable_claim( env: &Env, store: &SitesStore, did: &str, ) -> Result, XrpcError> { let Some(domain) = store.active_domain_for_did(did).await.map_err(internal)? else { return provision_handle_claim(env, store, did).await; }; if !claim::is_handle_domain(&domain) { return Ok(Some(domain)); } match claim::handle_title(&domain, did).await { claim::Title::Held => Ok(Some(domain)), claim::Title::Squatted => Err(XrpcError::new( "HandleNotOwned", "That handle belongs to another account.", 403, )), claim::Title::Unknown => Err(XrpcError::new( "HandleUnknown", "No account holds that handle.", 404, )), claim::Title::Unverifiable => Err(XrpcError::new( "ClaimUnverifiable", format!( "the zone that owns {} could not be asked, so this claim cannot be used", domain ), 503, )), } } // provision signup handle if d1 has no claim row yet async fn verified_signup_handle(env: &Env, did: &str) -> Result, XrpcError> { let Some(declared) = serviceauth::account_handle(env, did).await? else { return Ok(None); }; if !claim::is_handle_domain(&declared) { return Ok(None); } let resolved = claim::resolve_handle(declared.clone()).await.map_err(|e| { XrpcError::new( "ClaimUnverifiable", format!("handle authority lookup failed: {}", e), 503, ) })?; Ok(claim::self_claimed_handle( did, Some(&declared), resolved.as_deref(), )) } async fn provision_handle_claim( env: &Env, store: &SitesStore, did: &str, ) -> Result, XrpcError> { let Some(handle) = verified_signup_handle(env, did).await? else { return Ok(None); }; let allowed = allowed_tlds(env)?; let reserved = reserved_labels(env); let vouched = Some(did.to_string()); match claim::claim_vouched( store, Utc::now(), did, &handle, &refs(&allowed), &refs(&reserved), move |_domain| { // already verified above, avoid extra fetch let vouched = vouched.clone(); async move { Ok(vouched) } }, ) .await { Ok(()) => store.active_domain_for_did(did).await.map_err(internal), Err(e) => { console_warn!( "provisioning the handle claim {} for {} failed: {:?}", handle, did, e ); Err(claim_error_to_xrpc(e)) } } } fn is_public_host(host: &str) -> bool { // url hosts bracket ipv6 let host = host .trim_start_matches('[') .trim_end_matches(']') .trim_end_matches('.') .to_ascii_lowercase(); if host.is_empty() { return false; } if [ "localhost", "local", "internal", "home.arpa", "in-addr.arpa", "ip6.arpa", "onion", ] .iter() .any(|reserved| host == *reserved || host.ends_with(&format!(".{}", reserved))) { return false; } match host.parse::() { Ok(std::net::IpAddr::V4(ip)) => is_public_v4(ip), Ok(std::net::IpAddr::V6(ip)) => match ip.to_ipv4_mapped() { Some(mapped) => is_public_v4(mapped), None => { !(ip.is_loopback() || ip.is_unspecified() || ip.is_unique_local() || ip.is_unicast_link_local() || ip.is_multicast()) } }, Err(_) => true, } } fn is_public_v4(ip: std::net::Ipv4Addr) -> bool { !(ip.is_private() || ip.is_loopback() || ip.is_link_local() || ip.is_broadcast() || ip.is_documentation() || ip.is_unspecified() || ip.is_multicast() || ip.octets()[0] == 0) } fn public_https_host(raw: &str) -> Option { let url = Url::parse(raw.trim()).ok()?; if url.scheme() != "https" || !url.username().is_empty() || url.password().is_some() || url.query().is_some() || url.fragment().is_some() { return None; } let host = url.host_str()?; is_public_host(host).then(|| { host.trim_start_matches('[') .trim_end_matches(']') .to_ascii_lowercase() }) } fn is_record_key(rkey: &str) -> bool { !rkey.is_empty() && rkey != "." && rkey != ".." && rkey.len() <= 512 && rkey .chars() .all(|c| c.is_ascii_alphanumeric() || matches!(c, '.' | '-' | '_' | '~' | ':')) } // don't follow redirects to unvalidated hosts async fn authoritative_get(url: &str) -> Result { let url = Url::parse(url).map_err(|e| format!("bad url: {}", e))?; let mut init = RequestInit::new(); // workerd rejects redirect "error" when constructing a request. // "manual" leaves redirects for callers to reject. init.with_method(Method::Get) .with_redirect(RequestRedirect::Manual); let request = Request::new_with_init(url.as_str(), &init).map_err(|e| e.to_string())?; Fetch::Request(request) .send() .await .map_err(|e| e.to_string()) } const MAX_DOC_BYTES: u64 = 1024 * 1024; fn within_cap(len: u64) -> bool { len <= MAX_DOC_BYTES } fn oversized(what: &str, len: u64) -> XrpcError { unverifiable(&format!( "{} is {} bytes, over the {} byte limit this worker reads", what, len, MAX_DOC_BYTES )) } async fn bounded_json(resp: &mut Response, what: &str) -> Result { if let Some(declared) = resp .headers() .get("content-length") .ok() .flatten() .and_then(|len| len.trim().parse::().ok()) && !within_cap(declared) { return Err(oversized(what, declared)); } let body = resp .bytes() .await .map_err(|e| unverifiable(&format!("{} could not be read: {}", what, e)))?; if !within_cap(body.len() as u64) { return Err(oversized(what, body.len() as u64)); } serde_json::from_slice(&body) .map_err(|e| unverifiable(&format!("{} is unreadable: {}", what, e))) } fn knot_endpoint_for<'a>( doc: &'a serviceauth::DidDoc, repo_did: &str, ) -> Result, XrpcError> { if doc.id() != repo_did { return Err(unverifiable(&format!( "the DID document fetched for {} says it is {}", repo_did, doc.id() ))); } Ok(doc.knot_endpoint()) } #[derive(Clone, Debug, PartialEq)] struct RepoProof { owner: String, name: String, rkey: String, knot: String, } impl RepoProof { fn disputed_fields(&self, name: &str, rkey: &str, knot: &str) -> Vec<&'static str> { let mut disputed = Vec::new(); if !name.trim().is_empty() && self.name != name.trim() { disputed.push("name"); } if self.rkey != rkey { disputed.push("rkey"); } if self.knot != knot { disputed.push("knot"); } disputed } } async fn repo_proof(env: &Env, repo_did: &str) -> Result, XrpcError> { let doc_url = match serviceauth::did_doc_url_for(env, repo_did) { Ok(url) => url, // unsupported did methods have no document to resolve Err(_) => return Ok(None), }; if repo_did.starts_with("did:web:") && public_https_host(&doc_url).is_none() { return Err(unverifiable( "the did:web host of this repoDid is not a public https host", )); } let mut resp = authoritative_get(&doc_url).await.map_err(|e| { unverifiable(&format!( "the DID document for {} could not be read: {}", repo_did, e )) })?; let status = resp.status_code(); if status == 404 { return Ok(None); } if !(200..300).contains(&status) { return Err(unverifiable(&format!( "the DID document for {} answered HTTP {}", repo_did, status ))); } let doc: serviceauth::DidDoc = serde_json::from_value( bounded_json(&mut resp, &format!("the DID document for {}", repo_did)).await?, ) .map_err(|e| { unverifiable(&format!( "the DID document for {} is unreadable: {}", repo_did, e )) })?; let Some(endpoint) = knot_endpoint_for(&doc, repo_did)? else { return Ok(None); }; let Some(knot) = public_https_host(endpoint) else { return Err(unverifiable(&format!( "the knot endpoint of {} is not a public https host", repo_did ))); }; let mut url = Url::parse(&format!("https://{}/xrpc/com.atproto.repo.getRecord", knot)) .map_err(|e| XrpcError::internal(format!("bad knot url: {}", e)))?; url.query_pairs_mut() .append_pair("repo", repo_did) .append_pair("collection", MANIFEST_COLLECTION) .append_pair("rkey", "self"); let mut resp = authoritative_get(url.as_str()) .await .map_err(|e| unverifiable(&format!("the knot {} could not be asked: {}", knot, e)))?; let status = resp.status_code(); if status == 404 { return Ok(None); } let answer = bounded_json(&mut resp, &format!("the answer from the knot {}", knot)).await?; if status == 400 && matches!( answer.get("error").and_then(|e| e.as_str()), Some("RecordNotFound" | "RepoNotFound") ) { return Ok(None); } if !(200..300).contains(&status) { return Err(unverifiable(&format!( "the knot {} answered HTTP {}", knot, status ))); } Ok(Some(repo_proof_from_answer(repo_did, &knot, &answer)?)) } const MANIFEST_COLLECTION: &str = "org.tangled.repo.manifest"; // the manifest lives in the repo did's own repo on its knot, so only that knot can say who owns it fn repo_proof_from_answer( repo_did: &str, knot: &str, answer: &serde_json::Value, ) -> Result { let expected_uri = format!("at://{}/{}/self", repo_did, MANIFEST_COLLECTION); match answer.get("uri").and_then(|value| value.as_str()) { Some(uri) if uri == expected_uri => {} Some(uri) => { return Err(unverifiable(&format!( "the knot {} answered with {} instead of the manifest of {}", knot, uri, repo_did ))); } None => { return Err(unverifiable(&format!( "the knot {} answered without a record uri", knot ))); } } let declaration = answer.pointer("/value/declaration"); let field = |name: &str| { declaration .and_then(|declaration| declaration.get(name)) .and_then(|value| value.as_str()) .map(str::trim) .filter(|value| !value.is_empty()) }; let owner = field("owner") .filter(|owner| serviceauth::is_account_did(owner)) .ok_or_else(|| { unverifiable(&format!( "the knot {} answered without a usable owner DID", knot )) })?; let name = field("name") .filter(|name| is_record_key(&name.to_ascii_lowercase())) .ok_or_else(|| { unverifiable(&format!("the knot {} answered without a usable name", knot)) })?; Ok(RepoProof { owner: owner.to_string(), name: name.to_string(), // the declaration's rkey is the lowercased name rkey: name.to_ascii_lowercase(), knot: knot.to_string(), }) } fn site_name(name: &str) -> Option { let usable = !name.is_empty() && name.len() <= 63 && !name.starts_with(['.', '-']) && !name.contains("..") && name .chars() .all(|c| c.is_ascii_alphanumeric() || matches!(c, '-' | '_' | '.')); usable.then(|| name.to_string()) } fn config_identity(proof: &RepoProof, name: &str, rkey: &str, knot: &str) -> Result<(), XrpcError> { let mismatched = proof.disputed_fields(name, rkey, knot); if mismatched.is_empty() { return Ok(()); } Err(XrpcError::new( "RepoIdentityMismatch", format!( "the request's {} do not match what the knot hosting this repository reports; reload the repository and save again", mismatched.join(", ") ), 409, )) } fn unverifiable(message: &str) -> XrpcError { XrpcError::new( "OwnershipUnverifiable", format!("{}; refusing to act on the caller's word alone", message), 503, ) } #[derive(Clone, Copy, Debug, PartialEq)] enum RepoAccess { Owned, Disputed, } fn repo_access( caller: &str, stored_owner: Option<&str>, resolved_owner: Option<&str>, ) -> Result { match resolved_owner { None => Err(XrpcError::new( "RepoNotFound", "No knot reports hosting this repoDid.", 404, )), Some(owner) if owner != caller => Err(XrpcError::new( "NotOwner", "This repository's site config belongs to another account.", 403, )), Some(_) => Ok(match stored_owner { Some(stored) if stored != caller => RepoAccess::Disputed, _ => RepoAccess::Owned, }), } } fn require_repo_did(repo_did: &str) -> Result<(), XrpcError> { let id = repo_did .strip_prefix("did:plc:") .or_else(|| repo_did.strip_prefix("did:web:")); if id.is_some_and(|id| !id.is_empty()) { return Ok(()); } Err(XrpcError::new( "InvalidRequest", "'repoDid' must be a did:plc or did:web DID", 400, )) } async fn repo_scope( env: &Env, store: &SitesStore, did: &str, repo_did: &str, ) -> Result<(RepoAccess, Option, RepoProof), XrpcError> { require_repo_did(repo_did)?; let row = store.get_repo(repo_did).await.map_err(internal)?; let stored_owner = row.as_ref().map(|row| row.owner_did.as_str()); let Some(proof) = repo_proof(env, repo_did).await? else { return Err(XrpcError::new( "RepoNotFound", "No knot reports hosting this repoDid.", 404, )); }; let access = repo_access(did, stored_owner, Some(&proof.owner))?; Ok((access, row, proof)) } async fn verified_repo( env: &Env, store: &SitesStore, did: &str, repo_did: &str, ) -> Result<(Option, RepoProof), XrpcError> { match repo_scope(env, store, did, repo_did).await? { (RepoAccess::Owned, row, proof) => Ok((row, proof)), (RepoAccess::Disputed, ..) => Err(disputed_config()), } } fn disputed_config() -> XrpcError { XrpcError::new( "SiteConfigDisputed", "Another account's site configuration is stored for this repository; save the site configuration again to take it over.", 409, ) } async fn handle_get_site_config(req: Request, env: &Env) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.repo.getSiteConfig").await?; let url = req.url().map_err(|e| internal(e.to_string()))?; let Some(repo_did) = query_param(&url, "repoDid") else { return Err(XrpcError::new( "InvalidRequest", "missing 'repoDid' query parameter", 400, )); }; let store = store(env)?; if store.get_repo(&repo_did).await.map_err(internal)?.is_none() { return ok_json(json!({})); } // don't expose squatter's config to the real owner if let (RepoAccess::Disputed, _, _) = repo_scope(env, &store, &did, &repo_did).await? { console_warn!( "getSiteConfig: the stored config for {} was written by another account", repo_did ); return ok_json(json!({})); } match store .get_site_config(&repo_did) .await .map_err(|e| internal(e))? { Some(config) => ok_json(json!({ "config": { "branch": config.branch, "dir": config.dir, "isIndex": config.is_index, } })), None => ok_json(json!({})), } } /// fixed window, matching the lexicon maxLength, so truncation is detectable const DEPLOY_HISTORY_LIMIT: i32 = 20; #[derive(Serialize)] #[serde(rename_all = "camelCase")] struct DeployHistoryEntry { status: String, trigger: String, branch: String, dir: String, commit_sha: String, error: String, created_at: String, } async fn handle_get_deploy_history(req: Request, env: &Env) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.repo.getDeployHistory").await?; let url = req.url().map_err(|e| internal(e.to_string()))?; let Some(repo_did) = query_param(&url, "repoDid") else { return Err(XrpcError::new( "InvalidRequest", "missing 'repoDid' query parameter", 400, )); }; let store = store(env)?; // don't expose squatter's deploys to the real owner if let (RepoAccess::Disputed, _, _) = repo_scope(env, &store, &did, &repo_did).await? { console_warn!( "getDeployHistory: the stored config for {} was written by another account", repo_did ); return ok_json(json!({ "deploys": [] })); } match store.deploy_context(&repo_did).await.map_err(internal)? { Some(_) => {} None => { return Err(XrpcError::new( "SiteNotFound", "no site configuration for this repository", 404, )); } } let deploys = store .deploy_history_for_repo(&repo_did, DEPLOY_HISTORY_LIMIT) .await .map_err(internal)? .into_iter() .map(|row| DeployHistoryEntry { status: row.status, trigger: row.trigger, branch: row.branch, dir: row.dir, commit_sha: row.commit_sha, error: row.error, created_at: row.created_at, }) .collect::>(); ok_json(json!({ "deploys": deploys })) } async fn handle_disable_site(mut req: Request, env: &Env) -> Result { let did = verify_caller(&req, env, "org.tangled.temp.repo.disableSite").await?; let body: RepoDidBody = req .json() .await .map_err(|_| XrpcError::new("InvalidRequest", "request body must be JSON", 400))?; let store = store(env)?; let (row, proof) = verified_repo(env, &store, &did, &body.repo_did).await?; let Some(row) = row else { return Err(XrpcError::new( "SiteNotFound", "This repository has no site configuration.", 404, )); }; if store .get_site_config(&body.repo_did) .await .map_err(|e| internal(e))? .is_none() { return Err(XrpcError::new( "SiteNotFound", "This repository has no site configuration.", 404, )); } let bucket = env .bucket("SITES_BUCKET") .map_err(|_| XrpcError::internal("SITES_BUCKET is not configured"))?; // use verified rkey from the proof rather than stored row kvmap::delete_r2_prefix(&bucket, &format!("{}/{}/", row.owner_did, proof.rkey)) .await .map_err(|e| internal(e))?; store .delete_repo_and_config(&body.repo_did) .await .map_err(|e| internal(e))?; let kv = env .kv("SITES") .map_err(|_| XrpcError::internal("SITES KV is not configured"))?; if let Some(domain) = store .active_domain_for_did(&row.owner_did) .await .map_err(|e| internal(e))? { kvmap::rebuild_for_domain(&kv, &store, &domain) .await .map_err(|e| internal(e))?; } ok_json(json!({})) } async fn handle_get_deploy_context(req: Request, env: &Env) -> Result { let _did = verify_sd(&req, env, "org.tangled.temp.repo.getDeployContext").await?; let url = req.url().map_err(|e| internal(e.to_string()))?; let Some(repo_did) = query_param(&url, "repoDid") else { return Err(XrpcError::new( "InvalidRequest", "missing 'repoDid' query parameter", 400, )); }; let store = store(env)?; let Some(dc) = store.deploy_context(&repo_did).await.map_err(internal)? else { return ok_json(json!({})); }; let Some(proof) = repo_proof(env, &repo_did).await? else { return Err(XrpcError::new( "RepoNotFound", "No knot reports hosting this repoDid.", 404, )); }; if proof.owner != dc.owner_did { return Err(XrpcError::new( "NotOwner", "The stored site configuration for this repository was written by another account.", 403, )); } if claim::is_handle_domain(&dc.domain) { match claim::handle_title(&dc.domain, &dc.owner_did).await { claim::Title::Held => {} claim::Title::Squatted | claim::Title::Unknown => { return Err(XrpcError::new( "HandleNotOwned", "The domain this site would be published on is not held by the account that owns the repository.", 403, )); } claim::Title::Unverifiable => { return Err(XrpcError::new( "ClaimUnverifiable", format!("the zone that owns {} could not be asked", dc.domain), 503, )); } } } ok_json(json!({ "ownerDid": dc.owner_did, "domain": dc.domain, "name": dc.name, "rkey": proof.rkey, "knot": proof.knot, "branch": dc.branch, "dir": dc.dir, "isIndex": dc.is_index, })) } async fn handle_record_deploy(mut req: Request, env: &Env) -> Result { let _did = verify_sd(&req, env, "org.tangled.temp.repo.recordDeploy").await?; let body: RecordDeployBody = req .json() .await .map_err(|_| XrpcError::new("InvalidRequest", "request body must be JSON", 400))?; if body.status != "success" && body.status != "failure" { return Err(XrpcError::new( "InvalidRequest", "status must be 'success' or 'failure'", 400, )); } if !matches!(body.trigger.as_str(), "config_change" | "push" | "manual") { return Err(XrpcError::new( "InvalidRequest", "trigger must be 'config_change', 'push' or 'manual'", 400, )); } let store = store(env)?; store .insert_deploy( &body.repo_did, &body.branch, &body.dir, &body.commit_sha, &body.status, &body.trigger, &body.error, ) .await .map_err(|e| internal(e))?; ok_json(json!({})) } pub async fn route(req: Request, env: Env, ctx: Context) -> Result { let url = req.url()?; let path = url.path().to_string(); let nsid = path.trim_start_matches("/xrpc/").to_string(); if nsid.is_empty() || nsid.contains('/') { return render_error(XrpcError::new("MethodNotFound", "unknown xrpc method", 404)); } let is_query = matches!( nsid.as_str(), "org.tangled.temp.site.getDomainClaim" | "org.tangled.temp.site.getDomainClaimForDid" | "org.tangled.temp.repo.getSiteConfig" | "org.tangled.temp.repo.getDeployContext" | "org.tangled.temp.repo.getDeployHistory" ); let want = if is_query { Method::Get } else { Method::Post }; if req.method() != want { return render_error(XrpcError::new( "MethodNotAllowed", "wrong HTTP method for this lexicon method", 405, )); } let result = match nsid.as_str() { "org.tangled.temp.site.claimDomain" => handle_claim_domain(req, &env).await, "org.tangled.temp.site.getDomainClaim" => handle_get_domain_claim(req, &env).await, "org.tangled.temp.site.releaseDomain" => handle_release_domain(req, &env).await, "org.tangled.temp.site.getDomainClaimForDid" => { handle_get_domain_claim_for_did(req, &env).await } "org.tangled.temp.repo.updateSiteConfig" => { handle_update_site_config(req, &env, &ctx).await } "org.tangled.temp.repo.getSiteConfig" => handle_get_site_config(req, &env).await, "org.tangled.temp.repo.getDeployHistory" => handle_get_deploy_history(req, &env).await, "org.tangled.temp.repo.deploySite" => handle_deploy_site(req, &env, &ctx).await, "org.tangled.temp.repo.disableSite" => handle_disable_site(req, &env).await, "org.tangled.temp.repo.getDeployContext" => handle_get_deploy_context(req, &env).await, "org.tangled.temp.repo.recordDeploy" => handle_record_deploy(req, &env).await, other => Err(XrpcError::new( "MethodNotFound", format!("unknown xrpc method {}", other), 404, )), }; match result { Ok(resp) => Ok(resp), Err(e) => render_error(e), } } #[cfg(test)] mod tests { use super::*; fn err_name( status: u16, name: &str, caller: &str, stored: Option<&str>, resolved: Option<&str>, ) { let err = repo_access(caller, stored, resolved).unwrap_err(); assert_eq!((err.status, err.name), (status, name)); } fn manifest(uri: &str, declaration: serde_json::Value) -> serde_json::Value { serde_json::json!({ "uri": uri, "cid": "bafyrei", "value": { "$type": "org.tangled.repo.manifest", "createdAt": "2026-10-01T00:00:00Z", "declaration": declaration } }) } #[test] fn a_knot_answer_is_a_proof_only_for_the_repo_it_was_asked_about() { let repo = "did:plc:repo"; let knot = "knot1.tangled.sh"; let uri = "at://did:plc:repo/org.tangled.repo.manifest/self"; let answer = manifest( uri, serde_json::json!({"owner": "did:plc:owner", "name": "Site"}), ); assert_eq!( repo_proof_from_answer(repo, knot, &answer).unwrap(), RepoProof { owner: "did:plc:owner".to_string(), name: "Site".to_string(), rkey: "site".to_string(), knot: knot.to_string(), } ); for malformed in [ serde_json::json!({"value": {"declaration": {"owner": "did:plc:owner", "name": "site"}}}), manifest( "at://did:plc:other/org.tangled.repo.manifest/self", serde_json::json!({"owner": "did:plc:owner", "name": "site"}), ), manifest( "at://did:plc:repo/org.tangled.repo.manifest/other", serde_json::json!({"owner": "did:plc:owner", "name": "site"}), ), manifest(uri, serde_json::json!({"name": "site"})), manifest(uri, serde_json::json!({"owner": "", "name": "site"})), manifest( uri, serde_json::json!({"owner": "did:key:zQ3shokFTS3brHcDQrn82RUDfCZESWL1ZdCEJwekUDPQiYBme", "name": "site"}), ), manifest(uri, serde_json::json!({"owner": "did:plc:owner"})), manifest( uri, serde_json::json!({"owner": "did:plc:owner", "name": ""}), ), manifest( uri, serde_json::json!({"owner": "did:plc:owner", "name": "a/b"}), ), manifest( uri, serde_json::json!({"owner": "did:plc:owner", "name": ".."}), ), manifest( uri, serde_json::json!({"owner": "did:plc:owner", "name": 7}), ), manifest(uri, serde_json::json!("site")), serde_json::json!([repo, "did:plc:owner", "site"]), serde_json::json!("site"), ] { let err = repo_proof_from_answer(repo, knot, &malformed).unwrap_err(); assert_eq!( (err.status, err.name), (503, "OwnershipUnverifiable"), "{}", malformed ); } } #[test] fn a_record_from_an_owners_pds_is_not_a_proof() { for forged in [ serde_json::json!({ "cid": "bafyrei", "uri": "at://did:plc:attacker/org.tangled.repo.declaration/evil", "value": { "$type": "org.tangled.repo.declaration", "createdAt": "9999-01-01T00:00:00Z", "repo": "did:plc:victim-repo" } }), serde_json::json!({ "cid": "bafyrei", "uri": "at://did:plc:attacker/org.tangled.repo.manifest/self", "value": {"declaration": {"owner": "did:plc:attacker", "name": "evil"}} }), ] { let err = repo_proof_from_answer("did:plc:victim-repo", "knot1.tangled.sh", &forged) .unwrap_err(); assert_eq!((err.status, err.name), (503, "OwnershipUnverifiable")); } } #[test] fn a_document_must_be_about_the_did_it_was_fetched_for() { let with_service = |id: &str| { serde_json::from_str::(&format!( r##"{{"id":"{}","service":[{{"id":"#tangled_knot","type":"TangledKnot","serviceEndpoint":"https://knot.example"}}]}}"##, id )) .unwrap() }; let doc = with_service("did:plc:repo"); assert_eq!( knot_endpoint_for(&doc, "did:plc:repo").unwrap(), Some("https://knot.example") ); let err = knot_endpoint_for(&doc, "did:plc:other").unwrap_err(); assert_eq!((err.status, err.name), (503, "OwnershipUnverifiable")); let empty = serde_json::from_str::(r##"{"id":"did:plc:other"}"##).unwrap(); assert_eq!( knot_endpoint_for(&empty, "did:plc:repo") .unwrap_err() .status, 503 ); let no_service = serde_json::from_str::( r##"{"id":"did:plc:repo","service":[{"id":"#other","type":"Other","serviceEndpoint":"https://knot.example"}]}"##, ) .unwrap(); assert_eq!( knot_endpoint_for(&no_service, "did:plc:repo").unwrap(), None ); } #[test] fn a_document_over_the_read_limit_is_refused() { assert!(within_cap(0)); assert!(within_cap(MAX_DOC_BYTES)); assert!(!within_cap(MAX_DOC_BYTES + 1)); assert_eq!(MAX_DOC_BYTES, 1024 * 1024); let err = oversized("the DID document for did:plc:repo", MAX_DOC_BYTES + 1); assert_eq!((err.status, err.name), (503, "OwnershipUnverifiable")); assert!(err.message.contains("over the 1048576 byte limit")); } #[test] fn a_proof_refuses_hosts_it_must_not_dial() { for dialable in [ "https://knot1.tangled.sh", "https://knot.gaze.systems", "https://plc.directory", "https://1.1.1.1", "https://knot1.tangled.sh/path", ] { assert!( public_https_host(dialable).is_some(), "{} should be dialable", dialable ); } for refused in [ "http://knot.example", "ftp://knot.example", "knot.example", "https://localhost", "https://knot.localhost", "https://pds.internal", "https://plc.local", "https://metadata.home.arpa", "https://127.0.0.1", "https://127.1.2.3", "https://0.0.0.0", "https://10.1.2.3", "https://192.168.0.1", "https://172.16.0.1", "https://169.254.169.254", "https://224.0.0.1", "https://[::1]", "https://[::ffff:127.0.0.1]", "https://[fd00::1]", "https://[fe80::1]", "https://user:pass@knot.example", "https://knot.example/?x=1", "https://knot.example/#f", "https://", ] { assert!( public_https_host(refused).is_none(), "{} should be refused", refused ); } } #[test] fn a_write_that_restates_the_identity_is_refused() { let proof = RepoProof { owner: "did:plc:owner".to_string(), name: "Site".to_string(), rkey: "site".to_string(), knot: "knot.gaze.systems".to_string(), }; for (name, rkey, knot, why) in [ ("Site", "evil-rkey", "knot.gaze.systems", "another rkey"), ("Site", "site", "evil.example", "a knot it controls"), ("not-the-name", "site", "knot.gaze.systems", "another name"), ( "site", "site", "knot.gaze.systems", "the name in another case", ), ("blog", "evil-rkey", "evil.example", "everything"), ] { let err = config_identity(&proof, name, rkey, knot).unwrap_err(); assert_eq!( (err.status, err.name), (409, "RepoIdentityMismatch"), "{}", why ); } assert!(config_identity(&proof, "Site", "site", "knot.gaze.systems").is_ok()); assert!(config_identity(&proof, "", "site", "knot.gaze.systems").is_ok()); } #[test] fn a_site_name_is_a_single_path_segment() { assert_eq!(site_name("site").as_deref(), Some("site")); assert_eq!( site_name("under_score.ok").as_deref(), Some("under_score.ok") ); assert_eq!(site_name(&"a".repeat(63)).map(|n| n.len()), Some(63)); for unusable in [ "../x", ".hidden", "a/b", "a b", "-lead", "a".repeat(64).as_str(), "..", "a~b", "", ] { assert_eq!(site_name(unusable), None, "{:?}", unusable); } } #[test] fn a_repodid_that_is_not_a_did_is_a_bad_request() { for malformed in [ "not-a-did", "", "did:plc:", "did:web:", "did:key:z6Mk", "at://did:plc:repo", ] { let err = require_repo_did(malformed).unwrap_err(); assert_eq!( (err.status, err.name), (400, "InvalidRequest"), "{:?}", malformed ); } assert!(require_repo_did("did:plc:enmgst7mc62p6r72fukc3x3r").is_ok()); assert!(require_repo_did("did:web:knot.example").is_ok()); } #[test] fn a_foreign_repodid_is_not_writable_by_its_namer() { err_name( 403, "NotOwner", "did:plc:attacker", None, Some("did:plc:victim"), ); err_name( 403, "NotOwner", "did:plc:attacker", Some("did:plc:attacker"), Some("did:plc:victim"), ); err_name(404, "RepoNotFound", "did:plc:attacker", None, None); } #[test] fn the_verified_owner_writes_and_takes_over_a_squatted_row() { let access = |stored: Option<&str>| repo_access("did:plc:alice", stored, Some("did:plc:alice")); assert_eq!(access(None).unwrap(), RepoAccess::Owned); assert_eq!(access(Some("did:plc:alice")).unwrap(), RepoAccess::Owned); assert_eq!( access(Some("did:plc:attacker")).unwrap(), RepoAccess::Disputed ); } #[test] fn a_blocked_handle_claim_is_reported_not_hidden() { let err = claim_error_to_xrpc(ClaimError::DomainTaken); assert_eq!((err.status, err.name), (409, "DomainTaken")); let err = claim_error_to_xrpc(ClaimError::DomainCooldown); assert_eq!((err.status, err.name), (409, "DomainCooldown")); let err = claim_error_to_xrpc(ClaimError::AlreadyClaimed); assert_eq!((err.status, err.name), (409, "AlreadyClaimed")); } #[test] fn a_row_written_by_another_account_authorizes_nobody() { err_name( 403, "NotOwner", "did:plc:attacker", Some("did:plc:attacker"), Some("did:plc:victim"), ); assert_eq!( repo_access( "did:plc:victim", Some("did:plc:attacker"), Some("did:plc:victim") ) .unwrap(), RepoAccess::Disputed ); assert_eq!( repo_access("did:plc:victim", None, Some("did:plc:victim")).unwrap(), RepoAccess::Owned ); err_name( 404, "RepoNotFound", "did:plc:victim", Some("did:plc:victim"), None, ); } }