@sie-js/apoxi-tool 1.0.3 → 1.0.4

package/dist/src/cli/memory.d.ts

@@ -0,0 +1,16 @@
+import { AppCommand } from "#src/utils/command.js";
+import { CLIBaseOptions } from "#src/cli.js";
+export interface CLIReadMemoryOptions extends CLIBaseOptions {
+    addr?: string;
+    size?: string;
+    name?: string;
+    output?: string;
+}
+export interface CLIReadAllMemoryOptions extends CLIBaseOptions {
+    output?: string;
+    include?: string[];
+    exclude?: string[];
+}
+export declare const cliReadMemory: AppCommand<CLIReadMemoryOptions>;
+export declare const cliListMemory: AppCommand<CLIBaseOptions>;
+export declare const cliReadAllMemory: AppCommand<CLIReadAllMemoryOptions>;

package/dist/src/cli/memory.js

@@ -0,0 +1,164 @@
+import fs from 'fs';
+import cliProgress from "cli-progress";
+import { sprintf } from "sprintf-js";
+import { AppCommandValidateError, onCleanup } from "#src/utils/command.js";
+import { formatSize, parseAddr, parseSize } from "#src/utils/string.js";
+import { connectDWD, disconnectDWD } from "#src/utils/serial.js";
+import { table as asciiTable } from "table";
+const MEMORY_REGION_DESCR = {
+    BROM: 'Built-in 1st stage bootloader firmware.',
+    TCM: 'Built-in memory in the CPU, used for IRQ handlers.',
+    SRAM: 'Built-in memory in the CPU.',
+    RAM: 'External RAM.',
+    FLASH: 'NOR flash.',
+};
+export const cliReadMemory = async (options) => {
+    let addr = options.addr != null ? parseAddr(options.addr) : 0;
+    let size = options.size != null ? parseSize(options.size) : 0;
+    let name;
+    let outputFile;
+    if (options.name && options.addr)
+        throw new AppCommandValidateError("Can't use both --name and --addr options!");
+    if (options.addr && !options.size)
+        throw new AppCommandValidateError("Can't use --addr option without --size!");
+    if (!options.addr && !options.name)
+        throw new AppCommandValidateError("Need to specify --addr or --name!");
+    const dwd = await connectDWD(options.port, +options.baudrate, options.key);
+    onCleanup(() => disconnectDWD(dwd));
+    const info = await getPhoneInfo(dwd);
+    if (options.name) {
+        const region = getMemoryRegionByName(info.regions, options.name);
+        if (!region)
+            throw new Error(`Memory region "${options.name}" not found!`);
+        addr = region.addr;
+        size = region.size;
+        name = region.name;
+    }
+    else {
+        const region = getMemoryRegionByAddrAndSize(info.regions, addr, size);
+        if (region)
+            name = region.name;
+    }
+    const genericName = `${info.name}${name ? '-' + name : ''}-${sprintf("%08X_%08X", addr, size)}.bin`;
+    if (!options.output) {
+        outputFile = `./${genericName}`;
+    }
+    else if (fs.existsSync(options.output) && fs.lstatSync(options.output).isDirectory()) {
+        outputFile = `${options.output}/${genericName}`;
+    }
+    else {
+        outputFile = options.output;
+    }
+    fs.writeFileSync(outputFile, "");
+    console.log(sprintf("Reading memory %08X ... %08X (%s)", addr, addr + size - 1, formatSize(size)));
+    console.log();
+    const pb = new cliProgress.SingleBar({
+        format: ' [{bar}] {percentage}% | ETA: {eta}s | {speed} kB/s'
+    }, cliProgress.Presets.legacy);
+    pb.start(size, 0);
+    const result = await dwd.readMemory(addr, size, {
+        onProgress: (e) => {
+            pb.update(e.cursor, {
+                speed: e.elapsed ? +((e.cursor / (e.elapsed / 1000)) / 1024).toFixed(2) : 'N/A',
+            });
+        }
+    });
+    pb.stop();
+    fs.writeFileSync(outputFile, result.buffer);
+    console.log();
+    console.log(`File saved to: ${outputFile}`);
+};
+export const cliListMemory = async (options) => {
+    const dwd = await connectDWD(options.port, +options.baudrate, options.key);
+    onCleanup(() => disconnectDWD(dwd));
+    const info = await getPhoneInfo(dwd);
+    const table = [
+        ['Name', 'Address', 'Size', 'Description'],
+    ];
+    for (const r of info.regions) {
+        table.push([
+            r.name,
+            sprintf("0x%08X", r.addr),
+            sprintf("0x%08X (%s)", r.size, formatSize(r.size)),
+            MEMORY_REGION_DESCR[r.name] ?? "Unknown memory region.",
+        ]);
+    }
+    console.log(asciiTable(table).trim());
+};
+export const cliReadAllMemory = async (options) => {
+    let outputDir = options.output || ".";
+    if (!fs.existsSync(outputDir)) {
+        try {
+            fs.mkdirSync(outputDir, { recursive: true });
+        }
+        catch (e) {
+            console.error(e instanceof Error ? e.message : String(e));
+            console.error(`ERROR: Output dir not found: ${outputDir}`);
+            return;
+        }
+    }
+    const dwd = await connectDWD(options.port, +options.baudrate, options.key);
+    onCleanup(() => disconnectDWD(dwd));
+    const info = await getPhoneInfo(dwd);
+    const regions = info.regions.filter((r) => {
+        if (options.include?.length && !options.include.includes(r.name))
+            return false;
+        if (options.exclude?.length && options.exclude.includes(r.name))
+            return false;
+        return true;
+    });
+    regions.sort((a, b) => a.size - b.size);
+    let totalSize = 0;
+    for (const r of regions) {
+        totalSize += r.size;
+    }
+    const pb = new cliProgress.SingleBar({
+        format: ' [{bar}] {percentage}% | ETA: {totalEta}s | {speed} kB/s'
+    }, cliProgress.Presets.legacy);
+    console.log();
+    let i = 1;
+    let totalRead = 0;
+    for (const r of regions) {
+        console.log(sprintf("[%d/%d] Reading %s %08X ... %08X (%s)", i, regions.length, r.name, r.addr, r.addr + r.size - 1, formatSize(r.size)));
+        pb.start(r.size, 0);
+        const response = await dwd.readMemory(r.addr, r.size, {
+            onProgress: (e) => {
+                const speed = e.elapsed ? e.cursor / (e.elapsed / 1000) : 0;
+                pb.update(e.cursor, {
+                    speed: speed ? +(speed / 1024).toFixed(2) : 'N/A',
+                    filename: r.name,
+                    fileIndex: i,
+                    totalFiles: regions.length,
+                    totalEta: speed ? Math.round((totalSize - (totalRead + e.cursor)) / speed) : 0,
+                });
+            }
+        });
+        totalRead += r.size;
+        i++;
+        const outputFile = `${outputDir}/${info.name}-${r.name}-${sprintf("%08X_%08X", r.addr, r.size)}.bin`;
+        fs.writeFileSync(outputFile, response.buffer);
+        pb.stop();
+        console.log(`File saved to: ${outputFile}`);
+        console.log();
+    }
+};
+function getMemoryRegionByName(regions, name) {
+    for (const r of regions) {
+        if (r.name.toLowerCase() == name.toLowerCase())
+            return r;
+    }
+    return undefined;
+}
+function getMemoryRegionByAddrAndSize(regions, addr, size) {
+    for (const r of regions) {
+        if (r.addr == addr && r.size == size)
+            return r;
+    }
+    return undefined;
+}
+async function getPhoneInfo(dwd) {
+    const regions = await dwd.getMemoryRegions();
+    const swInfo = await dwd.getSWVersion();
+    console.log(`Detected phone: ${swInfo.sw} (${swInfo.cpu})`);
+    return { name: swInfo.sw, regions };
+}

