"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