.CIA

Task 088: .CIA File Format

Task 088: .CIA File Format

thinkmelt@protonmail.com

• 13 min read

1. List of Properties Intrinsic to the .CIA File Format

The .CIA (CTR Importable Archive) file format is a container structure designed for installing titles on the Nintendo 3DS system. It functions as a flat archive rather than a hierarchical file system, organizing data into sequential sections with indexed contents. All data is stored in little-endian byte order, and sections are aligned to 64-byte boundaries (padding with zeros if necessary to ensure the next section starts at a block boundary). The format supports up to 64 contents typically (though the bitfield allows for up to 65,536), which are concatenated in ascending order of their content index from the TMD, including only those marked as present. Contents are encrypted using AES-128-CBC, with the title key derived from the ticket and an initialization vector based on the content index padded with zeros. The optional meta section provides title metadata for the home menu. Below is a comprehensive list of intrinsic properties, grouped by structure for clarity.

General Container Properties

  • Endianness: Little-endian for all multi-byte values.
  • Alignment: All sections and data blocks aligned to 64 bytes (0x40); incomplete blocks are padded with zeros.
  • Maximum Number of Contents: Up to 64 (limited by TMD), though the content flags bitfield supports 65,536 (0xFFFF) potential indices.
  • Content Organization: Contents are stored as a single concatenated block after the TMD (or meta if present), in order of increasing content index (skipping absent ones). Offsets for individual contents are computed by cumulatively summing sizes of preceding present contents from the TMD, plus the base offset after prior sections.
  • Total File Size Calculation: Sum of header (0x2020 bytes) + certificate chain size + ticket size + TMD size + meta size (0 if absent) + total content size.
  • Encryption Scheme: Contents (NCCH or SRL) use AES-128-CBC encryption; key is the decrypted title key from the ticket; IV is the 16-byte content index (uint16, big-endian) padded with 14 zero bytes. Unencrypted variants exist for homebrew (via TMD flags) or pre-retail prototypes.
  • Section Sequencing: Fixed order: Header → Certificate Chain → Ticket → TMD → Contents → Meta (optional).
  • Content Flags: 0x2000-byte (8,192-byte) bitfield at header offset 0x20, where each bit indicates presence (1) or absence (0) of a content by its index (bit 0 of byte 0 for index 0, up to index 0xFFFF). Unused bits are zero-padded.
  • Dummy Sections: Older formats may use dummy TMD/meta of 0x200 bytes; ticket/cert chain may be 0 bytes for unencrypted prototypes.

CIA Header Properties (Offsets Relative to File Start at 0x00, Size 0x2020 Bytes)

  • Archive Header Size: uint32 at 0x00 (fixed value 0x2020).
  • Type: uint16 at 0x04 (0x0003 for retail titles, 0x0004 for debug/development titles).
  • Version: uint16 at 0x06 (typically 0x0000; indicates format version).
  • Certificate Chain Size: uint32 at 0x08 (size in bytes of the certificate section; typically 0x0A00).
  • Ticket Size: uint32 at 0x0C (size in bytes; typically 0x0400 including signature, or 0x350 for data only).
  • TMD Size: uint32 at 0x10 (size in bytes; typically 0x0B34 + (content count × 0x30)).
  • Meta Size: uint32 at 0x14 (size in bytes; typically 0x3AC0 for full meta, 0x0008 for updates like CVer, or 0x0000 if absent; absent in TWL/DS-mode CIAs or those without CXI).
  • Content Size: uint64 at 0x18 (total size in bytes of all concatenated contents).
  • Content Flags/Index: 8,192 bytes at 0x20 (bitfield as described above).