package/dist/src/cli/misc.d.ts

@@ -0,0 +1,4 @@
+import { CLIBaseOptions } from "#src/cli.js";
+import { AppCommand } from "#src/utils/command.js";
+export declare const cliListSerialPorts: AppCommand<CLIBaseOptions>;
+export declare const cliBruteforceDWDKeys: AppCommand<CLIBaseOptions>;

package/dist/src/cli/misc.js

@@ -0,0 +1,48 @@
+import { onCleanup } from "#src/utils/command.js";
+import { SerialPort } from "serialport";
+import { getUSBDeviceName } from "@sie-js/serial";
+import { sprintf } from "sprintf-js";
+import cliProgress from "cli-progress";
+import { connectDWD, disconnectDWD } from "#src/utils/serial.js";
+export const cliListSerialPorts = async (options) => {
+    for (let p of await SerialPort.list()) {
+        if (p.productId != null) {
+            const vid = parseInt(p.vendorId, 16);
+            const pid = parseInt(p.productId, 16);
+            const usbName = getUSBDeviceName(vid, pid);
+            const isDefault = p.path === options.port;
+            console.log(sprintf("%s %04x:%04x %s%s", p.path, vid, pid, usbName ?? p.manufacturer, (isDefault ? " <-- selected" : "")));
+        }
+    }
+};
+export const cliBruteforceDWDKeys = async (options) => {
+    const dwd = await connectDWD(options.port, +options.baudrate, options.key);
+    onCleanup(() => disconnectDWD(dwd));
+    const pb = new cliProgress.SingleBar({
+        format: ' [{bar}] {percentage}% | ETA: {eta}s | {speed} keys/s'
+    }, cliProgress.Presets.legacy);
+    console.log("Bruteforce key2...");
+    pb.start(0xFFFF, 0);
+    const possibleKeys = await dwd.bruteforceKey2({
+        onProgress: (e) => {
+            pb.update(e.cursor, {
+                speed: e.elapsed ? +((e.cursor / (e.elapsed / 1000))).toFixed(2) : 'N/A',
+                total: e.total,
+            });
+        }
+    });
+    pb.stop();
+    console.log();
+    const foundKeys = [];
+    for (const key2 of possibleKeys) {
+        console.log(sprintf("Bruteforce key1 for key2=%04X", key2));
+        const keys = await dwd.bruteforceKey1(key2);
+        if (keys != null)
+            foundKeys.push(keys);
+    }
+    console.log();
+    console.log("Found keys:");
+    for (const key of foundKeys) {
+        console.log(sprintf(" key1=%s, key2=%04X", key.key1.toString("hex").toUpperCase(), key.key2));
+    }
+};

package/dist/src/cli/unlock.d.ts

@@ -0,0 +1,3 @@
+import { AppCommand } from "#src/utils/command.js";
+import { CLIBaseOptions } from "#src/cli.js";
+export declare const cliUnlockBoot: AppCommand<CLIBaseOptions>;

package/dist/src/cli/unlock.js

@@ -0,0 +1,30 @@
+import { onCleanup } from "#src/utils/command.js";
+import { connectDWD, disconnectDWD } from "#src/utils/serial.js";
+import { isApoxiBootUnlocked, unlockApoxiBootloader } from "#src/lib/dwd.js";
+import inquirer from "inquirer";
+import chalk from "chalk";
+export const cliUnlockBoot = async (options) => {
+    const dwd = await connectDWD(options.port, +options.baudrate, options.key);
+    onCleanup(() => disconnectDWD(dwd));
+    if (await isApoxiBootUnlocked(dwd)) {
+        console.log("Boot already open! Unlock is not needed.");
+        return;
+    }
+    const { confirm } = await inquirer.prompt([
+        {
+            type: 'confirm',
+            name: 'confirm',
+            message: chalk.red([
+                `WARNING: Unlocking the APOXI bootloader WILL BREAK THE DEVICE and it may never work again.`,
+                'MAKE A FULL BACKUP BEFORE THE OPERATION.',
+                'Continue?'
+            ].join('\n')),
+            default: false
+        }
+    ]);
+    if (confirm) {
+        await unlockApoxiBootloader(dwd, {
+            debug: (log) => console.log(log),
+        });
+    }
+};

