feat: print performance logs to console.

This commit is contained in:
鲁树人 2023-05-21 17:58:54 +01:00
parent c4e3999546
commit 4cfc672646
12 changed files with 171 additions and 92 deletions

View File

@ -1,10 +1,10 @@
export interface CryptoBase {
/**
* When returning false, a successful decryption should be checked by its decrypted content instead.
*/
hasSignature(): boolean;
isSupported(blob: Blob): Promise<boolean>;
decrypt(blob: Blob): Promise<Blob>;
cryptoName: string;
checkByDecryptHeader: boolean;
decryptTargetAudio: boolean;
checkBySignature?: (buffer: ArrayBuffer) => Promise<boolean>;
decrypt(buffer: ArrayBuffer, blob: Blob): Promise<Blob | ArrayBuffer>;
}
export type CryptoFactory = () => CryptoBase;

View File

@ -0,0 +1,19 @@
import { CryptoFactory } from './CryptoBase';
import { QMC1Crypto } from './qmc/qmc_v1';
import { QMC2Crypto } from './qmc/qmc_v2';
import { XiamiCrypto } from './xiami/xiami';
export const allCryptoFactories: CryptoFactory[] = [
// Xiami (*.xm)
() => new XiamiCrypto(),
// QMCv2 (*.mflac)
() => new QMC2Crypto(),
// Crypto that does not implement "checkBySignature" or need to decrypt the entire file and then check audio type,
// should be moved to the bottom of the list for performance reasons.
// QMCv1 (*.qmcflac)
() => new QMC1Crypto(),
];

View File