Certificate Chain Properties (Follows Header, Size from Header Field)

  • Structure: Three concatenated certificates (CA, Ticket Cert, TMD Cert), each with:
  • Signature Type: uint32 (e.g., 0x00010004 for RSA-2048-SHA256).
  • Signature: Variable bytes (0x100 for RSA-2048, 0x200 for RSA-4096).
  • Padding: To 0x40-byte alignment.
  • Issuer: 0x40 bytes (ASCII, e.g., "Root-CA00000003-XS0000000C-CP0000000B").
  • Key Type: uint32 (3 for RSA-2048/4096).
  • Name: 0x40 bytes (ASCII, e.g., "CA00000003").
  • Public Key Modulus: Variable (0x100 for RSA-2048, 0x200 for RSA-4096).
  • Padding: To certificate end.
  • Retail vs. Debug: Retail uses CA00000003/XS0000000C/CP0000000B; debug uses CA00000004/XS00000009/CP0000000A.
  • Verification: CA verifies ticket/TMD certs; certs verify their respective sections.

Ticket Properties (Follows Cert Chain, Size from Header; Big-Endian Internals, RSA-2048-SHA256 Signature Typically)

  • Signature Type: uint32 at 0x00 (0x010004 for RSA-2048-SHA256).
  • Signature: 0x100 bytes at 0x04.
  • Padding: To 0x40 bytes.
  • Issuer: 0x40 bytes at ticket data start (0x104 total offset; ASCII, e.g., "CA00000003").
  • ECC Public Key: 0x3C bytes.
  • Version: uint8 (always 0x01 for 3DS).
  • CA CRL Version: uint8.
  • Signer CRL Version: uint8.
  • Title Key: 0x10 bytes (encrypted with common keyY; decrypted using slot from index below).
  • Reserved: uint8.
  • Ticket ID: uint64.
  • Console ID: uint32.
  • Title ID: uint64 (high 32 bits: category; low 32: unique ID).
  • Reserved: uint16.
  • Title Version: uint16.
  • Reserved: uint64.
  • License Type: uint8 (0x01 common).
  • Common Key Index: uint8 (0x00 or 0x01; selects keyY slot for decryption).
  • Reserved: 0x2A bytes.
  • Account ID: uint32 (eShop-related).
  • Reserved: uint8.
  • Audit: uint8.
  • Reserved: 0x42 bytes.
  • Limits: 0x40 bytes (access limits).
  • Content Indexes: Variable (bitfield of included contents, matching TMD).

TMD (Title Metadata) Properties (Follows Ticket, Size from Header; Big-Endian, RSA-2048-SHA256 Signature Typically)

  • Signature Type: uint32 at 0x00 (0x010004).
  • Signature: 0x100 bytes.
  • Padding: To 0x40 bytes.
  • Issuer: 0x40 bytes.
  • Version: uint8 (0x01).
  • CA CRL Version: uint8.
  • Signer CRL Version: uint8.
  • Reserved: uint8.
  • System Version: uint64 (firmware requirement).
  • Title ID: uint64.
  • Title Type: uint32 (e.g., 0x00040002 for application).
  • Group ID: uint16.
  • Save Data Size: uint32 LE (public save size in bytes).
  • Private Save Size: uint32 LE (SRL private save size).
  • Reserved: uint32.
  • SRL Flag: uint8 (0x01 if DSi enhanced).
  • Reserved: 0x31 bytes.
  • Access Rights: uint32.
  • Title Version: uint16.
  • Content Count: uint16 (number of contents, up to 64).
  • Boot Content: uint16 (index of bootable content, 0x0000 usually).
  • Padding: uint16.
  • Content Info Hash: 0x20 bytes (SHA-256 of content records).
  • Content Info Records: 64 fixed records (0x24 bytes each; only first N used):
  • Content Index: uint16.
  • Command Count: uint16.
  • Content Type: uint8 (flags: encrypted, etc.).
  • Content Size: uint24 (size in bytes, multiple of 16).
  • SHA-256 Hash: 0x20 bytes (of content).
  • Content Chunk Records: Content count × 0x30 bytes (offsets/sizes in NAND/SD).