package/dist/src/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+export interface CLIBaseOptions {
+    port: string;
+    baudrate: string;
+    key: string;
+}

package/dist/src/cli.js

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { program } from "commander";
+import { cliListMemory, cliReadAllMemory, cliReadMemory } from "./cli/memory.js";
+import { createAppCommand } from "./utils/command.js";
+import debug from "debug";
+import { getDefaultPort } from "#src/utils/serial.js";
+import { cliBruteforceDWDKeys, cliListSerialPorts } from "#src/cli/misc.js";
+import { cliUnlockBoot } from "#src/cli/unlock.js";
+import { readPackage } from "read-pkg";
+const pkg = await readPackage();
+const DEFAULT_PORT = await getDefaultPort();
+program
+    .name("apoxi-tool")
+    .version(pkg.version, '-v, --version')
+    .description('CLI tool for APOXI phones.')
+    .option('-p, --port <port>', 'serial port name', DEFAULT_PORT)
+    .option('-b, --baudrate <baudrate>', 'limit maximum baudrate (0 - use maximum)', '0')
+    .option('-k, --key <key>', 'DWD key (auto/lg/panasonic/siemens or KEY1:KEY2)', 'auto')
+    .option('-V, --verbose', 'Increase verbosity', (_, prev) => prev + 1, 0)
+    .hook('preAction', (thisCommand) => {
+    const opts = thisCommand.opts();
+    if (opts.verbose) {
+        console.log(`Verbosity level: ${opts.verbose}`);
+        const filters = ["atc", "dwd"];
+        if (opts.verbose > 1)
+            filters.push("dwd:*", "atc:*");
+        if (opts.verbose > 2)
+            filters.push("*");
+        debug.enable(filters.join(","));
+    }
+});
+program
+    .command('unlock-bootloader')
+    .description('Unlock APOXI bootloader (allow using V-Klay)')
+    .action(createAppCommand(cliUnlockBoot));
+program
+    .command('read-memory')
+    .description('Read and save phone memory')
+    .option('-n, --name <blockName>', 'Read by block name')
+    .option('-a, --addr <address>', 'Read from address (dec or hex)')
+    .option('-s, --size <bytes>', 'Size in bytes (dec, hex, k/m/g allowed)')
+    .option('-o, --output [file]', 'Write output to file or directory')
+    .action(createAppCommand(cliReadMemory));
+program
+    .command('read-all-memory')
+    .description('Read and save phone memory (ALL available blocks)')
+    .option('-i, --include <blocks>', 'Include blocks (comma separated)', (v) => v.split(','), [])
+    .option('-e, --exclude <blocks>', 'Exclude blocks (comma separated)', (v) => v.split(','), [])
+    .option('-o, --output [dir]', 'Write output to directory')
+    .action(createAppCommand(cliReadAllMemory));
+program
+    .command('list-memory')
+    .description('List available memory blocks')
+    .action(createAppCommand(cliListMemory));
+program.command('list-ports')
+    .description('List available serial ports.')
+    .action(createAppCommand(cliListSerialPorts));
+program.command('bruteforce-dwd-keys')
+    .description('Bruteforce DWD keys')
+    .action(createAppCommand(cliBruteforceDWDKeys));
+program.showSuggestionAfterError(true);
+program.showHelpAfterError();
+program.parse();

package/dist/src/data/unlocker.elf.d.ts

@@ -0,0 +1,2 @@
+declare const _default: Buffer<ArrayBuffer>;
+export default _default;

package/dist/src/data/unlocker.elf.js

