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.
This commit is contained in:
parent
fea876654b
commit
e59fa9c713
15 changed files with 1332 additions and 13 deletions
742
hub/tests/avatar.rs
Normal file
742
hub/tests/avatar.rs
Normal file
|
|
@ -0,0 +1,742 @@
|
|||
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);
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue