# compile the binary program
gcc self_memory.c -o self_memory

./self_memory   # run program ("Run count 1")
./self_memory   # run program ("Run count 2")
./self_memory   # run program ("Run count 3")

// self_memory.c
// A program that remembers how many times it has been run by appending
// state past the end of the signed Mach-O binary content.
//
// macOS only signature-verifies the Mach-O content, not bytes appended
// after it — so we can safely read/write state there without breaking
// the signature or needing to re-sign.
//
// State block layout:
//   [StateHeader (12 bytes)][body (header.length bytes)]
//
// Compile:  gcc self_memory.c -o self_memory
// Run:      ./self_memory

#include <mach-o/dyld.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <unistd.h>

/** --- Definitions --- **/

#define MAGIC_LEN 4
#define MAGIC_BYTES {0xDE, 0xAD, 0xBE, 0xEF}

// Fixed header — always written at the start of our appended block
typedef struct {
  uint8_t magic[MAGIC_LEN]; // sentinel to confirm block exists
  uint32_t version;         // schema version, for future changes
  uint32_t length;          // byte length of the body that follows
} StateHeader;

// Dynamic body — add/remove fields here as needed
typedef struct {
  int32_t run_count;
  int64_t last_run; // unix timestamp of last run
} StateBody;

/** --- Binary helpers --- **/

// Get path to our own executable
static int get_exe_path(char *buf, uint32_t size) {
  if (_NSGetExecutablePath(buf, &size) != 0) {
    fprintf(stderr, "Error: executable path buffer too small\n");
    return -1;
  }
  return 0;
}

// Open our own binary for reading and writing
static FILE *open_self(char *path_buf, uint32_t buf_size) {
  if (get_exe_path(path_buf, buf_size) != 0)
    return NULL;
  FILE *f = fopen(path_buf, "r+b");
  if (!f)
    perror("fopen");
  return f;
}

// Flush and close a file
static void flush_and_close(FILE *f) {
  fflush(f);
  fsync(fileno(f));
  fclose(f);
}

/** --- State block helpers --- **/

// Check if a header has a valid magic sentinel
static int header_is_valid(const StateHeader *h) {
  static const uint8_t magic[] = MAGIC_BYTES;
  return memcmp(h->magic, magic, MAGIC_LEN) == 0;
}

// Seek to end of file and return file size
static long seek_to_end(FILE *f) {
  fseek(f, 0, SEEK_END);
  return ftell(f);
}

// Find offset of our state body, or -1 if not present
// Header lives at EOF - sizeof(StateHeader), body lives before it
static long find_block_offset(FILE *f, long file_size) {
  if (file_size < (long)(sizeof(StateHeader) + sizeof(StateBody)))
    return -1;

  StateHeader h;
  fseek(f, file_size - sizeof(StateHeader), SEEK_SET);
  fread(&h, sizeof(StateHeader), 1, f);

  if (!header_is_valid(&h))
    return -1;

  // Body starts before the header
  return file_size - sizeof(StateHeader) - h.length;
}

// Read state body from file at given block offset
// Layout on disk: [body][header] — body comes first, header at end
static int read_body(FILE *f, long block_offset, StateHeader *h,
                     StateBody *body) {
  fseek(f, block_offset, SEEK_SET);
  uint32_t read_len =
      h->length < sizeof(StateBody) ? h->length : sizeof(StateBody);
  memset(body, 0, sizeof(StateBody)); // zero out in case schema grew
  fread(body, read_len, 1, f);
  return 0;
}

// Write body first, then header — header lives at EOF so we can always find it
static void write_block(FILE *f, const StateBody *body) {
  static const uint8_t magic[] = MAGIC_BYTES;

  StateHeader h;
  memcpy(h.magic, magic, MAGIC_LEN);
  h.version = 2;
  h.length = sizeof(StateBody);

  fwrite(body, sizeof(StateBody), 1, f); // body first
  fwrite(&h, sizeof(StateHeader), 1, f); // header last (findable at EOF)
}

/** --- Main --- **/

int main() {
  char path[4096]; // NOTE: large enough for any macOS path
  FILE *f = open_self(path, sizeof(path));
  if (!f)
    return 1;

  long file_size = seek_to_end(f);
  long block_offset = find_block_offset(f, file_size);

  StateHeader h;
  StateBody body = {0};

  if (block_offset != -1) {
    // Re-read header so read_body has the length
    fseek(f, file_size - sizeof(StateHeader), SEEK_SET);
    fread(&h, sizeof(StateHeader), 1, f);
    read_body(f, block_offset, &h, &body);

    char time_buf[64];
    time_t t = (time_t)body.last_run;
    strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S", localtime(&t));
    printf("Run count: %d (last run: %s)\n", body.run_count, time_buf);
  } else {
    printf("Run count: 0 (first run — appending state block)\n");
  }

  // Update state
  body.run_count++;
  body.last_run = (int64_t)time(NULL);

  // Write back — overwrite in place or append fresh
  if (block_offset != -1) {
    fseek(f, block_offset, SEEK_SET);
  } else {
    fseek(f, 0, SEEK_END);
  }

  write_block(f, &body);
  flush_and_close(f);

  printf("Updated run count to %d\n", body.run_count);
  return 0;
}

┌─────────────────────────────┬──────────────────┬─────────────┐
│        Mach-O content       │  Code Signature  │  Our state  │
│   (__TEXT, __DATA, etc.)    │  (verified ✓)    │  (ignored)  │
└─────────────────────────────┴──────────────────┴─────────────┘
                                                  ↑
                                             We write here

Offset +0   DE AD BE EF   ← magic sentinel (4 bytes)
Offset +4   XX XX XX XX   ← run_count as int32 (4 bytes)