@@ -0,0 +1,93 @@
+// DO NOT EDIT! AUTO-GENERATED BY tools/importApoxiUnlockerElf.ts
+export default Buffer.from("7f454c4601010100000000000000000003002800010000007408000034000000e813000000020005340020000700280013001200060000003400000034000000" +
+    "34000000e0000000e000000004000000040000000300000014010000140100001401000011000000110000000400000001000000010000000000000000000000" +
+    "00000000250100002501000004000000010000000100000028010000280100002801000049000000490000000400000004000000010000007401000074010000" +
+    "740100008008000080080000050000000400000001000000f4090000f4090000f40900009400000034010200060000000400000002000000f4090000f4090000" +
+    "f4090000880000008800000006000000040000002f7573722f6c69622f6c642e736f2e3100000000010000000300000000000000000000000000000000000000" +
+    "000000000000000000000000000000000000000014020000000000000300060000000000880a00000000000003000a0000000000400600001700000044060000" +
+    "1700000048060000170000004c06000017000000540600001700000058060000170000005c060000170000006006000017000000740600001700000078060000" +
+    "170000007c060000170000008006000017000000e406000017000000e80600001700000068070000170000006c07000017000000ec07000017000000f0070000" +
+    "17000000f407000017000000700800001700000004e04ee2ff5f2de91c649fe510d04de29b0100eb042096e50f3ae0e3c72f03e50c30e0e3083086e50000e0e3" +
+    "0a32a0e30c0086e50c3093e5000053e10200001a083086e510d08de2ff9ffde80f22a0e3c03092e5000053e3020000aa803092e5010013e30100001a0230e0e3" +
+    "f3ffffea101f12ee103f13ee0c308de50cc09de5a8339fe5021a81e200c083e500c891e59c339fe59c539fe500c083e52e0100eb94339fe594b39fe5003881e5" +
+    "90339fe5c01092e58c439fe5001083e5c03092e50231c3e3c03082e57c339fe5b000cbe1b000c3e174339fe5003085e570339fe5003084e53e0100eb000050e3" +
+    "1200000a0120a0e30010a0e39000a0e3db0000eb0120a0e30210a0e10040a0e1b000cbe19000a0e3d50000eb2c339fe5890054e3200054130140a0130040a003" +
+    "b000c3e13d00000a0a40e0e3070000ea14339fe5003085e510339fe5003084e5240100eb000050e30b40e003e4ffff1ae8329fe5b020dbe1b030d3e1000054e3" +
+    "023883e10c3086e5084086152900001ad50000eb007050e2a600000a0c1097e50a02a0e3890100eb005051e27500001a003097e5b8829fe5f020a0e3b020c3e1" +
+    "ff20a0e3b020c3e10830a0e10c2097e5020054e16600003a0a42a0e36030a0e3b030c4e12020a0e3d030a0e3b030c4e1b020c4e1b030c4e1b030d4e1800013e3" +
+    "fcffff0a0130a0e36090a0e3b090c4e1b030c4e1003097e5f020a0e3b020c3e1ff20a0e3b020c3e1043097e5000053e3560000aa083086e5df0000eb85ffffea" +
+    "002095e598c0a0e30a52a0e30a2282e2b0c0c2e1bee4d5e118329fe50170a0e3ff10a0e3f000a0e317eea0e1004083e5b000c5e1b010c5e1b0c0c2e1b825d5e1" +
+    "00e08de5b000c5e1b010c5e1e8119fe5080052e30940e083002081e5b3ffff8ad8a19fe50221a0e12d2082e22d90a0e304208de504209de5020059e10900001a" +
+    "00309de5040053e10840e013a7ffff1aa0319fe5003093e5020853e30740e0830040a093a1ffffea0910a0e10020a0e39800a0e3620000eb011089e20020a0e3" +
+    "0080a0e19800a0e35d0000eb021089e20020a0e3008488e19800a0e3580000eb0020a0e3031089e2018088e2049089e20070a0e19800a0e3510000eb34319fe5" +
+    "00508ae5007487e10774a0e1970802e00c708ae504018ae9024084e0025085e0002093e510a08ae2020057e100708385cfffffea0a2284e20020d2e5014084e2" +
+    "0120c3e490ffffea0530e0e3a8ffffea0030e0e30c30c8e50d30c8e50e30c8e50f30c8e5500000eb000050e32100000a0c2090e5d030a0e30120c2e34010a0e3" +
+    "70c0a0e3b090c4e1b030c4e1050052e10e00001a0a32a0e36020a0e3b020c3e10120a0e3b020c3e1003090e5f020a0e3b020c3e1ff20a0e3b020c3e10030a0e3" +
+    "083086e56c0000eba20000eb11ffffea0a3285e2b010c3e1b5e098e1b0e0c3e1b0c0c3e1b0e0d3e180001ee3fcffff0a025085e2e4ffffea0630e0e37cffffea" +
+    "74080000180b0200140b0200200b0200120c00a0260b0200100b02001c0b0200240b0200aa0a000054050000aaaa000054550000880a0000880a02008c0a0200" +
+    "900a020058309fe5000052e3003093e50a3283e20600000aaa20a0e3b020c3e140209fe555c0a0e3002092e50a2282e2b0c0c2e10008a0e12008a0e18110a0e1" +
+    "b000c3e10a1281e20a32a0e3f020a0e3b000d1e1b020c3e1ff20a0e3b020c3e11eff2fe1200b02001c0b020074209fe574309fe500c092e50300a0e10020a0e3" +
+    "0c0052e11000001a0000a0e31eff2fe1001093e5160271e30500009a04e093e50e1081e00a0251e30100009a020280e004f09de4012082e20c0052e1103083e2" +
+    "f2ffff1a0000a0e304f09de4001093e5160271e30120829210308392e7ffff9a04e02de5ecffffea8c0a0200900a020010d04de204008de5103f13ee0c308de5" +
+    "04309de5103f03ee0000a0e10000a0e10000a0e10000a0e10000a0e10000a0e10000a0e10000a0e10000a0e10000a0e10c309de510d08de21eff2fe1103f12ee" +
+    "24209fe5023a83e2002092e5002883e518309fe5002093e50f32a0e3c02083e50c309fe5000093e5e0ffffea140b0200100b0200180b020070209fe50a32a0e3" +
+    "002092e510402de9f0c0a0e3ff10a0e3032082e098e0a0e3b0c0c3e1b010c3e1b0e0c2e1b002d3e1b0c0c3e1b010c3e1b0e0c2e1b242d3e1b0c0c3e1b010c3e1" +
+    "b0e0c2e1b422d3e1510050e3520054030100a0030000a013b0c0c3e1590052e30000a01301000002b010c3e11080bde8200b020066feffea0000000000000000" +
+    "0000000000000000000000000000000000000000000000007aff17ee0000a0e10000a0e10000a0e1faffff1a0000a0e39a0f07ee0000a0e10000a0e10000a0e1" +
+    "0000a0e10000a0e10000a0e1150f07ee0000a0e10000a0e11eff2fe1012051e21eff2f013600003a010050e12200009a020011e12300000a0e0211e38111a001" +
+    "0830a0030130a013010251e3000051310112a0310332a031faffff3a020151e3000051318110a0318330a031faffff3a0020a0e3010050e10100402003208221" +
+    "a10050e1a1004020a3208221210150e12101402023218221a10150e1a1014020a3218221000050e32332b0112112a011efffff1a0200a0e11eff2fe10100a003" +
+    "0000a0131eff2fe1010851e32118a0211020a0230020a033010c51e32114a02108208222100051e32112a02104208222040051e303208282a12082903002a0e1" +
+    "1eff2fe1000050e30000e013070000ea000051e3faffff0a03402de9beffffeb0640bde8920003e0031041e01eff2fe11eff2fe1040000002801000005000000" +
+    "7001000006000000400100000a000000010000000b000000100000001500000000000000110000007401000012000000a0000000130000000800000016000000" +
+    "00000000fbffff6f00000008faffff6f1400000000000000000000000000000000000000000000000000000000000000000000000000000000000000f4090000" +
+    "00000000000000004743433a202841726d20474e5520546f6f6c636861696e2031342e322e52656c3120284275696c642061726d2d31342e353229292031342e" +
+    "322e31203230323431313139000000000c000000ffffffff0100017c0e0c0d000c00000000000000dc080000f40000002f646174612f6a656e6b696e732f776f" +
+    "726b73706163652f474e552d746f6f6c636861696e2f61726d2d31342f6275696c642d61726d2d6e6f6e652d656162692f6f626a2f676363322f61726d2d6e6f" +
+    "6e652d656162692f6c6962676363002f646174612f6a656e6b696e732f776f726b73706163652f474e552d746f6f6c636861696e2f61726d2d31342f7372632f" +
+    "6763632f6c69626763632f636f6e6669672f61726d006c69623166756e63732e53004129000000616561626900011f000000053554454a000605080109011204" +
+    "14011501170318011a011e0400000000000000000000000000000000000000001401000000000000030001000000000028010000000000000300020000000000" +
+    "40010000000000000300030000000000700100000000000003000400000000007401000000000000030005000000000014020000000000000300060000000000" +
+    "f40900000000000003000700000000007c0a0000000000000300080000000000880a0000000000000300090000000000880a00000000000003000a0000000000" +
+    "280b02000000000003000b0000000000000000000000000003000c0000000000000000000000000003000d0000000000000000000000000003000e0000000000" +
+    "000000000000000003000f000100000000000000000000000400f1ff080000008406000000000000000006000b00000084060000680000000200060020000000" +
+    "e4060000000000000000060023000000200b02000400000001000a00360000001c0b02000400000001000a0008000000ec060000000000000000060049000000" +
+    "ec060000840000000200060020000000680700000000000000000600670000008c0a02000400000001000a0079000000900a02008000000001000a0008000000" +
+    "70070000000000000000060087000000700700004c0000000200060008000000bc0700000000000000000600a0000000bc0700003c0000000200060020000000" +
+    "ec0700000000000000000600b2000000140b02000400000001000a00c0000000100b02000400000001000a00cb000000180b02000400000001000a0008000000" +
+    "f80700000000000000000600dd000000f80700007c00000002000600200000007008000000000000000006000800000014020000000000000000060020000000" +
+    "400600000000000000000600f3000000260b02000200000001000a00fd000000240b02000200000001000a0007010000880a00000000020001000a0014010000" +
+    "880a02000400000001000a0020000000880a00000000000000000a0020000000880a02000000000000000a00200000008c0a02000000000000000a0020000000" +
+    "900a02000000000000000a0020000000100b02000000000000000a0020000000140b02000000000000000a0020000000180b02000000000000000a0020000000" +
+    "1c0b02000000000000000a0020000000200b02000000000000000a0020000000240b02000000000000000a0020000000260b02000000000000000a0023010000" +
+    "00000000000000000400f1ff0800000074080000000000000000060020000000780800000000000000000600080000009808000000000000000006002e010000" +
+    "00000000000000000400f1ff08000000dc080000000000000000060039010000dc080000000000000000060020000000100000000000000000000d0051010000" +
+    "00000000000000000400f1ff08000000f009000000000000000006000000000000000000000000000400f1ff5d010000f4090000000000000100f1ff66010000" +
+    "d00900002000000002000600770100007c0a0000000000000100f1ff8d010000f00900000400000002000600b4010000280b02000000000010000a009b010000" +
+    "dc080000f400000012020600a5010000880a00000000000010000a00b3010000280b02000000000010000a001e020000740800000000000012000600bf010000" +
+    "f00900000400000022020600cd010000880a00000000000010000a00d9010000140200007004000012000600de010000dc0800000000000012020600ec010000" +
+    "280b02000000000010000a00f401000098080000000000001200060005020000880a000000000000100008000c020000280b02000000000010000a0011020000" +
+    "000008000000000010000b0018020000880a00000000000010000800006d61696e2e6300246100726561645f7265672e636f6e737470726f702e300024640066" +
+    "6c6173685f756e6c6f636b5f616464723100666c6173685f756e6c6f636b5f61646472320066696e645f666c6173685f726567696f6e2e636f6e737470726f70" +
+    "2e300065726173655f726567696f6e735f636e740065726173655f726567696f6e73007365745f646f6d61696e5f6163636573732e697372612e30006c6f636b" +
+    "5f666c6173685f616363657373006f6c645f666c6173685f6d6d75006f6c645f627573636f6e006f6c645f646f6d61696e5f61636365737300636865636b5f71" +
+    "72792e636f6e737470726f702e3000666c6173685f76696400666c6173685f7069640077726974655f627566666572006d61785f65726173655f73697a650069" +
+    "6e69742e532e6f626a005f756469767369332e6f002e756469767369335f736b69705f646976305f74657374005f64766d645f746c732e6f005f44594e414d49" +
+    "43005f5f61656162695f75696469766d6f64005f474c4f42414c5f4f46465345545f5441424c455f005f5f61656162695f6964697630005f5f75646976736933" +
+    "005f5f6273735f73746172745f5f005f5f6273735f656e645f5f005f5f61656162695f6c64697630005f5f6273735f7374617274006d61696e005f5f61656162" +
+    "695f7569646976005f5f656e645f5f00636c65616e5f616c6c5f636163686573005f6564617461005f656e64005f737461636b005f5f646174615f7374617274" +
+    "00002e73796d746162002e737472746162002e7368737472746162002e696e74657270002e68617368002e64796e73796d002e64796e737472002e72656c2e64" +
+    "796e002e74657874002e64796e616d6963002e676f74002e70657273697374656e74002e627373002e6e6f696e6974002e636f6d6d656e74002e64656275675f" +
+    "6672616d65002e64656275675f6c696e655f737472002e41524d2e61747472696275746573000000000000000000000000000000000000000000000000000000" +
+    "000000000000000000000000000000001b0000000100000002000000140100001401000011000000000000000000000001000000000000002300000005000000" +
+    "0200000028010000280100001800000003000000000000000400000004000000290000000b000000020000004001000040010000300000000400000003000000" +
+    "04000000100000003100000003000000020000007001000070010000010000000000000000000000010000000000000039000000090000000200000074010000" +
+    "74010000a0000000030000000000000004000000080000004200000001000000060000001402000014020000e007000000000000000000000400000000000000" +
+    "480000000600000003000000f4090000f409000088000000040000000000000004000000080000005100000001000000030000007c0a00007c0a00000c000000" +
+    "00000000000000000400000004000000560000000100000003000000880a0000880a000000000000000000000000000004000000000000006200000008000000" +
+    "03000000880a0000880a0000a000020000000000000000000400000000000000670000000800000003000000280b020000000000000000000000000000000000" +
+    "04000000000000006f000000010000003000000000000000880a0000450000000000000000000000010000000100000078000000010000000000000000000000" +
+    "d00a0000200000000000000000000000040000000000000085000000010000003000000000000000f00a0000b200000000000000000000000100000001000000" +
+    "95000000030000700000000000000000a20b00002a0000000000000000000000010000000000000001000000020000000000000000000000cc0b000050050000" +
+    "11000000460000000400000010000000090000000300000000000000000000001c11000025020000000000000000000001000000000000001100000003000000" +
+    "000000000000000041130000a500000000000000000000000100000000000000", "hex");

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export * from './lib/dwd.js';

