Skip to contentSkip to conversation

fs/ntfs3: reserve NUL byte when converting UTF-16 names

PATCH In review Kyle Zeng 3 participants 3 messages Jun 11 – Jul 23 NTFS3 filesystem

lore
Share & tools
lore

Kyle Zeng

author
#0 lore raw

PATCH 1/1 fs/ntfs3: reserve NUL byte when converting UTF-16 names

ntfs_utf16_to_nls() appends a trailing NUL to the converted output, but it passes the caller-supplied size directly to the conversion loop. For the UTF-8 path, utf16s_to_utf8s() can legitimately fill all buf_len bytes and return buf_len, after which ntfs_utf16_to_nls() writes the terminator one byte past the end of the destination buffer.

The same contract problem exists for the NLS path when a converted character consumes the last available byte.

Reserve one byte for the terminator before doing either conversion. The function continues to return the number of converted bytes, excluding the NUL terminator.

Assisted-by Codex:gpt-5.5
---
 fs/ntfs3/dir.c | 5 +++++
 1 file changed, 5 insertions(+)
fs/ntfs3/dir.c +5 -0
index d99ab086ef6f..e8892cd94e04 100644
@@ -25,6 +25,11 @@ int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const __le16 *name, u32 len,
 
 	static_assert(sizeof(wchar_t) == sizeof(__le16));
 
+	if (buf_len <= 0)
+		return -EINVAL;
+
+	buf_len -= 1;
+
 	if (!nls) {
 		/* UTF-16 -> UTF-8 */
 		ret = utf16s_to_utf8s((wchar_t *)name, len, UTF16_LITTLE_ENDIAN,
Signature · 1 line
2.43.0
#1 lore raw

From: XIAOWU <[email protected]>
To: Kyle Zeng <[email protected]>
Cc: [email protected], [email protected]
Subject: Re: [PATCH] fs/ntfs3: reserve NUL byte when converting UTF-16 names
In-Reply-To: <[email protected]>

Hi Kyle,

I came across a Sashiko AI code review [1] that flagged a potential use-after-free in ntfs_utf16_to_nls() — specifically, the read of sbi->options->nls without holding sb->s_umount, allowing a concurrent remount to free the options structure while a directory iteration is in progress.

I was able to reproduce this in QEMU with KASAN enabled.  The trigger is a race between getdents64 (which enters ntfs_readdir → ntfs_read_hdr → ntfs_utf16_to_nls) and a concurrent mount -o remount, which swaps and frees the old options via ntfs_fs_reconfigure().

Quoted 2 lines · Kyle Zeng

This commit fixes an out-of-bounds write in ntfs_utf16_to_nls() by reserving a byte for the NUL terminator...

...

fs/ntfs3/dir.c int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, · line 27

Quoted 6 lines
fs/ntfs3/dir.c +0 -0
@@ -25,6 +25,11 @@ int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi,
                        const __le16 *name, u32 len,
 
       static_assert(sizeof(wchar_t) == sizeof(__le16));

At this point, sbi->options->nls is dereferenced without any lock protecting it against concurrent modification:

```c
int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, ...)
{
    const struct nls_table *nls = sbi->options->nls;  // unprotected read
```

Meanwhile, a concurrent remount path does:

    swap(sbi->options, fc->fs_private);  // in ntfs_fs_reconfigure()
    ...
    put_mount_options(opts);             // kfree() the old options

If the free lands between the nls pointer being loaded and being dereferenced, the directory iteration hits freed memory.

[Reproduction]

I set up an NTFS filesystem image and ran two threads in parallel:
one calling getdents64 in a loop, the other calling mount -o remount. The race triggered a KASAN report within a few seconds.

[KASAN report — kernel 7.1.0-rc6+, CONFIG_KASAN=y]

  ==================================================================

  BUG: KASAN: slab-use-after-free in ntfs_utf16_to_nls+0x563/0x5f0
  Read of size 8 at addr ffff888026403028 by task poc/9531

  Call Trace:
   <TASK>
   dump_stack_lvl+0x116/0x1f0
   print_report+0xf4/0x600
   kasan_report+0xe0/0x110
   ntfs_utf16_to_nls+0x563/0x5f0
   ntfs_read_hdr+0x6a7/0xb60
   ntfs_readdir+0x6ef/0x10a0
   iterate_dir+0x336/0x560
   __do_sys_getdents64+0x1de/0x380
   do_syscall_64+0xcd/0xf80
   entry_SYSCALL_64_after_hwframe+0x77/0x7f

  Allocated by task 9532:
   ntfs_init_fs_context+0x...      // remount allocates new options
   alloc_mount_options+0x...
   kfree+0x...

  Freed by task 9532:
   put_mount_options+0x...         // old options freed during remount
   ntfs_fs_free+0x...

The crash is a read of the freed sbi->options->nls pointer. The allocate and free traces confirm the remount path as the source of the free.

[1] https://sashiko.dev/#/patchset/20260611213331.16763-1-kylebot%40openai.com
    (Sashiko AI code review — "Use-After-Free", Severity: High)

Thanks,
XIAO

#2 lore raw
In reply to Kyle Zeng
Quoted 36 lines · Kyle Zeng

ntfs_utf16_to_nls() appends a trailing NUL to the converted output, but it passes the caller-supplied size directly to the conversion loop. For the UTF-8 path, utf16s_to_utf8s() can legitimately fill all buf_len bytes and return buf_len, after which ntfs_utf16_to_nls() writes the terminator one byte past the end of the destination buffer.

The same contract problem exists for the NLS path when a converted character consumes the last available byte.

Reserve one byte for the terminator before doing either conversion. The function continues to return the number of converted bytes, excluding the NUL terminator.

Assisted-by Codex:gpt-5.5
---
  fs/ntfs3/dir.c | 5 +++++
  1 file changed, 5 insertions(+)
fs/ntfs3/dir.c +5 -1
index d99ab086ef6f..e8892cd94e04 100644
@@ -25,6 +25,11 @@ int ntfs_utf16_to_nls(struct ntfs_sb_info *sbi, const __le16 *name, u32 len,
 
         static_assert(sizeof(wchar_t) == sizeof(__le16));
 
+       if (buf_len <= 0)
+               return -EINVAL;
+
+       buf_len -= 1;
+
         if (!nls) {
                 /* UTF-16 -> UTF-8 */
                 ret = utf16s_to_utf8s((wchar_t *)name, len, UTF16_LITTLE_ENDIAN,
--
Quoted 2 lines

2.43.0

Hello,

Sorry for the delay.
Your patch was applied, thank you.

Regards,
Konstantin