Files
mtusi2026lab7/src/modules/images.ts
T

412 lines
20 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// Потоковая проверка PNG/JPEG по содержимому: без декодирования пикселей и без буферизации файла.
// Размеры берутся из заголовка (IHDR / SOF) и проверяются ДО распаковки данных, поэтому «бомба» отсекается сразу.
// PNG: сигнатура, порядок chunk-ов, CRC каждого chunk, длина PLTE; поток zlib распаковывается с подсчётом байтов
// (вывод выбрасывается, смотрится только байт фильтра 0–4 в начале каждой строки) и сверяется с объёмом,
// который следует из размеров и формата пикселя.
// JPEG: структура маркеров, ровно один SOF до первого SOS, обязательный EOI и те же проверки заголовков, на которых
// останавливается libjpeg-turbo (декодер Pillow и браузеров): 8 бит, 1/3/4 компонента, прореживание, таблицы
// DQT/DHT для каждого скана, параметры SOS; скан не пустой. Энтропийные данные не декодируются — битый
// Huffman-код libjpeg тоже считает лишь предупреждением.
// Обработанный кусок можно сразу передавать дальше: состояние проверки — несколько чисел и ≤ 13 байт хвоста
// (у JPEG ещё сегмент заголовка, ≤ 64 KiB).
import { finished } from 'node:stream/promises';
import { createInflate, crc32 } from 'node:zlib';
import { tooLarge, unsupported } from '../http/errors.ts';
export type Dimensions = { width: number; height: number };
export type ImageValidator = {
write(chunk: Buffer): Promise<void>;
end(): Promise<Dimensions>; // весь файл получен; бросает 415, если он обрезан
close(): void; // освободить ресурсы при обрыве загрузки
};
const broken = (why: string) => unsupported(`Содержимое не является корректным изображением: ${why}`);
export function imageValidator(type: 'image/png' | 'image/jpeg', maxPixels: number): ImageValidator {
return type === 'image/png' ? png(maxPixels) : jpeg(maxPixels);
}
function checkPixels(width: number, height: number, maxPixels: number): void {
if (width * height > maxPixels) throw tooLarge(`Изображение больше ${maxPixels} пикселей`);
}
const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
const CHANNELS: Record<number, number> = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
const DEPTHS: Record<number, number[]> = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
const ADAM7 = [[0, 0, 8, 8], [4, 0, 8, 8], [0, 4, 4, 8], [2, 0, 4, 4], [0, 2, 2, 4], [1, 0, 2, 2], [0, 1, 1, 2]];
// Строки распакованных данных PNG как [число строк, байт в строке]: байт фильтра + пиксели;
// при interlace — по одной паре на каждый непустой проход Adam7.
function rowLayout(width: number, height: number, bits: number, interlaced: boolean): [number, number][] {
const row = (w: number) => 1 + Math.ceil((w * bits) / 8);
if (!interlaced) return [[height, row(width)]];
const passes: [number, number][] = [];
for (const [x0, y0, dx, dy] of ADAM7) {
const w = Math.ceil((width - x0) / dx);
const h = Math.ceil((height - y0) / dy);
if (w > 0 && h > 0) passes.push([h, row(w)]);
}
return passes;
}
function png(maxPixels: number): ImageValidator {
let carry = Buffer.alloc(0);
let state: 'signature' | 'header' | 'data' | 'crc' | 'done' = 'signature';
let type = '';
let left = 0;
let crc = 0;
let ihdr = Buffer.alloc(0);
let dims: Dimensions | null = null;
let color = 0;
let palette = false;
let idat: 'none' | 'open' | 'closed' = 'none';
let expected = 0;
let inflated = 0;
let rows: [number, number][] = [];
let pass = 0; // текущий проход Adam7 (без interlace — единственный)
let rowsLeft = 0; // строк до конца прохода
let inRow = 0; // позиция внутри текущей строки
let badFilter = false;
const inflate = createInflate();
let zerr: Error | null = null;
let wake: (() => void) | null = null;
inflate.on('data', (d: Buffer) => {
inflated += d.length;
// Первый байт каждой строки — тип фильтра, допустимы только 0–4 (ISO/IEC 15948, 9.2).
for (let i = 0; i < d.length && pass < rows.length;) {
const len = rows[pass][1];
if (inRow === 0 && d[i] > 4) badFilter = true;
const step = Math.min(len - inRow, d.length - i);
i += step;
inRow += step;
if (inRow === len) {
inRow = 0;
if (--rowsLeft === 0 && ++pass < rows.length) rowsLeft = rows[pass][0];
}
}
});
// При ошибке zlib callback write не вызывается: будим ожидающего вручную.
inflate.on('error', (e) => { zerr = e; wake?.(); });
const feed = (data: Buffer) => zerr ? Promise.resolve() : new Promise<void>((resolve) => {
wake = resolve;
inflate.write(data, () => resolve());
});
function startChunk(len: number) {
if (!/^[A-Za-z]{4}$/.test(type) || len > 0x7fffffff) throw broken('неверный заголовок chunk');
if (!dims && type !== 'IHDR') throw broken('первым должен быть IHDR');
if (dims && type === 'IHDR') throw broken('повторный IHDR');
if (type === 'IHDR' && len !== 13) throw broken('неверная длина IHDR');
// Неизвестный критический chunk (заглавная первая буква) декодер обязан отвергнуть.
if (/^[A-Z]/.test(type) && !['IHDR', 'PLTE', 'IDAT', 'IEND'].includes(type)) throw broken(`неизвестный chunk ${type}`);
if (type === 'IDAT') {
if (idat === 'closed') throw broken('IDAT идут не подряд');
if (color === 3 && !palette) throw broken('нет палитры PLTE');
idat = 'open';
} else if (idat === 'open') {
idat = 'closed';
}
if (type === 'PLTE') {
if (palette || !len || len > 256 * 3 || len % 3) throw broken('неверная палитра PLTE');
palette = true;
}
if (type === 'IEND' && (len !== 0 || idat === 'none')) throw broken('неверный IEND');
}
function endChunk() {
if (type === 'IHDR') {
const width = ihdr.readUInt32BE(0);
const height = ihdr.readUInt32BE(4);
const depth = ihdr[8];
color = ihdr[9];
if (!width || !height || width > 0x7fffffff || height > 0x7fffffff) throw broken('неверные размеры');
if (!DEPTHS[color]?.includes(depth) || ihdr[10] !== 0 || ihdr[11] !== 0 || ihdr[12] > 1) throw broken('неверные параметры IHDR');
checkPixels(width, height, maxPixels); // до первого байта IDAT
dims = { width, height };
rows = rowLayout(width, height, CHANNELS[color] * depth, ihdr[12] === 1);
expected = rows.reduce((sum, [h, len]) => sum + h * len, 0);
rowsLeft = rows[0][0];
}
state = type === 'IEND' ? 'done' : 'header';
}
async function write(chunk: Buffer) {
const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
let pos = 0;
while (pos < buf.length) {
const avail = buf.length - pos;
if (state === 'signature') {
if (avail < 8) break;
if (!buf.subarray(pos, pos + 8).equals(SIGNATURE)) throw broken('нет сигнатуры PNG');
pos += 8;
state = 'header';
} else if (state === 'header') {
if (avail < 8) break;
left = buf.readUInt32BE(pos);
type = buf.toString('latin1', pos + 4, pos + 8);
startChunk(left);
crc = crc32(buf.subarray(pos + 4, pos + 8));
pos += 8;
state = left ? 'data' : 'crc';
} else if (state === 'data') {
const part = buf.subarray(pos, pos + Math.min(left, avail));
crc = crc32(part, crc);
if (type === 'IHDR') ihdr = Buffer.concat([ihdr, part]);
if (type === 'IDAT') {
await feed(part);
if (zerr) throw broken('повреждён поток zlib');
if (badFilter) throw broken('неверный тип фильтра строки');
if (inflated > expected) throw broken('данных больше, чем пикселей');
}
left -= part.length;
pos += part.length;
if (!left) state = 'crc';
} else if (state === 'crc') {
if (avail < 4) break;
if (buf.readUInt32BE(pos) !== crc) throw broken(`неверная CRC chunk ${type}`);
pos += 4;
endChunk();
} else {
throw broken('данные после IEND');
}
}
carry = Buffer.from(buf.subarray(pos));
}
return {
async write(chunk) {
try {
await write(chunk);
} catch (err) {
inflate.destroy();
throw err;
}
},
async end() {
if (state !== 'done') throw broken('файл обрезан');
inflate.end();
try {
await finished(inflate);
} catch {
throw broken('поток zlib не завершён');
}
if (badFilter) throw broken('неверный тип фильтра строки');
if (inflated !== expected) throw broken('объём данных не совпадает с размерами');
return dims!;
},
close: () => inflate.destroy(),
};
}
// SOF0–SOF15 кроме DHT (C4), JPG (C8), DAC (CC): в них ширина и высота кадра.
const SOF = new Set([0xc0, 0xc1, 0xc2, 0xc3, 0xc5, 0xc6, 0xc7, 0xc9, 0xca, 0xcb, 0xcd, 0xce, 0xcf]);
// Принимается то, что декодирует libjpeg-turbo через обычный 8-битный API: baseline, extended, progressive
// с Huffman- или arithmetic-кодированием. Lossless и hierarchical (C3, C5–C7, CB, CD–CF) отвергаются.
const SUPPORTED_SOF = new Set([0xc0, 0xc1, 0xc2, 0xc9, 0xca]);
const DHT = 0xc4;
const SOS = 0xda;
const DQT = 0xdb;
const DRI = 0xdd;
const PARSED = new Set([...SUPPORTED_SOF, DHT, SOS, DQT]);
type Component = { h: number; v: number; tq: number };
function jpeg(maxPixels: number): ImageValidator {
let carry = Buffer.alloc(0);
let state: 'soi' | 'marker' | 'length' | 'payload' | 'scan' | 'done' = 'soi';
let marker = 0;
let left = 0;
let seg = Buffer.alloc(0); // payload разбираемого сегмента (SOF, DHT, DQT, SOS)
let dims: Dimensions | null = null;
let progressive = false;
let arithmetic = false;
let scanned = false;
let scanData = 0; // байт энтропийных данных в текущем скане
const components = new Map<number, Component>();
const quant = new Set<number>(); // номера определённых таблиц DQT
const huff = new Set<number>(); // таблицы DHT: класс << 2 | номер
function frame() {
const [precision, n] = [seg[0], seg[5]];
const height = seg.readUInt16BE(1);
const width = seg.readUInt16BE(3);
if (!width || !height) throw broken('нулевые размеры');
if (precision !== 8) throw broken('поддерживается только 8 бит на канал');
if (![1, 3, 4].includes(n) || seg.length !== 6 + 3 * n) throw broken('неверный SOF');
for (let i = 6; i < seg.length; i += 3) {
const [id, h, v, tq] = [seg[i], seg[i + 1] >> 4, seg[i + 1] & 15, seg[i + 2]];
if (components.has(id) || h < 1 || h > 4 || v < 1 || v > 4 || tq > 3) throw broken('неверные компоненты SOF');
components.set(id, { h, v, tq });
}
// libjpeg восстанавливает цвет только при целом отношении прореживания к максимальному.
const all = [...components.values()];
const [maxH, maxV] = [Math.max(...all.map((c) => c.h)), Math.max(...all.map((c) => c.v))];
if (all.some((c) => maxH % c.h || maxV % c.v)) throw broken('неподдерживаемое прореживание цвета');
checkPixels(width, height, maxPixels); // до энтропийных данных
dims = { width, height };
progressive = marker === 0xc2 || marker === 0xca;
arithmetic = marker >= 0xc9;
}
function quantTables() {
for (let i = 0; i < seg.length;) {
const [pq, tq] = [seg[i] >> 4, seg[i] & 15];
const size = 1 + 64 * (pq + 1);
if (pq > 1 || tq > 3 || i + size > seg.length) throw broken('неверная таблица DQT');
quant.add(tq);
i += size;
}
}
function huffmanTables() {
for (let i = 0; i < seg.length;) {
if (i + 17 > seg.length) throw broken('неверная таблица DHT');
const [tc, th] = [seg[i] >> 4, seg[i] & 15];
let total = 0;
let code = 0;
for (let len = 1; len <= 16; len++) {
total += seg[i + len];
code += seg[i + len];
// Как jpeg_make_d_derived_tbl: коды длины len не должны занять всё пространство (код из одних 1 зарезервирован).
if (code >= 1 << len) throw broken('неверная таблица DHT');
code <<= 1;
}
const symbols = seg.subarray(i + 17, i + 17 + total);
if (tc > 1 || th > 3 || total > 256 || symbols.length !== total) throw broken('неверная таблица DHT');
if (tc === 0 && symbols.some((s) => s > 15)) throw broken('неверная таблица DHT');
huff.add((tc << 2) | th);
i += 17 + total;
}
}
function scan() {
const n = seg[0];
if (n < 1 || n > 4 || seg.length !== 4 + 2 * n) throw broken('неверный SOS');
const [ss, se, ah, al] = [seg[1 + 2 * n], seg[2 + 2 * n], seg[3 + 2 * n] >> 4, seg[3 + 2 * n] & 15];
if (progressive && (ss === 0 ? se !== 0 : ss > se || se > 63 || n !== 1)) throw broken('неверные параметры скана');
if (progressive && ((ah && al !== ah - 1) || al > 13)) throw broken('неверные параметры скана');
const seen = new Set<number>();
let blocks = 0;
for (let i = 1; i < 1 + 2 * n; i += 2) {
const comp = components.get(seg[i]);
if (!comp || seen.has(seg[i])) throw broken('SOS ссылается на неизвестный компонент');
seen.add(seg[i]);
blocks += comp.h * comp.v;
if (!quant.has(comp.tq)) throw broken('нет таблицы квантования DQT');
// Отсутствующие таблицы Хаффмана 0 и 1 libjpeg-turbo заменяет стандартными (Motion JPEG); 2 и 3 — нет.
// У arithmetic-кодирования таблицы условий (DAC) необязательны, проверяется только номер.
const [td, ta] = [seg[i + 1] >> 4, seg[i + 1] & 15];
const missing = (cls: number, t: number) => t > 3 || (!arithmetic && t > 1 && !huff.has((cls << 2) | t));
const needDC = !progressive || (ss === 0 && ah === 0);
const needAC = !progressive || ss > 0;
if ((needDC && missing(0, td)) || (needAC && missing(1, ta))) throw broken('нет таблицы энтропийного кодирования');
}
if (n > 1 && blocks > 10) throw broken('слишком большой MCU');
scanned = true;
scanData = 0;
}
function write(chunk: Buffer) {
const buf = carry.length ? Buffer.concat([carry, chunk]) : chunk;
let pos = 0;
loop: while (pos < buf.length) {
const avail = buf.length - pos;
switch (state) {
case 'soi':
if (avail < 2) break loop;
if (buf[pos] !== 0xff || buf[pos + 1] !== 0xd8) throw broken('нет сигнатуры JPEG');
pos += 2;
state = 'marker';
break;
case 'marker': {
if (avail < 2) break loop;
if (buf[pos] !== 0xff) throw broken('ожидался маркер');
const code = buf[pos + 1];
if (code === 0xff) { // байты-заполнители 0xFF перед маркером
pos += 1;
break;
}
pos += 2;
if (code === 0xd9) {
if (!scanned) throw broken('EOI до данных изображения');
state = 'done';
} else if (code === 0x00 || code === 0xd8 || (code >= 0xd0 && code <= 0xd7)) {
throw broken('неожиданный маркер');
} else if (code !== 0x01) { // TEM не имеет длины
marker = code;
state = 'length';
}
break;
}
case 'length': {
if (avail < 2) break loop;
left = buf.readUInt16BE(pos) - 2;
pos += 2;
if (left < 0) throw broken('неверная длина сегмента');
if (SOF.has(marker) && !SUPPORTED_SOF.has(marker)) throw broken('неподдерживаемый вид JPEG (lossless, hierarchical)');
if (SOF.has(marker) && (dims || left < 6)) throw broken('неверный SOF');
if (marker === SOS && !dims) throw broken('SOS до SOF');
if (marker === DRI && left !== 2) throw broken('неверный DRI');
seg = Buffer.alloc(0);
state = 'payload';
break;
}
case 'payload': {
const n = Math.min(left, avail);
if (PARSED.has(marker)) seg = Buffer.concat([seg, buf.subarray(pos, pos + n)]);
pos += n;
left -= n;
if (left) break;
if (SUPPORTED_SOF.has(marker)) frame();
else if (marker === DQT) quantTables();
else if (marker === DHT) huffmanTables();
else if (marker === SOS) scan();
state = marker === SOS ? 'scan' : 'marker';
break;
}
case 'scan': {
// Внутри энтропийных данных 0xFF допустим только как FF00 (stuffing) и RSTn; иначе начинается маркер.
const ff = buf.indexOf(0xff, pos);
scanData += (ff < 0 ? buf.length : ff) - pos;
if (ff < 0) {
pos = buf.length;
} else if (ff + 1 >= buf.length) {
pos = ff;
break loop;
} else {
const next = buf[ff + 1];
if (next === 0x00) {
pos = ff + 2;
scanData += 1;
} else if (next >= 0xd0 && next <= 0xd7) {
pos = ff + 2;
} else if (next === 0xff) {
pos = ff + 1; // заполнитель перед маркером
} else {
if (!scanData) throw broken('скан без данных');
pos = ff;
state = 'marker';
}
}
break;
}
case 'done': // данные после EOI (MPF, «живые» фото) — нормальная практика камер
pos = buf.length;
break;
}
}
carry = Buffer.from(buf.subarray(pos));
}
return {
write: async (chunk) => write(chunk),
async end() {
if (state !== 'done') throw broken('нет EOI: файл обрезан');
return dims!;
},
close: () => {},
};
}