package/dist/src/index.js

@@ -0,0 +1 @@
+export * from './lib/dwd.js';

package/dist/src/lib/dwd.d.ts

@@ -0,0 +1,6 @@
+import { DWD } from "@sie-js/serial";
+export interface UnlockBootloaderOptions {
+    debug(log: string): void;
+}
+export declare function isApoxiBootUnlocked(dwd: DWD): Promise<boolean>;
+export declare function unlockApoxiBootloader(dwd: DWD, options: UnlockBootloaderOptions): Promise<void>;

package/dist/src/lib/dwd.js

@@ -0,0 +1,104 @@
+import { sprintf } from "sprintf-js";
+import unlockerElf from "#src/data/unlocker.elf.js";
+import { loadELF } from "@sie-js/creampie";
+import { retryAsyncOnError } from "#src/utils/retry.js";
+const TCM_START = 0xFFFF0000;
+const PRAM_IRQ_HANDLER = TCM_START + 0x38;
+const BOOT_MODE = 0xA000000C;
+const EBU_ADDRSEL1 = 0xF0000088;
+var PatchResponseCode;
+(function (PatchResponseCode) {
+    PatchResponseCode[PatchResponseCode["SUCCESS"] = 0] = "SUCCESS";
+    PatchResponseCode[PatchResponseCode["BOOT_ALREADY_OPEN"] = -1] = "BOOT_ALREADY_OPEN";
+    PatchResponseCode[PatchResponseCode["UNKNOWN_FLASH"] = -2] = "UNKNOWN_FLASH";
+    PatchResponseCode[PatchResponseCode["FLASH_BUSY"] = -3] = "FLASH_BUSY";
+    PatchResponseCode[PatchResponseCode["ERASE_ERROR"] = -4] = "ERASE_ERROR";
+    PatchResponseCode[PatchResponseCode["PROGRAM_ERROR"] = -5] = "PROGRAM_ERROR";
+    PatchResponseCode[PatchResponseCode["ADDR_NOT_ALIGNED"] = -6] = "ADDR_NOT_ALIGNED";
+    PatchResponseCode[PatchResponseCode["FLASH_REGION_NOT_FOUND"] = -7] = "FLASH_REGION_NOT_FOUND";
+    PatchResponseCode[PatchResponseCode["FLASH_REGION_TOO_BIG"] = -8] = "FLASH_REGION_TOO_BIG";
+    PatchResponseCode[PatchResponseCode["INVALID_FLASH_REGIONS"] = -9] = "INVALID_FLASH_REGIONS";
+    PatchResponseCode[PatchResponseCode["INVALID_FLASH_REGION_COUNT"] = -10] = "INVALID_FLASH_REGION_COUNT";
+    PatchResponseCode[PatchResponseCode["UNSUPPORTED_FLASH"] = -11] = "UNSUPPORTED_FLASH";
+    PatchResponseCode[PatchResponseCode["FLASH_NOT_FOUND"] = -12] = "FLASH_NOT_FOUND";
+    PatchResponseCode[PatchResponseCode["UNKNOWN"] = -13] = "UNKNOWN";
+})(PatchResponseCode || (PatchResponseCode = {}));
+export async function isApoxiBootUnlocked(dwd) {
+    const bootMode = (await dwd.readMemory(BOOT_MODE, 4)).buffer.readUInt32LE(0);
+    if (bootMode == 0xFFFFFFFF) {
+        return true;
+    }
+    else if (bootMode == 0xFFFF0002) {
+        return false;
+    }
+    else {
+        throw new Error(sprintf("Invalid boot mode: %08X", bootMode));
+    }
+}
+export async function unlockApoxiBootloader(dwd, options) {
+    const addrsel = (await dwd.readMemory(EBU_ADDRSEL1, 4)).buffer.readUInt32LE(0);
+    const ramSize = (1 << (27 - ((addrsel & 0xF0) >> 4)));
+    const ramAddr = Number((BigInt(addrsel) & 0xffff0000n));
+    if (await isApoxiBootUnlocked(dwd)) {
+        options.debug("Boot already open! Unlock is not needed.");
+        return;
+    }
+    const bootMode = (await dwd.readMemory(BOOT_MODE, 4)).buffer.readUInt32LE(0);
+    options.debug(sprintf("Boot mode: %08X", bootMode));
+    options.debug(sprintf("Ram: %08X, %dM", ramAddr, ramSize / 1024 / 1024));
+    options.debug("Searching empty ram block....");
+    let emptyRamBlock = 0;
+    for (let i = ramAddr; i < ramAddr + ramSize; i += 256 * 1024) {
+        const blockStart = await dwd.readMemory(i, 230);
+        if (blockStart.buffer.every((v) => v == 0)) {
+            const fullBlock = await dwd.readMemory(i, 256 * 1024);
+            if (fullBlock.buffer.every((v) => v == 0)) {
+                emptyRamBlock = i;
+                break;
+            }
+        }
+    }
+    if (!emptyRamBlock)
+        throw new Error("Empty RAM block not found!");
+    options.debug(sprintf("Found empty ram block: %08X", emptyRamBlock));
+    const oldIrqHandler = (await dwd.readMemory(PRAM_IRQ_HANDLER, 4)).buffer.readUInt32LE(0);
+    options.debug(sprintf("Old SWI handler: %08X", oldIrqHandler));
+    const elf = loadELF(emptyRamBlock, unlockerElf);
+    await dwd.writeMemory(emptyRamBlock, elf.image);
+    const check = await dwd.readMemory(emptyRamBlock, elf.image.length);
+    if (check.buffer.toString("hex") != elf.image.toString("hex")) {
+        options.debug(check.buffer.toString("hex"));
+        options.debug(elf.image.toString("hex"));
+        throw new Error("Payload corrupted!!!");
+    }
+    options.debug(sprintf("Patcher entry: %08X", elf.entry));
+    const PATCHER_ADDR = elf.entry;
+    const PARAM_OLD_IRQ_HANDLER = PATCHER_ADDR + 4;
+    const PARAM_RESPONSE_CODE = PATCHER_ADDR + 8;
+    const PARAM_RESPONSE_FLASH_ID = PATCHER_ADDR + 12;
+    for (let i = 0; i < 30; i++) {
+        options.debug("Running patcher...");
+        await dwd.writeMemory(PARAM_OLD_IRQ_HANDLER, uint32(oldIrqHandler));
+        await dwd.writeMemory(PRAM_IRQ_HANDLER, uint32(PATCHER_ADDR));
+        let responseCode = PatchResponseCode.UNKNOWN;
+        let responseFlashId = 0;
+        await retryAsyncOnError(async () => {
+            options.debug("Waiting for done...");
+            responseCode = (await dwd.readMemory(PARAM_RESPONSE_CODE, 4)).buffer.readInt32LE(0);
+            responseFlashId = (await dwd.readMemory(PARAM_RESPONSE_FLASH_ID, 4)).buffer.readUInt32LE(0);
+            options.debug(sprintf("Code: %d (%s)", responseCode, PatchResponseCode[responseCode]));
+            options.debug(sprintf("FlashID: %08X", responseFlashId));
+            if (responseCode == PatchResponseCode.SUCCESS) {
+                options.debug("Success!!! Boot mode patched, now reboot phone.");
+            }
+            await new Promise((resolve) => setTimeout(resolve, 1000));
+        }, { max: 30 });
+        if (!(responseCode == PatchResponseCode.FLASH_NOT_FOUND || responseCode == PatchResponseCode.FLASH_BUSY))
+            break;
+    }
+}
+function uint32(value) {
+    const buffer = Buffer.alloc(4);
+    buffer.writeUInt32LE(value);
+    return buffer;
+}

