Tidy banner

Author: WorksButNotTested

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "frida-cshell",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "Frida's CShell",
   "scripts": {
     "prepare": "npm run version && npm run build && npm run package && npm run copy",

package.json

@@ -14,7 +14,10 @@ import { Exception } from './misc/exception.js';
 import { Version } from './misc/version.js';
 import { Format } from './misc/format.js';
 
-export const DEFAULT_SRC_PATH: string = `${Process.getHomeDir()}/.cshellrc`;
+export const HOME_DIR: string = Process.getHomeDir();
+export const DEFAULT_SRC_PATH: string = HOME_DIR.endsWith('/')
+  ? `${HOME_DIR}.cshellrc`
+  : `${HOME_DIR}/.cshellrc`;
 
 type InitParams = {
   debug: boolean;
@@ -23,8 +26,8 @@ type InitParams = {
 rpc.exports = {
   async init(stage: string, params: InitParams | null = null) {
     if (params != null) {
-      Output.writeln(`params: ${JSON.stringify(params)}`);
       Output.setDebugging(params.debug);
+      Output.debug(`params: ${JSON.stringify(params)}`);
     }
     Output.debug(`init - stage: ${stage}`);
     Output.banner();

src/entrypoint.ts

@@ -3,6 +3,7 @@ import { Vars } from '../vars/vars.js';
 import { DEFAULT_SRC_PATH } from '../entrypoint.js';
 import { Format } from '../misc/format.js';
 import { APP_VERSION, GIT_COMMIT_HASH } from '../version.js';
+import { Endian } from '../misc/endian.js';
 
 export class Output {
   private static readonly shell: string[] = [
@@ -31,35 +32,90 @@ export class Output {
   private static suppressed: boolean = false;
 
   public static banner() {
-    this.shell
-      .map((s, i) => {
-        return { shell: s, label: this.label[i] };
-      })
-      .forEach(r => {
-        this.writeln(this.blue(`${r.shell.padEnd(21, ' ')}${r.label}`));
-      });
+    const banner: [string, string][] = this.shell.map((s, i) => [
+      (s as string).trimEnd(),
+      (this.label[i] as string).trimEnd(),
+    ]);
+
+    const metadata: [string, string][] = Object.entries({
+      cshell: APP_VERSION,
+      commit: GIT_COMMIT_HASH,
+      frida: Frida.version,
+      runtime: Script.runtime,
+      arch: Process.arch,
+      endian: Endian.get(),
+      pid: Process.id.toString(),
+      binary: Process.enumerateModules()[0]?.name ?? null,
+      script: DEFAULT_SRC_PATH,
+    }).filter(([_key, value]) => value !== null) as [string, string][];
+
+    const [maxShellLength, maxLabelLength] = banner.reduce(
+      ([maxShell, maxLabel], [shell, label]) => [
+        Math.max(maxShell, shell.length),
+        Math.max(maxLabel, label.length),
+      ],
+      [0, 0],
+    );
 
-    this.writeln();
-    this.writeln(
-      this.bold(
-        [
-          `CSHELL: v${APP_VERSION}`,
-          `COMMIT: ${GIT_COMMIT_HASH}`,
-          `FRIDA: ${Frida.version}`,
-          `RUNTIME: ${Script.runtime}`,
-        ].join('\n'),
-      ),
+    const [maxKeyLength, maxValueLength] = metadata.reduce(
+      ([maxKey, maxVal], [key, value]) => [
+        Math.max(maxKey, key.length),
+        Math.max(maxVal, value.length),
+      ],
+      [0, 0],
+    );
+
+    const bannerSpacer = ' '.repeat(3);
+
+    const metaPrefix: string = '| ';
+    const metaSpacer: string = ' | ';
+    const metaSuffix: string = ' |';
+
+    const maxBannerLineLength =
+      maxShellLength + bannerSpacer.length + maxLabelLength;
+    const maxMetaLineLength =
+      metaPrefix.length +
+      maxKeyLength +
+      metaSpacer.length +
+      maxValueLength +
+      metaSuffix.length;
+    const bannerIndent = ' '.repeat(
+      Math.max(0, maxMetaLineLength - maxBannerLineLength) / 2,
     );
-    this.writeln(`init script: ${Output.bold(DEFAULT_SRC_PATH)}`);
 
-    this.writeln('Attached to:');
-    this.writeln(`\tPID:  ${this.green(Process.id.toString())}`);
+    const metaSeperator = this.red(
+      [
+        '+-',
+        '-'.repeat(maxKeyLength),
+        '-+-',
+        '-'.repeat(maxValueLength),
+        '-+',
+      ].join(''),
+    );
 
-    const modules = Process.enumerateModules();
-    if (modules.length === 0) return;
+    banner.forEach(([shell, label]) => {
+      this.write(bannerIndent);
+      this.write(this.blue(shell.padEnd(maxShellLength, ' ')));
+      this.write(bannerSpacer);
+      this.write(this.blue(label.padEnd(maxLabelLength, ' ')));
+      this.writeln();
+    });
 
-    const first = modules[0] as Module;
-    this.writeln(`\tName: ${this.green(first.name)}`);
+    this.writeln();
+
+    this.writeln(metaSeperator);
+
+    for (const [key, value] of metadata) {
+      this.write(this.red(metaPrefix));
+      this.write(this.green(key.toUpperCase().padStart(maxKeyLength, ' ')));
+      this.write(this.red(metaSpacer));
+      this.write(this.bold(this.yellow(value.padEnd(maxValueLength, ' '))));
+      this.write(this.red(metaSuffix));
+      this.writeln();
+    }
+    this.writeln(metaSeperator);
+
+    this.writeln();
   }
 
   public static debug(buffer: string | null) {

src/io/output.ts

@@ -0,0 +1,40 @@
+export enum Endianness {
+  Big = 'big',
+  Little = 'little',
+}
+
+export class Endian {
+  private static endianness: Endianness | null = null;
+  private static readonly TEST_VALUE_SIZE: number = 4;
+  private static readonly TEST_VALUE: number = 0x12345678;
+
+  private static readonly LITTLE_ENDIAN_TEST: Uint8Array = new Uint8Array([
+    0x78, 0x56, 0x34, 0x12,
+  ]);
+
+  private static readonly BIG_ENDIAN_TEST: Uint8Array = new Uint8Array([
+    0x12, 0x34, 0x56, 0x78,
+  ]);
+
+  public static get(): Endianness | null {
+    if (Endian.endianness !== null) {
+      return Endian.endianness;
+    }
+    const mem = Memory.alloc(Endian.TEST_VALUE_SIZE);
+    mem.writeU32(Endian.TEST_VALUE);
+    const buffer = mem.readByteArray(Endian.TEST_VALUE_SIZE);
+    if (buffer === null) {
+      return null;
+    }
+    const bytes = new Uint8Array(buffer);
+    const matches = (a: Uint8Array, b: Uint8Array) =>
+      a.every((v, i) => v === b[i]);
+
+    if (matches(Endian.LITTLE_ENDIAN_TEST, bytes)) {
+      return (Endian.endianness = Endianness.Little);
+    } else if (matches(Endian.BIG_ENDIAN_TEST, bytes)) {
+      return (Endian.endianness = Endianness.Big);
+    }
+    return null;
+  }
+}