252 lines
9.7 KiB
JavaScript
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
|