Something went wrong. Try again.
Monorepo for Tangled tangled.org
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839use 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<Response> { 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, XrpcError> { 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<SitesStore, XrpcError> { 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<Vec<String>, 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<String> { 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<String> { url.query_pairs() .find(|(k, _)| k == name) .map(|(_, v)| v.into_owned())}
fn require_non_empty(field: &str, value: &str) -> Result<String, XrpcError> { 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<String, XrpcError> { 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<String, XrpcError> { 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<Response, XrpcError> { 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<Response, XrpcError> { 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<Response, XrpcError> { 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<Response, XrpcError> { 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<Response, XrpcError> { 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 handlefn db_handle(env: &Env) -> Result<D1Database, XrpcError> { env.d1("SITES_DB") .map_err(|_| XrpcError::internal("SITES_DB is not configured"))}
/// an omitted trigger is sitesd's config-change deployfn 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<Response, XrpcError> { 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<Option<String>, 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 yetasync fn verified_signup_handle(env: &Env, did: &str) -> Result<Option<String>, 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<Option<String>, 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::<std::net::IpAddr>() { 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<String> { 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 hostsasync fn authoritative_get(url: &str) -> Result<Response, String> { 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<serde_json::Value, XrpcError> { if let Some(declared) = resp .headers() .get("content-length") .ok() .flatten() .and_then(|len| len.trim().parse::<u64>().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<Option<&'a str>, 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<Option<RepoProof>, 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 itfn repo_proof_from_answer( repo_did: &str, knot: &str, answer: &serde_json::Value,) -> Result<RepoProof, XrpcError> { 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<String> { 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<RepoAccess, XrpcError> { 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<sites::RepoRow>, 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<sites::RepoRow>, 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<Response, XrpcError> { 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 detectableconst 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<Response, XrpcError> { 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::<Vec<_>>();
ok_json(json!({ "deploys": deploys }))}
async fn handle_disable_site(mut req: Request, env: &Env) -> Result<Response, XrpcError> { 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<Response, XrpcError> { 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<Response, XrpcError> { 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<Response> { 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::<serviceauth::DidDoc>(&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::<serviceauth::DidDoc>(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::<serviceauth::DidDoc>( 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, ); }}