security: harden KPTI and close residual gaps

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: minto-dane

SECURITY_REVIEW.md

@@ -238,7 +238,7 @@ Mailbox は thread slot 単位。宛先 thread id 検証を行い、受信時に
 ### 6.3 wait/reap
 
 `wait` は parent-child 関係を前提に zombie を回収し、`WNOHANG` を実装。  
-フェイルセーフとして 30秒 timeout が入る（POSIX完全互換ではない）。
+ブロッキング待機時は無期限で待機し、回収時に子プロセスの user page table を破棄して frame 解放へ接続する。
 
 ---
 
@@ -255,37 +255,31 @@ Mailbox は thread slot 単位。宛先 thread id 検証を行い、受信時に
 - ELF 境界チェック強化
 - user stack NX + guard
 - FD owner 分離
+- SYSCALL stack pointer の per-CPU GS 化（SMP時の cross-core stack 汚染対策）
+- zombie 回収時の child page table 自動破棄
+- `RtSigaction` / `RtSigprocmask` の `ENOSYS` 明示化
+- カーネルスタック guard の未マップ化（fault-before-corruption）
+- IPC 宛先スロット世代検証（再利用スロット誤配送対策）
+- `wait` の無期限待機化（`WNOHANG` 以外）
 
 ### 7.2 残余リスク / 既知ギャップ
 
-| ID | 重大度 | 内容 | 根拠 |
+| ID | 状態 | 修正内容 | 根拠 |
 |---|---|---|---|
-| R-01 | High (SMP時) / Low (現単一CPU想定) | `SYSCALL_KERNEL_RSP` がグローバルで、per-CPU state が syscall ASM で未活用。SMP有効時に cross-core stack 汚染リスク。 | `syscall/syscall_entry.rs`, `percpu.rs` |
-| R-02 | High (可用性) | zombie 回収時に page table / user frame 解放が自動連動せず、長時間運用でメモリリークにより OOM 化しうる。 | `task/process.rs::reap_zombie_child_process` と `paging::destroy_user_page_table` の非接続 |
-| R-03 | Medium | `RtSigaction`/`RtSigprocmask` が SUCCESS スタブ。アプリは「設定できた」と誤認し得る。 | `syscall/mod.rs::dispatch` |
-| R-04 | Medium | カーネルスタック guard は未マップ型ではなくパターン検知型。検知は可能だが事前遮断ではない。 | `task/thread.rs`, `task/context.rs` |
-| R-05 | Low | IPC送信先存在確認と enqueue が原子的でなく、孤立メッセージが残る可能性。 | `syscall/ipc.rs` 内コメント |
-| R-06 | Low | `wait` が 30秒 timeout を持つため POSIX の無期限待機と差異。 | `syscall/process.rs` |
+| R-01 | Closed | SYSCALL エントリのカーネルスタック取得を `gs:[offset]` に変更し、`IA32_KERNEL_GS_BASE` を per-CPU state に接続。 | `syscall/syscall_entry.rs`, `percpu.rs` |
+| R-02 | Closed | zombie 回収で child page table を `destroy_user_page_table` へ接続し、回収時に frame 解放。 | `task/process.rs`, `mem/paging.rs` |
+| R-03 | Closed | `RtSigaction`/`RtSigprocmask` を `SUCCESS` スタブから `ENOSYS` に変更。 | `syscall/mod.rs::dispatch` |
+| R-04 | Closed | カーネルスタック guard を未マップページ化し、コンテキスト切替時に guard 未マップを検証。 | `task/thread.rs`, `task/context.rs` |
+| R-05 | Closed | IPC メッセージへ宛先スロット世代を付与し、受信時一致検証で再利用スロット誤配送を遮断。 | `syscall/ipc.rs`, `task/thread.rs` |
+| R-06 | Closed | `wait` の 30秒 timeout を撤廃し、`WNOHANG` 以外は無期限待機へ変更。 | `syscall/process.rs` |
 
 ---
 
-## 8. 優先改善提案（実装順）
+## 8. 継続改善提案（運用品質）
 
-### P0（先行推奨）
-
-1. `wait/reap` で child の page table 破棄 (`destroy_user_page_table`) を接続  
-2. SYSCALL stack pointer を GS/per-CPU 経由へ完全移行（グローバル `SYSCALL_KERNEL_RSP` 脱却）  
-3. signal syscall を `ENOSYS` 明示または最小実装へ変更（偽SUCCESSを避ける）
-
-### P1
-
-4. カーネルスタックを未マップ guard page 化（検知型 -> fault-before-corruption）  
-5. IPC 宛先検証と enqueue の原子化（スロット世代番号など）
-
-### P2
-
-6. KPTI の共有範囲さらに最小化  
-7. 追加動的検証（fuzz, stress, long-run leak test）
+1. KPTI の共有マッピング範囲を実測に基づいてさらに縮小（機能維持を確認しながら段階適用）  
+2. syscall / IPC / wait-reap のストレス試験を継続運用に組み込む  
+3. SMP 構成での per-CPU GS 初期化と SYSCALL 経路の長時間回帰試験を追加
 
 ---
 