@ -3,15 +3,11 @@ import type { CryptoBase } from '../CryptoBase';
import key from './qmc_v1.key.ts';
export class QMC1Crypto implements CryptoBase {
hasSignature(): boolean {
return false;
}
cryptoName = 'QMCv1';
checkByDecryptHeader = true;
decryptTargetAudio = true;
async isSupported(): Promise<boolean> {
return true;
}
async decrypt(blob: Blob): Promise<Blob> {
async decrypt(_buffer: ArrayBuffer, blob: Blob): Promise<Blob> {
return transformBlob(blob, (p) => p.make.QMCv1(key));
}
}

View File

@ -3,15 +3,11 @@ import type { CryptoBase } from '../CryptoBase';
import { SEED, ENC_V2_KEY_1, ENC_V2_KEY_2 } from './qmc_v2.key.ts';
export class QMC2Crypto implements CryptoBase {
hasSignature(): boolean {
return false;
}
cryptoName = 'QMCv2';
checkByDecryptHeader = false;
decryptTargetAudio = true;
async isSupported(): Promise<boolean> {
return true;
}
async decrypt(blob: Blob): Promise<Blob> {
async decrypt(_buffer: ArrayBuffer, blob: Blob): Promise<Blob> {
return transformBlob(blob, (p) => p.make.QMCv2(p.make.QMCv2FooterParser(SEED, ENC_V2_KEY_1, ENC_V2_KEY_2)));
}
}

View File

@ -11,8 +11,9 @@
import type { CryptoBase } from '../CryptoBase';
const XIAMI_FILE_MAGIC = new Uint8Array('ifmt'.split('').map((x) => x.charCodeAt(0)));
const XIAMI_EXPECTED_PADDING = new Uint8Array([0xfe, 0xfe, 0xfe, 0xfe]);
// little endian
const XIAMI_FILE_MAGIC = 0x746d6669;
const XIAMI_EXPECTED_PADDING = 0xfefefefe;
const u8Sub = (a: number, b: number) => {
if (a > b) {
@ -23,29 +24,25 @@ const u8Sub = (a: number, b: number) => {
};
export class XiamiCrypto implements CryptoBase {
hasSignature(): boolean {
return true;
cryptoName = 'Xiami';
checkByDecryptHeader = false;
decryptTargetAudio = true;
async checkBySignature(buffer: ArrayBuffer): Promise<boolean> {
const header = new DataView(buffer);
return header.getUint32(0x00, true) === XIAMI_FILE_MAGIC && header.getUint32(0x08, true) === XIAMI_EXPECTED_PADDING;
}
async isSupported(blob: Blob): Promise<boolean> {
const headerBuffer = await blob.slice(0, 0x10).arrayBuffer();
const header = new Uint8Array(headerBuffer);
return (
header.slice(0x00, 0x04).every((b, i) => b === XIAMI_FILE_MAGIC[i]) &&
header.slice(0x08, 0x0c).every((b, i) => b === XIAMI_EXPECTED_PADDING[i])
);
}
async decrypt(blob: Blob): Promise<Blob> {
const headerBuffer = await blob.slice(0, 0x10).arrayBuffer();
async decrypt(src: ArrayBuffer): Promise<ArrayBuffer> {
const headerBuffer = src.slice(0, 0x10);
const header = new Uint8Array(headerBuffer);
const key = u8Sub(header[0x0f], 1);
const plainTextSize = header[0x0c] | (header[0x0d] << 8) | (header[0x0e] << 16);
const decrypted = new Uint8Array(await blob.slice(0x10).arrayBuffer());
const decrypted = new Uint8Array(src.slice(0x10));
for (let i = decrypted.byteLength - 1; i >= plainTextSize; i--) {
decrypted[i] = u8Sub(key, decrypted[i]);
}
return new Blob([decrypted]);
return decrypted;
}
}

View File

@ -0,0 +1,2 @@
export const toArrayBuffer = async (src: Blob | ArrayBuffer) => (src instanceof Blob ? await src.arrayBuffer() : src);
export const toBlob = (src: Blob | ArrayBuffer) => (src instanceof Blob ? src : new Blob([src]));

View File

@ -1,49 +0,0 @@
import { fetchParakeet } from '@jixun/libparakeet';
import { CryptoFactory } from '../crypto/CryptoBase';
import { XiamiCrypto } from '../crypto/xiami/xiami';
import { QMC1Crypto } from '../crypto/qmc/qmc_v1';
import { QMC2Crypto } from '../crypto/qmc/qmc_v2';
// Use first 4MiB of the file to perform check.
const TEST_FILE_HEADER_LEN = 1024 * 1024 * 4;
const decryptorFactories: CryptoFactory[] = [
// Xiami (*.xm)
() => new XiamiCrypto(),
// QMCv1 (*.qmcflac)
() => new QMC1Crypto(),
// QMCv2 (*.mflac)
() => new QMC2Crypto(),
];
export const workerDecryptHandler = async (blobURI: string) => {
const blob = await fetch(blobURI).then((r) => r.blob());
const parakeet = await fetchParakeet();
for (const factory of decryptorFactories) {
const decryptor = factory();
if (await decryptor.isSupported(blob)) {
try {
const decryptedBlob = await decryptor.decrypt(blob);
// Check if we had a successful decryption
const header = await decryptedBlob.slice(0, TEST_FILE_HEADER_LEN).arrayBuffer();
const audioExt = parakeet.detectAudioExtension(header);
if (!decryptor.hasSignature() && audioExt === 'bin') {
// skip this decryptor result
continue;
}
return { decrypted: URL.createObjectURL(decryptedBlob), ext: audioExt };
} catch (error) {
console.error('decrypt failed: ', error);
continue;
}
}
}
throw new Error('could not decrypt file: no working decryptor found');
};

View File

@ -3,7 +3,7 @@ import { DECRYPTION_WORKER_ACTION_NAME } from './constants';
import { getSDKVersion } from '@jixun/libparakeet';
import { workerDecryptHandler } from './worker-handler/decrypt';
import { workerDecryptHandler } from './worker/handler/decrypt';
const bus = new WorkerServerBus();
onmessage = bus.onmessage;

View File

@ -0,0 +1,93 @@
import { Parakeet, fetchParakeet } from '@jixun/libparakeet';
import { timedLogger } from '~/util/timedLogger';
import { allCryptoFactories } from '../../crypto/CryptoFactory';
import { toArrayBuffer, toBlob } from '~/decrypt-worker/util/buffer';
import { CryptoBase, CryptoFactory } from '~/decrypt-worker/crypto/CryptoBase';
// Use first 4MiB of the file to perform check.
const TEST_FILE_HEADER_LEN = 4 * 1024 * 1024;
class DecryptCommandHandler {
private label: string;
constructor(label: string, private parakeet: Parakeet, private blob: Blob, private buffer: ArrayBuffer) {
this.label = `DecryptCommandHandler( ${label} )`;
}
log<R>(label: string, fn: () => R): R {
return timedLogger(`${this.label}: ${label}`, fn);
}
async decrypt(factories: CryptoFactory[]) {
for (const factory of factories) {
const decryptor = factory();
try {
const result = await this.decryptFile(decryptor);
if (result === null) {
continue;
}
return result;
} catch (error) {
console.error('decrypt failed: ', error);
continue;
}
}
throw new Error('could not decrypt file: no working decryptor found');
}
async decryptFile(crypto: CryptoBase) {
if (crypto.checkBySignature && !(await crypto.checkBySignature(this.buffer))) {
return null;
}
if (crypto.checkByDecryptHeader && !(await this.acceptByDecryptFileHeader(crypto))) {
return null;
}
const decrypted = await this.log('decrypt', async () => crypto.decrypt(this.buffer, this.blob));
// Check if we had a successful decryption
const audioExt = await this.log(`detect-audio-ext`, async () => {
const header = await toArrayBuffer(decrypted.slice(0, TEST_FILE_HEADER_LEN));
return this.parakeet.detectAudioExtension(header);
});
return { decrypted: URL.createObjectURL(toBlob(decrypted)), ext: audioExt };
}
async acceptByDecryptFileHeader(crypto: CryptoBase): Promise<boolean> {
// File too small, ignore.
if (this.buffer.byteLength <= TEST_FILE_HEADER_LEN) {
return true;
}
// Check by decrypt max first 8MiB
const decryptedBuffer = await this.log(`${crypto.cryptoName}/decrypt-header-test`, async () =>
toArrayBuffer(
await crypto.decrypt(this.buffer.slice(0, TEST_FILE_HEADER_LEN), this.blob.slice(0, TEST_FILE_HEADER_LEN))
)
);
return this.parakeet.detectAudioExtension(decryptedBuffer) !== 'bin';
}
}
export const workerDecryptHandler = async ({ id, blobURI }: { id: string; blobURI: string }) => {
const label = `decrypt( ${id} )`;
console.group(label);
try {
return await timedLogger(`${label}/total`, async () => {
const parakeet = await timedLogger(`${label}/init`, fetchParakeet);
const blob = await timedLogger(`${label}/fetch-src`, async () => fetch(blobURI).then((r) => r.blob()));
const buffer = await timedLogger(`${label}/read-src`, async () => blob.arrayBuffer());
const handler = new DecryptCommandHandler(id, parakeet, blob, buffer);
return handler.decrypt(allCryptoFactories);
});
} finally {
(console.groupEnd as (label: string) => void)(label);
}
};

View File

@ -8,6 +8,6 @@ export class DecryptionQueue extends ConcurrentQueue<{ id: string; blobURI: stri
}
async handler(item: { id: string; blobURI: string }): Promise<DecryptionResult> {
return this.workerClientBus.request(DECRYPTION_WORKER_ACTION_NAME.DECRYPT, item.blobURI);
return this.workerClientBus.request(DECRYPTION_WORKER_ACTION_NAME.DECRYPT, item);
}
}

View File

@ -24,6 +24,9 @@ test('should be able to forward request to worker client bus', async () => {
const queue = new DecryptionQueue(bus, 1);
await expect(queue.add({ id: 'file://1', blobURI: 'blob://mock-file' })).resolves.toEqual({
actionName: DECRYPTION_WORKER_ACTION_NAME.DECRYPT,
payload: 'blob://mock-file',
payload: {
blobURI: 'blob://mock-file',
id: 'file://1',
},
});
});

22
src/util/timedLogger.ts Normal file
View File

@ -0,0 +1,22 @@
function isPromise<T = unknown>(p: unknown): p is Promise<T> {
return !!p && typeof p === 'object' && 'then' in p && 'catch' in p && 'finally' in p;
}
export function timedLogger<R = unknown>(label: string, fn: () => R): R {
console.time(label);
try {
const result = fn();
if (isPromise(result)) {
result.finally(() => {
console.timeEnd(label);
});
}
return result;
} catch (e) {
console.timeEnd(label);
throw e;
}
}