VNOX-Server/hub/tests/avatar.rs
loki5512344 a2b0f26645
feat(hub): let users upload their own avatar
POST/DELETE /v1/account/avatar (session, exact Origin, CSRF) and public
GET /v1/avatars/<id>. Uploads are sniffed, size and dimension limited,
fully decoded, re-encoded to a 256x256 PNG without metadata and stored in
SQLite, one per account. avatar_url in the session points to it, with the
provider avatar as fallback.

Claude-Session: https://claude.ai/code/session_01GDjxLvBcnJqniFQGUGb1V4
2026-10-24 21:48:05 +02:00

742 lines
24 KiB
Rust

use axum::{
Router,
body::{Body, to_bytes},
http::{Method, Request, Response, StatusCode},
};
use image::{ExtendedColorType, ImageEncoder, RgbImage};
use std::sync::Arc;
use tower::ServiceExt;
use vnox_hub::{
auth::{
self,
provider::GitHubProfile,
store::{self, User},
},
database,
identity::Issuer,
web::{self, HubState},
};
const ORIGIN: &str = "https://central.loki-code.dev";
const GITHUB_AVATAR: &str = "https://avatars.githubusercontent.com/u/123?v=4";
struct Session {
user: User,
token: String,
csrf: String,
}
struct Fixture {
_dir: tempfile::TempDir,
state: Arc<HubState>,
app: Router,
}
async fn fixture() -> Fixture {
let dir = tempfile::tempdir().unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(dir.path(), std::fs::Permissions::from_mode(0o700)).unwrap();
}
let issuer = Issuer::load_or_create(dir.path()).unwrap();
let pool = database::open(dir.path(), &issuer).await.unwrap();
let auth = auth::AuthService::with_provider(pool.clone(), ORIGIN.parse().unwrap(), None);
let state = Arc::new(HubState {
database: pool,
auth: Arc::new(auth),
issuer,
smtp_configured: false,
started: std::time::Instant::now(),
});
Fixture {
_dir: dir,
app: web::router(state.clone()),
state,
}
}
impl Fixture {
async fn email_user(&self, address: &str) -> Session {
let user = store::upsert_email_identity(&self.state.database, address)
.await
.unwrap();
self.session(user).await
}
async fn github_user(&self) -> Session {
let profile = GitHubProfile {
id: 123,
login: "person".into(),
name: Some("Person".into()),
avatar_url: Some(GITHUB_AVATAR.into()),
};
let user = store::upsert_identity(&self.state.database, &profile)
.await
.unwrap();
self.session(user).await
}
async fn session(&self, user: User) -> Session {
let (token, csrf) = store::create_session(&self.state.database, &user.user_id)
.await
.unwrap();
Session { user, token, csrf }
}
async fn send(&self, request: Request<Body>) -> Response<Body> {
self.app.clone().oneshot(request).await.unwrap()
}
/// A well-formed request; callers override pieces to break it.
fn change<'a>(
&'a self,
method: Method,
session: Option<&Session>,
csrf: Option<&str>,
origin: Option<&str>,
content_type: &str,
body: Vec<u8>,
) -> impl std::future::Future<Output = Response<Body>> + use<'a> {
let mut request = Request::builder()
.method(method)
.uri("/v1/account/avatar")
.header("content-type", content_type);
if let Some(session) = session {
request = request.header("cookie", format!("__Host-vnox_session={}", session.token));
}
if let Some(csrf) = csrf {
request = request.header("x-csrf-token", csrf);
}
if let Some(origin) = origin {
request = request.header("origin", origin);
}
self.send(request.body(Body::from(body)).unwrap())
}
async fn upload(&self, session: &Session, content_type: &str, body: Vec<u8>) -> Response<Body> {
self.change(
Method::POST,
Some(session),
Some(&session.csrf),
Some(ORIGIN),
content_type,
body,
)
.await
}
async fn remove(&self, session: &Session) -> Response<Body> {
self.change(
Method::DELETE,
Some(session),
Some(&session.csrf),
Some(ORIGIN),
"application/json",
Vec::new(),
)
.await
}
async fn get(&self, path: &str) -> Response<Body> {
self.send(Request::builder().uri(path).body(Body::empty()).unwrap())
.await
}
async fn session_avatar(&self, session: &Session) -> serde_json::Value {
let response = self
.send(
Request::builder()
.uri("/v1/auth/session")
.header("cookie", format!("__Host-vnox_session={}", session.token))
.body(Body::empty())
.unwrap(),
)
.await;
json(response).await["user"]["avatar_url"].clone()
}
async fn avatar_rows(&self) -> i64 {
sqlx::query_scalar("SELECT COUNT(*) FROM avatars")
.fetch_one(&self.state.database)
.await
.unwrap()
}
}
async fn json(response: Response<Body>) -> serde_json::Value {
serde_json::from_slice(&to_bytes(response.into_body(), 1 << 20).await.unwrap()).unwrap()
}
async fn bytes(response: Response<Body>) -> Vec<u8> {
to_bytes(response.into_body(), 1 << 22)
.await
.unwrap()
.to_vec()
}
fn picture(width: u32, height: u32) -> RgbImage {
RgbImage::from_fn(width, height, |x, y| {
image::Rgb([(x % 256) as u8, (y % 256) as u8, ((x + y) % 256) as u8])
})
}
fn png(width: u32, height: u32) -> Vec<u8> {
let mut out = Vec::new();
image::codecs::png::PngEncoder::new(&mut out)
.write_image(
picture(width, height).as_raw(),
width,
height,
ExtendedColorType::Rgb8,
)
.unwrap();
out
}
fn jpeg(width: u32, height: u32) -> Vec<u8> {
let mut out = Vec::new();
image::codecs::jpeg::JpegEncoder::new(&mut out)
.write_image(
picture(width, height).as_raw(),
width,
height,
ExtendedColorType::Rgb8,
)
.unwrap();
out
}
fn webp(width: u32, height: u32) -> Vec<u8> {
let mut out = Vec::new();
image::codecs::webp::WebPEncoder::new_lossless(&mut out)
.write_image(
picture(width, height).as_raw(),
width,
height,
ExtendedColorType::Rgb8,
)
.unwrap();
out
}
/// Inserts an EXIF APP1 segment carrying `marker` right after the JPEG start marker.
fn with_exif(jpeg: &[u8], marker: &str) -> Vec<u8> {
let mut payload = b"Exif\0\0".to_vec();
payload.extend_from_slice(marker.as_bytes());
let mut out = jpeg[..2].to_vec();
out.extend_from_slice(&[0xFF, 0xE1]);
out.extend_from_slice(&((payload.len() + 2) as u16).to_be_bytes());
out.extend_from_slice(&payload);
out.extend_from_slice(&jpeg[2..]);
out
}
fn crc32(data: &[u8]) -> u32 {
let mut crc = !0u32;
for byte in data {
crc ^= u32::from(*byte);
for _ in 0..8 {
crc = if crc & 1 == 1 {
(crc >> 1) ^ 0xEDB8_8320
} else {
crc >> 1
};
}
}
!crc
}
/// Inserts an ancillary chunk before IEND.
fn with_chunk(png: &[u8], kind: &[u8; 4], data: &[u8]) -> Vec<u8> {
let end = png.len() - 12;
let mut out = png[..end].to_vec();
out.extend_from_slice(&(data.len() as u32).to_be_bytes());
let mut body = kind.to_vec();
body.extend_from_slice(data);
out.extend_from_slice(&body);
out.extend_from_slice(&crc32(&body).to_be_bytes());
out.extend_from_slice(&png[end..]);
out
}
/// Rewrites the IHDR size of a PNG and fixes its CRC: a tiny file that claims huge pixels.
fn claim_size(png: &[u8], width: u32, height: u32) -> Vec<u8> {
let mut out = png.to_vec();
out[16..20].copy_from_slice(&width.to_be_bytes());
out[20..24].copy_from_slice(&height.to_be_bytes());
let crc = crc32(&out[12..29]);
out[29..33].copy_from_slice(&crc.to_be_bytes());
out
}
fn chunk_names(png: &[u8]) -> Vec<String> {
let mut names = Vec::new();
let mut at = 8;
while at + 8 <= png.len() {
let length = u32::from_be_bytes(png[at..at + 4].try_into().unwrap()) as usize;
names.push(String::from_utf8_lossy(&png[at + 4..at + 8]).into_owned());
at += 12 + length;
}
names
}
fn contains(haystack: &[u8], needle: &[u8]) -> bool {
haystack.windows(needle.len()).any(|w| w == needle)
}
async fn assert_error(response: Response<Body>, status: StatusCode, code: &str) {
assert_eq!(response.status(), status);
assert_eq!(response.headers()["cache-control"], "no-store");
assert_eq!(json(response).await["error"], code);
}
#[tokio::test]
async fn upload_reencodes_to_a_square_png_and_serves_it_with_safe_headers() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
assert_eq!(fx.session_avatar(&alice).await, serde_json::Value::Null);
let response = fx.upload(&alice, "image/png", png(600, 300)).await;
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.headers()["cache-control"], "no-store");
let url = json(response).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
assert!(url.starts_with("/v1/avatars/"));
assert_eq!(url.len(), "/v1/avatars/".len() + 64);
assert_eq!(fx.session_avatar(&alice).await, url);
let served = fx.get(&url).await;
assert_eq!(served.status(), StatusCode::OK);
let h = served.headers();
assert_eq!(h["content-type"], "image/png");
assert_eq!(h["x-content-type-options"], "nosniff");
assert_eq!(h["cache-control"], "public, max-age=31536000, immutable");
assert!(
h["content-security-policy"]
.to_str()
.unwrap()
.contains("default-src 'none'")
);
assert!(h.get("set-cookie").is_none());
let body = bytes(served).await;
let decoded = image::load_from_memory(&body).unwrap();
assert_eq!((decoded.width(), decoded.height()), (256, 256));
// The id is the content hash.
assert_eq!(
url,
format!("/v1/avatars/{}", vnox_hub::avatar::content_id(&body))
);
}
#[tokio::test]
async fn jpeg_and_webp_are_accepted_and_exif_and_png_text_chunks_are_removed() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let tagged = with_exif(&jpeg(200, 200), "SECRET-GPS-48.8566N");
assert!(contains(&tagged, b"SECRET-GPS"));
let response = fx.upload(&alice, "image/jpeg", tagged).await;
assert_eq!(response.status(), StatusCode::OK);
let url = json(response).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
let body = bytes(fx.get(&url).await).await;
assert!(!contains(&body, b"SECRET"));
assert!(!contains(&body, b"Exif"));
assert_eq!(chunk_names(&body), ["IHDR", "IDAT", "IEND"]);
let marked = with_chunk(&png(100, 100), b"tEXt", b"Comment\0SECRET-AUTHOR");
let marked = with_chunk(&marked, b"eXIf", b"SECRET-EXIF");
assert!(contains(&marked, b"SECRET-AUTHOR"));
let response = fx.upload(&alice, "image/png", marked).await;
assert_eq!(response.status(), StatusCode::OK);
let url = json(response).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
let body = bytes(fx.get(&url).await).await;
assert!(!contains(&body, b"SECRET"));
assert_eq!(chunk_names(&body), ["IHDR", "IDAT", "IEND"]);
let response = fx.upload(&alice, "image/webp", webp(120, 90)).await;
assert_eq!(response.status(), StatusCode::OK);
let url = json(response).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
let served = fx.get(&url).await;
assert_eq!(served.headers()["content-type"], "image/png");
let decoded = image::load_from_memory(&bytes(served).await).unwrap();
assert_eq!((decoded.width(), decoded.height()), (256, 256));
}
#[tokio::test]
async fn changes_need_session_csrf_and_exact_origin() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let image = png(64, 64);
for method in [Method::POST, Method::DELETE] {
let go = |session, csrf: Option<&str>, origin: Option<&str>| {
fx.change(
method.clone(),
session,
csrf,
origin,
"image/png",
image.clone(),
)
};
assert_error(
go(None, Some(&alice.csrf), Some(ORIGIN)).await,
StatusCode::UNAUTHORIZED,
"not_authenticated",
)
.await;
assert_error(
go(Some(&alice), None, Some(ORIGIN)).await,
StatusCode::FORBIDDEN,
"invalid_csrf",
)
.await;
assert_error(
go(Some(&alice), Some("0".repeat(64).as_str()), Some(ORIGIN)).await,
StatusCode::FORBIDDEN,
"invalid_csrf",
)
.await;
for origin in [
None,
Some("https://evil.example"),
Some("http://central.loki-code.dev"),
Some("https://central.loki-code.dev:8443"),
Some("null"),
] {
assert_error(
go(Some(&alice), Some(&alice.csrf), origin).await,
StatusCode::FORBIDDEN,
"invalid_origin",
)
.await;
}
}
assert_eq!(fx.avatar_rows().await, 0);
}
#[tokio::test]
async fn another_account_cannot_change_or_remove_my_avatar() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let bob = fx.email_user("bob@example.com").await;
let response = fx.upload(&alice, "image/png", png(64, 64)).await;
let alice_url = json(response).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
// Bob's session with Alice's CSRF token, and Alice's cookie with Bob's token.
let mixed = [
fx.change(
Method::DELETE,
Some(&bob),
Some(&alice.csrf),
Some(ORIGIN),
"x/y",
vec![],
)
.await,
fx.change(
Method::POST,
Some(&bob),
Some(&alice.csrf),
Some(ORIGIN),
"image/png",
png(64, 64),
)
.await,
fx.change(
Method::DELETE,
Some(&alice),
Some(&bob.csrf),
Some(ORIGIN),
"x/y",
vec![],
)
.await,
];
for response in mixed {
assert_eq!(response.status(), StatusCode::FORBIDDEN);
}
assert_eq!(fx.session_avatar(&alice).await, alice_url);
assert_eq!(fx.session_avatar(&bob).await, serde_json::Value::Null);
// Bob acting as himself only affects Bob.
assert_eq!(
fx.upload(&bob, "image/png", png(80, 80)).await.status(),
StatusCode::OK
);
assert_eq!(fx.remove(&bob).await.status(), StatusCode::OK);
assert_eq!(fx.session_avatar(&alice).await, alice_url);
assert_eq!(fx.get(&alice_url).await.status(), StatusCode::OK);
}
#[tokio::test]
async fn wrong_types_and_swapped_extensions_are_refused() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let gif = b"GIF89a\x01\x00\x01\x00\x80\x00\x00\x00\x00\x00\xff\xff\xff,\x00\x00\x00\x00\x01\x00\x01\x00\x00\x02\x02D\x01\x00;".to_vec();
let svg = br#"<svg xmlns="http://www.w3.org/2000/svg" width="64" height="64"><script>alert(1)</script></svg>"#.to_vec();
for (declared, body, code) in [
("image/gif", gif.clone(), "unsupported_type"),
("image/png", gif, "unsupported_type"),
("image/svg+xml", svg.clone(), "unsupported_type"),
("image/png", svg, "unsupported_type"),
("text/plain", b"hello".to_vec(), "unsupported_type"),
("application/json", b"{}".to_vec(), "unsupported_type"),
(
"image/png",
b"not an image at all".to_vec(),
"unsupported_type",
),
// A JPEG sent as a PNG, a PNG sent as a JPEG, WebP sent as PNG: the name does not matter.
("image/png", jpeg(64, 64), "type_mismatch"),
("image/jpeg", png(64, 64), "type_mismatch"),
("image/png", webp(64, 64), "type_mismatch"),
] {
assert_error(
fx.upload(&alice, declared, body).await,
StatusCode::UNSUPPORTED_MEDIA_TYPE,
code,
)
.await;
}
// No content type at all.
let response = fx
.send(
Request::builder()
.method(Method::POST)
.uri("/v1/account/avatar")
.header("cookie", format!("__Host-vnox_session={}", alice.token))
.header("x-csrf-token", &alice.csrf)
.header("origin", ORIGIN)
.body(Body::from(png(64, 64)))
.unwrap(),
)
.await;
assert_eq!(response.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
assert_eq!(fx.avatar_rows().await, 0);
}
#[tokio::test]
async fn oversized_bodies_are_refused() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let mut big = png(64, 64);
big.resize(2 * 1024 * 1024 + 1, 0);
// Without a Content-Length (chunked), the read itself stops at the limit.
assert_error(
fx.upload(&alice, "image/png", big.clone()).await,
StatusCode::PAYLOAD_TOO_LARGE,
"too_large",
)
.await;
// With an announced length, it is refused before reading.
let response = fx
.send(
Request::builder()
.method(Method::POST)
.uri("/v1/account/avatar")
.header("cookie", format!("__Host-vnox_session={}", alice.token))
.header("x-csrf-token", &alice.csrf)
.header("origin", ORIGIN)
.header("content-type", "image/png")
.header("content-length", big.len())
.body(Body::from(big))
.unwrap(),
)
.await;
assert_eq!(response.status(), StatusCode::PAYLOAD_TOO_LARGE);
// Unauthenticated callers never get their body read or decoded.
let response = fx
.change(
Method::POST,
None,
None,
Some(ORIGIN),
"image/png",
vec![0; 3 << 20],
)
.await;
assert_eq!(response.status(), StatusCode::UNAUTHORIZED);
assert_eq!(fx.avatar_rows().await, 0);
}
#[tokio::test]
async fn decompression_bomb_and_odd_dimensions_are_refused_before_decoding() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
// Tiny files whose headers claim huge or oversized pictures.
for (w, h) in [(60_000, 60_000), (4097, 64), (64, 4097), (u32::MAX >> 1, 1)] {
let lie = claim_size(&png(64, 64), w, h);
assert!(lie.len() < 100_000);
assert_error(
fx.upload(&alice, "image/png", lie).await,
StatusCode::UNPROCESSABLE_ENTITY,
"bad_dimensions",
)
.await;
}
// Real, merely oversized or undersized pictures.
assert_error(
fx.upload(&alice, "image/png", png(4097, 40)).await,
StatusCode::UNPROCESSABLE_ENTITY,
"bad_dimensions",
)
.await;
assert_error(
fx.upload(&alice, "image/jpeg", jpeg(16, 16)).await,
StatusCode::UNPROCESSABLE_ENTITY,
"bad_dimensions",
)
.await;
// Truncated and corrupted data.
let mut cut = png(300, 300);
cut.truncate(cut.len() / 2);
assert_error(
fx.upload(&alice, "image/png", cut).await,
StatusCode::UNPROCESSABLE_ENTITY,
"invalid_image",
)
.await;
let mut cut = jpeg(300, 300);
cut.truncate(60);
let response = fx.upload(&alice, "image/jpeg", cut).await;
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
assert_eq!(fx.avatar_rows().await, 0);
}
#[tokio::test]
async fn a_new_upload_replaces_the_old_one() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let first = json(fx.upload(&alice, "image/png", png(100, 100)).await).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
let second = json(fx.upload(&alice, "image/jpeg", jpeg(150, 150)).await).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
assert_ne!(first, second);
assert_eq!(fx.avatar_rows().await, 1);
assert_eq!(fx.get(&first).await.status(), StatusCode::NOT_FOUND);
assert_eq!(fx.get(&second).await.status(), StatusCode::OK);
assert_eq!(fx.session_avatar(&alice).await, second);
}
#[tokio::test]
async fn delete_returns_the_provider_avatar_or_the_default() {
let fx = fixture().await;
let github = fx.github_user().await;
assert_eq!(fx.session_avatar(&github).await, GITHUB_AVATAR);
let url = json(fx.upload(&github, "image/png", png(64, 64)).await).await["avatar_url"]
.as_str()
.unwrap()
.to_owned();
assert_ne!(fx.session_avatar(&github).await, GITHUB_AVATAR);
let response = fx.remove(&github).await;
assert_eq!(response.status(), StatusCode::OK);
assert_eq!(response.headers()["cache-control"], "no-store");
assert_eq!(json(response).await["avatar_url"], GITHUB_AVATAR);
assert_eq!(fx.session_avatar(&github).await, GITHUB_AVATAR);
assert_eq!(fx.get(&url).await.status(), StatusCode::NOT_FOUND);
assert_eq!(fx.avatar_rows().await, 0);
// Removing again is harmless, and an email account falls back to the default (null).
assert_eq!(fx.remove(&github).await.status(), StatusCode::OK);
let alice = fx.email_user("alice@example.com").await;
fx.upload(&alice, "image/png", png(64, 64)).await;
let response = fx.remove(&alice).await;
assert_eq!(json(response).await["avatar_url"], serde_json::Value::Null);
assert_eq!(fx.session_avatar(&alice).await, serde_json::Value::Null);
}
#[tokio::test]
async fn avatar_urls_are_validated_and_unknown_ids_are_not_found() {
let fx = fixture().await;
for path in [
"/v1/avatars/".to_owned(),
"/v1/avatars/abc".to_owned(),
format!("/v1/avatars/{}", "0".repeat(64)),
format!("/v1/avatars/{}", "G".repeat(64)),
format!("/v1/avatars/{}", "A".repeat(64)),
"/v1/avatars/..%2F..%2Fhub.sqlite3".to_owned(),
] {
let response = fx.get(&path).await;
assert_eq!(response.status(), StatusCode::NOT_FOUND, "{path}");
assert_eq!(response.headers()["cache-control"], "no-store");
}
}
#[tokio::test]
async fn upload_rate_limit_applies_per_account() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
let bob = fx.email_user("bob@example.com").await;
let image = png(64, 64);
for _ in 0..10 {
assert_eq!(
fx.upload(&alice, "image/png", image.clone()).await.status(),
StatusCode::OK
);
}
assert_error(
fx.upload(&alice, "image/png", image.clone()).await,
StatusCode::TOO_MANY_REQUESTS,
"try_later",
)
.await;
assert_error(
fx.remove(&alice).await,
StatusCode::TOO_MANY_REQUESTS,
"try_later",
)
.await;
// Another account from the same source still has its own budget.
assert_eq!(
fx.upload(&bob, "image/png", image).await.status(),
StatusCode::OK
);
}
#[tokio::test]
async fn upload_rate_limit_applies_per_source() {
let fx = fixture().await;
let image = png(64, 64);
let mut accepted = 0;
for n in 0..40 {
let user = fx.email_user(&format!("user{n}@example.com")).await;
let response = fx
.send(
Request::builder()
.method(Method::POST)
.uri("/v1/account/avatar")
.header("cookie", format!("__Host-vnox_session={}", user.token))
.header("x-csrf-token", &user.csrf)
.header("origin", ORIGIN)
.header("x-forwarded-for", "203.0.113.9")
.header("content-type", "image/png")
.body(Body::from(image.clone()))
.unwrap(),
)
.await;
match response.status() {
StatusCode::OK => accepted += 1,
StatusCode::TOO_MANY_REQUESTS => break,
other => panic!("unexpected {other}"),
}
}
assert_eq!(accepted, 30);
}
#[tokio::test]
async fn deleting_an_account_removes_its_avatar() {
let fx = fixture().await;
let alice = fx.email_user("alice@example.com").await;
fx.upload(&alice, "image/png", png(64, 64)).await;
sqlx::query("DELETE FROM accounts WHERE user_id=?")
.bind(&alice.user.user_id)
.execute(&fx.state.database)
.await
.unwrap();
assert_eq!(fx.avatar_rows().await, 0);
}