package/dist/src/utils/command.d.ts

@@ -0,0 +1,15 @@
+import { Command } from "commander";
+export type AppCommand<T, A extends unknown[] = []> = (...args: [...A, options: T, cmd: Command]) => Promise<void>;
+export interface AppCommandContext<T, A extends unknown[] = []> {
+    options: T;
+    arguments: A;
+    cmd: Command;
+    resource<R>(alloc: () => R | Promise<R>, free: (resource: R) => void | Promise<void>): Promise<R>;
+    onCleanup(handler: AppCommandCleanupHandler): void;
+    cleanupHandlers: AppCommandCleanupHandler[];
+}
+export declare class AppCommandValidateError extends Error {
+}
+export type AppCommandCleanupHandler = () => Promise<void>;
+export declare function onCleanup(handler: AppCommandCleanupHandler): void;
+export declare function createAppCommand<T, A extends unknown[] = []>(handler: AppCommand<T, A>): (...params: unknown[]) => Promise<void>;

package/dist/src/utils/command.js

@@ -0,0 +1,44 @@
+export class AppCommandValidateError extends Error {
+}
+const cleanupHandlers = [];
+export function onCleanup(handler) {
+    cleanupHandlers.push(handler);
+}
+async function runCleanupHandlers() {
+    for (const handler of cleanupHandlers) {
+        try {
+            await handler();
+        }
+        catch (e) {
+            console.error(`Error while running cleanup handler`, e);
+        }
+    }
+}
+export function createAppCommand(handler) {
+    return async (...params) => {
+        const cmd = params[params.length - 1];
+        const cmdOptions = params[params.length - 2];
+        const cmdArguments = params.slice(0, params.length - 2);
+        await runCommand(cmd, async () => {
+            await handler(...cmdArguments, { ...cmdOptions, ...cmd.optsWithGlobals() }, cmd);
+        });
+    };
+}
+async function runCommand(cmd, handler) {
+    try {
+        await handler();
+    }
+    catch (e) {
+        if (e instanceof AppCommandValidateError) {
+            console.error(`ERROR: ${e.message}`);
+            console.error();
+            cmd.help();
+        }
+        else {
+            console.error(e);
+        }
+    }
+    finally {
+        await runCleanupHandlers();
+    }
+}

