forked from mtusi2026/mtusi2026lab7
412 lines
20 KiB
TypeScript
412 lines
20 KiB
TypeScript
// Потоковая проверка 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: () => {},
|
||
};
|
||
}
|