613 lines
23 KiB
TypeScript
613 lines
23 KiB
TypeScript
|
import { describe, it, expect } from 'vitest';
|
||
|
|
import {
|
||
|
|
scrubLocation,
|
||
|
|
scrubLocationStream,
|
||
|
|
scrubTiffGps,
|
||
|
|
scrubXmpLocation,
|
||
|
|
isLocationScrubbable,
|
||
|
|
Pending,
|
||
|
|
HEAD_CAP,
|
||
|
|
} from '../locationScrub';
|
||
|
|
import {
|
||
|
|
ALT,
|
||
|
|
ICC,
|
||
|
|
JFIF,
|
||
|
|
LAT,
|
||
|
|
LON,
|
||
|
|
SCAN,
|
||
|
|
XMP_LOCATION_VALUES,
|
||
|
|
XMP_PACKET,
|
||
|
|
ascii,
|
||
|
|
asciiOf,
|
||
|
|
be32,
|
||
|
|
bytes,
|
||
|
|
cameraHeic,
|
||
|
|
cameraJpeg,
|
||
|
|
cameraTiff,
|
||
|
|
cat,
|
||
|
|
chunked,
|
||
|
|
contains,
|
||
|
|
exifOf,
|
||
|
|
exifSegment,
|
||
|
|
heicExif,
|
||
|
|
indexOf,
|
||
|
|
jpegSegments,
|
||
|
|
latin1,
|
||
|
|
parseTiff,
|
||
|
|
seg,
|
||
|
|
SOS,
|
||
|
|
EOI,
|
||
|
|
utf8,
|
||
|
|
xmpSegment,
|
||
|
|
be16,
|
||
|
|
} from './fixtures/location';
|
||
|
|
|
||
|
|
const LAT_BYTES = (le: boolean) => LAT.value(le);
|
||
|
|
const LON_BYTES = (le: boolean) => LON.value(le);
|
||
|
|
const ALT_BYTES = (le: boolean) => ALT.value(le);
|
||
|
|
|
||
|
|
/** Run the stream scrubber over `data`, delivered in `size`-byte chunks. */
|
||
|
|
async function viaStream(data: Uint8Array, size: number): Promise<Uint8Array | null> {
|
||
|
|
const result = await scrubLocationStream(chunked(data, size));
|
||
|
|
if (!result.ok) return null;
|
||
|
|
return new Uint8Array(await new Response(result.stream).arrayBuffer());
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Camera data that must come through untouched. */
|
||
|
|
function expectCameraData(tiff: Uint8Array) {
|
||
|
|
const t = parseTiff(tiff);
|
||
|
|
expect(asciiOf(t.ifd0.get(0x010f))).toBe('Canon');
|
||
|
|
expect(asciiOf(t.ifd0.get(0x0110))).toBe('Canon EOS R5');
|
||
|
|
expect(asciiOf(t.ifd0.get(0x8298))).toBe('(c) Jane Doe');
|
||
|
|
expect(asciiOf(t.exif?.get(0xa434))).toBe('RF24-70mm F2.8 L IS USM');
|
||
|
|
expect(t.exif?.get(0x8827)).toBeDefined();
|
||
|
|
expect(t.ifd1?.get(0x0103)).toBeDefined(); // IFD1 still chained
|
||
|
|
return t;
|
||
|
|
}
|
||
|
|
|
||
|
|
function expectNoGps(tiff: Uint8Array, le: boolean) {
|
||
|
|
const t = parseTiff(tiff);
|
||
|
|
expect(t.ifd0.has(0x8825)).toBe(false);
|
||
|
|
expect(t.exif?.has(0x8825)).toBe(false);
|
||
|
|
expect(t.gps).toBeNull();
|
||
|
|
expect(contains(tiff, LAT_BYTES(le))).toBe(false);
|
||
|
|
expect(contains(tiff, LON_BYTES(le))).toBe(false);
|
||
|
|
expect(contains(tiff, ALT_BYTES(le))).toBe(false);
|
||
|
|
}
|
||
|
|
|
||
|
|
function expectXmpScrubbed(text: string) {
|
||
|
|
expect(text).not.toMatch(/:GPS|:Gps/);
|
||
|
|
for (const v of XMP_LOCATION_VALUES) expect(text).not.toContain(v);
|
||
|
|
expect(text).toContain('photoshop:City="Berlin"');
|
||
|
|
expect(text).toContain('photoshop:Country="Germany"');
|
||
|
|
expect(text).toContain('<Iptc4xmpExt:City>Berlin</Iptc4xmpExt:City>');
|
||
|
|
expect(text).toContain('© Jane Doe');
|
||
|
|
expect(text).toContain('tiff:Make="Canon"');
|
||
|
|
}
|
||
|
|
|
||
|
|
describe('scrubTiffGps', () => {
|
||
|
|
for (const le of [true, false]) {
|
||
|
|
const order = le ? 'little-endian (II)' : 'big-endian (MM)';
|
||
|
|
|
||
|
|
it(`removes the GPS IFD and keeps the camera tags, ${order}`, () => {
|
||
|
|
const tiff = cameraTiff(le);
|
||
|
|
const before = parseTiff(tiff);
|
||
|
|
expect(before.gps?.get(0x0002)).toBeDefined(); // the fixture really has GPS
|
||
|
|
|
||
|
|
const out = tiff.slice();
|
||
|
|
expect(scrubTiffGps(out, 0, out.length)).toBe(true);
|
||
|
|
expect(out.length).toBe(tiff.length);
|
||
|
|
expectNoGps(out, le);
|
||
|
|
const after = expectCameraData(out);
|
||
|
|
// Values are byte-identical, not just present.
|
||
|
|
for (const tag of [0x010f, 0x0110, 0x0112, 0x8298]) {
|
||
|
|
expect(after.ifd0.get(tag)).toEqual(before.ifd0.get(tag));
|
||
|
|
}
|
||
|
|
expect(after.exif).toEqual(before.exif);
|
||
|
|
});
|
||
|
|
|
||
|
|
it(`leaves a file without GPS byte-identical, ${order}`, () => {
|
||
|
|
const tiff = cameraTiff(le, { withGps: false });
|
||
|
|
const out = tiff.slice();
|
||
|
|
expect(scrubTiffGps(out, 0, out.length)).toBe(true);
|
||
|
|
expect(out).toEqual(tiff);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
it('scrubs XMP embedded in TIFF tag 700', () => {
|
||
|
|
const tiff = cameraTiff(false, { xmp: utf8(XMP_PACKET) });
|
||
|
|
const out = tiff.slice();
|
||
|
|
expect(scrubTiffGps(out, 0, out.length)).toBe(true);
|
||
|
|
const xmp = parseTiff(out).ifd0.get(0x02bc)!;
|
||
|
|
expectXmpScrubbed(Buffer.from(xmp.value).toString('utf8'));
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses what it cannot walk', () => {
|
||
|
|
const bad = (mutate: (t: Uint8Array) => void) => {
|
||
|
|
const t = cameraTiff(true);
|
||
|
|
mutate(t);
|
||
|
|
return scrubTiffGps(t, 0, t.length);
|
||
|
|
};
|
||
|
|
expect(bad((t) => t.set(ascii('XX'), 0))).toBe(false); // byte order
|
||
|
|
expect(bad((t) => (t[2] = 43))).toBe(false); // BigTIFF
|
||
|
|
expect(bad((t) => t.set([0xff, 0xff, 0, 0], 4))).toBe(false); // IFD0 out of range
|
||
|
|
expect(scrubTiffGps(bytes(0x49, 0x49), 0, 2)).toBe(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses a GPS IFD whose values point outside the block', () => {
|
||
|
|
const t = cameraTiff(false);
|
||
|
|
const gps = parseTiff(t);
|
||
|
|
expect(gps.gps).not.toBeNull();
|
||
|
|
// Find the GPSLatitude entry (tag 2, RATIONAL) and point it past the end.
|
||
|
|
const entry = indexOf(t, bytes(0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x03));
|
||
|
|
t.set(be32(0x7fffffff), entry + 8);
|
||
|
|
expect(scrubTiffGps(t, 0, t.length)).toBe(false);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('scrubXmpLocation', () => {
|
||
|
|
it('blanks every location property, keeps the length and the rest', () => {
|
||
|
|
const packet = utf8(XMP_PACKET);
|
||
|
|
const out = packet.slice();
|
||
|
|
expect(scrubXmpLocation(out, 0, out.length)).toBe(true);
|
||
|
|
expect(out.length).toBe(packet.length);
|
||
|
|
expectXmpScrubbed(Buffer.from(out).toString('utf8'));
|
||
|
|
});
|
||
|
|
|
||
|
|
it('leaves a packet without location untouched', () => {
|
||
|
|
const packet = utf8('<x:xmpmeta><rdf:Description photoshop:City="Berlin"/></x:xmpmeta>');
|
||
|
|
const out = packet.slice();
|
||
|
|
expect(scrubXmpLocation(out, 0, out.length)).toBe(true);
|
||
|
|
expect(out).toEqual(packet);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses an unclosed location element', () => {
|
||
|
|
const out = utf8('<rdf:Description><exif:GPSLatitude>52,31N</rdf:Description>');
|
||
|
|
expect(scrubXmpLocation(out, 0, out.length)).toBe(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses UTF-16, which it cannot read byte-wise', () => {
|
||
|
|
const out = new Uint8Array(Buffer.from('<exif:GPSLatitude>1</exif:GPSLatitude>', 'utf16le'));
|
||
|
|
expect(scrubXmpLocation(out, 0, out.length)).toBe(false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('tolerates trailing NUL padding', () => {
|
||
|
|
const out = cat(utf8('<a exif:GPSLatitude="1"/>'), bytes(0, 0, 0));
|
||
|
|
expect(scrubXmpLocation(out, 0, out.length)).toBe(true);
|
||
|
|
expect(latin1(out)).not.toContain('GPS');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('JPEG', () => {
|
||
|
|
for (const le of [true, false]) {
|
||
|
|
const order = le ? 'little-endian' : 'big-endian';
|
||
|
|
|
||
|
|
it(`removes location and keeps everything else, ${order} EXIF`, async () => {
|
||
|
|
const { file, primaryHeadLength, primaryLength } = cameraJpeg(le);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out).not.toBeNull();
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
|
||
|
|
// EXIF: GPS gone, camera data intact.
|
||
|
|
const tiff = exifOf(out)!;
|
||
|
|
expectNoGps(tiff, le);
|
||
|
|
expectCameraData(tiff);
|
||
|
|
|
||
|
|
// XMP: GPS gone, city/country/rights intact.
|
||
|
|
const xmp = jpegSegments(out).find((s) =>
|
||
|
|
latin1(s.payload).startsWith('http://ns.adobe.com/xap/1.0/'),
|
||
|
|
)!;
|
||
|
|
expectXmpScrubbed(Buffer.from(xmp.payload).toString('utf8'));
|
||
|
|
|
||
|
|
// JFIF and ICC are byte-identical.
|
||
|
|
const segs = jpegSegments(out);
|
||
|
|
expect(segs.find((s) => s.marker === 0xe0)!.payload).toEqual(JFIF);
|
||
|
|
expect(segs.find((s) => s.marker === 0xe2)!.payload).toEqual(ICC);
|
||
|
|
|
||
|
|
// Extended XMP and the C2PA manifest are zeroed whole.
|
||
|
|
const ext = segs.filter((s) => s.marker === 0xe1)[2];
|
||
|
|
expect(ext.payload.every((x) => x === 0)).toBe(true);
|
||
|
|
const jumbf = segs.find((s) => s.marker === 0xeb)!;
|
||
|
|
expect(jumbf.payload.every((x) => x === 0)).toBe(true);
|
||
|
|
|
||
|
|
// APP13: the IPTC record stays, its EXIF resource loses GPS.
|
||
|
|
const app13 = segs.find((s) => s.marker === 0xed)!;
|
||
|
|
expect(latin1(app13.payload)).toContain('Copyright Jane Doe');
|
||
|
|
const irbExif = app13.payload.slice(indexOf(app13.payload, ascii(le ? 'MM' : 'II')));
|
||
|
|
expectNoGps(irbExif, !le);
|
||
|
|
expectCameraData(irbExif);
|
||
|
|
|
||
|
|
// Scan data and everything after the primary head is identical apart
|
||
|
|
// from the appended image's metadata.
|
||
|
|
expect(out.slice(primaryHeadLength, primaryLength)).toEqual(
|
||
|
|
file.slice(primaryHeadLength, primaryLength),
|
||
|
|
);
|
||
|
|
|
||
|
|
// The appended (MPF) image: GPS gone there too, camera data kept.
|
||
|
|
const second = exifOf(out, primaryLength)!;
|
||
|
|
expectNoGps(second, le);
|
||
|
|
expectCameraData(second);
|
||
|
|
expect(out.slice(out.length - SCAN.length - 2)).toEqual(
|
||
|
|
file.slice(file.length - SCAN.length - 2),
|
||
|
|
);
|
||
|
|
|
||
|
|
// Nothing location-shaped anywhere in the file.
|
||
|
|
const text = latin1(out);
|
||
|
|
expect(text).not.toContain('52.520095');
|
||
|
|
expect(contains(out, LAT_BYTES(le))).toBe(false);
|
||
|
|
expect(contains(out, LAT_BYTES(!le))).toBe(false);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
it('gives the same bytes however the stream is chunked', async () => {
|
||
|
|
const { file } = cameraJpeg(true);
|
||
|
|
const whole = (await scrubLocation(file))!;
|
||
|
|
for (const size of [1, 2, 3, 7, 64, 1000, 4096]) {
|
||
|
|
expect(await viaStream(file, size)).toEqual(whole);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
it('zeroes an EXIF segment it cannot parse, and only that segment', async () => {
|
||
|
|
const broken = cat(ascii('MM'), bytes(0, 42), be32(0x7fffff00), ascii('GPS 52.520095'));
|
||
|
|
const file = cat(
|
||
|
|
bytes(0xff, 0xd8),
|
||
|
|
seg(0xe0, JFIF),
|
||
|
|
exifSegment(broken),
|
||
|
|
xmpSegment(XMP_PACKET),
|
||
|
|
seg(0xe2, ICC),
|
||
|
|
SOS,
|
||
|
|
SCAN,
|
||
|
|
EOI,
|
||
|
|
);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
const segs = jpegSegments(out);
|
||
|
|
expect(segs[1].payload.every((x) => x === 0)).toBe(true);
|
||
|
|
expectXmpScrubbed(Buffer.from(segs[2].payload).toString('utf8'));
|
||
|
|
expect(segs[3].payload).toEqual(ICC);
|
||
|
|
expect(latin1(out)).not.toContain('52.520095');
|
||
|
|
});
|
||
|
|
|
||
|
|
it('zeroes an unknown APP1 in the primary image', async () => {
|
||
|
|
const file = cat(bytes(0xff, 0xd8), seg(0xe1, ascii('FLIR\0GPS 52.520095')), SOS, SCAN, EOI);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(latin1(out)).not.toContain('52.520095');
|
||
|
|
});
|
||
|
|
|
||
|
|
it('accepts fill bytes before a marker', async () => {
|
||
|
|
const file = cat(bytes(0xff, 0xd8, 0xff, 0xff), exifSegment(cameraTiff(true)), SOS, SCAN, EOI);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out).not.toBeNull();
|
||
|
|
expectNoGps(exifOf(cat(bytes(0xff, 0xd8), out.slice(4)))!, true);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses a JPEG whose head never reaches the image data', async () => {
|
||
|
|
const truncated = cat(bytes(0xff, 0xd8), exifSegment(cameraTiff(true))).slice(0, 60);
|
||
|
|
expect(await scrubLocation(truncated)).toBeNull();
|
||
|
|
const noSos = cat(bytes(0xff, 0xd8), seg(0xe0, JFIF));
|
||
|
|
expect(await scrubLocation(noSos)).toBeNull();
|
||
|
|
const garbage = cat(bytes(0xff, 0xd8), seg(0xe0, JFIF), bytes(0x12, 0x34, 0x56, 0x78));
|
||
|
|
expect(await scrubLocation(garbage)).toBeNull();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('HEIF / AVIF', () => {
|
||
|
|
const check = (out: Uint8Array, file: Uint8Array, imageAt: number, le: boolean) => {
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
const tiff = heicExif(out)!;
|
||
|
|
expect(tiff).not.toBeNull();
|
||
|
|
expectNoGps(tiff, le);
|
||
|
|
expectCameraData(tiff);
|
||
|
|
expectXmpScrubbed(latin1(out.slice(indexOf(out, ascii('<?xpacket')))));
|
||
|
|
expect(out.slice(imageAt, imageAt + 20)).toEqual(file.slice(imageAt, imageAt + 20));
|
||
|
|
};
|
||
|
|
|
||
|
|
for (const le of [true, false]) {
|
||
|
|
it(`removes location from the Exif and XMP items, ${le ? 'II' : 'MM'}`, async () => {
|
||
|
|
const { file, imageAt } = cameraHeic({ le });
|
||
|
|
check((await scrubLocation(file))!, file, imageAt, le);
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
it('handles EXIF stored in idat (construction method 1)', async () => {
|
||
|
|
const { file, imageAt } = cameraHeic({ idatExif: true });
|
||
|
|
check((await scrubLocation(file))!, file, imageAt, false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('handles a meta box after mdat', async () => {
|
||
|
|
const { file, imageAt } = cameraHeic({ metaLast: true });
|
||
|
|
check((await scrubLocation(file))!, file, imageAt, false);
|
||
|
|
});
|
||
|
|
|
||
|
|
it('zeroes a C2PA manifest box', async () => {
|
||
|
|
const { file } = cameraHeic({ c2pa: true });
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(latin1(out)).not.toContain('52.520095');
|
||
|
|
expect(latin1(out)).not.toContain('c2pa manifest');
|
||
|
|
});
|
||
|
|
|
||
|
|
it('gives the same bytes however the stream is chunked', async () => {
|
||
|
|
const { file } = cameraHeic({ c2pa: true });
|
||
|
|
const whole = (await scrubLocation(file))!;
|
||
|
|
for (const size of [1, 5, 13, 100, 4096]) {
|
||
|
|
expect(await viaStream(file, size)).toEqual(whole);
|
||
|
|
}
|
||
|
|
const { file: last } = cameraHeic({ metaLast: true, c2pa: true });
|
||
|
|
const lastWhole = (await scrubLocation(last))!;
|
||
|
|
for (const size of [1, 7, 333]) {
|
||
|
|
expect(await viaStream(last, size)).toEqual(lastWhole);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
it('zeroes an Exif item it cannot parse', async () => {
|
||
|
|
const payload = cat(be32(6), ascii('Exif\0\0'), ascii('XXnot-a-tiff GPS 52.520095'));
|
||
|
|
const { file } = cameraHeic({ exifPayload: payload });
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
expect(latin1(out)).not.toContain('52.520095');
|
||
|
|
expect(latin1(out)).not.toContain('not-a-tiff');
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses a file whose meta box cannot be parsed', async () => {
|
||
|
|
const { file } = cameraHeic();
|
||
|
|
const broken = file.slice();
|
||
|
|
const iloc = indexOf(broken, ascii('iloc'));
|
||
|
|
broken.set([0xff, 0xff], iloc + 4 + 4 + 2); // item_count far beyond the box
|
||
|
|
expect(await scrubLocation(broken)).toBeNull();
|
||
|
|
});
|
||
|
|
|
||
|
|
it('refuses a truncated meta box', async () => {
|
||
|
|
const { file } = cameraHeic();
|
||
|
|
const meta = indexOf(file, ascii('meta'));
|
||
|
|
expect(await scrubLocation(file.slice(0, meta + 40))).toBeNull();
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('other formats', () => {
|
||
|
|
it('passes PNG, TIFF/DNG, video and unknown bytes through unchanged', async () => {
|
||
|
|
const samples = [
|
||
|
|
cat(bytes(0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a), ascii('IHDR...GPS')),
|
||
|
|
cameraTiff(true),
|
||
|
|
cat(be32(20), ascii('ftypqt '), be32(0), ascii('qt '), ascii('moov....')),
|
||
|
|
ascii('image-bytes'),
|
||
|
|
bytes(),
|
||
|
|
];
|
||
|
|
for (const sample of samples) {
|
||
|
|
const result = await scrubLocationStream(chunked(sample, 3));
|
||
|
|
expect(result.ok && result.format).toBe('passthrough');
|
||
|
|
expect(await viaStream(sample, 3)).toEqual(sample);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
it('reports which formats it edits', async () => {
|
||
|
|
const jpeg = await scrubLocationStream(
|
||
|
|
chunked(cat(bytes(0xff, 0xd8), seg(0xe0, JFIF), SOS, EOI), 4),
|
||
|
|
);
|
||
|
|
expect(jpeg.ok && jpeg.format).toBe('jpeg');
|
||
|
|
const heic = await scrubLocationStream(chunked(cameraHeic().file, 4));
|
||
|
|
expect(heic.ok && heic.format).toBe('heif');
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('isLocationScrubbable', () => {
|
||
|
|
it('judges by the original MIME type, then the file name', () => {
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalMimeType: 'image/jpeg' })).toBe(true);
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalMimeType: 'image/heic' })).toBe(true);
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalMimeType: 'image/avif' })).toBe(true);
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalMimeType: 'image/x-adobe-dng' })).toBe(
|
||
|
|
false,
|
||
|
|
);
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalMimeType: 'image/png' })).toBe(false);
|
||
|
|
expect(isLocationScrubbable({ type: 'VIDEO', originalMimeType: 'video/mp4' })).toBe(false);
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalFileName: 'IMG_0001.HEIC' })).toBe(true);
|
||
|
|
expect(isLocationScrubbable({ type: 'IMAGE', originalFileName: 'DSC_0001.NEF' })).toBe(false);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('XMP matching stays linear', () => {
|
||
|
|
const time = (packet: string) => {
|
||
|
|
const b = utf8(packet);
|
||
|
|
const started = performance.now();
|
||
|
|
const ok = scrubXmpLocation(b, 0, b.length);
|
||
|
|
return { ok, ms: performance.now() - started, text: latin1(b) };
|
||
|
|
};
|
||
|
|
|
||
|
|
it('scans long name runs without retrying at every character', () => {
|
||
|
|
for (const size of [64 * 1024, 1024 * 1024]) {
|
||
|
|
const run = time(`<x:xmpmeta exif:GPSLatitude="1">${'a'.repeat(size)}</x:xmpmeta>`);
|
||
|
|
expect(run.ok).toBe(true);
|
||
|
|
expect(run.text).not.toContain('GPS');
|
||
|
|
expect(run.ms).toBeLessThan(100);
|
||
|
|
|
||
|
|
const colons = time(`<x:xmpmeta exif:GPSLatitude="1">${'a:'.repeat(size / 2)}</x:xmpmeta>`);
|
||
|
|
expect(colons.ok).toBe(true);
|
||
|
|
expect(colons.ms).toBeLessThan(100);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
it('blanks deeply nested location elements in one pass', () => {
|
||
|
|
const depth = 20000;
|
||
|
|
const nested = time(
|
||
|
|
`<x:xmpmeta>${'<exif:GPSArea>'.repeat(depth)}${'</exif:GPSArea>'.repeat(depth)}</x:xmpmeta>`,
|
||
|
|
);
|
||
|
|
expect(nested.ok).toBe(true);
|
||
|
|
expect(nested.text).not.toContain('GPS');
|
||
|
|
expect(nested.ms).toBeLessThan(100);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('place names below city level', () => {
|
||
|
|
const STREET = 'Hauptstrasse 12';
|
||
|
|
|
||
|
|
it('blanks sub-city XMP place names and keeps city, state and country', () => {
|
||
|
|
const packet = `<x:xmpmeta xmlns:x="adobe:ns:meta/"><rdf:RDF><rdf:Description rdf:about=""
|
||
|
|
Iptc4xmpCore:Location="${STREET}"
|
||
|
|
Iptc4xmpCore:CountryCode="DE"
|
||
|
|
photoshop:City="Berlin" photoshop:State="Berlin" photoshop:Country="Germany">
|
||
|
|
<xmpDM:shotLocation>${STREET}</xmpDM:shotLocation>
|
||
|
|
<Iptc4xmpExt:LocationShown><rdf:Bag><rdf:li rdf:parseType="Resource">
|
||
|
|
<Iptc4xmpExt:Sublocation>${STREET}</Iptc4xmpExt:Sublocation>
|
||
|
|
<Iptc4xmpExt:LocationName>Café am Markt</Iptc4xmpExt:LocationName>
|
||
|
|
<Iptc4xmpExt:City>Berlin</Iptc4xmpExt:City>
|
||
|
|
<Iptc4xmpExt:ProvinceState>Berlin</Iptc4xmpExt:ProvinceState>
|
||
|
|
<Iptc4xmpExt:CountryName>Germany</Iptc4xmpExt:CountryName>
|
||
|
|
<Iptc4xmpExt:CountryCode>DE</Iptc4xmpExt:CountryCode>
|
||
|
|
</rdf:li></rdf:Bag></Iptc4xmpExt:LocationShown>
|
||
|
|
</rdf:Description></rdf:RDF></x:xmpmeta>`;
|
||
|
|
const b = utf8(packet);
|
||
|
|
expect(scrubXmpLocation(b, 0, b.length)).toBe(true);
|
||
|
|
const text = Buffer.from(b).toString('utf8');
|
||
|
|
expect(b.length).toBe(utf8(packet).length);
|
||
|
|
expect(text).not.toContain(STREET);
|
||
|
|
expect(text).not.toContain('Café am Markt');
|
||
|
|
expect(text).not.toMatch(/:(Sub)?[Ll]ocation\b|shotLocation|LocationName/);
|
||
|
|
for (const kept of [
|
||
|
|
'Iptc4xmpCore:CountryCode="DE"',
|
||
|
|
'photoshop:City="Berlin"',
|
||
|
|
'photoshop:State="Berlin"',
|
||
|
|
'photoshop:Country="Germany"',
|
||
|
|
'<Iptc4xmpExt:City>Berlin</Iptc4xmpExt:City>',
|
||
|
|
'<Iptc4xmpExt:ProvinceState>Berlin</Iptc4xmpExt:ProvinceState>',
|
||
|
|
'<Iptc4xmpExt:CountryName>Germany</Iptc4xmpExt:CountryName>',
|
||
|
|
'<Iptc4xmpExt:CountryCode>DE</Iptc4xmpExt:CountryCode>',
|
||
|
|
'<Iptc4xmpExt:LocationShown>',
|
||
|
|
]) {
|
||
|
|
expect(text).toContain(kept);
|
||
|
|
}
|
||
|
|
});
|
||
|
|
|
||
|
|
it('blanks the IIM sub-location (2:92) in place and keeps the rest of the record', async () => {
|
||
|
|
const dataset = (n: number, value: string) =>
|
||
|
|
cat(bytes(0x1c, 0x02, n), be16(value.length), ascii(value));
|
||
|
|
const iim = cat(
|
||
|
|
dataset(90, 'Berlin'),
|
||
|
|
dataset(92, STREET),
|
||
|
|
dataset(101, 'Germany'),
|
||
|
|
dataset(116, 'Copyright Jane Doe'),
|
||
|
|
);
|
||
|
|
const irb = cat(
|
||
|
|
ascii('Photoshop 3.0\0'),
|
||
|
|
ascii('8BIM'),
|
||
|
|
be16(0x0404),
|
||
|
|
bytes(0, 0),
|
||
|
|
be32(iim.length),
|
||
|
|
iim,
|
||
|
|
iim.length % 2 ? bytes(0) : bytes(),
|
||
|
|
);
|
||
|
|
const file = cat(bytes(0xff, 0xd8), seg(0xed, irb), SOS, SCAN, EOI);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
const text = latin1(out);
|
||
|
|
expect(text).not.toContain(STREET);
|
||
|
|
expect(text).toContain(`\x1c\x02\x5c\x00\x0f${' '.repeat(STREET.length)}`);
|
||
|
|
for (const kept of ['Berlin', 'Germany', 'Copyright Jane Doe']) expect(text).toContain(kept);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('vendor APPn segments', () => {
|
||
|
|
const GOPRO = cat(ascii('GoPro\0'), ascii('GPS5 52.520095 13.401577'));
|
||
|
|
const KODAK = cat(ascii('Meta\0\0'), ascii('GPS 52.520095'));
|
||
|
|
const MPF = cat(ascii('MPF\0'), ascii('MM'), bytes(0, 42), be32(8), ascii('mp-index'));
|
||
|
|
const ADOBE = cat(ascii('Adobe'), bytes(0, 100, 0, 0, 0, 0, 1));
|
||
|
|
|
||
|
|
const head = () =>
|
||
|
|
cat(
|
||
|
|
seg(0xe0, JFIF),
|
||
|
|
seg(0xe2, MPF),
|
||
|
|
seg(0xe2, ICC),
|
||
|
|
seg(0xe3, KODAK),
|
||
|
|
seg(0xe6, GOPRO),
|
||
|
|
seg(0xe0, ascii('AVI1\0GPS 52.520095')),
|
||
|
|
seg(0xee, ADOBE),
|
||
|
|
);
|
||
|
|
|
||
|
|
const check = (out: Uint8Array, soi: number) => {
|
||
|
|
const segs = jpegSegments(out, soi);
|
||
|
|
const payload = (marker: number, n = 0) => segs.filter((x) => x.marker === marker)[n].payload;
|
||
|
|
expect(payload(0xe0)).toEqual(JFIF);
|
||
|
|
expect(payload(0xe2, 0)).toEqual(MPF);
|
||
|
|
expect(payload(0xe2, 1)).toEqual(ICC);
|
||
|
|
expect(payload(0xee)).toEqual(ADOBE);
|
||
|
|
for (const zeroed of [payload(0xe3), payload(0xe6), payload(0xe0, 1)]) {
|
||
|
|
expect(zeroed.every((x) => x === 0)).toBe(true);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
|
||
|
|
it('zeroes APPn segments off the allowlist and keeps JFIF, ICC, MPF and Adobe', async () => {
|
||
|
|
const primary = cat(bytes(0xff, 0xd8), head(), SOS, SCAN, EOI);
|
||
|
|
const secondary = cat(bytes(0xff, 0xd8), head(), SOS, SCAN, EOI);
|
||
|
|
const file = cat(primary, secondary);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
expect(latin1(out)).not.toContain('52.520095');
|
||
|
|
check(out, 0);
|
||
|
|
check(out, primary.length);
|
||
|
|
for (const size of [1, 9, 100]) expect(await viaStream(file, size)).toEqual(out);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('progressive JPEG', () => {
|
||
|
|
const DHT = seg(0xc4, bytes(0x10, ...new Array(16).fill(0), 0));
|
||
|
|
|
||
|
|
it('scrubs an APPn segment between scans, and only inside the image', async () => {
|
||
|
|
const trailer = cat(ascii('TRAILER'), bytes(0xff, 0xe1, 0x00, 0x10), ascii('not a segment!'));
|
||
|
|
const file = cat(
|
||
|
|
bytes(0xff, 0xd8),
|
||
|
|
seg(0xe0, JFIF),
|
||
|
|
SOS,
|
||
|
|
SCAN,
|
||
|
|
exifSegment(cameraTiff(true)),
|
||
|
|
xmpSegment(XMP_PACKET),
|
||
|
|
seg(0xe6, ascii('GoPro\0GPS5')),
|
||
|
|
DHT,
|
||
|
|
SOS,
|
||
|
|
SCAN,
|
||
|
|
EOI,
|
||
|
|
trailer,
|
||
|
|
);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
const between = indexOf(out, ascii('Exif\0\0'));
|
||
|
|
const tiff = parseTiff(out.slice(between + 6));
|
||
|
|
expect(tiff.gps).toBeNull();
|
||
|
|
expect(asciiOf(tiff.ifd0.get(0x010f))).toBe('Canon');
|
||
|
|
expect(latin1(out)).not.toMatch(/exif:GPS|GoPro/);
|
||
|
|
// Bytes after EOI that merely look like a marker are not touched.
|
||
|
|
expect(out.slice(out.length - trailer.length)).toEqual(trailer);
|
||
|
|
for (const size of [1, 3, 50, 777]) expect(await viaStream(file, size)).toEqual(out);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('padding between segments', () => {
|
||
|
|
it('accepts NUL padding and FF fill bytes between segments', async () => {
|
||
|
|
const file = cat(
|
||
|
|
bytes(0xff, 0xd8),
|
||
|
|
seg(0xe0, JFIF),
|
||
|
|
bytes(0, 0, 0),
|
||
|
|
exifSegment(cameraTiff(false)),
|
||
|
|
bytes(0xff, 0xff, 0xff),
|
||
|
|
seg(0xe2, ICC),
|
||
|
|
bytes(0x00),
|
||
|
|
SOS,
|
||
|
|
SCAN,
|
||
|
|
EOI,
|
||
|
|
);
|
||
|
|
const out = (await scrubLocation(file))!;
|
||
|
|
expect(out).not.toBeNull();
|
||
|
|
expect(out.length).toBe(file.length);
|
||
|
|
expect(contains(out, LAT_BYTES(false))).toBe(false);
|
||
|
|
expect(latin1(out)).toContain('Canon EOS R5');
|
||
|
|
expect(contains(out, ICC)).toBe(true);
|
||
|
|
});
|
||
|
|
});
|
||
|
|
|
||
|
|
describe('Pending', () => {
|
||
|
|
it('never allocates more than the head cap plus one chunk', () => {
|
||
|
|
const pending = new Pending();
|
||
|
|
const chunk = new Uint8Array(1024 * 1024);
|
||
|
|
while (pending.length < HEAD_CAP) pending.push(chunk);
|
||
|
|
pending.push(chunk);
|
||
|
|
expect(pending.capacity).toBeLessThanOrEqual(HEAD_CAP + chunk.length);
|
||
|
|
});
|
||
|
|
});
|