Anonymous
2 years ago
18 changed files with 1148 additions and 451 deletions
File diff suppressed because it is too large
|
After Width: | Height: | Size: 2.0 KiB |
@ -0,0 +1,152 @@ |
|||
import { buf } from "crc-32"; |
|||
import { Buffer } from "buffer"; |
|||
import { EMBED_TYPES, ImageProcessor, EmbeddedFile, EMBED_STATUS } from './main'; |
|||
import { PNGDecoder, PNGEncoder } from "./png"; |
|||
import { decodeCoom3Payload } from "./utils"; |
|||
|
|||
const CUM0 = Buffer.from("CUM\0" + "0"); |
|||
const CUM3 = Buffer.from("CUM\0" + "3"); |
|||
|
|||
const BufferReadStream = (b: Buffer) => { |
|||
const ret = new ReadableStream<Buffer>({ |
|||
pull(cont) { |
|||
cont.enqueue(b); |
|||
cont.close(); |
|||
} |
|||
}); |
|||
return ret; |
|||
}; |
|||
|
|||
const extract = async (png: Buffer): Promise<EmbeddedFile[] | undefined> => { |
|||
let magic = false; |
|||
let coom3 = false; |
|||
const reader = BufferReadStream(png).getReader(); |
|||
const sneed = new PNGDecoder(reader); |
|||
try { |
|||
let lastIDAT: Buffer | null = null; |
|||
for await (const [name, chunk, crc, offset] of sneed.chunks()) { |
|||
let buff: Buffer; |
|||
switch (name) { |
|||
// should exist at the beginning of file to signal decoders if the file indeed has an embedded chunk
|
|||
case 'tEXt': |
|||
buff = chunk; |
|||
if (buff.slice(4, 4 + CUM0.length).equals(CUM0)) |
|||
magic = true; |
|||
if (buff.slice(4, 4 + CUM0.length).equals(CUM3)) { |
|||
coom3 = true; |
|||
magic = true; |
|||
} |
|||
break; |
|||
case 'IDAT': |
|||
if (magic) { |
|||
lastIDAT = chunk; |
|||
break; |
|||
} |
|||
// eslint-disable-next-line no-fallthrough
|
|||
case 'IEND': |
|||
if (!magic) |
|||
return; // Didn't find tExt Chunk;
|
|||
// eslint-disable-next-line no-fallthrough
|
|||
default: |
|||
break; |
|||
} |
|||
} |
|||
if (lastIDAT) { |
|||
let data = (lastIDAT as Buffer).slice(4); |
|||
if (coom3) { |
|||
let file = decodeCoom3Payload(data) |
|||
return; |
|||
} |
|||
const fnsize = data.readUInt32LE(0); |
|||
const fn = data.slice(4, 4 + fnsize).toString(); |
|||
// Todo: xor the buffer to prevent scanning for file signatures (4chan embedded file detection)?
|
|||
data = data.slice(4 + fnsize); |
|||
return [{ embed_type: EMBED_TYPES.MEDIA_EMBED, filename: fn, data } as EmbeddedFile]; |
|||
} |
|||
} catch (e) { |
|||
console.error(e); |
|||
} finally { |
|||
reader.releaseLock(); |
|||
} |
|||
}; |
|||
|
|||
const buildChunk = (tag: string, data: Buffer) => { |
|||
const ret = Buffer.alloc(data.byteLength + 4); |
|||
ret.write(tag.slice(0, 4), 0); |
|||
data.copy(ret, 4); |
|||
return ret; |
|||
}; |
|||
|
|||
export const BufferWriteStream = () => { |
|||
let b = Buffer.from([]); |
|||
const ret = new WritableStream<Buffer>({ |
|||
write(chunk) { |
|||
b = Buffer.concat([b, chunk]); |
|||
} |
|||
}); |
|||
return [ret, () => b] as [WritableStream<Buffer>, () => Buffer]; |
|||
}; |
|||
|
|||
const inject = async (container: File, inj: File) => { |
|||
const [writestream, extract] = BufferWriteStream(); |
|||
const encoder = new PNGEncoder(writestream); |
|||
const decoder = new PNGDecoder(container.stream().getReader()); |
|||
|
|||
let magic = false; |
|||
for await (const [name, chunk, crc, offset] of decoder.chunks()) { |
|||
if (magic && name != "IDAT") |
|||
break; |
|||
if (!magic && name == "IDAT") { |
|||
await encoder.insertchunk(["tEXt", buildChunk("tEXt", CUM0), 0, 0]); |
|||
magic = true; |
|||
} |
|||
await encoder.insertchunk([name, chunk, crc, offset]); |
|||
} |
|||
const injb = Buffer.alloc(4 + inj.name.length + inj.size); |
|||
injb.writeInt32LE(inj.name.length, 0); |
|||
injb.write(inj.name, 4); |
|||
Buffer.from(await inj.arrayBuffer()).copy(injb, 4 + inj.name.length); |
|||
await encoder.insertchunk(["IDAT", buildChunk("IDAT", injb), 0, 0]); |
|||
await encoder.insertchunk(["IEND", buildChunk("IEND", Buffer.from([])), 0, 0]); |
|||
return extract(); |
|||
}; |
|||
|
|||
const has_embed = async (png: Buffer): Promise<EMBED_STATUS> => { |
|||
const reader = BufferReadStream(png).getReader(); |
|||
const sneed = new PNGDecoder(reader); |
|||
try { |
|||
for await (const [name, chunk, crc, offset] of sneed.chunks()) { |
|||
let buff: Buffer; |
|||
switch (name) { |
|||
// should exist at the beginning of file to signal decoders if the file indeed has an embedded chunk
|
|||
case 'tEXt': |
|||
buff = chunk; |
|||
if (buff.slice(4, 4 + CUM0.length).equals(CUM0)) |
|||
return EMBED_STATUS.SUCCESS; |
|||
if (buff.slice(4, 4 + CUM0.length).equals(CUM3)) |
|||
return EMBED_STATUS.SUCCESS; |
|||
break; |
|||
case 'IDAT': |
|||
// eslint-disable-next-line no-fallthrough
|
|||
case 'IEND': |
|||
return EMBED_STATUS.NONE; // Didn't find tExt Chunk; Definite no
|
|||
// eslint-disable-next-line no-fallthrough
|
|||
default: |
|||
break; |
|||
} |
|||
} |
|||
// stream ended on chunk boundary, so no unexpected EOF was fired, need more data anyway
|
|||
} catch (e) { |
|||
return EMBED_STATUS.PEE_UNDEFINED; // possibly unexpected EOF, need more data to decide
|
|||
} finally { |
|||
reader.releaseLock(); |
|||
} |
|||
return EMBED_STATUS.PEE_UNDEFINED; // possibly unexpected EOF, need more data to decide
|
|||
}; |
|||
|
|||
export default { |
|||
extract, |
|||
has_embed, |
|||
inject, |
|||
match: fn => !!fn.match(/\.png$/) |
|||
} as ImageProcessor; |
|||
@ -0,0 +1,76 @@ |
|||
import { EmbeddedFile, EMBED_STATUS, EMBED_TYPES, ImageProcessor } from "./main"; |
|||
import { GM_fetch, GM_head } from "./requests"; |
|||
import type { Buffer } from "buffer"; |
|||
import thumbnail from "./assets/hasembed.png"; |
|||
|
|||
const sources = [ |
|||
{ host: 'Catbox', prefix: 'https://files.catbox.moe/' }, |
|||
{ host: 'Litter', prefix: 'https://litter.catbox.moe/' }, |
|||
{ host: 'Pomf', prefix: 'https://a.pomf.cat/' }, |
|||
]; |
|||
|
|||
const getExt = (fn: string) => { |
|||
const isDum = fn!.match(/^([a-z0-9]{6}\.(?:jpe?g|png|webm|gif))/gi); |
|||
const isB64 = fn!.match(/^((?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=))?\.(gif|jpe?g|png|webm)/); |
|||
const isExt = fn!.match(/\[.*=(.*)\]/); |
|||
let ext; |
|||
if (isDum) { |
|||
ext = isDum[0]; |
|||
} else if (isB64) { |
|||
ext = atob(isB64[1]); |
|||
} else if (isExt) { |
|||
ext = isExt[1]; |
|||
} |
|||
return ext; |
|||
}; |
|||
|
|||
const extract = async (b: Buffer, fn?: string) : Promise<EmbeddedFile[]> => { |
|||
const ext = getExt(fn!); |
|||
|
|||
let rsource: string; |
|||
for (const source of sources) { |
|||
try { |
|||
await GM_head(source.prefix + ext); |
|||
rsource = source.prefix + ext; |
|||
break; |
|||
} catch { |
|||
// 404
|
|||
} |
|||
} |
|||
|
|||
return [{ |
|||
embed_type: EMBED_TYPES.MEDIA_EMBED, |
|||
filename: ext, |
|||
data: async (lsn) => { |
|||
try { |
|||
return (await GM_fetch(rsource, undefined, lsn)).arrayBuffer(); |
|||
} catch (e) { |
|||
//404
|
|||
} |
|||
}, |
|||
// thumbnail
|
|||
} as EmbeddedFile]; |
|||
}; |
|||
|
|||
const has_embed = async (b: Buffer, fn?: string) : Promise<EMBED_STATUS> => { |
|||
const ext = getExt(fn!); |
|||
if (!ext) |
|||
return EMBED_STATUS.NONE; |
|||
for (const source of sources) { |
|||
try { |
|||
const e = await GM_head(source.prefix + ext); |
|||
return EMBED_STATUS.SUCCESS; |
|||
} catch { |
|||
// 404
|
|||
} |
|||
} |
|||
|
|||
return EMBED_STATUS.NONE; |
|||
}; |
|||
|
|||
export default { |
|||
skip: true, |
|||
extract, |
|||
has_embed, |
|||
match: fn => !!getExt(fn) |
|||
} as ImageProcessor; |
|||
@ -0,0 +1,5 @@ |
|||
import type { Buffer } from "buffer"; |
|||
|
|||
export const decodeCoom3Payload = (buff: Buffer) => { |
|||
//
|
|||
}; |
|||
Loading…
Reference in new issue