use crate::persistence::sql::entry::{EntryEntity, EntryRepository};
use crate::shared::{HttpError, HttpResult};
use crate::{
client_server::{
auth::{has_read_permission, AuthSession},
middleware::pubky_host::PubkyHost,
query_params::ListQueryParams,
AppState,
},
shared::webdav::{EntryPath, WebDavPathAxum},
};
use axum::{
body::Body,
extract::{Path, State},
http::{header, HeaderMap, HeaderValue, Response, StatusCode},
response::IntoResponse,
};
use httpdate::HttpDate;
use sqlx::types::chrono::{DateTime, Utc};
use std::str::FromStr;
use std::time::SystemTime;
pub async fn head(
State(state): State<AppState>,
session: Option<AuthSession>,
pubky: PubkyHost,
Path(path): Path<WebDavPathAxum>,
) -> HttpResult<impl IntoResponse> {
has_read_permission(session.as_ref(), Some(pubky.public_key()), path.inner())?;
state
.user_service
.get_or_http_error(pubky.public_key(), false)
.await?;
let entry_path = EntryPath::new(pubky.public_key().clone(), path.inner().clone());
let entry = state
.file_service
.get_info(&entry_path, &mut state.sql_db.pool().into())
.await?;
let response = entry.to_response_headers().into_response();
Ok(response)
}
#[axum::debug_handler]
pub async fn get(
State(state): State<AppState>,
headers: HeaderMap,
session: Option<AuthSession>,
pubky: PubkyHost,
Path(path): Path<WebDavPathAxum>,
params: ListQueryParams,
) -> HttpResult<impl IntoResponse> {
has_read_permission(session.as_ref(), Some(pubky.public_key()), path.inner())?;
let public_key = pubky.public_key().clone();
let entry_path = EntryPath::new(public_key.clone(), path.inner().clone());
if entry_path.path().is_directory() {
return list(state, &entry_path, params).await;
}
let entry = state
.file_service
.get_info(&entry_path, &mut state.sql_db.pool().into())
.await?;
if let Some(request_etag) = headers
.get(header::IF_NONE_MATCH)
.and_then(|h| h.to_str().ok())
{
let current_etag = format!(
"\"{}\"",
base64::Engine::encode(
&base64::engine::general_purpose::STANDARD,
entry.content_hash.as_bytes()
)
);
if request_etag
.trim()
.split(',')
.map(|s| s.trim())
.any(|tag| tag == current_etag)
{
return not_modified_response(&entry);
}
} else if let Some(condition_http_date) = headers
.get(header::IF_MODIFIED_SINCE)
.and_then(|h| h.to_str().ok())
.and_then(|s| HttpDate::from_str(s).ok())
{
let entry_http_date: HttpDate = to_http_date(&entry.modified_at);
if condition_http_date >= entry_http_date {
return not_modified_response(&entry);
}
}
let stream = state.file_service.get_stream(&entry_path).await?;
let body_stream = Body::from_stream(stream);
let mut response = entry.to_response_headers().into_response();
*response.body_mut() = body_stream;
Ok(response)
}
async fn list(
state: AppState,
entry_path: &EntryPath,
params: ListQueryParams,
) -> HttpResult<Response<Body>> {
let contains_dir =
EntryRepository::contains_directory(entry_path, &mut state.sql_db.pool().into()).await?;
if !contains_dir {
return Err(HttpError::new_with_message(
StatusCode::NOT_FOUND,
"Directory Not Found",
));
}
let parsed_cursor = match parse_cursor(params.cursor) {
Ok(cursor) => cursor,
Err(_) => {
return Err(HttpError::new_with_message(
StatusCode::BAD_REQUEST,
"Invalid cursor",
))
}
};
let entries = if params.shallow {
EntryRepository::list_shallow(
entry_path,
params.limit,
parsed_cursor,
params.reverse,
&mut state.sql_db.pool().into(),
)
.await?
} else {
EntryRepository::list_deep(
entry_path,
params.limit,
parsed_cursor,
params.reverse,
&mut state.sql_db.pool().into(),
)
.await?
};
let pubky_urls = entries
.iter()
.map(|entry| format!("pubky://{}", entry))
.collect::<Vec<_>>();
Ok(Response::builder()
.status(StatusCode::OK)
.header(header::CONTENT_TYPE, "text/plain")
.body(Body::from(pubky_urls.join("\n")))?)
}
fn parse_cursor(cursor: Option<String>) -> anyhow::Result<Option<EntryPath>> {
let cursor = match cursor {
Some(cursor) => cursor,
None => return Ok(None),
};
let cursor = cursor.trim_start_matches("pubky://");
let path = EntryPath::from_str(cursor)?;
Ok(Some(path))
}
fn not_modified_response(entry: &EntryEntity) -> HttpResult<Response<Body>> {
Ok(Response::builder()
.status(StatusCode::NOT_MODIFIED)
.header(
header::ETAG,
format!(
"\"{}\"",
base64::Engine::encode(
&base64::engine::general_purpose::STANDARD,
entry.content_hash.as_bytes()
)
),
)
.header(
header::LAST_MODIFIED,
to_http_date(&entry.modified_at).to_string().as_str(),
)
.header(header::VARY, "pubky-host")
.header(header::CACHE_CONTROL, "private, must-revalidate")
.body(Body::empty())?)
}
fn to_http_date(date: &sqlx::types::chrono::NaiveDateTime) -> HttpDate {
let sys_datetime = SystemTime::from(DateTime::<Utc>::from_naive_utc_and_offset(*date, Utc));
httpdate::HttpDate::from(sys_datetime)
}
impl EntryEntity {
pub fn to_response_headers(&self) -> HeaderMap {
let mut headers = HeaderMap::new();
headers.insert(header::CONTENT_LENGTH, self.content_length.into());
headers.insert(
header::LAST_MODIFIED,
HeaderValue::from_str(to_http_date(&self.modified_at).to_string().as_str())
.expect("http date is valid header value"),
);
headers.insert(
header::CONTENT_TYPE,
self.content_type
.clone()
.try_into()
.or(HeaderValue::from_str(""))
.expect("valid header value"),
);
headers.insert(
header::ETAG,
format!(
"\"{}\"",
base64::Engine::encode(
&base64::engine::general_purpose::STANDARD,
self.content_hash.as_bytes()
)
)
.try_into()
.expect("base64 string is valid"),
);
headers.insert(header::VARY, HeaderValue::from_static("pubky-host"));
headers.insert(
header::CACHE_CONTROL,
HeaderValue::from_static("private, must-revalidate"),
);
headers
}
}
#[cfg(test)]
mod tests {
use axum::http::{header, HeaderMap, Method, StatusCode};
use axum::Router;
use axum_test::TestServer;
use pubky_common::{
auth::AuthToken,
capabilities::Capability,
crypto::{Keypair, PublicKey},
};
use crate::app_context::AppContext;
use crate::client_server::ClientServer;
async fn create_user_with_capabilities(
server: &axum_test::TestServer,
keypair: &Keypair,
capabilities: Vec<Capability>,
) -> anyhow::Result<String> {
let auth_token = AuthToken::sign(keypair, capabilities);
let body_bytes: axum::body::Bytes = auth_token.serialize().into();
let response = server
.post("/signup")
.add_header("host", keypair.public_key().to_z32())
.bytes(body_bytes)
.expect_success()
.await;
let header_value = response
.headers()
.get(header::SET_COOKIE)
.and_then(|h| h.to_str().ok())
.expect("should return a set-cookie header")
.to_string();
Ok(header_value)
}
pub async fn create_root_user(
server: &axum_test::TestServer,
keypair: &Keypair,
) -> anyhow::Result<String> {
create_user_with_capabilities(server, keypair, vec![Capability::root()]).await
}
async fn sign_in_with_capabilities(
server: &axum_test::TestServer,
keypair: &Keypair,
capabilities: Vec<Capability>,
) -> anyhow::Result<String> {
let auth_token = AuthToken::sign(keypair, capabilities);
let body_bytes: axum::body::Bytes = auth_token.serialize().into();
let response = server
.post("/session")
.add_header("host", keypair.public_key().to_z32())
.bytes(body_bytes)
.expect_success()
.await;
Ok(response
.headers()
.get(header::SET_COOKIE)
.and_then(|h| h.to_str().ok())
.expect("should return a set-cookie header")
.to_string())
}
async fn create_environment_with_keypair(
) -> anyhow::Result<(AppContext, Router, TestServer, Keypair, String)> {
let context = AppContext::test().await;
let router = ClientServer::create_router(&context)?;
let server = axum_test::TestServer::new(router.clone()).unwrap();
let keypair = Keypair::random();
let cookie = create_root_user(&server, &keypair).await?.to_string();
Ok((context, router, server, keypair, cookie))
}
pub async fn create_environment(
) -> anyhow::Result<(AppContext, Router, TestServer, PublicKey, String)> {
let (context, router, server, keypair, cookie) = create_environment_with_keypair().await?;
let public_key = keypair.public_key();
Ok((context, router, server, public_key, cookie))
}
fn header_value(headers: &HeaderMap, name: header::HeaderName) -> Option<&str> {
headers.get(name).and_then(|value| value.to_str().ok())
}
fn assert_private_cache_policy(headers: &HeaderMap) {
assert_eq!(
header_value(headers, header::CACHE_CONTROL),
Some("no-store")
);
assert_eq!(
header_value(headers, header::VARY),
Some("pubky-host, Authorization, Cookie")
);
}
fn assert_no_validators(headers: &HeaderMap) {
assert!(!headers.contains_key(header::ETAG));
assert!(!headers.contains_key(header::LAST_MODIFIED));
}
fn assert_validators_present(headers: &HeaderMap) {
assert!(headers.contains_key(header::ETAG));
assert!(headers.contains_key(header::LAST_MODIFIED));
}
#[tokio::test]
#[pubky_test_utils::test]
async fn invalid_path_aliases_cannot_modify_canonical_file() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/pub/report")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.text("original")
.expect_success()
.await;
for alias in [
"/pub/report%20",
"/pub/report%C2%A0",
"/pub/report%E3%80%80",
"/pub/scope/%5C..%5Creport",
] {
server
.put(alias)
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.text("overwritten")
.expect_failure()
.await
.assert_status(StatusCode::BAD_REQUEST);
server
.delete(alias)
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.expect_failure()
.await
.assert_status(StatusCode::BAD_REQUEST);
}
let response = server
.get("/pub/report")
.add_header("host", public_key.z32())
.expect_success()
.await;
assert_eq!(response.text(), "original");
}
#[tokio::test]
#[pubky_test_utils::test]
async fn if_last_modified() {
let (_context, _router, server, public_key, cookie) = create_environment().await.unwrap();
let data = vec![1_u8, 2, 3, 4, 5];
server
.put("/pub/foo")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.bytes(data.into())
.expect_success()
.await;
let response = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.expect_success()
.await;
let response = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.add_header(
header::IF_MODIFIED_SINCE,
response.headers().get(header::LAST_MODIFIED).unwrap(),
)
.await;
response.assert_status(StatusCode::NOT_MODIFIED);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn if_none_match() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
let data = vec![1_u8, 2, 3, 4, 5];
server
.put("/pub/foo")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.bytes(data.into())
.expect_success()
.await;
let response = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.expect_success()
.await;
let response = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.add_header(
header::IF_NONE_MATCH,
response.headers().get(header::ETAG).unwrap(),
)
.await;
response.assert_status(StatusCode::NOT_MODIFIED);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn test_content_with_magic_bytes() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
let data = vec![0x89_u8, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A];
server
.put("/pub/foo")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.bytes(data.into())
.expect_success()
.await;
let response = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.await;
response.assert_header(header::CONTENT_TYPE, "image/png");
}
#[tokio::test]
#[pubky_test_utils::test]
async fn test_content_by_extension() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
let data = vec![108, 111, 114, 101, 109, 32, 105, 112, 115, 117, 109];
server
.put("/pub/text.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.bytes(data.into())
.expect_success()
.await;
let response = server
.get("/pub/text.txt")
.add_header("host", public_key.z32())
.await;
response.assert_header(header::CONTENT_TYPE, "text/plain");
}
#[tokio::test]
async fn if_none_match_precedes_if_modified_since() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/pub/foo")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("alice").into())
.expect_success()
.await;
let base = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.expect_success()
.await;
let etag_v1 = base
.headers()
.get(header::ETAG)
.unwrap()
.to_str()
.unwrap()
.to_string();
let lm_v1 = base.headers().get(header::LAST_MODIFIED).unwrap().clone();
server
.put("/pub/foo")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("bob").into())
.expect_success()
.await;
let r = server
.get("/pub/foo")
.add_header("host", public_key.z32())
.add_header(header::IF_NONE_MATCH, etag_v1)
.add_header(header::IF_MODIFIED_SINCE, lm_v1)
.await;
r.assert_status(StatusCode::OK);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn pub_get_stays_anonymous_after_dual_root_switch() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/pub/foo.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.bytes(Vec::from("public").into())
.expect_success()
.await;
server
.get("/pub/foo.txt")
.add_header("host", public_key.z32())
.expect_success()
.await;
}
#[tokio::test]
#[pubky_test_utils::test]
async fn priv_get_requires_authentication() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("top secret").into())
.expect_success()
.await;
server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.await
.assert_status(StatusCode::UNAUTHORIZED);
let resp = server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.expect_success()
.await;
assert_eq!(resp.text(), "top secret");
}
#[tokio::test]
#[pubky_test_utils::test]
async fn priv_get_is_not_an_existence_oracle() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/priv/exists.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("data").into())
.expect_success()
.await;
server
.get("/priv/exists.txt")
.add_header("host", public_key.z32())
.await
.assert_status(StatusCode::UNAUTHORIZED);
server
.get("/priv/absent.txt")
.add_header("host", public_key.z32())
.await
.assert_status(StatusCode::UNAUTHORIZED);
server
.get("/priv/absent.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.await
.assert_status(StatusCode::NOT_FOUND);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn priv_head_mirrors_get() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("hello").into())
.expect_success()
.await;
server
.method(Method::HEAD, "/priv/secret.txt")
.add_header("host", public_key.z32())
.await
.assert_status(StatusCode::UNAUTHORIZED);
server
.method(Method::HEAD, "/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.await
.assert_status(StatusCode::OK);
server
.method(Method::HEAD, "/priv/absent.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.await
.assert_status(StatusCode::NOT_FOUND);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn priv_conditional_get_is_authorized_first() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("v1").into())
.expect_success()
.await;
let owned = server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.expect_success()
.await;
let etag = owned.headers().get(header::ETAG).unwrap().clone();
server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::IF_NONE_MATCH, etag)
.await
.assert_status(StatusCode::UNAUTHORIZED);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn priv_directory_listing_requires_auth() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
for name in ["a.txt", "b.txt"] {
server
.put(&format!("/priv/app/{name}"))
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("x").into())
.expect_success()
.await;
}
server
.get("/priv/app/")
.add_header("host", public_key.z32())
.await
.assert_status(StatusCode::UNAUTHORIZED);
server
.get("/priv/nope/")
.add_header("host", public_key.z32())
.await
.assert_status(StatusCode::UNAUTHORIZED);
let resp = server
.get("/priv/app/")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.expect_success()
.await;
let body = resp.text();
assert!(
body.contains("/priv/app/a.txt"),
"listing should include a.txt, got: {body}"
);
assert!(
body.contains("/priv/app/b.txt"),
"listing should include b.txt, got: {body}"
);
}
#[tokio::test]
#[pubky_test_utils::test]
async fn priv_responses_use_no_store_and_auth_vary() {
let (_, _, server, keypair, cookie) = create_environment_with_keypair().await.unwrap();
let public_key = keypair.public_key();
server
.put("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("top secret").into())
.expect_success()
.await;
server
.put("/priv/app/a.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("a").into())
.expect_success()
.await;
let ok = server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.expect_success()
.await;
assert_private_cache_policy(ok.headers());
assert_validators_present(ok.headers());
let not_modified = server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.add_header(
header::IF_NONE_MATCH,
ok.headers().get(header::ETAG).unwrap(),
)
.await;
not_modified.assert_status(StatusCode::NOT_MODIFIED);
assert_private_cache_policy(not_modified.headers());
assert_validators_present(not_modified.headers());
let head = server
.method(Method::HEAD, "/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.await;
head.assert_status(StatusCode::OK);
assert_private_cache_policy(head.headers());
assert_validators_present(head.headers());
let listing = server
.get("/priv/app/")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.expect_success()
.await;
assert_private_cache_policy(listing.headers());
let unauthorized = server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.await;
unauthorized.assert_status(StatusCode::UNAUTHORIZED);
assert_private_cache_policy(unauthorized.headers());
assert_no_validators(unauthorized.headers());
let write_only_cookie = sign_in_with_capabilities(
&server,
&keypair,
vec![Capability::write("/priv/").unwrap()],
)
.await
.unwrap();
let forbidden = server
.get("/priv/secret.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, write_only_cookie)
.await;
forbidden.assert_status(StatusCode::FORBIDDEN);
assert_private_cache_policy(forbidden.headers());
assert_no_validators(forbidden.headers());
let missing = server
.get("/priv/missing.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.await;
missing.assert_status(StatusCode::NOT_FOUND);
assert_private_cache_policy(missing.headers());
assert_no_validators(missing.headers());
}
#[tokio::test]
#[pubky_test_utils::test]
async fn pub_headers_are_unchanged_by_private_cache_policy() {
let (_, _, server, public_key, cookie) = create_environment().await.unwrap();
server
.put("/pub/file.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie.clone())
.bytes(Vec::from("public").into())
.expect_success()
.await;
server
.put("/pub/app/a.txt")
.add_header("host", public_key.z32())
.add_header(header::COOKIE, cookie)
.bytes(Vec::from("a").into())
.expect_success()
.await;
let ok = server
.get("/pub/file.txt")
.add_header("host", public_key.z32())
.expect_success()
.await;
assert_eq!(
header_value(ok.headers(), header::CACHE_CONTROL),
Some("private, must-revalidate")
);
assert_eq!(header_value(ok.headers(), header::VARY), Some("pubky-host"));
assert_validators_present(ok.headers());
let not_modified = server
.get("/pub/file.txt")
.add_header("host", public_key.z32())
.add_header(
header::IF_NONE_MATCH,
ok.headers().get(header::ETAG).unwrap(),
)
.await;
not_modified.assert_status(StatusCode::NOT_MODIFIED);
assert_eq!(
header_value(not_modified.headers(), header::CACHE_CONTROL),
Some("private, must-revalidate")
);
assert_eq!(
header_value(not_modified.headers(), header::VARY),
Some("pubky-host")
);
assert_validators_present(not_modified.headers());
let listing = server
.get("/pub/app/")
.add_header("host", public_key.z32())
.expect_success()
.await;
assert!(header_value(listing.headers(), header::CACHE_CONTROL).is_none());
}
}