choose-files kitten: Sanitize untrusted text in the preview panel

File names, archive member names, symlink targets, error messages and
ebook metadata were written to the terminal unsanitized, allowing
crafted names to inject escape codes (e.g. OSC 52 to overwrite the
clipboard) merely by highlighting the entry.
This commit is contained in:
Kovid Goyal 2026-11-14 12:02:45 +05:30
parent add52d9cf7
commit 4fa6709910
No known key found for this signature in database
GPG key ID: 06BC317B515ACE7C
12 changed files with 246 additions and 36 deletions

View file

@ -135,6 +135,8 @@ Detailed list of changes
- Unicode input kitten: Fix searching by name not finding some characters such as the pound sign (:iss:`10862`)
- choose-files kitten: Sanitize file names, archive member names, ebook metadata and previewer output everywhere they are displayed so they cannot inject escape codes into the terminal
- :doc:`Custom shaders <custom-shaders>`: Add ``screen-shake`` shaders that shake
a window on bell and new events and uniforms for command start/finish and
alternate screen enter/exit

View file

@ -48,7 +48,7 @@ type archive_preview struct {
func displayFilename(s string) string {
if isPrintableUTF8(s) {
return s
return sanitize_name(s)
}
return fmt.Sprintf("%X", utils.UnsafeStringToBytes(s))
}
@ -95,12 +95,7 @@ func (p *archive_preview) render(output chan<- *MessagePreview, base *MessagePre
if err == nil || errors.Is(err, zip.ErrInsecurePath) {
defer r.Close()
for _, f := range r.File {
if f.NonUTF8 {
names = append(names, displayFilename(f.Name))
} else {
names = append(names, f.Name)
}
names = append(names, displayFilename(f.Name))
}
}
case ".rar":

View file

@ -13,15 +13,18 @@ import (
var _ = fmt.Print
func new_test_archive_preview(t *testing.T) (*archive_preview, *MessagePreview) {
func new_test_archive_preview(t *testing.T, names ...string) (*archive_preview, *MessagePreview) {
t.Helper()
if len(names) == 0 {
names = []string{"a.txt", "dir/b.txt"}
}
path := filepath.Join(t.TempDir(), "test.zip")
f, err := os.Create(path)
if err != nil {
t.Fatal(err)
}
zw := zip.NewWriter(f)
for _, name := range []string{"a.txt", "dir/b.txt"} {
for _, name := range names {
w, err := zw.Create(name)
if err != nil {
t.Fatal(err)
@ -100,3 +103,19 @@ func TestArchivePreviewWorkerPanic(t *testing.T) {
t.Fatalf("archive preview does not report the panic: %#v", result.trailers)
}
}
// Names of archive members are untrusted and must not be able to inject
// escape codes into the terminal.
func TestArchivePreviewSanitizesNames(t *testing.T) {
evil := "x\x1b]52;c;aGFja2Vk\x07\ny.txt"
p, base := new_test_archive_preview(t, evil)
result := run_archive_preview_worker(t, p, base)
for _, line := range result.trailers {
if strings.ContainsAny(line, "\x1b\x07\n") {
t.Fatalf("archive preview contains unsanitized name: %#v", line)
}
}
if expected := "x␛]52;c;aGFja2Vk␇␤y.txt"; !slices.Contains(result.trailers, expected) {
t.Fatalf("archive preview does not list %#v: %#v", expected, result.trailers)
}
}

View file

@ -362,18 +362,18 @@ func (c calibre_renderer) ShowMetadata(h *Handler, s ShowData) (offset int) {
offset += h.render_wrapped_text_in_region(text, s.x, s.y+offset, s.width, s.height-offset, center)
}
}
ext := filepath.Ext(s.abspath)
ext := sanitize_name(filepath.Ext(s.abspath))
text := fmt.Sprintf("%s: %s", ext, humanize.Bytes(uint64(s.metadata.Size())))
icon := icons.IconForPath(s.abspath)
w(icon+" "+text, true)
r := s.custom_metadata.custom.(*CalibreResponse)
w("Title: "+r.Metadata.Title, false)
w("Authors: "+strings.Join(r.Metadata.Authors, " & "), false)
w("Title: "+sanitize(r.Metadata.Title), false)
w("Authors: "+sanitize(strings.Join(r.Metadata.Authors, " & ")), false)
if r.Metadata.Series != "" {
w(fmt.Sprintf("Series: Book %g of %s", r.Metadata.Series_index, r.Metadata.Series), false)
w(fmt.Sprintf("Series: Book %g of %s", r.Metadata.Series_index, sanitize(r.Metadata.Series)), false)
}
if len(r.Metadata.Tags) > 0 {
w("Tags: "+strings.Join(r.Metadata.Tags, ", "), false)
w("Tags: "+sanitize(strings.Join(r.Metadata.Tags, ", ")), false)
}
return
}

View file

@ -90,13 +90,13 @@ func (c cmd_renderer) ShowMetadata(h *Handler, s ShowData) (offset int) {
offset += h.render_wrapped_text_in_region(text, s.x, s.y+offset, s.width, s.height-offset, center)
}
}
ext := filepath.Ext(s.abspath)
ext := sanitize_name(filepath.Ext(s.abspath))
r := s.custom_metadata.custom.(*CmdResult)
text := fmt.Sprintf("%s: %s%s", ext, humanize.Bytes(uint64(s.metadata.Size())), r.TitleExtra)
text := fmt.Sprintf("%s: %s%s", ext, humanize.Bytes(uint64(s.metadata.Size())), keep_only_sgr(r.TitleExtra))
icon := icons.IconForPath(s.abspath)
w(icon+" "+text, true)
for _, line := range r.Lines {
w(line, false)
w(keep_only_sgr(line), false)
}
h.lp.QueueWriteString("\x1b[m") // reset SGR attributes
return

View file

@ -154,7 +154,7 @@ func (c ffmpeg_renderer) ShowMetadata(h *Handler, s ShowData) (offset int) {
offset += h.render_wrapped_text_in_region(text, s.x, s.y+offset, s.width, s.height-offset, center)
}
}
ext := filepath.Ext(s.abspath)
ext := sanitize_name(filepath.Ext(s.abspath))
text := fmt.Sprintf("%s: %s", ext, humanize.Bytes(uint64(s.metadata.Size())))
r := s.custom_metadata.custom.(*FFMpegMetadata)
icon := icons.IconForPath(s.abspath)

View file

@ -91,7 +91,7 @@ func (h *Handler) draw_footer() (num_lines int, err error) {
if rel, rerr := filepath.Rel(h.state.CurrentDir(), s); rerr == nil {
text = rel
}
w(" ", text, nil, s, func(abspath string) { h.state.ToggleSelection(abspath) })
w(" ", sanitize_name(text), nil, s, func(abspath string) { h.state.ToggleSelection(abspath) })
if len(lines)-before > 2 && len(h.state.selections)-i-1 > 3 {
w(" ", fmt.Sprintf("and %d more…", len(h.state.selections)-1-i), nil, "", nil)
break

View file

@ -44,11 +44,10 @@ type PreviewManager struct {
highlighter highlight.Highlighter
}
func NewPreviewManager(err_chan chan error, settings Settings, WakeupMainThread func() bool) (ans *PreviewManager) {
defer func() { sanitize = ans.highlighter.Sanitize }()
func NewPreviewManager(err_chan chan error, settings Settings, WakeupMainThread func() bool) *PreviewManager {
return &PreviewManager{
report_errors: err_chan, settings: settings, WakeupMainThread: WakeupMainThread,
cache: make(map[string]Preview), highlighter: highlight.NewHighlighter(nil),
cache: make(map[string]Preview), highlighter: highlight.NewHighlighter(sanitize),
}
}
@ -116,27 +115,25 @@ func (p MessagePreview) Render(h *Handler, x, y, width, height int) {
func NewErrorPreview(err error) Preview {
sctx := style.Context{AllowEscapeCodes: true}
text := fmt.Sprintf("%s: %s", sctx.SprintFunc("fg=red")("Error"), err)
text := fmt.Sprintf("%s: %s", sctx.SprintFunc("fg=red")("Error"), sanitize(err.Error()))
return &MessagePreview{msg: text}
}
var sanitize func(string) string
func write_file_metadata(abspath string, metadata fs.FileInfo, entries []fs.DirEntry) (header string, trailers []string) {
buf := strings.Builder{}
buf.Grow(4096)
add := func(key, val string) { fmt.Fprintf(&buf, "%s: %s\n", key, val) }
ftype := metadata.Mode().Type()
const file_icon = " "
fmt.Fprintln(&buf, filepath.Base(abspath))
fmt.Fprintln(&buf, sanitize_name(filepath.Base(abspath)))
switch ftype {
case 0:
add("Size", humanize.Bytes(uint64(metadata.Size())))
case fs.ModeSymlink:
if tgt, err := os.Readlink(abspath); err == nil {
add("Target", sanitize(tgt))
add("Target", sanitize_name(tgt))
} else {
add("Target", err.Error())
add("Target", sanitize(err.Error()))
}
case fs.ModeDir:
num_files, num_dirs := 0, 0
@ -164,7 +161,7 @@ func write_file_metadata(abspath string, metadata fs.FileInfo, entries []fs.DirE
slices.SortFunc(names, func(a, b string) int { return strings.Compare(type_map[a].lname, type_map[b].lname) })
fmt.Fprintln(&buf, "Contents:")
for _, n := range names {
trailers = append(trailers, icons.IconForFileWithMode(n, type_map[n].ftype, false)+" "+sanitize(n))
trailers = append(trailers, icons.IconForFileWithMode(n, type_map[n].ftype, false)+" "+sanitize_name(n))
}
}
return buf.String(), trailers
@ -181,7 +178,7 @@ func NewDirectoryPreview(abspath string, metadata fs.FileInfo) Preview {
}
func NewFileMetadataPreview(abspath string, metadata fs.FileInfo) *MessagePreview {
ext := filepath.Ext(abspath)
ext := sanitize_name(filepath.Ext(abspath))
if ext == "" {
ext = "File"
}
@ -191,14 +188,14 @@ func NewFileMetadataPreview(abspath string, metadata fs.FileInfo) *MessagePrevie
}
func NewFileMetadataPreviewWithError(abspath string, metadata fs.FileInfo, err error) *MessagePreview {
ext := filepath.Ext(abspath)
ext := sanitize_name(filepath.Ext(abspath))
if ext == "" {
ext = "File"
}
title := icons.IconForFileWithMode(filepath.Base(abspath), metadata.Mode().Type(), false) + " " + ext
h, t := write_file_metadata(abspath, metadata, nil)
ans := &MessagePreview{title: title, msg: h, trailers: t}
lines := style.WrapTextAsLines(err.Error(), 30, style.WrapOptions{})
lines := style.WrapTextAsLines(sanitize(err.Error()), 30, style.WrapOptions{})
ans.trailers = append(ans.trailers, "")
ans.trailers = append(ans.trailers, lines...)
return ans
@ -246,7 +243,7 @@ func (p *TextFilePreview) Render(h *Handler, x, y, width, height int) {
s := utils.NewLineScanner(text)
buf := strings.Builder{}
buf.Grow(1024 * height)
title := icons.IconForPath(p.path) + " " + filepath.Base(p.path) + fmt.Sprintf(" %s", humanize.Bytes(uint64(p.metadata.Size())))
title := icons.IconForPath(p.path) + " " + sanitize_name(filepath.Base(p.path)) + fmt.Sprintf(" %s", humanize.Bytes(uint64(p.metadata.Size())))
for num := 1 + h.render_wrapped_text_in_region(title, x, y, width, height, true); s.Scan() && num < height; num++ {
line := s.Text()
truncated := wcswidth.TruncateToVisualLength(line, width)

View file

@ -25,7 +25,7 @@ func (h *Handler) draw_results_title() {
if strings.HasPrefix(text, home) {
text = "~" + text[len(home):]
}
text = sanitize(text)
text = sanitize_name(text)
available_width := h.screen_size.width - 9
if available_width < 2 {
return
@ -154,7 +154,7 @@ func (h *Handler) draw_column_of_matches(matches ResultsType, current_idx int, x
} else {
icon = icon_for(filepath.Join(root_dir, m.text), m.ftype)
}
text := sanitize(m.text)
text := sanitize_name(m.text)
add_ellipsis := false
width := wcswidth.Stringwidth(text)
if width > available_width-3 {

View file

@ -0,0 +1,97 @@
// License: GPLv3 Copyright: 2026, Kovid Goyal, <kovid at kovidgoyal.net>
package choose_files
import (
"strings"
"unicode/utf8"
"github.com/kovidgoyal/kitty/tools/utils"
"github.com/kovidgoyal/kitty/tools/wcswidth"
)
// replace_c1_controls replaces the UTF-8 encoded C1 control characters
// (U+0080 to U+009F) with U+FFFD. Some terminals interpret these as escape
// code introducers, for example U+009B as CSI. Each control is replaced by
// exactly one rune so that rune offsets into the text remain valid.
func replace_c1_controls(text string) string {
// All C1 controls are encoded as 0xc2 followed by a byte in 0x80-0x9f
idx := strings.IndexByte(text, 0xc2)
if idx < 0 {
return text
}
var buf strings.Builder
for idx > -1 {
if idx+1 < len(text) && text[idx+1] >= 0x80 && text[idx+1] <= 0x9f {
if buf.Cap() == 0 {
buf.Grow(len(text) + 16)
}
buf.WriteString(text[:idx])
buf.WriteRune(utf8.RuneError)
text = text[idx+2:]
idx = strings.IndexByte(text, 0xc2)
} else if n := strings.IndexByte(text[idx+1:], 0xc2); n > -1 {
idx += n + 1
} else {
break
}
}
if buf.Cap() == 0 {
return text
}
buf.WriteString(text)
return buf.String()
}
// sanitize replaces control codes in untrusted multi-line text, such as file
// contents, before it is written to the terminal. Newlines are preserved.
func sanitize(text string) string {
return replace_c1_controls(utils.ReplaceControlCodes(text, " ", "\n"))
}
// sanitize_name replaces control codes, including newlines and tabs, in
// untrusted text that must occupy a single line, such as file names. Every
// control character is replaced by exactly one rune, so rune offsets into the
// original text, such as match positions, remain valid.
func sanitize_name(text string) string {
return replace_c1_controls(utils.ReplaceControlCodes(text, "␉", "␤"))
}
// keep_only_sgr removes all escape codes other than SGR (formatting) codes
// from a single line of untrusted text, and sanitizes the remaining text.
func keep_only_sgr(text string) string {
var buf, pending strings.Builder
buf.Grow(len(text))
flush := func() {
if pending.Len() > 0 {
buf.WriteString(sanitize_name(pending.String()))
pending.Reset()
}
}
p := wcswidth.EscapeCodeParser{ReplaceInvalidUtf8Bytes: true}
p.HandleRune = func(ch rune) error {
pending.WriteRune(ch)
return nil
}
p.HandleCSI = func(data []byte) error {
if len(data) == 0 || data[len(data)-1] != 'm' {
return nil
}
for _, b := range data[:len(data)-1] {
if !(b >= '0' && b <= '9') && b != ';' && b != ':' {
return nil
}
}
flush()
buf.WriteString("\x1b[")
buf.Write(data)
return nil
}
if err := p.ParseString(text); err != nil {
// The callbacks never fail, so this cannot happen, but be safe and
// drop any escape codes entirely.
return sanitize_name(wcswidth.StripEscapeCodes(text))
}
flush()
return buf.String()
}

View file

@ -0,0 +1,95 @@
package choose_files
import (
"fmt"
"os"
"path/filepath"
"strings"
"testing"
"unicode/utf8"
)
var _ = fmt.Print
func TestFileMetadataPreviewSanitizesNames(t *testing.T) {
dir := t.TempDir()
evil := "x\x1b]52;c;aGFja2Vk\x07\ny"
path := filepath.Join(dir, evil)
if err := os.Mkdir(path, 0o755); err != nil {
t.Fatal(err)
}
if err := os.WriteFile(filepath.Join(path, evil+".\x1b[31m"), nil, 0o644); err != nil {
t.Fatal(err)
}
if err := os.Symlink(evil, filepath.Join(path, "link")); err != nil {
t.Fatal(err)
}
const sanitized = "x␛]52;c;aGFja2Vk␇␤y"
check := func(mp *MessagePreview) {
t.Helper()
for _, text := range append([]string{mp.title, mp.msg}, mp.trailers...) {
if strings.ContainsAny(text, "\x1b\x07") {
t.Fatalf("preview contains unsanitized name: %#v", text)
}
}
if all := mp.title + mp.msg + strings.Join(mp.trailers, "\n"); !strings.Contains(all, sanitized) {
t.Fatalf("preview does not contain the sanitized name %#v: %#v", sanitized, all)
}
}
st, err := os.Stat(path)
if err != nil {
t.Fatal(err)
}
check(NewDirectoryPreview(path, st).(*MessagePreview))
for _, name := range []string{evil + ".\x1b[31m", "link"} {
fp := filepath.Join(path, name)
st, err = os.Lstat(fp)
if err != nil {
t.Fatal(err)
}
check(NewFileMetadataPreview(fp, st))
check(NewFileMetadataPreviewWithError(fp, st, fmt.Errorf("failed for %s", fp)))
}
}
func TestSanitize(t *testing.T) {
for _, tc := range []struct{ input, name, multiline string }{
{"plain.txt", "plain.txt", "plain.txt"},
{"a\x1b[31mb\x07", "a␛[31mb␇", "a␛[31mb␇"},
{"a\tb\nc\x7f", "a␉b␤c␡", "a b\nc␡"},
{"a›31mb52;c;eAœ", "a<>31mb<6D>52;c;eA<65>", "a<>31mb<6D>52;c;eA<65>"},
{"頀", "é <C3A9>", "é <C3A9>"},
} {
if actual := sanitize_name(tc.input); actual != tc.name {
t.Fatalf("sanitize_name(%#v) = %#v, expected %#v", tc.input, actual, tc.name)
}
if actual := sanitize(tc.input); actual != tc.multiline {
t.Fatalf("sanitize(%#v) = %#v, expected %#v", tc.input, actual, tc.multiline)
}
}
// match positions are rune offsets, so sanitize_name must preserve them
input := "a\tb\nc\x1b›d"
if a, b := utf8.RuneCountInString(input), utf8.RuneCountInString(sanitize_name(input)); a != b {
t.Fatalf("sanitize_name changed the number of runes from %d to %d", a, b)
}
}
func TestKeepOnlySGR(t *testing.T) {
for input, expected := range map[string]string{
"plain": "plain",
"\x1b[1;31mred\x1b[m": "\x1b[1;31mred\x1b[m",
"\x1b[38:5:1mx": "\x1b[38:5:1mx",
"a\x1b]52;c;aGFja2Vk\x07b": "ab",
"a\x1b]52;c;aGFja2Vk\x1b\\b": "ab",
"a\x1bP+q\x1b\\b": "ab",
"a\x1b[2Jb\x1b[?1049hc": "abc",
"a\x1b[>1mb": "ab",
"a\u009d52;c;eA\u009cb": "ab",
"a\nb\x07": "a␤b␇",
"a\x1b[200~\x1b]52;c;eA\x07\x1b[201~": "a␛]52;c;eA␇",
} {
if actual := keep_only_sgr(input); actual != expected {
t.Fatalf("keep_only_sgr(%#v) = %#v, expected %#v", input, actual, expected)
}
}
}

View file

@ -136,6 +136,11 @@ func (h *Handler) initialize_save_file_name(fname string) {
}
}
}
if sanitize_name(fname) != fname {
// Do not pre-fill names containing control codes as the readline
// would write them to the terminal unsanitized.
fname = ""
}
h.rl.SetText(fname)
}
@ -146,7 +151,7 @@ func (h *Handler) draw_save_file_name_screen() (err error) {
h.lp.Println(h.state.WindowTitle())
}
h.lp.Println("Enter the name of the", desc, "below, relative to:")
h.lp.Println(h.lp.SprintStyled("fg=green", h.state.CurrentDir()))
h.lp.Println(h.lp.SprintStyled("fg=green", sanitize_name(h.state.CurrentDir())))
if h.state.mode.AllowsMultipleSelection() {
h.lp.Println("Use shift+enter (or whatever you mapped the select action to) to enter multiple filenames")
}