games_app/backend/dist-test-faq/utils/apkParser.js

252 lines
9.7 KiB
JavaScript

"use strict";
/**
* Parse Android APK metadata and signing certificate fingerprint.
* Supports JAR signing (v1) and APK Signature Scheme v2/v3.
*/
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.assertApkZipMagic = assertApkZipMagic;
exports.extractSigningCertSha256FromApkSigningBlock = extractSigningCertSha256FromApkSigningBlock;
exports.extractSigningCertSha256 = extractSigningCertSha256;
exports.parseApkFile = parseApkFile;
const fs_1 = __importDefault(require("fs"));
const crypto_1 = __importDefault(require("crypto"));
const path_1 = __importDefault(require("path"));
const adm_zip_1 = __importDefault(require("adm-zip"));
const node_forge_1 = __importDefault(require("node-forge"));
// eslint-disable-next-line @typescript-eslint/no-require-imports
const AppInfoParser = require('app-info-parser');
const APK_SIG_BLOCK_MAGIC = Buffer.from('APK Sig Block 42', 'utf8');
const APK_SIGNATURE_SCHEME_V2_BLOCK_ID = 0x7109871a;
const APK_SIGNATURE_SCHEME_V3_BLOCK_ID = 0xf05368c0;
/** Enough for EOCD + typical APK Signing Block without loading the whole APK. */
const APK_TAIL_READ_BYTES = 4 * 1024 * 1024;
/** True when file starts with ZIP/APK magic bytes. */
function assertApkZipMagic(filePath) {
const fd = fs_1.default.openSync(filePath, 'r');
try {
const buf = Buffer.alloc(4);
const read = fs_1.default.readSync(fd, buf, 0, 4, 0);
if (read < 4 || buf[0] !== 0x50 || buf[1] !== 0x4b || buf[2] !== 0x03 || buf[3] !== 0x04) {
throw new Error('File is not a valid APK/ZIP archive');
}
}
finally {
fs_1.default.closeSync(fd);
}
}
function sha256OfDer(der) {
return crypto_1.default.createHash('sha256').update(der).digest('hex');
}
function readU32LE(buf, offset) {
return buf.readUInt32LE(offset);
}
function readU64LEAsNumber(buf, offset) {
const lo = buf.readUInt32LE(offset);
const hi = buf.readUInt32LE(offset + 4);
return hi * 0x100000000 + lo;
}
/** Read the last N bytes of a file (for EOCD / APK Signing Block). */
function readFileTail(filePath, maxBytes) {
const fileSize = fs_1.default.statSync(filePath).size;
const readSize = Math.min(fileSize, maxBytes);
const tailStart = fileSize - readSize;
const tail = Buffer.alloc(readSize);
const fd = fs_1.default.openSync(filePath, 'r');
try {
fs_1.default.readSync(fd, tail, 0, readSize, tailStart);
}
finally {
fs_1.default.closeSync(fd);
}
return { tail, fileSize, tailStart };
}
/**
* Locate ZIP End of Central Directory inside a file tail and return absolute CD offset.
*/
function findCentralDirectoryOffsetInTail(tail, tailStart, fileSize) {
const maxComment = 0xffff;
const minEocd = 22;
const start = Math.max(0, tail.length - (minEocd + maxComment));
for (let i = tail.length - minEocd; i >= start; i--) {
if (tail[i] === 0x50 && tail[i + 1] === 0x4b && tail[i + 2] === 0x05 && tail[i + 3] === 0x06) {
const commentLen = tail.readUInt16LE(i + 20);
if (tailStart + i + minEocd + commentLen === fileSize) {
return tail.readUInt32LE(i + 16);
}
}
}
throw new Error('ZIP End of Central Directory not found');
}
/**
* Extract first X.509 certificate DER from an APK Signing Block v2 or v3 value.
*/
function firstCertDerFromV2orV3Block(blockValue) {
if (blockValue.length < 4)
return null;
const signersLen = readU32LE(blockValue, 0);
if (signersLen <= 0 || 4 + signersLen > blockValue.length)
return null;
let offset = 4;
const signersEnd = 4 + signersLen;
while (offset + 4 <= signersEnd) {
const signerLen = readU32LE(blockValue, offset);
offset += 4;
if (signerLen <= 0 || offset + signerLen > signersEnd)
break;
const signer = blockValue.subarray(offset, offset + signerLen);
offset += signerLen;
if (signer.length < 4)
continue;
const signedDataLen = readU32LE(signer, 0);
if (signedDataLen <= 0 || 4 + signedDataLen > signer.length)
continue;
const signedData = signer.subarray(4, 4 + signedDataLen);
if (signedData.length < 4)
continue;
const digestsLen = readU32LE(signedData, 0);
let sdOff = 4 + digestsLen;
if (digestsLen < 0 || sdOff + 4 > signedData.length)
continue;
const certsLen = readU32LE(signedData, sdOff);
sdOff += 4;
if (certsLen <= 0 || sdOff + certsLen > signedData.length)
continue;
const certsEnd = sdOff + certsLen;
if (sdOff + 4 > certsEnd)
continue;
const certLen = readU32LE(signedData, sdOff);
sdOff += 4;
if (certLen <= 0 || sdOff + certLen > certsEnd)
continue;
return Buffer.from(signedData.subarray(sdOff, sdOff + certLen));
}
return null;
}
/**
* Read signing cert from APK Signature Scheme v2/v3 using only a file tail (no full APK load).
*/
function extractSigningCertSha256FromApkSigningBlock(filePath) {
let tail;
let fileSize;
let tailStart;
try {
({ tail, fileSize, tailStart } = readFileTail(filePath, APK_TAIL_READ_BYTES));
}
catch {
return null;
}
let cdOffset;
try {
cdOffset = findCentralDirectoryOffsetInTail(tail, tailStart, fileSize);
}
catch {
return null;
}
if (cdOffset < 32 || cdOffset > fileSize)
return null;
// Signing block must sit entirely inside the tail we loaded.
if (cdOffset < tailStart)
return null;
const cdInTail = cdOffset - tailStart;
const magicOffset = cdInTail - 16;
if (magicOffset < 0)
return null;
if (!tail.subarray(magicOffset, cdInTail).equals(APK_SIG_BLOCK_MAGIC))
return null;
const blockSizeFooter = readU64LEAsNumber(tail, cdInTail - 24);
if (blockSizeFooter < 24)
return null;
const blockStartAbs = cdOffset - blockSizeFooter - 8;
if (blockStartAbs < tailStart)
return null;
const blockStart = blockStartAbs - tailStart;
const blockSizeHeader = readU64LEAsNumber(tail, blockStart);
if (blockSizeHeader !== blockSizeFooter)
return null;
let pairsOffset = blockStart + 8;
const pairsEnd = cdInTail - 24;
let v2Value = null;
let v3Value = null;
while (pairsOffset + 12 <= pairsEnd) {
const pairLen = readU64LEAsNumber(tail, pairsOffset);
pairsOffset += 8;
if (pairLen < 4 || pairsOffset + pairLen > pairsEnd)
break;
const id = readU32LE(tail, pairsOffset);
const value = tail.subarray(pairsOffset + 4, pairsOffset + pairLen);
pairsOffset += pairLen;
if (id === APK_SIGNATURE_SCHEME_V2_BLOCK_ID)
v2Value = Buffer.from(value);
if (id === APK_SIGNATURE_SCHEME_V3_BLOCK_ID)
v3Value = Buffer.from(value);
}
for (const value of [v3Value, v2Value]) {
if (!value)
continue;
const der = firstCertDerFromV2orV3Block(value);
if (der && der.length > 0)
return sha256OfDer(der);
}
return null;
}
/** JAR v1 META-INF/*.RSA|DSA|EC — loads zip central directory via AdmZip (heavier). */
function extractSigningCertSha256FromJar(filePath) {
try {
const zip = new adm_zip_1.default(filePath);
const entries = zip.getEntries().filter((e) => {
const name = e.entryName.replace(/\\/g, '/');
return (name.startsWith('META-INF/') &&
!e.isDirectory &&
/\.(RSA|DSA|EC)$/i.test(path_1.default.basename(name)));
});
for (const entry of entries) {
try {
const der = entry.getData();
const asn1 = node_forge_1.default.asn1.fromDer(der.toString('binary'));
const p7 = node_forge_1.default.pkcs7.messageFromAsn1(asn1);
const certs = p7.certificates || [];
if (!certs.length)
continue;
const asn1Cert = certs[0].toAsn1();
const derBytes = Buffer.from(node_forge_1.default.asn1.toDer(asn1Cert).getBytes(), 'binary');
return sha256OfDer(derBytes);
}
catch {
// try next entry
}
}
}
catch {
return null;
}
return null;
}
/**
* Extract SHA-256 of the first signing certificate (APK v2/v3 first, then JAR v1).
*/
function extractSigningCertSha256(filePath) {
return (extractSigningCertSha256FromApkSigningBlock(filePath) || extractSigningCertSha256FromJar(filePath));
}
/** Parse packageName / versionCode / versionName and signing cert fingerprint. */
async function parseApkFile(filePath) {
assertApkZipMagic(filePath);
const parser = new AppInfoParser(filePath);
const info = await parser.parse();
const packageName = String(info.package || info.packageName || '').trim();
const versionName = String(info.versionName || info.version || '').trim();
const versionCodeRaw = info.versionCode ?? info.version_code ?? 0;
const versionCode = typeof versionCodeRaw === 'number' ? versionCodeRaw : parseInt(String(versionCodeRaw), 10);
if (!packageName)
throw new Error('APK package name could not be read');
if (!Number.isFinite(versionCode) || versionCode < 1) {
throw new Error('APK versionCode could not be read');
}
if (!versionName)
throw new Error('APK versionName could not be read');
const signingCertSha256 = extractSigningCertSha256(filePath);
return { packageName, versionName, versionCode, signingCertSha256 };
}
//# sourceMappingURL=apkParser.js.map