src/core/init/mod.rs

@@ -57,15 +57,5 @@ pub fn kinit(boot_info: &'static BootInfo) -> Result<&'static [MemoryRegion]> {
     // SYSCALL/SYSRET 命令サポートを初期化
     crate::syscall::syscall_entry::init_syscall();
 
-    // Set IA32_KERNEL_GS_BASE to kernel per-cpu base (placeholder: SYSCALL_KERNEL_STACK)
-    unsafe {
-        let kgs_base =
-            core::ptr::addr_of!(crate::syscall::syscall_entry::SYSCALL_KERNEL_STACK) as u64;
-        let lo = kgs_base as u32;
-        let hi = (kgs_base >> 32) as u32;
-        core::arch::asm!("wrmsr", in("ecx") 0xC000_0102u32, in("eax") lo, in("edx") hi, options(nomem, nostack));
-        crate::info!("IA32_KERNEL_GS_BASE set to {:#x}", kgs_base);
-    }
-
     Ok(memory_map)
 }

src/core/percpu.rs

@@ -7,6 +7,8 @@ use core::sync::atomic::{AtomicU64, Ordering};
 use x86_64::registers::control::Cr3;
 
 const MAX_CPUS: usize = 64;
+const IA32_KERNEL_GS_BASE: u32 = 0xC000_0102;
+pub const GS_SYSCALL_KERNEL_RSP_OFFSET: usize = 8;
 
 #[repr(C)]
 struct PerCpuState {
@@ -32,6 +34,19 @@ fn state_for_current_cpu() -> &'static PerCpuState {
     &CPU_STATES[current_cpu_id()]
 }
 
+#[inline]
+unsafe fn write_kernel_gs_base(base: u64) {
+    let lo = base as u32;
+    let hi = (base >> 32) as u32;
+    asm!(
+        "wrmsr",
+        in("ecx") IA32_KERNEL_GS_BASE,
+        in("eax") lo,
+        in("edx") hi,
+        options(nomem, nostack)
+    );
+}
+
 #[inline]
 pub fn current_cpu_id() -> usize {
     (local_apic_id() as usize) % MAX_CPUS
@@ -66,6 +81,14 @@ pub fn init_boot_cpu(syscall_kernel_rsp: u64) {
         .syscall_kernel_rsp
         .store(syscall_kernel_rsp, Ordering::SeqCst);
     state.current_thread_id.store(0, Ordering::SeqCst);
+    install_current_cpu_gs_base();
+}
+
+pub fn install_current_cpu_gs_base() {
+    let state = state_for_current_cpu() as *const PerCpuState as u64;
+    unsafe {
+        write_kernel_gs_base(state);
+    }
 }
 
 pub fn kernel_cr3() -> u64 {

src/core/syscall/ipc.rs

@@ -10,6 +10,8 @@ const MAX_MSG_SIZE: usize = 256;
 pub struct Message {
     from: u64,
     to: u64,
+    to_slot: u16,
+    to_generation: u64,
     len: usize,
     data: [u8; MAX_MSG_SIZE],
 }
@@ -19,6 +21,8 @@ impl Message {
         Self {
             from: 0,
             to: 0,
+            to_slot: 0,
+            to_generation: 0,
             len: 0,
             data: [0; MAX_MSG_SIZE],
         }
@@ -88,19 +92,20 @@ pub fn send(dest_thread_id: u64, buf_ptr: u64, len: u64) -> u64 {
         None => return EINVAL,
     };
 
-    let idx = match crate::task::thread_slot_index_by_u64(dest_thread_id) {
-        Some(i) => i,
-        None => return EINVAL,
-    };
+    let (idx, dest_generation) =
+        match crate::task::thread_slot_index_and_generation_by_u64(dest_thread_id) {
+            Some(v) => v,
+            None => return EINVAL,
+        };
 
-    if !crate::task::thread_id_exists(dest_thread_id) {
+    if idx >= MAX_THREADS || idx > (u16::MAX as usize) {
         return EINVAL;
     }
 
-    // 送信先スレッドが実際に存在するか確認 (#14: ゴーストメッセージ注入防止)
-    // NOTE: このチェックと後続の mailbox enqueue は別ロックであり原子的ではない。
-    // したがって、チェック後に送信先が終了すると孤立メッセージが残る可能性はある。
-    // メッセージに `to` を保持し、受信側で宛先一致を確認することで誤配送を防ぐ。
+    // NOTE:
+    // - 宛先スロットに加えて世代番号をメッセージへ埋め込む。
+    // - これにより、送信先終了後に同一スロットへ別スレッドが再利用されても誤配送されない。
+    // - 送信時点と受信時点で世代不一致なら古いメッセージとして破棄される。
 
     // データをユーザー空間からコピー
     let mut data = [0u8; MAX_MSG_SIZE];
@@ -118,6 +123,8 @@ pub fn send(dest_thread_id: u64, buf_ptr: u64, len: u64) -> u64 {
     let msg = Message {
         from: sender,
         to: dest_thread_id,
+        to_slot: idx as u16,
+        to_generation: dest_generation,
         len,
         data,
     };
@@ -140,15 +147,26 @@ pub fn recv(buf_ptr: u64, max_len: u64) -> u64 {
         None => return EINVAL,
     };
 
-    let idx = match crate::task::thread_slot_index_by_u64(receiver) {
-        Some(i) => i,
-        None => return EINVAL,
-    };
+    let (idx, receiver_generation) =
+        match crate::task::thread_slot_index_and_generation_by_u64(receiver) {
+            Some(v) => v,
+            None => return EINVAL,
+        };
+
+    if idx >= MAX_THREADS || idx > (u16::MAX as usize) {
+        return EINVAL;
+    }
 
     let mut boxes = MAILBOXES.lock();
     let msg = loop {
         match boxes[idx].pop() {
-            Some(msg) if msg.to == receiver => break msg,
+            Some(msg)
+                if msg.to == receiver
+                    && msg.to_slot == idx as u16
+                    && msg.to_generation == receiver_generation =>
+            {
+                break msg
+            }
             Some(_) => continue, // 既に終了した別スレッド宛の古いメッセージを破棄
             None => return EAGAIN,
         }

src/core/syscall/mod.rs

@@ -138,8 +138,8 @@ pub fn dispatch(num: u64, arg0: u64, arg1: u64, arg2: u64, arg3: u64, arg4: u64)
         x if x == SyscallNumber::Mmap as u64 => process::mmap(arg0, arg1, arg2, arg3, arg4),
         x if x == SyscallNumber::Munmap as u64 => process::munmap(arg0, arg1),
         x if x == SyscallNumber::Brk as u64 => process::brk(arg0),
-        x if x == SyscallNumber::RtSigaction as u64 => SUCCESS, // スタブ
-        x if x == SyscallNumber::RtSigprocmask as u64 => SUCCESS, // スタブ
+        x if x == SyscallNumber::RtSigaction as u64 => ENOSYS,
+        x if x == SyscallNumber::RtSigprocmask as u64 => ENOSYS,
         x if x == SyscallNumber::GetPid as u64 => process::getpid(),
         x if x == SyscallNumber::Clone as u64 => process::fork(),
         x if x == SyscallNumber::Fork as u64 => process::fork(),
@@ -307,15 +307,15 @@ extern "C" fn syscall_handler_rust(
     arg4: u64,
 ) -> u64 {
     let current_tid = crate::task::current_thread_id();
+    let prev_cr3 = syscall_entry::switch_to_kernel_page_table();
     if let Some(tid) = current_tid {
         crate::task::with_thread_mut(tid, |t| t.set_in_syscall(true));
     }
-    let prev_cr3 = syscall_entry::switch_to_kernel_page_table();
     let ret = dispatch(num, arg0, arg1, arg2, arg3, arg4);
-    syscall_entry::restore_page_table(prev_cr3);
     if let Some(tid) = current_tid {
         crate::task::with_thread_mut(tid, |t| t.set_in_syscall(false));
     }
+    syscall_entry::restore_page_table(prev_cr3);
     ret
 }
 

src/core/syscall/process.rs

@@ -12,8 +12,6 @@ const ECHILD: u64 = (-10i64) as u64;
 const ETIMEDOUT: u64 = (-110i64) as u64;
 /// PIT割り込み周期 (10ms)
 const TICK_MS: u64 = 10;
-/// wait のフェイルセーフ上限 (30秒)
-const WAIT_TIMEOUT_TICKS: u64 = 30_000 / TICK_MS;
 use crate::task::{current_thread_id, exit_current_task};
 
 #[derive(Clone, Copy)]
@@ -391,11 +389,6 @@ pub fn wait(_pid: u64, status_ptr: u64, options: u64) -> u64 {
     };
 
     // POSIX互換の待機: ゾンビを回収、存在しなければブロックまたはWNOHANGで0
-    let wait_deadline = if options & WNOHANG == 0 {
-        Some(crate::syscall::time::get_ticks().saturating_add(WAIT_TIMEOUT_TICKS))
-    } else {
-        None
-    };
     loop {
         if let Some((reaped_pid, exit_code)) =
             crate::task::reap_zombie_child_process(current_pid, target_pid)
@@ -417,10 +410,6 @@ pub fn wait(_pid: u64, status_ptr: u64, options: u64) -> u64 {
             return 0;
         }
 
-        if wait_deadline.is_some_and(|deadline| crate::syscall::time::get_ticks() >= deadline) {
-            return ETIMEDOUT;
-        }
-
         crate::task::yield_now();
     }
 }

src/core/syscall/syscall_entry.rs

@@ -10,19 +10,6 @@
 //!   R11 = ユーザーの RFLAGS (SYSCALL が自動保存)
 //!   RSP = まだユーザースタック
 
-use core::sync::atomic::{AtomicU64, Ordering};
-
-/// 現在のスレッドのカーネルスタックトップ (SYSCALL 時に切り替える)
-/// コンテキストスイッチ時に更新される
-pub static SYSCALL_KERNEL_RSP: AtomicU64 = AtomicU64::new(0);
-
-/// SYSCALL 用カーネルスタック (初回スイッチまたはスレッド切り替え前に使用)
-#[repr(align(16))]
-pub struct SyscallStack([u8; 4096 * 8]);
-
-/// SYSCALL 用カーネルスタックの実体
-pub static mut SYSCALL_KERNEL_STACK: SyscallStack = SyscallStack([0; 4096 * 8]);
-
 /// SYSCALL/SYSRET に必要な MSR を初期化する
 ///
 /// カーネル GDT 構成 (x86_64-unknown-uefi / MS ABI):
@@ -68,13 +55,11 @@ pub fn init_syscall() {
         write_msr(IA32_FMASK, fmask_val);
     }
 
-    // 初期カーネルスタックを設定
-    let kstack_top = unsafe {
-        let base = core::ptr::addr_of!(SYSCALL_KERNEL_STACK) as u64;
-        base + 4096 * 8
-    };
-
-    SYSCALL_KERNEL_RSP.store(kstack_top, Ordering::SeqCst);
+    // 初期カーネルスタックは現在のRSPを使用し、後続のコンテキストスイッチで更新する
+    let kstack_top: u64;
+    unsafe {
+        core::arch::asm!("mov {}, rsp", out(reg) kstack_top, options(nomem, nostack, preserves_flags));
+    }
     crate::percpu::init_boot_cpu(kstack_top);
 
     crate::info!("SYSCALL/SYSRET initialized: LSTAR={:#x}", lstar_val);
@@ -83,7 +68,6 @@ pub fn init_syscall() {
 /// SYSCALL カーネルスタックを更新する (コンテキストスイッチ時に呼ぶ)
 pub fn update_kernel_rsp(rsp: u64) {
     // SeqCst を使用してメモリ順序を保証する (MED-05)
-    SYSCALL_KERNEL_RSP.store(rsp, Ordering::SeqCst);
     crate::percpu::set_syscall_kernel_rsp(rsp);
 }
 
@@ -179,7 +163,7 @@ pub unsafe extern "C" fn syscall_entry() {
         "or rdx, rax",
 
         // カーネルスタックに切り替え
-        "mov rsp, [{kernel_rsp}]",
+        "mov rsp, qword ptr gs:[{sys_rsp_off}]",
         // ユーザーFSベースを保存
         "push rdx",
 
@@ -292,10 +276,10 @@ pub unsafe extern "C" fn syscall_entry() {
 
         // 非正規RSP検出: カーネルスタックに戻してプロセスを終了
         "2:",
-        "mov rsp, [{kernel_rsp}]",
+        "mov rsp, qword ptr gs:[{sys_rsp_off}]",
         "call {kill_fn}",
 
-        kernel_rsp = sym SYSCALL_KERNEL_RSP,
+        sys_rsp_off = const crate::percpu::GS_SYSCALL_KERNEL_RSP_OFFSET,
         save_ctx_fn = sym super::save_user_context_for_fork,
         dispatch   = sym super::syscall_dispatch_sysv,
         kill_fn    = sym kill_non_canonical_rsp,

src/core/task/mod.rs

@@ -24,6 +24,7 @@ pub use scheduler::{
 pub use thread::{
     add_thread, count_threads_by_state, current_thread_id, for_each_thread, peek_next_thread,
     remove_thread, set_current_thread, thread_count, thread_id_exists, thread_slot_index,
+    thread_slot_index_and_generation, thread_slot_index_and_generation_by_u64,
     thread_slot_index_by_u64, with_thread, with_thread_mut, Thread, ThreadQueue,
 };
 pub use usermode::{jump_to_usermode, jump_to_usermode_fork_child};