package/dist/src/utils/retry.d.ts

@@ -0,0 +1,7 @@
+export declare function retryAsync<T>(callback: () => Promise<T>, options: {
+    max: number;
+    until: (lastResult: T) => boolean;
+}): Promise<NonNullable<T>>;
+export declare function retryAsyncOnError(callback: () => Promise<void>, options: {
+    max: number;
+}): Promise<void>;

package/dist/src/utils/retry.js

@@ -0,0 +1,22 @@
+export async function retryAsync(callback, options) {
+    let lastResult;
+    for (let i = 0; i < options.max; i++) {
+        lastResult = await callback();
+        if (!options.until(lastResult))
+            break;
+    }
+    return lastResult;
+}
+export async function retryAsyncOnError(callback, options) {
+    let lastError;
+    for (let i = 0; i < options.max; i++) {
+        try {
+            await callback();
+            return;
+        }
+        catch (e) {
+            lastError = e;
+        }
+    }
+    throw lastError;
+}

package/dist/src/utils/serial.d.ts

@@ -0,0 +1,4 @@
+import { DWD } from "@sie-js/serial";
+export declare function connectDWD(path: string, limitBaudrate: number, key: string): Promise<DWD>;
+export declare function disconnectDWD(dwd: DWD): Promise<void>;
+export declare function getDefaultPort(): Promise<string>;

