@altronix/webtobin 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@altronix/webtobin",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "type": "module",
   "description": "",
   "main": "./webtobin.mjs",

package/webtobin.d.ts

@@ -1,7 +1,49 @@
-export default class {
+export interface McubootVersion {
+  major: number;
+  minor: number;
+  revision: number;
+  build: number;
+}
+
+export interface McubootHeader {
+  magic: number;
+  loadAddr: number;
+  hdrSize: number;
+  protectTlvSize: number;
+  imgSize: number;
+  flags: number;
+  version: McubootVersion;
+}
+
+export interface McubootTlv {
+  type: number;
+  value: Uint8Array;
+}
+
+export interface McubootImage {
+  header: McubootHeader;
+  image: Uint8Array;
+  protectedTlvs: McubootTlv[];
+  tlvs: McubootTlv[];
+}
+
+export function parseMcubootImages(bin: Buffer | Uint8Array): McubootImage[];
+
+export class AltronixImage {
+  partitionIndex: number;
+  partitionName: string;
+  constructor(mcubootImage: McubootImage);
+  static fromMcubootImage(img: McubootImage): AltronixImage;
+  readTlv(type: number): Uint8Array | null;
+  get header(): McubootHeader;
+  get image(): Uint8Array;
+  get version(): McubootVersion;
+}
+
+export default class Webtobin {
   constructor();
   files: { path: string; data: Uint8Array }[];
-  static from(bin: Uint8Array): this;
+  static from(bin: Uint8Array): Webtobin;
   append(path: string, data: string | Uint8Array): this;
   remove(path: string): this;
   print(): Uint8Array;

package/webtobin.mjs

@@ -1,5 +1,214 @@
 //! webtobin.mjs
 
+const IMAGE_MAGIC = 0x96f3b83d;
+const TLV_INFO_MAGIC = 0x6907;
+const TLV_PROT_INFO_MAGIC = 0x6908;
+
+/**
+ * @typedef {Object} McubootVersion
+ * @property {number} major
+ * @property {number} minor
+ * @property {number} revision
+ * @property {number} build
+ */
+
+/**
+ * @typedef {Object} McubootHeader
+ * @property {number} magic
+ * @property {number} loadAddr
+ * @property {number} hdrSize
+ * @property {number} protectTlvSize
+ * @property {number} imgSize
+ * @property {number} flags
+ * @property {McubootVersion} version
+ */
+
+/**
+ * @typedef {Object} McubootTlv
+ * @property {number} type
+ * @property {Uint8Array} value
+ */
+
+/**
+ * @typedef {Object} McubootImage
+ * @property {McubootHeader} header
+ * @property {Uint8Array} image
+ * @property {McubootTlv[]} protectedTlvs
+ * @property {McubootTlv[]} tlvs
+ */
+
+/**
+ * Parse MCUboot signed binary into array of images
+ * @param {Buffer|Uint8Array} bin
+ * @returns {McubootImage[]}
+ */
+export function parseMcubootImages(bin) {
+  const images = [];
+  const buf = new Uint8Array(bin).buffer;
+  const view = new DataView(buf);
+  const le = true;
+
+  let offset = 0;
+  while (offset < buf.byteLength) {
+    const magic = view.getUint32(offset, le);
+    if (magic !== IMAGE_MAGIC) break;
+
+    const header = parseHeader(view, offset);
+    const imgStart = offset + header.hdrSize;
+    const imgEnd = imgStart + header.imgSize;
+    const image = new Uint8Array(buf.slice(imgStart, imgEnd));
+
+    const protectedTlvs = [];
+    const tlvs = [];
+    let tlvOffset = imgEnd;
+
+    // Parse protected TLVs (magic 0x6908)
+    if (header.protectTlvSize > 0) {
+      const protMagic = view.getUint16(tlvOffset, le);
+      if (protMagic === TLV_PROT_INFO_MAGIC) {
+        const protSize = view.getUint16(tlvOffset + 2, le);
+        parseTlvs(view, tlvOffset + 4, protSize - 4, protectedTlvs);
+        tlvOffset += protSize;
+      }
+    }
+
+    // Parse standard TLVs (magic 0x6907)
+    const tlvMagic = view.getUint16(tlvOffset, le);
+    if (tlvMagic === TLV_INFO_MAGIC) {
+      const tlvSize = view.getUint16(tlvOffset + 2, le);
+      parseTlvs(view, tlvOffset + 4, tlvSize - 4, tlvs);
+      tlvOffset += tlvSize;
+    }
+
+    images.push({ header, image, protectedTlvs, tlvs });
+    offset = tlvOffset;
+  }
+
+  return images;
+}
+
+/**
+ * @param {DataView} view
+ * @param {number} offset
+ * @returns {McubootHeader}
+ */
+function parseHeader(view, offset) {
+  const le = true;
+  return {
+    magic: view.getUint32(offset + 0x00, le),
+    loadAddr: view.getUint32(offset + 0x04, le),
+    hdrSize: view.getUint16(offset + 0x08, le),
+    protectTlvSize: view.getUint16(offset + 0x0a, le),
+    imgSize: view.getUint32(offset + 0x0c, le),
+    flags: view.getUint32(offset + 0x10, le),
+    version: {
+      major: view.getUint8(offset + 0x14),
+      minor: view.getUint8(offset + 0x15),
+      revision: view.getUint16(offset + 0x16, le),
+      build: view.getUint32(offset + 0x18, le),
+    },
+  };
+}
+
+/**
+ * @param {DataView} view
+ * @param {number} offset
+ * @param {number} length
+ * @param {McubootTlv[]} out
+ */
+function parseTlvs(view, offset, length, out) {
+  const le = true;
+  const end = offset + length;
+  while (offset < end) {
+    const type = view.getUint16(offset, le);
+    const len = view.getUint16(offset + 2, le);
+    const data = new Uint8Array(view.buffer.slice(offset + 4, offset + 4 + len));
+    out.push({ type, value: data });
+    offset += 4 + len;
+  }
+}
+
+// Application-specific TLV types
+const TLV_PARTITION_INDEX = 0x8001;
+const TLV_PARTITION_NAME = 0x8002;
+
+/**
+ * @typedef {Object} AltronixImageInfo
+ * @property {number} partitionIndex
+ * @property {string} partitionName
+ * @property {McubootHeader} header
+ * @property {Uint8Array} image
+ * @property {McubootVersion} version
+ */
+
+/** Application-specific wrapper for MCUboot images */
+export class AltronixImage {
+  #mcuboot;
+
+  /** @type {number} */
+  partitionIndex;
+
+  /** @type {string} */
+  partitionName;
+
+  /**
+   * @param {McubootImage} mcubootImage
+   */
+  constructor(mcubootImage) {
+    this.#mcuboot = mcubootImage;
+
+    const indexTlv = this.#mcuboot.protectedTlvs.find((t) => t.type === TLV_PARTITION_INDEX);
+    if (!indexTlv) {
+      throw new Error("AltronixImage: missing required TLV_PARTITION_INDEX (0x8001)");
+    }
+    this.partitionIndex = new DataView(
+      indexTlv.value.buffer,
+      indexTlv.value.byteOffset,
+      indexTlv.value.byteLength
+    ).getUint32(0, true);
+
+    const nameTlv = this.#mcuboot.protectedTlvs.find((t) => t.type === TLV_PARTITION_NAME);
+    if (!nameTlv) {
+      throw new Error("AltronixImage: missing required TLV_PARTITION_NAME (0x8002)");
+    }
+    this.partitionName = new TextDecoder().decode(nameTlv.value);
+  }
+
+  /**
+   * Create AltronixImage from McubootImage
+   * @param {McubootImage} img
+   * @returns {AltronixImage}
+   */
+  static fromMcubootImage(img) {
+    return new AltronixImage(img);
+  }
+
+  /**
+   * Read a TLV value by type from protected TLVs
+   * @param {number} type
+   * @returns {Uint8Array|null}
+   */
+  readTlv(type) {
+    const tlv = this.#mcuboot.protectedTlvs.find((t) => t.type === type);
+    return tlv ? tlv.value : null;
+  }
+
+  /** @returns {McubootHeader} */
+  get header() {
+    return this.#mcuboot.header;
+  }
+
+  /** @returns {Uint8Array} */
+  get image() {
+    return this.#mcuboot.image;
+  }
+
+  /** @returns {McubootVersion} */
+  get version() {
+    return this.#mcuboot.header.version;
+  }
+}
+
 /** Class holding Webtobin state */
 export default class Webtobin {
   constructor() {