Meta Section Properties (Optional, Follows Contents, Size from Header)

  • Dependency List: 0x180 bytes at 0x00 (8 × uint64 Title IDs from ExHeader).
  • Reserved: 0x180 bytes at 0x180.
  • Core Version: uint32 at 0x300 (from ExHeader).
  • Reserved: 0xFC bytes at 0x304.
  • SMDH Icon Data: 0x36C0 bytes at 0x400 (from ExeFS/icon; includes title, icons, banners in SMDH format).

Content Section Properties (Follows TMD or Meta, Total Size from Header)

  • Individual Contents: Each is an NCCH (CXI for executable, CFA for data) or SRL (DS-mode); size and index from TMD.
  • Encryption Groups: "Menu" (ExHeader, icons; primary key) and "Content" (code, RomFS; secondary key via flags).
  • Filesystem: ExeFS (code, assets) and RomFS (read-only data) within NCCH, optional/compressible.

These properties define the format's integrity, verifiability (via signatures/hashes), and installability on the 3DS.

Two examples of legal homebrew .CIA files (open-source tools for 3DS, not commercial games):

3. Ghost Blog Embedded HTML JavaScript

The following is a self-contained HTML snippet embeddable in a Ghost blog post (e.g., via HTML card). It uses drag-and-drop to load a .CIA file, parses the header and key sections using DataView, and dumps all listed properties to a

element on screen. Deep parsing (full ticket/TMD) is implemented at a high level; full binary parsing is feasible but kept concise. Save as .html and open in a browser.

CIA File Parser
Drag and drop a .CIA file here

    


4. Python Class
The following Python class uses the struct module to parse a .CIA file, decode all properties, print them to console, and supports basic write (rebuilds a simple CIA with same properties, writing to file). It assumes binary I/O; full encryption/decryption omitted for brevity (requires crypto libs like cryptography for title key).
import struct
import os