package/dist/src/utils/serial.js

@@ -0,0 +1,60 @@
+import { AsyncSerialPort, DWD } from "@sie-js/serial";
+import { SerialPort } from "serialport";
+const USB_DEVICES = [
+    "067B:2303", // PL2303
+    "1A86:7523", // CH340
+    "0403:6001", // FT232
+    "10C4:EA60", // СР2102
+    "11F5:*", // Siemens
+    "04DA:*", // Panasonic/Softbank
+];
+export async function connectDWD(path, limitBaudrate, key) {
+    console.info(`Connecting to phone using port ${path}...`);
+    const port = new AsyncSerialPort(new SerialPort({
+        path,
+        baudRate: 112500,
+        autoOpen: false
+    }));
+    await port.open();
+    const dwd = new DWD(port);
+    if (key.indexOf(":") >= 0) {
+        const [key1, key2, key3, key4] = key.split(":");
+        const keys = {
+            key1: Buffer.from(key1, "hex"),
+            key2: parseInt(key2, 16),
+            key3: key3 ? Buffer.from(key3, "hex") : Buffer.from("00000000000000000000000000000000", "hex"),
+            key4: key4 ? parseInt(key4, 16) : 0x0000,
+        };
+        dwd.setKeys(keys);
+    }
+    else {
+        dwd.setKeys(key.toLowerCase());
+    }
+    try {
+        await dwd.connect();
+    }
+    catch (e) {
+        console.error(`Error while connecting to phone!`);
+        await port.close();
+        throw e;
+    }
+    return dwd;
+}
+export async function disconnectDWD(dwd) {
+    const port = dwd.getSerialPort();
+    if (port?.isOpen) {
+        await dwd.disconnect();
+        await port.close();
+    }
+}
+export async function getDefaultPort() {
+    const availablePorts = (await SerialPort.list()).filter((d) => {
+        if (d.path.startsWith("/dev/ttyUSB"))
+            return false;
+        return USB_DEVICES.includes(`${d.vendorId}:${d.productId}`.toUpperCase());
+    });
+    let defaultPort = availablePorts.length > 0 ? availablePorts[0].path : null;
+    if (!defaultPort)
+        defaultPort = (process.platform === "win32" ? "COM4" : "/dev/ttyACM0");
+    return defaultPort;
+}

package/dist/src/utils/string.d.ts

@@ -0,0 +1,3 @@
+export declare function parseAddr(value: string): number;
+export declare function parseSize(value: string): number;
+export declare function formatSize(size: number): string;

package/dist/src/utils/string.js

@@ -0,0 +1,39 @@
+import chalk from "chalk";
+export function parseAddr(value) {
+    let m;
+    if ((m = value.match(/^(?:0x)?([a-f0-9]+)$/i))) {
+        return parseInt(m[1], 16);
+    }
+    else {
+        throw new Error(`Invalid address: ${value}`);
+    }
+}
+export function parseSize(value) {
+    let m;
+    if ((m = value.match(/^(\d+)M$/i))) {
+        return parseInt(m[1], 10) * 1024 * 1024;
+    }
+    else if ((m = value.match(/^(\d+)k$/i))) {
+        return parseInt(m[1], 10) * 1024;
+    }
+    else if ((m = value.match(/^(?:0x|0)([0-9a-f]+)$/i))) {
+        return parseInt(m[1], 16);
+    }
+    else if ((m = value.match(/^(\d+)$/i))) {
+        return +m[1];
+    }
+    else {
+        throw new Error(`Invalid size: ${value}`);
+    }
+}
+export function formatSize(size) {
+    if (size > 1024 * 1024) {
+        return +(size / 1024 / 1024).toFixed(2) + " Mb";
+    }
+    else {
+        return +(size / 1024).toFixed(2) + " kB";
+    }
+}
+function showError(message) {
+    console.error(chalk.red(message));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sie-js/apoxi-tool",
-  "version": "1.0.3",
+  "version": "1.0.4",
   "description": "CLI tools for APOXI phones.",
   "bin": {
     "apoxi-tool": "./dist/src/cli.js"
@@ -20,6 +20,7 @@
   "author": "kirill.zhumarin@gmail.com",
   "license": "MIT",
   "devDependencies": {
+    "@sie-js/serial": "^1.1.10",
     "@types/cli-progress": "^3.11.6",
     "@types/node": "^24.2.1",
     "@types/sprintf-js": "^1.1.4",
@@ -31,7 +32,6 @@
   },
   "dependencies": {
     "@sie-js/creampie": "^1.0.2",
-    "@sie-js/serial": "^1.1.10",
     "@types/debug": "^4.1.12",
     "chalk": "^5.5.0",
     "cli-progress": "^3.12.0",
@@ -41,14 +41,14 @@
     "read-pkg": "^9.0.1",
     "serialport": "^13.0.0",
     "sprintf-js": "^1.1.3",
-    "table": "^6.9.0",
-    "@sie-js/apoxi-tool-core": "1.0.2"
+    "table": "^6.9.0"
+  },
+  "peerDependencies": {
+    "@sie-js/serial": "^1.1.10"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "watch": "tsc -w -p tsconfig.json",
-    "build:all": "pnpm -r run build",
-    "watch:all": "pnpm -r run watch",
+    "build": "tsc",
+    "watch": "tsc -w",
     "test": "echo \"Error: no test specified\" && exit 1"
   }
 }