mirror of
https://github.com/mauriceboe/TREK.git
synced 2026-11-22 21:11:14 +00:00
411ec4af59
Public trip and journey share links handed out more than the owner chose to share: - A travel-only trip link still returned every day's title, and every link with the map returned the free-text day notes the shared page never shows. Days now go out through a public projection without notes, and travel-only links carry no day titles. Day notes, packing, budget and chat use explicit field lists too, and the category list holds only the categories the shared places use, without creator ids. - The public journey payload spread whole entry and photo rows, including storage keys (file_path, thumbnail_path) and internal fields. It is now built from allow-lists and pinned by a strict response contract. - /uploads/journey served every entry photo, original and video to anyone who knew the file name, so a URL kept working after a share link was revoked or the gallery switched off. It now serves journey covers and other non-entry objects only; entry media go through the token-checked proxy. - Anonymous byte paths served stored originals unchanged, so EXIF GPS left the server even with map sharing off. Every public path (journey share proxy, covers, trip share photos, public uploads) now sends a copy with location data blanked in place (EXIF GPS, XMP and IPTC location, MP4/MOV location atoms), falling back to a metadata-free re-encode or a 404, never the raw file. Owners and members still get their originals. - An entry's visibility field never decided the share link but was offered by MCP and the assistant as if it did. It is now documented as having no effect and no longer shown as a privacy label; is_draft keeps an entry off the link.
157 lines
5.7 KiB
TypeScript
157 lines
5.7 KiB
TypeScript
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
|
|
/**
|
|
* A real JPEG carrying the capture tags a phone writes, built byte by byte so
|
|
* no actual person's photo has to live in the repo.
|
|
*
|
|
* The image data is tests/fixtures/small-image.jpg (a decodable 1x1 JPEG); its
|
|
* JFIF APP0 is swapped for an Exif APP1 the way a camera lays the file out:
|
|
* SOI, APP1 "Exif", then the rest. Every value is written as the raw tag string
|
|
* or rational, so a test can also hand in a malformed one.
|
|
*/
|
|
export interface ExifJpegTags {
|
|
/** 0x9003, e.g. '2026:05:30 15:52:19'. */
|
|
DateTimeOriginal?: string;
|
|
/** 0x9004 (DateTimeDigitized). */
|
|
CreateDate?: string;
|
|
/** 0x9010, the offset of the IFD0 DateTime. */
|
|
OffsetTime?: string;
|
|
/** 0x9011, the offset of DateTimeOriginal. */
|
|
OffsetTimeOriginal?: string;
|
|
/** 0x9012, the offset of DateTimeDigitized. */
|
|
OffsetTimeDigitized?: string;
|
|
/** Decimal degrees, stored as the usual degree/minute/second rationals plus N/S and E/W. */
|
|
gps?: { lat: number; lng: number };
|
|
/** 0x0112 in IFD0, 1 to 8. */
|
|
Orientation?: number;
|
|
}
|
|
|
|
const BASE_JPEG = path.join(__dirname, '../fixtures/small-image.jpg');
|
|
|
|
const BYTE = 1;
|
|
const ASCII = 2;
|
|
const SHORT = 3;
|
|
const LONG = 4;
|
|
const RATIONAL = 5;
|
|
|
|
interface Entry {
|
|
tag: number;
|
|
type: number;
|
|
count: number;
|
|
data: Buffer;
|
|
}
|
|
|
|
function ascii(tag: number, value: string): Entry {
|
|
const data = Buffer.from(`${value}\0`, 'latin1');
|
|
return { tag, type: ASCII, count: data.length, data };
|
|
}
|
|
|
|
function long(tag: number, value: number): Entry {
|
|
const data = Buffer.alloc(4);
|
|
data.writeUInt32LE(value);
|
|
return { tag, type: LONG, count: 1, data };
|
|
}
|
|
|
|
function rationals(tag: number, pairs: Array<[number, number]>): Entry {
|
|
const data = Buffer.alloc(pairs.length * 8);
|
|
pairs.forEach(([num, den], i) => {
|
|
data.writeUInt32LE(num, i * 8);
|
|
data.writeUInt32LE(den, i * 8 + 4);
|
|
});
|
|
return { tag, type: RATIONAL, count: pairs.length, data };
|
|
}
|
|
|
|
function dms(deg: number): Array<[number, number]> {
|
|
const abs = Math.abs(deg);
|
|
const d = Math.floor(abs);
|
|
const m = Math.floor((abs - d) * 60);
|
|
const s = Math.round(((abs - d) * 60 - m) * 60 * 10000);
|
|
return [
|
|
[d, 1],
|
|
[m, 1],
|
|
[s, 10000],
|
|
];
|
|
}
|
|
|
|
function ifdSize(entries: Entry[]): number {
|
|
const outOfLine = entries.reduce((sum, e) => sum + (e.data.length > 4 ? e.data.length + (e.data.length % 2) : 0), 0);
|
|
return 2 + entries.length * 12 + 4 + outOfLine;
|
|
}
|
|
|
|
/** One IFD at TIFF offset `at`, entries sorted by tag as the spec wants. */
|
|
function writeIfd(entries: Entry[], at: number): Buffer {
|
|
const sorted = [...entries].sort((a, b) => a.tag - b.tag);
|
|
const head = Buffer.alloc(2 + sorted.length * 12 + 4);
|
|
const tail: Buffer[] = [];
|
|
let dataAt = at + head.length;
|
|
head.writeUInt16LE(sorted.length, 0);
|
|
sorted.forEach((e, i) => {
|
|
const o = 2 + i * 12;
|
|
head.writeUInt16LE(e.tag, o);
|
|
head.writeUInt16LE(e.type, o + 2);
|
|
head.writeUInt32LE(e.count, o + 4);
|
|
if (e.data.length <= 4) {
|
|
e.data.copy(head, o + 8);
|
|
} else {
|
|
head.writeUInt32LE(dataAt, o + 8);
|
|
const padded = e.data.length % 2 ? Buffer.concat([e.data, Buffer.alloc(1)]) : e.data;
|
|
tail.push(padded);
|
|
dataAt += padded.length;
|
|
}
|
|
});
|
|
head.writeUInt32LE(0, head.length - 4);
|
|
return Buffer.concat([head, ...tail]);
|
|
}
|
|
|
|
export function jpegWithExif(tags: ExifJpegTags): Buffer {
|
|
const exifEntries: Entry[] = [];
|
|
if (tags.DateTimeOriginal !== undefined) exifEntries.push(ascii(0x9003, tags.DateTimeOriginal));
|
|
if (tags.CreateDate !== undefined) exifEntries.push(ascii(0x9004, tags.CreateDate));
|
|
if (tags.OffsetTime !== undefined) exifEntries.push(ascii(0x9010, tags.OffsetTime));
|
|
if (tags.OffsetTimeOriginal !== undefined) exifEntries.push(ascii(0x9011, tags.OffsetTimeOriginal));
|
|
if (tags.OffsetTimeDigitized !== undefined) exifEntries.push(ascii(0x9012, tags.OffsetTimeDigitized));
|
|
|
|
const gpsEntries: Entry[] = [];
|
|
if (tags.gps) {
|
|
gpsEntries.push({ tag: 0x0000, type: BYTE, count: 4, data: Buffer.from([2, 2, 0, 0]) });
|
|
gpsEntries.push(ascii(0x0001, tags.gps.lat < 0 ? 'S' : 'N'));
|
|
gpsEntries.push(rationals(0x0002, dms(tags.gps.lat)));
|
|
gpsEntries.push(ascii(0x0003, tags.gps.lng < 0 ? 'W' : 'E'));
|
|
gpsEntries.push(rationals(0x0004, dms(tags.gps.lng)));
|
|
}
|
|
|
|
// IFD0 holds the orientation and the two pointers, so its size is known before the offsets are.
|
|
const ifd0Count =
|
|
(tags.Orientation !== undefined ? 1 : 0) + (exifEntries.length ? 1 : 0) + (gpsEntries.length ? 1 : 0);
|
|
const ifd0At = 8;
|
|
const exifAt = ifd0At + 2 + ifd0Count * 12 + 4;
|
|
const gpsAt = exifAt + (exifEntries.length ? ifdSize(exifEntries) : 0);
|
|
const ifd0Entries: Entry[] = [];
|
|
if (tags.Orientation !== undefined) {
|
|
const data = Buffer.alloc(2);
|
|
data.writeUInt16LE(tags.Orientation);
|
|
ifd0Entries.push({ tag: 0x0112, type: SHORT, count: 1, data });
|
|
}
|
|
if (exifEntries.length) ifd0Entries.push(long(0x8769, exifAt));
|
|
if (gpsEntries.length) ifd0Entries.push(long(0x8825, gpsAt));
|
|
|
|
const tiffHeader = Buffer.from([0x49, 0x49, 0x2a, 0x00, 0x08, 0x00, 0x00, 0x00]);
|
|
const tiff = Buffer.concat([
|
|
tiffHeader,
|
|
writeIfd(ifd0Entries, ifd0At),
|
|
exifEntries.length ? writeIfd(exifEntries, exifAt) : Buffer.alloc(0),
|
|
gpsEntries.length ? writeIfd(gpsEntries, gpsAt) : Buffer.alloc(0),
|
|
]);
|
|
const payload = Buffer.concat([Buffer.from('Exif\0\0', 'latin1'), tiff]);
|
|
const app1 = Buffer.alloc(4);
|
|
app1.writeUInt16BE(0xffe1, 0);
|
|
app1.writeUInt16BE(payload.length + 2, 2);
|
|
|
|
const base = fs.readFileSync(BASE_JPEG);
|
|
// SOI, then skip the JFIF APP0 (marker + its big-endian length).
|
|
const app0Length = base.readUInt16BE(4);
|
|
const rest = base.subarray(4 + app0Length);
|
|
return Buffer.concat([base.subarray(0, 2), app1, payload, rest]);
|
|
}
|