forked from mtusi2026/mtusi2026lab4
510 lines
14 KiB
TypeScript
510 lines
14 KiB
TypeScript
import { createHash, randomBytes, randomUUID } from 'node:crypto';
|
|
import { readFileSync } from 'node:fs';
|
|
import net from 'node:net';
|
|
import { setTimeout as sleep } from 'node:timers/promises';
|
|
import { afterAll, beforeAll, describe, expect, it } from 'vitest';
|
|
import type { Pool } from 'pg';
|
|
import type { ApiErrorBody } from '../src/common/errors/api-error.js';
|
|
import type { Page } from '../src/common/http/page.js';
|
|
import type { Message } from '../src/messages/message.js';
|
|
import {
|
|
Actor,
|
|
actor,
|
|
baseUrl,
|
|
bearer,
|
|
createChat,
|
|
database,
|
|
download,
|
|
expectError,
|
|
http,
|
|
postMessage,
|
|
upload,
|
|
uploadRaw,
|
|
} from './support/e2e.js';
|
|
import sharp from 'sharp';
|
|
import { jpegWithMetadata, jpegWithoutScanData } from './support/jpeg.js';
|
|
import {
|
|
maxPixelsRgba16Png,
|
|
noisePng,
|
|
padPngTo,
|
|
pixelBombPng,
|
|
pngWithGarbageIdat,
|
|
} from './support/png.js';
|
|
|
|
const png = readFileSync(
|
|
new URL('../../tests/fixtures/sample.png', import.meta.url),
|
|
);
|
|
const jpeg = readFileSync(new URL('./fixtures/sample.jpg', import.meta.url));
|
|
const progressive = readFileSync(
|
|
new URL('./fixtures/sample-progressive.jpg', import.meta.url),
|
|
);
|
|
const MAX = 10_485_760;
|
|
|
|
let db: Pool;
|
|
let alice: Actor;
|
|
let bob: Actor;
|
|
let eve: Actor;
|
|
let chatId: string;
|
|
let eveChatId: string;
|
|
let leftoverChatId: string;
|
|
|
|
const sha256 = (data: Uint8Array) =>
|
|
createHash('sha256').update(data).digest('hex');
|
|
|
|
async function ready(data: Buffer, type = 'image/png', chat = chatId) {
|
|
const result = await upload(alice.token, chat, data, {
|
|
contentType: type,
|
|
});
|
|
expect(result.response.status).toBe(201);
|
|
return result.body;
|
|
}
|
|
|
|
describe('attachments (proxy upload)', () => {
|
|
beforeAll(async () => {
|
|
db = database();
|
|
alice = await actor();
|
|
bob = await actor();
|
|
eve = await actor();
|
|
chatId = (await createChat(alice, [bob])).id;
|
|
eveChatId = (await createChat(eve, [])).id;
|
|
// Chat for rejected uploads: it must end up without any row.
|
|
leftoverChatId = (await createChat(alice, [])).id;
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await db.end();
|
|
});
|
|
|
|
it('stores a PNG and serves it only to chat members', async () => {
|
|
const created = await upload(alice.token, chatId, png, {
|
|
filename: 'Снимок.png',
|
|
});
|
|
expect(created.response.status).toBe(201);
|
|
expect(created.body).toMatchObject({
|
|
chat_id: chatId,
|
|
owner_id: alice.user.id,
|
|
filename: 'Снимок.png',
|
|
content_type: 'image/png',
|
|
size_bytes: png.length,
|
|
sha256: sha256(png),
|
|
status: 'ready',
|
|
variants: [],
|
|
error_code: null,
|
|
});
|
|
const id = created.body.id;
|
|
|
|
const metadata = await http<typeof created.body>(
|
|
`/api/v1/attachments/${id}`,
|
|
{ headers: bearer(bob.token) },
|
|
);
|
|
expect(metadata.response.status).toBe(200);
|
|
expect(metadata.body.sha256).toBe(sha256(png));
|
|
|
|
const content = await download(bob.token, id);
|
|
expect(content.response.status).toBe(200);
|
|
expect(content.response.headers.get('content-type')).toBe('image/png');
|
|
expect(content.response.headers.get('x-content-type-options')).toBe(
|
|
'nosniff',
|
|
);
|
|
expect(content.response.headers.get('content-length')).toBe(
|
|
String(png.length),
|
|
);
|
|
expect(content.response.headers.get('content-disposition')).toContain(
|
|
"filename*=UTF-8''%D0%A1",
|
|
);
|
|
expect(content.bytes.equals(png)).toBe(true);
|
|
|
|
for (const path of [`/${id}`, `/${id}/content`]) {
|
|
expectError(
|
|
await http(`/api/v1/attachments${path}`, {
|
|
headers: bearer(eve.token),
|
|
}),
|
|
404,
|
|
'not_found',
|
|
);
|
|
}
|
|
expectError(
|
|
await http(`/api/v1/attachments/${id}/content`),
|
|
401,
|
|
'unauthorized',
|
|
);
|
|
expectError(await upload(eve.token, chatId, png), 404, 'not_found');
|
|
expectError(
|
|
await http(`/api/v1/attachments/${randomUUID()}`, {
|
|
headers: bearer(bob.token),
|
|
}),
|
|
404,
|
|
'not_found',
|
|
);
|
|
});
|
|
|
|
it.each([
|
|
['JPEG', jpeg],
|
|
['progressive JPEG', progressive],
|
|
])('accepts a %s', async (_name, data) => {
|
|
const created = await ready(data, 'image/jpeg');
|
|
expect(created.content_type).toBe('image/jpeg');
|
|
const content = await download(alice.token, created.id);
|
|
expect(content.bytes.equals(data)).toBe(true);
|
|
});
|
|
|
|
it('accepts camera-size images up to the pixel limit', async () => {
|
|
// 7728x5152 = 39.8 MP, like a 40 MP camera; decoded size far above the
|
|
// replica's 16 MiB /tmp, so libvips must not spill to a temp file.
|
|
const camera = sharp({
|
|
create: {
|
|
width: 7728,
|
|
height: 5152,
|
|
channels: 3,
|
|
background: { r: 120, g: 80, b: 40 },
|
|
},
|
|
});
|
|
const baseline = await camera.clone().jpeg({ quality: 85 }).toBuffer();
|
|
const progressiveCamera = await camera
|
|
.clone()
|
|
.jpeg({ quality: 85, progressive: true })
|
|
.toBuffer();
|
|
for (const data of [baseline, progressiveCamera])
|
|
expect((await ready(data, 'image/jpeg')).size_bytes).toBe(
|
|
data.length,
|
|
);
|
|
const rgba16 = await maxPixelsRgba16Png();
|
|
expect((await ready(rgba16)).size_bytes).toBe(rgba16.length);
|
|
}, 120_000);
|
|
|
|
it('accepts a JPEG with megabytes of metadata before the frame header', async () => {
|
|
const data = jpegWithMetadata(jpeg, 20);
|
|
expect(data.length).toBeGreaterThan(1_048_576);
|
|
expect((await ready(data, 'image/jpeg')).sha256).toBe(sha256(data));
|
|
});
|
|
|
|
it('authenticates before judging the content type', async () => {
|
|
const zip = await http<ApiErrorBody>(
|
|
`/api/v1/chats/${chatId}/attachments?filename=a.zip`,
|
|
{
|
|
method: 'POST',
|
|
headers: { 'content-type': 'application/zip' },
|
|
body: png as unknown as BodyInit,
|
|
},
|
|
);
|
|
expectError(zip, 401, 'unauthorized');
|
|
expectError(
|
|
await upload(alice.token, leftoverChatId, png, {
|
|
contentType: 'application/json',
|
|
}),
|
|
415,
|
|
'unsupported_media_type',
|
|
);
|
|
});
|
|
|
|
it('answers 413 with the error envelope to an oversized text body on JSON routes', async () => {
|
|
const result = await http<ApiErrorBody>(
|
|
`/api/v1/chats/${chatId}/messages`,
|
|
{
|
|
method: 'POST',
|
|
headers: {
|
|
...bearer(alice.token),
|
|
'content-type': 'text/plain',
|
|
'idempotency-key': randomUUID().replaceAll('-', ''),
|
|
},
|
|
body: 'x'.repeat(2_100_000),
|
|
},
|
|
);
|
|
expectError(result, 413, 'payload_too_large');
|
|
});
|
|
|
|
it('keeps one slow client from taking every upload slot', async () => {
|
|
const slow = await actor();
|
|
const slowChat = (await createChat(slow, [])).id;
|
|
const url = new URL(baseUrl);
|
|
const sockets: net.Socket[] = [];
|
|
try {
|
|
for (let index = 0; index < 12; index += 1) {
|
|
const socket = net.connect(
|
|
Number(url.port || 80),
|
|
url.hostname,
|
|
);
|
|
socket.on('error', () => {});
|
|
socket.write(
|
|
`POST /api/v1/chats/${slowChat}/attachments?filename=slow.png HTTP/1.1\r\n` +
|
|
`Host: ${url.host}\r\nAuthorization: Bearer ${slow.token}\r\n` +
|
|
`Content-Type: image/png\r\nContent-Length: ${png.length}\r\n\r\n`,
|
|
);
|
|
socket.write(png.subarray(0, 4));
|
|
sockets.push(socket);
|
|
}
|
|
await sleep(1000);
|
|
const extra = await upload(slow.token, slowChat, png);
|
|
expectError(extra, 429, 'rate_limited');
|
|
expect(extra.response.headers.get('retry-after')).toBe('1');
|
|
// Another user is not affected by the slow client.
|
|
for (let index = 0; index < 4; index += 1)
|
|
expect(
|
|
(await upload(bob.token, chatId, png)).response.status,
|
|
).toBe(201);
|
|
} finally {
|
|
for (const socket of sockets) socket.destroy();
|
|
}
|
|
await settled(slowChat);
|
|
});
|
|
|
|
it('enforces the 10 MiB limit exactly', async () => {
|
|
const exact = padPngTo(png, MAX);
|
|
const created = await ready(exact);
|
|
expect(created.size_bytes).toBe(MAX);
|
|
expectError(
|
|
await upload(alice.token, leftoverChatId, padPngTo(png, MAX + 1)),
|
|
413,
|
|
'payload_too_large',
|
|
);
|
|
});
|
|
|
|
it('rejects a pixel bomb before storing anything', async () => {
|
|
expectError(
|
|
await upload(alice.token, leftoverChatId, pixelBombPng()),
|
|
413,
|
|
'payload_too_large',
|
|
);
|
|
});
|
|
|
|
it('rejects damaged images', async () => {
|
|
const flipped = Buffer.from(png);
|
|
flipped[Math.floor(png.length / 2)] ^= 0xff;
|
|
const cases: Buffer[] = [
|
|
png.subarray(0, png.length - 100),
|
|
flipped,
|
|
Buffer.concat([png.subarray(0, 8), randomBytes(2048)]),
|
|
Buffer.alloc(0),
|
|
// Structure and CRCs are fine; the pixel data does not decode.
|
|
pngWithGarbageIdat(),
|
|
];
|
|
for (const data of cases)
|
|
expectError(
|
|
await upload(alice.token, leftoverChatId, data),
|
|
415,
|
|
'unsupported_media_type',
|
|
);
|
|
});
|
|
|
|
it.each([
|
|
['baseline', jpeg],
|
|
['progressive', progressive],
|
|
])('rejects a %s JPEG without scan data', async (_name, data) => {
|
|
expectError(
|
|
await upload(
|
|
alice.token,
|
|
leftoverChatId,
|
|
jpegWithoutScanData(data),
|
|
{
|
|
contentType: 'image/jpeg',
|
|
},
|
|
),
|
|
415,
|
|
'unsupported_media_type',
|
|
);
|
|
});
|
|
|
|
it('rejects a content type that does not match the bytes', async () => {
|
|
const gif = Buffer.from('GIF89a' + 'x'.repeat(64));
|
|
const cases: [Buffer, string][] = [
|
|
[png, 'image/jpeg'],
|
|
[jpeg, 'image/png'],
|
|
[gif, 'image/png'],
|
|
[png, 'text/plain'],
|
|
[png, 'application/octet-stream'],
|
|
];
|
|
for (const [data, type] of cases)
|
|
expectError(
|
|
await upload(alice.token, leftoverChatId, data, {
|
|
contentType: type,
|
|
}),
|
|
415,
|
|
'unsupported_media_type',
|
|
);
|
|
});
|
|
|
|
it('validates filenames by code points and forbidden characters', async () => {
|
|
const bad = [
|
|
'?filename=a%2Fb.png',
|
|
'?filename=a%5Cb.png',
|
|
'?filename=a%00b.png',
|
|
'?filename=a%07b.png',
|
|
'?filename=%E2%80%AEgnp.exe',
|
|
'?filename=%20',
|
|
'?filename=',
|
|
`?filename=${'a'.repeat(256)}`,
|
|
'',
|
|
'?filename=a.png&filename=b.png',
|
|
];
|
|
for (const query of bad)
|
|
expectError(
|
|
await uploadRaw(alice.token, leftoverChatId, query, png),
|
|
400,
|
|
'invalid_request',
|
|
);
|
|
const long = '😀'.repeat(255);
|
|
const created = await upload(alice.token, chatId, png, {
|
|
filename: long,
|
|
});
|
|
expect(created.response.status).toBe(201);
|
|
expect(created.body.filename).toBe(long);
|
|
});
|
|
|
|
it('links attachments to messages in the given order', async () => {
|
|
const first = await ready(png);
|
|
const second = await ready(jpeg, 'image/jpeg');
|
|
const order = [second.id, first.id];
|
|
const key = randomUUID().replaceAll('-', '');
|
|
const sent = await postMessage(
|
|
alice.token,
|
|
chatId,
|
|
{ text: '', attachment_ids: order },
|
|
key,
|
|
);
|
|
expect(sent.response.status).toBe(201);
|
|
expect(sent.body.attachment_ids).toEqual(order);
|
|
|
|
const history = await http<Page<Message>>(
|
|
`/api/v1/chats/${chatId}/messages?limit=100`,
|
|
{ headers: bearer(bob.token) },
|
|
);
|
|
const stored = history.body.items.find((m) => m.id === sent.body.id);
|
|
expect(stored?.attachment_ids).toEqual(order);
|
|
|
|
const replay = await postMessage(
|
|
alice.token,
|
|
chatId,
|
|
{ text: '', attachment_ids: order },
|
|
key,
|
|
);
|
|
expect(replay.response.status).toBe(201);
|
|
expect(replay.body).toEqual(sent.body);
|
|
expectError(
|
|
await postMessage(
|
|
alice.token,
|
|
chatId,
|
|
{ text: '', attachment_ids: [first.id] },
|
|
key,
|
|
),
|
|
409,
|
|
'conflict',
|
|
);
|
|
|
|
const textOnly = await postMessage(alice.token, chatId, {
|
|
text: 'hello',
|
|
});
|
|
expect(textOnly.response.status).toBe(201);
|
|
expect(textOnly.body.attachment_ids).toEqual([]);
|
|
});
|
|
|
|
it('rejects invalid attachment references', async () => {
|
|
const mine = await ready(png);
|
|
const foreign = await upload(eve.token, eveChatId, png);
|
|
expect(foreign.response.status).toBe(201);
|
|
expectError(
|
|
await postMessage(alice.token, chatId, { text: '' }),
|
|
400,
|
|
'invalid_request',
|
|
);
|
|
expectError(
|
|
await postMessage(alice.token, chatId, {
|
|
text: '',
|
|
attachment_ids: [foreign.body.id],
|
|
}),
|
|
404,
|
|
'not_found',
|
|
);
|
|
expectError(
|
|
await postMessage(alice.token, chatId, {
|
|
text: 'x',
|
|
attachment_ids: [randomUUID()],
|
|
}),
|
|
404,
|
|
'not_found',
|
|
);
|
|
for (const ids of [
|
|
[mine.id, mine.id],
|
|
[mine.id, mine.id.toUpperCase()],
|
|
Array.from({ length: 11 }, () => randomUUID()),
|
|
null,
|
|
['not-a-uuid'],
|
|
])
|
|
expectError(
|
|
await postMessage(alice.token, chatId, {
|
|
text: 'x',
|
|
attachment_ids: ids,
|
|
}),
|
|
400,
|
|
'invalid_request',
|
|
);
|
|
});
|
|
|
|
it('serves unknown content variants as errors, not bytes', async () => {
|
|
const created = await ready(png);
|
|
const variant = (name: string) =>
|
|
http<ApiErrorBody>(
|
|
`/api/v1/attachments/${created.id}/content?variant=${name}`,
|
|
{
|
|
headers: bearer(alice.token),
|
|
},
|
|
);
|
|
expect((await variant('original')).response.status).toBe(200);
|
|
expectError(await variant('thumbnail'), 404, 'not_found');
|
|
expectError(await variant('bogus'), 400, 'invalid_request');
|
|
});
|
|
|
|
it('answers 4xx, not 500, for raw image or text bodies on JSON routes', async () => {
|
|
for (const [type, status, code] of [
|
|
['image/png', 415, 'unsupported_media_type'],
|
|
['image/jpeg', 415, 'unsupported_media_type'],
|
|
['text/plain', 400, 'invalid_request'],
|
|
] as const) {
|
|
const result = await http<ApiErrorBody>('/api/v1/users', {
|
|
method: 'POST',
|
|
headers: { 'content-type': type },
|
|
body: 'x',
|
|
});
|
|
expectError(result, status, code);
|
|
}
|
|
});
|
|
|
|
it('removes the pending row when the client drops the connection', async () => {
|
|
const data = noisePng(2 * 1024 * 1024);
|
|
const url = new URL(baseUrl);
|
|
const socket = net.connect(Number(url.port || 80), url.hostname);
|
|
await new Promise<void>((resolve, reject) => {
|
|
socket.once('connect', resolve);
|
|
socket.once('error', reject);
|
|
});
|
|
socket.on('error', () => {});
|
|
socket.write(
|
|
`POST /api/v1/chats/${leftoverChatId}/attachments?filename=cut.png HTTP/1.1\r\n` +
|
|
`Host: ${url.host}\r\nAuthorization: Bearer ${alice.token}\r\n` +
|
|
`Content-Type: image/png\r\nContent-Length: ${data.length}\r\n\r\n`,
|
|
);
|
|
socket.write(data.subarray(0, 512 * 1024));
|
|
await sleep(500);
|
|
socket.destroy();
|
|
await settled(leftoverChatId);
|
|
});
|
|
|
|
it('leaves no rows behind after rejected uploads', async () => {
|
|
await settled(leftoverChatId);
|
|
});
|
|
});
|
|
|
|
async function settled(chat: string): Promise<void> {
|
|
const deadline = Date.now() + 10_000;
|
|
let count = -1;
|
|
while (Date.now() < deadline) {
|
|
const result = await db.query<{ count: string }>(
|
|
'SELECT count(*) FROM attachments WHERE chat_id = $1',
|
|
[chat],
|
|
);
|
|
count = Number(result.rows[0].count);
|
|
if (count === 0) return;
|
|
await sleep(250);
|
|
}
|
|
expect(count).toBe(0);
|
|
}
|