web/src/decrypt/qmc.ts

145 lines
5.7 KiB
TypeScript
Raw Normal View History

import {QmcMask, QmcMaskDetectMflac, QmcMaskDetectMgg, QmcMaskGetDefault} from "./qmcMask";
2021-05-24 15:48:52 +00:00
import {toByteArray as Base64Decode} from 'base64-js'
2021-05-23 17:30:38 +00:00
import {
AudioMimeType,
GetArrayBuffer,
GetCoverFromFile,
GetImageFromURL,
2021-05-24 15:48:52 +00:00
GetMetaFromFile,
SniffAudioExt, WriteMetaToFlac, WriteMetaToMp3
2021-12-14 06:57:48 +00:00
} from "@/decrypt/utils";
import {parseBlob as metaParseBlob} from "music-metadata-browser";
import {decryptMGG} from "./qmcv2";
2020-04-26 06:32:32 +00:00
2021-05-23 22:50:20 +00:00
import iconv from "iconv-lite";
2021-05-24 07:05:14 +00:00
import {DecryptResult} from "@/decrypt/entity";
2021-05-24 15:48:52 +00:00
import {queryAlbumCover, queryKeyInfo, reportKeyUsage} from "@/utils/api";
2021-05-23 22:50:20 +00:00
interface Handler {
ext: string
detect: boolean
handler(data?: Uint8Array): QmcMask | undefined
}
export const HandlerMap: { [key: string]: Handler } = {
2020-02-11 06:48:27 +00:00
"mgg": {handler: QmcMaskDetectMgg, ext: "ogg", detect: true},
"mflac": {handler: QmcMaskDetectMflac, ext: "flac", detect: true},
"mgg.cache": {handler: QmcMaskDetectMgg, ext: "ogg", detect: false},
"mflac.cache": {handler: QmcMaskDetectMflac, ext: "flac", detect: false},
2020-02-11 06:48:27 +00:00
"qmc0": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
2020-04-04 17:01:59 +00:00
"qmc2": {handler: QmcMaskGetDefault, ext: "ogg", detect: false},
2020-02-11 06:48:27 +00:00
"qmc3": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
"qmcogg": {handler: QmcMaskGetDefault, ext: "ogg", detect: false},
"qmcflac": {handler: QmcMaskGetDefault, ext: "flac", detect: false},
"bkcmp3": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
"bkcflac": {handler: QmcMaskGetDefault, ext: "flac", detect: false},
2020-09-19 04:03:02 +00:00
"tkm": {handler: QmcMaskGetDefault, ext: "m4a", detect: false},
"666c6163": {handler: QmcMaskGetDefault, ext: "flac", detect: false},
"6d7033": {handler: QmcMaskGetDefault, ext: "mp3", detect: false},
"6f6767": {handler: QmcMaskGetDefault, ext: "ogg", detect: false},
"6d3461": {handler: QmcMaskGetDefault, ext: "m4a", detect: false},
"776176": {handler: QmcMaskGetDefault, ext: "wav", detect: false}
2020-01-27 04:50:24 +00:00
};
2020-01-21 11:03:41 +00:00
function mergeUint8(array: Uint8Array[]): Uint8Array {
// Get the total length of all arrays.
let length = 0;
array.forEach(item => {
length += item.length;
});
// Create a new array with total length and merge all source arrays.
let mergedArray = new Uint8Array(length);
let offset = 0;
array.forEach(item => {
mergedArray.set(item, offset);
offset += item.length;
});
return mergedArray;
}
export async function Decrypt(file: Blob, raw_filename: string, raw_ext: string): Promise<DecryptResult> {
if (!(raw_ext in HandlerMap)) throw `Qmc cannot handle type: ${raw_ext}`;
const handler = HandlerMap[raw_ext];
const decodedParts = await decryptMGG(await file.arrayBuffer());
let musicDecoded = mergeUint8(decodedParts);
const ext = SniffAudioExt(musicDecoded, handler.ext);
2020-02-11 07:51:07 +00:00
const mime = AudioMimeType[ext];
let musicBlob = new Blob(decodedParts, {type: mime});
2020-04-05 09:32:19 +00:00
const musicMeta = await metaParseBlob(musicBlob);
2020-04-06 04:53:16 +00:00
for (let metaIdx in musicMeta.native) {
2021-05-23 22:50:20 +00:00
if (!musicMeta.native.hasOwnProperty(metaIdx)) continue
2020-04-06 04:53:16 +00:00
if (musicMeta.native[metaIdx].some(item => item.id === "TCON" && item.value === "(12)")) {
2021-05-23 22:50:20 +00:00
console.warn("try using gbk encoding to decode meta")
musicMeta.common.artist = iconv.decode(new Buffer(musicMeta.common.artist ?? ""), "gbk");
musicMeta.common.title = iconv.decode(new Buffer(musicMeta.common.title ?? ""), "gbk");
musicMeta.common.album = iconv.decode(new Buffer(musicMeta.common.album ?? ""), "gbk");
2020-04-06 04:53:16 +00:00
}
}
2020-04-06 04:53:16 +00:00
const info = GetMetaFromFile(raw_filename, musicMeta.common.title, musicMeta.common.artist)
2020-04-05 09:32:19 +00:00
let imgUrl = GetCoverFromFile(musicMeta);
if (!imgUrl) {
2021-05-24 15:48:52 +00:00
imgUrl = await getCoverImage(info.title, info.artist, musicMeta.common.album);
if (imgUrl) {
2021-05-23 17:30:38 +00:00
const imageInfo = await GetImageFromURL(imgUrl);
if (imageInfo) {
imgUrl = imageInfo.url
try {
2021-05-23 22:50:20 +00:00
const newMeta = {picture: imageInfo.buffer, title: info.title, artists: info.artist?.split(" _ ")}
if (ext === "mp3") {
2021-05-23 22:50:20 +00:00
musicDecoded = WriteMetaToMp3(Buffer.from(musicDecoded), newMeta, musicMeta)
musicBlob = new Blob([musicDecoded], {type: mime});
} else if (ext === 'flac') {
musicDecoded = WriteMetaToFlac(Buffer.from(musicDecoded), newMeta, musicMeta)
musicBlob = new Blob([musicDecoded], {type: mime});
2020-12-05 18:32:57 +00:00
} else {
console.info("writing metadata for " + ext + " is not being supported for now")
}
} catch (e) {
console.warn("Error while appending cover image to file " + e)
}
}
}
2020-04-05 09:32:19 +00:00
}
return {
2020-01-21 11:03:41 +00:00
title: info.title,
artist: info.artist,
2020-02-11 07:51:07 +00:00
ext: ext,
2020-04-05 09:32:19 +00:00
album: musicMeta.common.album,
picture: imgUrl,
file: URL.createObjectURL(musicBlob),
2021-05-24 19:06:28 +00:00
blob: musicBlob,
mime: mime
}
}
2021-05-23 22:50:20 +00:00
2021-05-24 15:48:52 +00:00
async function queryKey(keyData: Uint8Array, filename: string, format: string): Promise<QmcMask | undefined> {
try {
2021-05-24 15:48:52 +00:00
const data = await queryKeyInfo(keyData, filename, format)
return new QmcMask(Base64Decode(data.Matrix44));
} catch (e) {
2021-05-24 14:19:37 +00:00
console.warn(e);
}
}
2020-04-05 09:32:19 +00:00
2021-05-24 15:48:52 +00:00
async function getCoverImage(title: string, artist?: string, album?: string): Promise<string> {
2021-05-23 22:50:20 +00:00
const song_query_url = "https://stats.ixarea.com/apis" + "/music/qq-cover"
2020-04-05 09:32:19 +00:00
try {
2021-05-24 15:48:52 +00:00
const data = await queryAlbumCover(title, artist, album)
return `${song_query_url}/${data.Type}/${data.Id}`
2020-07-18 13:45:53 +00:00
} catch (e) {
2021-05-24 14:19:37 +00:00
console.warn(e);
2020-04-05 09:32:19 +00:00
}
2021-05-24 15:48:52 +00:00
return ""
2020-04-23 10:15:47 +00:00
}