class CIAParser:
    def __init__(self, filename=None):
        self.filename = filename
        self.data = None
        self.properties = {}
        if filename:
            self.load(filename)

    def load(self, filename):
        with open(filename, 'rb') as f:
            self.data = f.read()
        self.parse()

    def parse(self):
        pos = 0
        # Header
        self.properties['header_size'] = struct.unpack_from('<I', self.data, pos)[0]; pos += 4
        self.properties['type'] = struct.unpack_from('<H', self.data, pos)[0]; pos += 2
        self.properties['version'] = struct.unpack_from('<H', self.data, pos)[0]; pos += 2
        self.properties['cert_size'] = struct.unpack_from('<I', self.data, pos)[0]; pos += 4
        self.properties['ticket_size'] = struct.unpack_from('<I', self.data, pos)[0]; pos += 4
        self.properties['tmd_size'] = struct.unpack_from('<I', self.data, pos)[0]; pos += 4
        self.properties['meta_size'] = struct.unpack_from('<I', self.data, pos)[0]; pos += 4
        self.properties['content_size'] = struct.unpack_from('<Q', self.data, pos)[0]; pos += 8
        # Content flags (bitfield; sample count present)
        flags_start = pos
        present_indices = [i for i in range(64) if self.data[flags_start + i // 8] & (1 << (i % 8))]
        self.properties['content_flags_sample'] = present_indices
        pos += 0x2000  # Skip full flags

        # Cert chain (high-level)
        self.properties['cert_sig_type'] = struct.unpack_from('>I', self.data, pos)[0]  # Big-endian sig
        pos = 0x2020 + self.properties['cert_size']  # Skip to ticket

        # Ticket (big-endian internals)
        ticket_pos = pos
        self.properties['ticket_sig_type'] = struct.unpack_from('>I', self.data, ticket_pos)[0]
        title_key_start = ticket_pos + 0x104 + 0x7C  # Approx
        self.properties['title_key'] = self.data[title_key_start:title_key_start+16].hex()
        ticket_id_start = title_key_start + 0x10 + 0x1F  # Adjusted
        self.properties['ticket_id'] = struct.unpack_from('>Q', self.data, ticket_id_start)[0]
        title_id_start = ticket_id_start + 0x8 + 0x4 + 0x44  # Relative
        self.properties['title_id'] = struct.unpack_from('>Q', self.data, title_id_start)[0]
        common_key_idx = struct.unpack_from('B', self.data, title_id_start + 0xB1 - 0xA4)[0]  # Adjusted
        self.properties['common_key_index'] = common_key_idx
        pos += self.properties['ticket_size']

        # TMD
        tmd_pos = pos
        self.properties['tmd_sig_type'] = struct.unpack_from('>I', self.data, tmd_pos)[0]
        tmd_title_id_start = tmd_pos + 0x104 + 0xC
        self.properties['tmd_title_id'] = struct.unpack_from('>Q', self.data, tmd_title_id_start)[0]
        content_count_start = tmd_title_id_start + 0x9E - 0xC
        self.properties['content_count'] = struct.unpack_from('>H', self.data, content_count_start)[0]

        # Meta
        meta_pos = pos + self.properties['tmd_size'] + self.properties['content_size']
        if self.properties['meta_size'] > 0:
            self.properties['core_version'] = struct.unpack_from('<I', self.data, meta_pos + 0x300)[0]

        # Print
        self.print_properties()

    def print_properties(self):
        print("CIA Properties:")
        for k, v in self.properties.items():
            print(f"{k}: {v}")

    def write(self, output_filename):
        with open(output_filename, 'wb') as f:
            # Rebuild header (simplified; copy data for full)
            f.write(self.data)  # Placeholder: full rebuild would repack sections
        print(f"Written to {output_filename}")

# Usage
if __name__ == "__main__":
    parser = CIAParser("example.cia")
    parser.write("output.cia")

5. Java Class
The following Java class uses ByteBuffer and FileInputStream to parse a .CIA file, decode properties, print to console, and supports write (rebuilds by copying with modifications). Compile with Java 8+; full crypto omitted.
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;

public class CIAParser {
    private String filename;
    private byte[] data;
    private Map<String, Object> properties = new HashMap<>();

    public CIAParser(String filename) throws IOException {
        this.filename = filename;
        this.data = Files.readAllBytes(Paths.get(filename));
        parse();
    }

    private void parse() {
        ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
        int pos = 0;

        // Header
        properties.put("header_size", buffer.getInt(pos)); pos += 4;
        properties.put("type", buffer.getShort(pos)); pos += 2;
        properties.put("version", buffer.getShort(pos)); pos += 2;
        properties.put("cert_size", buffer.getInt(pos)); pos += 4;
        properties.put("ticket_size", buffer.getInt(pos)); pos += 4;
        properties.put("tmd_size", buffer.getInt(pos)); pos += 4;
        properties.put("meta_size", buffer.getInt(pos)); pos += 4;
        properties.put("content_size", buffer.getLong(pos)); pos += 8;

        // Content flags sample
        int[] presentIndices = new int[64];
        int count = 0;
        for (int i = 0; i < 64; i++) {
            if ((data[pos + i / 8] & (1 << (i % 8))) != 0) {
                presentIndices[count++] = i;
            }
        }
        properties.put("content_flags_sample", Arrays.copyOf(presentIndices, count));
        pos += 0x2000;

        // Skip to ticket
        pos = 0x2020 + (int) properties.get("cert_size");
        ByteBuffer ticketBuffer = ByteBuffer.wrap(data, pos, (int) properties.get("ticket_size")).order(ByteOrder.BIG_ENDIAN);
        properties.put("ticket_sig_type", ticketBuffer.getInt(0));
        byte[] titleKey = new byte[16];
        ticketBuffer.position(0x104 + 0x7C);
        ticketBuffer.get(titleKey);
        properties.put("title_key", bytesToHex(titleKey));
        ticketBuffer.position(0x104 + 0x7C + 0x10 + 0x1F);
        properties.put("ticket_id", ticketBuffer.getLong());
        ticketBuffer.position(0x104 + 0xA4 + 0x44);
        properties.put("title_id", ticketBuffer.getLong());
        properties.put("common_key_index", data[pos + 0xB1] & 0xFF);  // Adjusted

        // TMD similar
        pos += (int) properties.get("ticket_size");
        ByteBuffer tmdBuffer = ByteBuffer.wrap(data, pos, (int) properties.get("tmd_size")).order(ByteOrder.BIG_ENDIAN);
        properties.put("tmd_sig_type", tmdBuffer.getInt(0));
        properties.put("tmd_title_id", tmdBuffer.getLong(0x104 + 0xC));
        properties.put("content_count", tmdBuffer.getShort(0x104 + 0x9E));

        // Meta
        long metaPos = pos + properties.get("tmd_size") + (long) properties.get("content_size");
        if ((int) properties.get("meta_size") > 0) {
            ByteBuffer metaBuffer = ByteBuffer.wrap(data, (int) metaPos, (int) properties.get("meta_size")).order(ByteOrder.LITTLE_ENDIAN);
            properties.put("core_version", metaBuffer.getInt(0x300));
        }

        printProperties();
    }

    private void printProperties() {
        System.out.println("CIA Properties:");
        properties.forEach((k, v) -> System.out.println(k + ": " + v));
    }

    private static String bytesToHex(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (byte b : bytes) sb.append(String.format("%02x", b));
        return sb.toString();
    }

    public void write(String outputFilename) throws IOException {
        try (FileOutputStream fos = new FileOutputStream(outputFilename)) {
            fos.write(data);  // Placeholder: full rebuild packs sections
        }
        System.out.println("Written to " + outputFilename);
    }

    public static void main(String[] args) throws IOException {
        if (args.length > 0) {
            CIAParser parser = new CIAParser(args[0]);
            parser.write("output.cia");
        }
    }
}

6. JavaScript Class (Node.js)
The following Node.js class uses fs and Buffer to parse a .CIA file, decode properties, print to console, and supports write (rebuilds by copying). Run with node cia.js example.cia.
const fs = require('fs');

class CIAParser {
    constructor(filename = null) {
        this.filename = filename;
        this.data = null;
        this.properties = {};
        if (filename) {
            this.load(filename);
        }
    }

    load(filename) {
        this.data = fs.readFileSync(filename);
        this.parse();
    }

    parse() {
        let pos = 0;
        const buffer = this.data;
        // Header (little-endian)
        this.properties.header_size = buffer.readUInt32LE(pos); pos += 4;
        this.properties.type = buffer.readUInt16LE(pos); pos += 2;
        this.properties.version = buffer.readUInt16LE(pos); pos += 2;
        this.properties.cert_size = buffer.readUInt32LE(pos); pos += 4;
        this.properties.ticket_size = buffer.readUInt32LE(pos); pos += 4;
        this.properties.tmd_size = buffer.readUInt32LE(pos); pos += 4;
        this.properties.meta_size = buffer.readUInt32LE(pos); pos += 4;
        this.properties.content_size = buffer.readBigUInt64LE(pos); pos += 8;

        // Content flags sample
        let presentIndices = [];
        for (let i = 0; i < 64; i++) {
            if (buffer[pos + Math.floor(i / 8)] & (1 << (i % 8))) {
                presentIndices.push(i);
            }
        }
        this.properties.content_flags_sample = presentIndices;
        pos += 0x2000;

        // Ticket (big-endian approx)
        pos = 0x2020 + this.properties.cert_size;
        const ticketSigType = buffer.readUInt32BE(pos);
        const titleKeyStart = pos + 0x104 + 0x7C;
        const titleKey = buffer.slice(titleKeyStart, titleKeyStart + 16).toString('hex');
        const ticketIdStart = titleKeyStart + 0x10 + 0x1F;
        const ticketId = buffer.readBigUInt64BE(ticketIdStart);
        const titleIdStart = pos + 0x104 + 0xA4 + 0x44;
        const titleId = buffer.readBigUInt64BE(titleIdStart);
        const commonKeyIdx = buffer[pos + 0xB1];
        this.properties.ticket_sig_type = ticketSigType;
        this.properties.title_key = titleKey;
        this.properties.ticket_id = ticketId;
        this.properties.title_id = titleId;
        this.properties.common_key_index = commonKeyIdx;

        // TMD
        pos += this.properties.ticket_size;
        const tmdSigType = buffer.readUInt32BE(pos);
        const tmdTitleIdStart = pos + 0x104 + 0xC;
        const tmdTitleId = buffer.readBigUInt64BE(tmdTitleIdStart);
        const contentCountStart = tmdTitleIdStart + 0x9E - 0xC;
        const contentCount = buffer.readUInt16BE(contentCountStart);
        this.properties.tmd_sig_type = tmdSigType;
        this.properties.tmd_title_id = tmdTitleId;
        this.properties.content_count = contentCount;

        // Meta
        const metaPos = pos + this.properties.tmd_size + Number(this.properties.content_size);
        if (this.properties.meta_size > 0) {
            this.properties.core_version = buffer.readUInt32LE(metaPos + 0x300);
        }

        this.printProperties();
    }

    printProperties() {
        console.log('CIA Properties:');
        Object.entries(this.properties).forEach(([k, v]) => console.log(`${k}: ${v}`));
    }

    write(outputFilename) {
        fs.writeFileSync(outputFilename, this.data);  // Placeholder: full repack
        console.log(`Written to ${outputFilename}`);
    }
}

// Usage
if (require.main === module && process.argv.length > 2) {
    const parser = new CIAParser(process.argv[2]);
    parser.write('output.cia');
}

7. C Class (Struct and Functions)
The following C code defines a struct for properties and functions to open/parse a .CIA file, decode/read properties, print to console, and write (rebuilds by copying). Compile with gcc cia.c -o cia; run ./cia example.cia. Uses stdio for binary I/O; full parsing simplified.
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    uint32_t header_size;
    uint16_t type;
    uint16_t version;
    uint32_t cert_size;
    uint32_t ticket_size;
    uint32_t tmd_size;
    uint32_t meta_size;
    uint64_t content_size;
    int content_flags_sample[64];  // Sample present indices
    int num_flags_sample;
    uint32_t ticket_sig_type;
    char title_key[33];  // Hex
    uint64_t ticket_id;
    uint64_t title_id;
    uint8_t common_key_index;
    uint32_t tmd_sig_type;
    uint64_t tmd_title_id;
    uint16_t content_count;
    uint32_t core_version;  // If meta present
} CIAProperties;

typedef struct {
    FILE *file;
    uint8_t *data;
    size_t size;
    CIAProperties props;
} CIAParser;

void parse_header(CIAParser *parser) {
    uint8_t *buf = parser->data;
    size_t pos = 0;
    // Little-endian reads
    parser->props.header_size = *(uint32_t *)&buf[pos]; pos += 4;  // LE assumed in unpack
    parser->props.type = *(uint16_t *)&buf[pos]; pos += 2;
    parser->props.version = *(uint16_t *)&buf[pos]; pos += 2;
    parser->props.cert_size = *(uint32_t *)&buf[pos]; pos += 4;
    parser->props.ticket_size = *(uint32_t *)&buf[pos]; pos += 4;
    parser->props.tmd_size = *(uint32_t *)&buf[pos]; pos += 4;
    parser->props.meta_size = *(uint32_t *)&buf[pos]; pos += 4;
    parser->props.content_size = *(uint64_t *)&buf[pos]; pos += 8;

    // Content flags sample
    parser->props.num_flags_sample = 0;
    for (int i = 0; i < 64; i++) {
        if (buf[pos + i / 8] & (1 << (i % 8))) {
            parser->props.content_flags_sample[parser->props.num_flags_sample++] = i;
        }
    }
    pos += 0x2000;

    // Skip to ticket
    pos = 0x2020 + parser->props.cert_size;
    // Ticket (big-endian approx; manual unpack)
    uint32_t ticket_sig_type = (buf[pos] << 24) | (buf[pos+1] << 16) | (buf[pos+2] << 8) | buf[pos+3];
    parser->props.ticket_sig_type = ticket_sig_type;
    size_t title_key_start = pos + 0x104 + 0x7C;
    for (int i = 0; i < 16; i++) {
        sprintf(parser->props.title_key + i*2, "%02x", buf[title_key_start + i]);
    }
    size_t ticket_id_start = title_key_start + 0x10 + 0x1F;
    parser->props.ticket_id = (uint64_t)buf[ticket_id_start] << 56 | (uint64_t)buf[ticket_id_start+1] << 48 | /* ... full BE unpack */;
    // Simplified; assume LE for id, adjust as needed
    parser->props.ticket_id = *(uint64_t *)&buf[ticket_id_start];  // Placeholder
    size_t title_id_start = pos + 0x104 + 0xA4 + 0x44;
    parser->props.title_id = *(uint64_t *)&buf[title_id_start];
    parser->props.common_key_index = buf[pos + 0xB1];

    // TMD similar
    pos += parser->props.ticket_size;
    uint32_t tmd_sig_type = (buf[pos] << 24) | (buf[pos+1] << 16) | (buf[pos+2] << 8) | buf[pos+3];
    parser->props.tmd_sig_type = tmd_sig_type;
    size_t tmd_title_id_start = pos + 0x104 + 0xC;
    parser->props.tmd_title_id = *(uint64_t *)&buf[tmd_title_id_start];
    size_t content_count_start = tmd_title_id_start + 0x9E - 0xC;
    parser->props.content_count = *(uint16_t *)&buf[content_count_start];

    // Meta
    size_t meta_pos = pos + parser->props.tmd_size + parser->props.content_size;
    if (parser->props.meta_size > 0) {
        parser->props.core_version = *(uint32_t *)&buf[meta_pos + 0x300];
    }
}

void print_properties(CIAProperties *props) {
    printf("CIA Properties:\n");
    printf("header_size: %u\n", props->header_size);
    printf("type: %u\n", props->type);
    // ... print all fields similarly
    printf("content_flags_sample: ");
    for (int i = 0; i < props->num_flags_sample; i++) printf("%d ", props->content_flags_sample[i]);
    printf("\n");
    // Add prints for all
}

CIAParser *load_cia(const char *filename) {
    FILE *f = fopen(filename, "rb");
    if (!f) return NULL;
    fseek(f, 0, SEEK_END);
    size_t size = ftell(f);
    fseek(f, 0, SEEK_SET);
    uint8_t *data = malloc(size);
    fread(data, 1, size, f);
    fclose(f);

    CIAParser *parser = malloc(sizeof(CIAParser));
    parser->file = NULL;
    parser->data = data;
    parser->size = size;
    parse_header(parser);
    print_properties(&parser->props);
    return parser;
}

void write_cia(CIAParser *parser, const char *output) {
    FILE *f = fopen(output, "wb");
    if (f) {
        fwrite(parser->data, 1, parser->size, f);  // Copy; full rebuild packs
        fclose(f);
        printf("Written to %s\n", output);
    }
}

int main(int argc, char **argv) {
    if (argc > 1) {
        CIAParser *p = load_cia(argv[1]);
        if (p) {
            write_cia(p, "output.cia");
            free(p->data);
            free(p);
        }
    }
    return 0;
}