HN 日本語サマリー

← 一覧へ戻る
プログラミング

Rust標準ライブラリにおけるメモリ安全性バグ

Memory Safety Bugs in Rust Standard Library (forge-blog.github.io)

161 pointsby pjmlp134 コメント

要約

MicrosoftのFORGE Labは、Rustの標準ライブラリ(stdおよびcore)において、安全なRustコードからでも未定義動作を引き起こしうるメモリ安全性に関する複数の問題を発見しました。これらのバグは、コードがパニックしないこと、ユーザー提供の実装が正しいこと、基盤となるシステムを信頼するという3つのパターンに分類され、AIを活用したツールによって特定されました。

全文翻訳

Rust標準ライブラリにおけるメモリ安全性バグ

MicrosoftのFORGE Labは、Rustの標準ライブラリ(stdおよびcore)において、安全なRustコードのみで未定義動作を引き起こす可能性のあるメモリ安全性に関する複数の問題を発見しました。この調査は、AI搭載の脆弱性スキャンシステムであるFORGEの最先端研究バージョン、codename MDASHのHyenasを使用しました。発見された問題は、unsafeコードにおける信頼の置き所の誤りに起因する3つの繰り返しパターンを明らかにしています。それは、コードがパニックしないという信頼、ユーザー提供の実装が正しいという信頼、そして基盤となるシステムへの信頼です。

Rustの安全性保証は、まさにこれらの発見を興味深いものにしています。その豊富な型システムと所有権モデルは、多くのメモリ安全性問題を排除しますが、標準ライブラリの多くは、安全なAPIの下でunsafeコードに依存しています。そのunsafeコードが安全性契約を破ると、安全なRustでさえ、言語が防止するように設計されている動作に遭遇する可能性があります。

Rustのメモリ安全性保証は、この言語が日々数十億人もの人々が依存するソフトウェアの一部となるにつれて、ますます重要になっています。Rustベースのソフトウェアやオペレーティングシステムに毎日、しばしば知らず知らずのうちに、数十億人が関わっていると推定されています。MicrosoftはRustをC++、C#、TypeScriptと並ぶTier-1内部言語とし、GitHubはCopilotのエージェントランタイムをRustで書き直し、Bun、Android、Linuxカーネル、CloudflareなどもRustへ移行しています。これらのソフトウェアの多くは、Rustの基盤となるライブラリであるcoreとstd、およびそれらが提供するAPIの安全性保証に依存しています。これらのライブラリのバグは、発生源となったコードをはるかに超える影響を与える可能性があります。

Unsafe Rustは、私たちにとって長年の関心事です。私たちのチームには、2021年にRustエコシステム全体でメモリ安全性バグを探した静的アナライザーであるRudraの背後にいる人々がいます。また、私たちは多くのツールをRustで自作しているため、その安全性は単なる研究トピック以上のものです。今年、私たちは標準ライブラリをさらに詳しく調査し、今日でもそのunsafeコードにどのような種類のミスが残っているかを確認しました。

この記事では、Rustのissueトラッカーに報告したバグの一部を共有します。それらを用いて、Rustが何を保証し、何を保証しないのか、なぜ正しいunsafe Rustを書くことがそれほど難しいのか、そしてRustのメモリ安全性が完璧ではないとしても、なぜRustの安全性モデルが依然として重要なのかを議論します。

バグの発見と検証方法

Microsoft FORGE Labでは、Rust標準ライブラリを含む複雑なソフトウェアの脆弱性を研究しています。私たちのチームは、脆弱性研究における長年の経験と、コードの調査や従来の分析だけでは発見が難しいバグを見つけるのに役立つAI支援ツールを組み合わせています。

この記事のバグの一部は、研究用バージョンのcodename MDASHであるHyenasの助けを借りて発見されました。研究者は、基盤となるコードを調査し、バグを再現し、潜在的なセキュリティ影響を評価し、Rustのメンテナーと協力して報告・修正しました。

この記事では、標準ライブラリのunsafeコードにおける健全性(soundness)バグに焦点を当てます。コンパイラ自体のバグ、例えば誤コンパイルや型システムの穴などは、ここでは扱わない別のトピックです。

Rustの安全性バグのパターン

最も低いレベルでは、Rustは生のポインタを操作したり、オペレーティングシステムと直接やり取りしたりするためにunsafeブロックを使用します。VecやStringを含む標準ライブラリの多くは、安全なAPIでラップされた小さなunsafeの断片から構築されています。unsafeブロック内では、プログラマーはコンパイラがチェックできない保証の責任を負い、その責任はそれを囲む安全なAPIにまで及びます。そのAPIは健全(sound)でなければなりません。つまり、安全なコードがどのように使用しても、未定義動作を引き起こすことは不可能でなければなりません。

その約束を守ることは、見た目よりもはるかに困難です。バイトスライスとして見ることができる任意の型からidx番目のバイトを返す関数を考えてみましょう。この関数は、独自のチェックを行った後に冗長な境界チェックをスキップします。

pub fn get<S: AsRef<[u8]>>(s: &S, idx: usize) -> Option<u8> {
    if idx < s.as_ref().len() {
        // SAFETY: we just checked that `idx` is in bounds.
        Some(unsafe { *s.as_ref().get_unchecked(idx) })
    } else {
        None
    }
}

unsafe Rustの難しい点は、何を信頼できるかを知ることです。上記の関数は正しく見えますが、2回のas_ref呼び出しが同じスライスを返すことを前提としています。Sは呼び出し元によって選択されるため、安全なAsRef実装は、最初には長いスライスを返し、次に空のスライスを返す可能性があり、getは境界外を読み取ることになります。unsafeコードは、行うすべての呼び出しに注意する必要があります。そして、私たちが発見したバグは、信頼の置き所の誤りに起因する3つのパターンに分類されます。コードがパニックしないという信頼、ユーザー提供の実装が正しいという信頼、そして基盤となるシステムへの信頼です。

パターン1:コードがパニックしないという信頼

Unsafeコードは、しばしば一時的に不変条件を破り、その後それを復元します。例えば、初期化されていないバッファを割り当てて直接埋めることで、メモリをゼロにする冗長な書き込みを回避することがあります。これは関数が最後まで実行される限り問題ありません。しかし、Rustの多くの操作は、境界外インデックス指定からユーザー提供コードへの呼び出しまで、パニックする可能性があります。デフォルトでは、パニックはアンワインドします。つまり、デストラクタを実行しながら関数を早期に終了します。このウィンドウ内でのアンワインドは、それを信頼しているコードに壊れた不変条件をさらけ出す、目に見えない終了となります。この種のバグは、パニック安全性バグと呼ばれます。

[画像: フローダイアグラム:関数が不変条件を破り、パニックする可能性のあるコードを呼び出し、返す前に不変条件を復元する。呼び出しがパニックした場合、アンワインドは復元ステップをスキップし、壊れた状態のデストラクタを実行して未定義動作を引き起こす。]

MapWindows::clone (#156501)

私たちはMapWindows::cloneにおけるパニック安全性問題を特定しました。Iterator::map_windows(nightly API)は、N個のアイテムの重複するウィンドウを生成します。現在のウィンドウをBuffer内に保持し、そのデストラクタはstartから始まるN個のアイテムをドロップします。Rust 1.97.0では、library/core/src/iter/adapters/map_windows.rsで次のように定義されています。

37struct Buffer<T, const N: usize> {
38    // Invariant: `self.buffer[self.start..self.start + N]` is initialized,
39    // with all other elements being uninitialized. This also
40    // implies that `self.start <= N`.
41    buffer: [[MaybeUninit<T>; N]; 2],
42    start: usize,
43}

同じファイルのBuffer::cloneは、新しいバッファを先に構築し、後から埋めました。

195impl<T: Clone, const N: usize> Clone for Buffer<T, N> {
196    fn clone(&self) -> Self {
197        let mut buffer = Buffer {
198            buffer: [[const { MaybeUninit::uninit() }; N], [const { MaybeUninit::uninit() }; N]],
199            start: self.start,
200        };
201        buffer.as_uninit_array_mut().write(self.as_array_ref().clone());
202        buffer
203    }
204}

197行目の後、bufferはその不変条件を破ります。そのスロットは初期化されていませんが、デストラクタは既に準備されています。201行目のclone()呼び出しは、スロットが書き込まれる前にユーザーのT::cloneを実行します。もしそれがパニックした場合、アンワインドはbufferをドロップし、N個の未初期化値に対してdrop_in_placeを実行します。私たちの概念実証は安全なコードのみを使用します。cloneが常にパニックする要素型を使用すると、デストラクタが未初期化メモリにアクセスしたときにクラッシュが発生します。修正では、新しいバッファを完全に書き込むまでManuallyDropで保持するため、アンワインドは構築途中のバッファをドロップする代わりにリークさせます。

一般的な教訓は、clone、drop、比較、クロージャ、イテレータメソッドなど、自分で制御できないコードへのすべての呼び出しを、早期終了の可能性として扱うことです。パニックする可能性のある作業を不変条件を破る前に行うか、アンワインドしても安全な状態にするかのいずれかです。それをManuallyDropで保持するか、デストラクタが不変条件を復元するガード(Vecの内部のSetLenOnDropなど)を使用します。Rustonomiconでは、これを例外安全性でカバーしています。

アロケータはパニックしてはならない

最近安定化されたAllocator APIは、パニック安全性を正しく実装するのがいかに難しいかを示しています。stdでは、デフォルトでアロケーション失敗はアンワインドせずにプロセスをアボートするため、標準ライブラリのunsafeコードの多くは、アロケーションが決してアンワインドしないと仮定しています。カスタムアロケータはこの仮定を破る可能性があります。APIが安定化される間、私たちはBTreeMap::insertの1箇所がアロケータがアンワインドすると不正になることを報告し、他の人もさらに報告しました(#159334、#159368、#159370)。それらを一つずつ修正することは、すべてのアロケーションを監査することを意味するため、安定化(11月12日にRust 1.100でリリース)では、代わりに実装者にトレイトのメソッドやdropからアンワインドしないことを要求しています。提案では、「多くのアロケーション関連メソッドからのアンワインドは、不健全性の広範な原因であることが判明した」と述べています。

パターン2:ユーザー提供の実装が正しいという信頼

Unsafeコードはしばしば、呼び出し元が提供するコード(比較関数、トレイト実装、クロージャ)を呼び出します。そのコードは安全ですが、安全だからといって正しいとは限りません。不整合な、あるいは明らかに間違った結果を返す可能性があります。問題は、それが起こったときに誰が責任を負うかです。C++では、それは呼び出し元です。std::sortは、その比較関数が厳密な弱順序(strict weak ordering)であることを要求し、その規則を破ることは未定義動作です。libstdc++では、等しい要素を<=でソートすると、ベクタの末尾を超えて読み取ります。

std::vector<int> v(100, 42);
// Bug: `<=` は厳密な弱順序ではない。なぜなら cmp(a, a) が true になるから。
std::sort(v.begin(), v.end(), [](int a, int b) { return a <= b; });
// AddressSanitizer: heap-buffer-overflow in std::__introsort_loop

Rustのsort_byに渡された同じ比較関数は、単なる論理エラーです。ソートはパニックする可能性や、スライスを未定義の順序で残す可能性がありますが、未定義動作を引き起こすことはありません。責任はunsafeコードにあります。比較関数は呼び出し元によって提供される安全なコードなので、内部のunsafeコードは、それが何を返しても健全でなければなりません。これは、ユーザーが実装できるすべての安全なトレイトについても同様です。比較は不整合になる可能性があり、ExactSizeIteratorはyieldするアイテムと一致しない長さを報告する可能性があり、Borrowは呼び出しごとに異なる値を返す可能性があります。

str::replaceとカスタムPattern (#156491)

私たちの別のバグ報告は、この信頼をいかに簡単に逃してしまうかを示しています。str::replaceでカスタムPatternを使用すると、UTF-8でないStringが生成される可能性があります。文字列検索APIは、nightlyのPatternトレイトを実装する任意の型を受け入れ、パターンはそのas_utf8_patternを通じて自身を記述できます。str::replaceはその記述を使用して、ASCIIバイトを別のものに置き換える際に高速パスを取ります。Rust 1.96.0では、library/alloc/src/str.rsの高速パスは次のようでした。

268pub fn replace<P: Pattern>(&self, from: P, to: &str) -> String {
269    // Fast path for replacing a single ASCII character with another.
270    if let Some(from_byte) = match from.as_utf8_pattern() {
271        Some(Utf8Pattern::StringPattern([from_byte])) => Some(*from_byte),
272        Some(Utf8Pattern::CharPattern(c)) => c.as_ascii().map(|ascii_char| ascii_char.to_u8()),
273        _ => None,
274    } {
275        if let [to_byte] = to.as_bytes() {
276            return unsafe { replace_ascii(self.as_bytes(), from_byte, *to_byte) };
277        }
278    }

同じファイルのreplace_asciiは、バイトを書き換えます。

708unsafe fn replace_ascii(utf8_bytes: &[u8], from: u8, to: u8) -> String {
709    let result: Vec<u8> = utf8_bytes.iter().map(|b| if *b == from { to } else { *b }).collect();
710    // SAFETY: We replaced ascii with ascii on valid utf8 strings.
711    unsafe { String::from_utf8_unchecked(result) }
712}

272行目のCharPatternブランチは文字がASCIIであることをチェックしますが、271行目のStringPatternブランチは1バイトの文字列パターンがASCIIであると仮定します。これは&strパターンでは成り立ちますが、StringPatternは&[u8]を格納しており、as_utf8_patternは任意のPatternが実装できる安全なメソッドです。私たちの概念実証では、カスタムパターンが単一バイト0x80を報告します。これはマルチバイトUTF-8シーケンス内にのみ現れます。

impl Pattern for NonAsciiBytePattern {
    // ...
    fn as_utf8_pattern(&self) -> Option<Utf8Pattern<'_>> {
        static NEEDLE: [u8; 1] = [0x80];
        Some(Utf8Pattern::StringPattern(&NEEDLE))
    }
}

// "\u{d000}" は [ed, 80, 80] です。結果は [ed, 3f, 3f] となり、UTF-8ではありません。
let corrupted = "\u{d000}".replace(NonAsciiBytePattern, "?");

str::replaceは継続バイトを書き換え、有効なUTF-8ではないStringを返します。その後、UTF-8に依存する文字列操作は未定義動作に達します。修正はStringPatternが&[u8]ではなく&strを格納するように変更したため、型自体がUTF-8を保証するようになりました。

unsafeコードがユーザー提供の実装のプロパティに依存する場合、それを鵜呑みにしないでください。実装を一度呼び出して結果を保持するか、返されたものを検証するか、あるいは安全なコードが偽造できない型にプロパティをエンコードします(この修正のように)。それらがどれもうまくいかない場合は、実装者がそれを明示的に約束するように、トレイトをunsafeにします。

その他の例

joinは、この種のバグを部分的にしか修正するのがいかに簡単かを示しています。2020年には、Borrow::borrowが呼び出しごとに同じ文字列を返すことを信頼していたと報告しました(CVE-2020-36323)。修正は、呼び出し間で縮小する文字列を処理しました。2026年4月には、同じ関数が別の修正を必要としました。joinは最初の要素を2回借用し、2回目の呼び出しで要素が増加すると、残りの長さの計算がアンダーフローしてヒープオーバーフローを引き起こします。以前の修正ではそのパスはカバーされていませんでした。

今年は、他の人もPattern APIで同様の問題を報告しました。安全なPatternは、異なる文字列用に構築された有効な検索器を返すことができ、strip_prefix_ofのようなコンシューマは、その範囲を元の文字列にチェックなしで適用し、境界外を読み取ります(#158265)。同じ問題がsplit_onceでも発生しました(#165076)。これは、str::splitが依存するSearcher契約が明確にされていないという報告の後でした(#164904)。これらのバグは両方ともまだオープンです。

パターン3:基盤となるシステムへの信頼

最初の2つのパターンはRustコード内に留まります。3番目のパターンはオペレーティングシステムとの境界に位置し、そこではunsafeコードがシグナルスタック、メモリマッピング、環境変数などのプロセス全体の状態を信頼しますが、これらは他のスレッド、Cライブラリ、またはカーネルがいつでも触れる可能性があります。これらのバグは自動的に見つけるのが困難でした。なぜなら、静的アナライザーは、その周囲のすべての動作をモデル化する必要があるからです。AIエージェントはこの状況を変えます。それらは、コードが実行される環境について十分な知識を持っているため、この領域の検索を実用的なものにします。私たちはその調査を開始し、いくつかの興味深いバグを発見しました。

process::exitとメインスレッドのシグナルスタック (#161018)

スレッドがスタックをオーバーフローすると、Rustは明確なメッセージを表示し、単純なセグメンテーションフォルトでクラッシュする代わりにアボートします。

thread 'main' (3307186) has overflowed its stack
fatal runtime error: stack overflow, aborting

これは、プロセス全体の状態のいくつかの部分に依存しています。各スレッドのスタックはガードページで終わります。これはスタックの制限のすぐ下にあるアクセス不可能な領域です。pthreadは、生成されたすべてのスレッドに対して1つを予約し、Linuxではカーネル自身のスタックガードがメインスレッドの役割を果たします。それに触れるとSIGSEGVが発生し、Rustはそのシグナルに対するハンドラを登録します。ハンドラはそのオーバーフローしたスタック上で実行できないため、Rustは各スレッドに代替シグナルスタックも提供します。これは、独自のガードページを持つ小さな別のマッピングであり、カーネルがシグナルを配信するときに切り替わります。ハンドラは、フォルトが発生したアドレスがガードページ内にあることをチェックし、メッセージを表示してアボートします。

[画像: 図:メモリの1つの列。メインスレッドのスタックフレームは下に向かって成長し、次のフレームが下のガードページに着地すると、アクセスできなくなる。そのアクセスがSIGSEGVを発生させ、Rustが登録したシグナルハンドラが呼び出される。ハンドラは、さらに下にある別の読み書き可能なマッピングである代替シグナルスタック上で、独自のガードページとともに実行される。バグでは、子スレッドのprocess::exitが、それがまだ登録されている間にメインスレッドの代替スタックをアンマップする。]

私たちは、子スレッドからprocess::exitを呼び出すと、メインスレッドが実行中である間にメインスレッドの代替スタックが破壊されることを発見しました(https://github.com/rust-lang/rust/issues/161018)。process::exitはlibcのexitを呼び出す前にランタイムのクリーンアップを実行し、Rust 1.98.0ではそのクリーンアップはlibrary/std/src/sys/pal/unix/stack_overflow.rsで終わります。

196pub unsafe fn cleanup() {
197    if cfg!(panic = "immediate-abort") {
198        return;
199    }
200    // FIXME: I probably cause more bugs than I'm worth!
201    // see https://github.com/rust-lang/rust/issues/111272
202    unsafe { drop_handler(MAIN_ALTSTACK.load(Ordering::Relaxed)) };
203}

202行目は、メインスレッドの代替スタックであるMAIN_ALTSTACKをdrop_handlerに渡します。

297// SAFETY: we warned the caller this disables the alternate signal stack!
298unsafe { sigaltstack(&disabling_stack, ptr::null_mut()) };
299// SAFETY: We know from `get_stackp` that the alternate stack we installed is part of
300// a mapping that started one page earlier, so walk back a page and unmap from there.
301unsafe { munmap(data.sub(page_size), sigstack_size + page_size) };

298行目は呼び出し元のスレッドの代替スタックを無効にしますが、301行目はメインスレッドのスタックをアンマップします。このコードは、子スレッドがprocess::exitを呼び出している場合には真ではない、メインスレッドで実行されていると仮定しています。メインスレッドは、libcのexitが終了するまで実行を続けますが、そのシグナルスタック登録はアンマップされたメモリを指したままです。このウィンドウ内でスタックをオーバーフローさせると、カーネルはシグナルを配信できず、私たちの概念実証はRustのメッセージではなく、単純なセグメンテーションフォルトで終了します。このバグは2015年に遡り、修正はメインスレッドの代替スタックのクリーンアップを完全に停止します。

これがセキュリティ問題になる可能性も調査しました。理論的には、コード実行につながる可能性があります。書き込み可能なマッピングが古い代替スタックのアドレスに配置された場合、カーネルはその上でメインスレッドの次のシグナルを配信し、別のスレッドが実行中にハンドラのフレーム(リターンアドレスなど)を上書きする可能性があります。実際には、条件は非常に厳しいです。すべてがlibcのexitが終了するまでの短いウィンドウ内で発生し、新しいマッピングはそのアドレスを再利用するために正確に正しいサイズを持つ必要があり、フレームの上書きには短いハンドラ内での2番目のレースが必要です。問題#161018については、私たちのテストでは調査された条件下で信頼性の高い悪用パスは見つからず、実用的な悪用の可能性は低いと評価しました。この評価は、議論された他の問題に自動的に適用されるわけではありません。問題には、セキュリティ影響分析の詳細が含まれています。

CommandExt::execとグローバル環境 (#156951)

私たちのもう一つの報告は、プロセス環境に関係しています。Unixでは、CommandExt::execは現在のプロセスを新しいプログラムに置き換えます。コマンドが独自の環境変数を持つ場合、execはプロセスグローバルのenvironを新しい配列に向け、execvpを呼び出し、execvpが失敗した場合はenvironを復元します。Rust 1.99.0では、Command::execはlibrary/std/src/sys/process/unix/unix.rsで環境ロックを取得します。

242let _lock = sys::env::env_read_lock();
243
244let Err(e) = self.do_exec(theirs, envp.as_ref());

同じファイルのCommand::do_execは、環境をスワップします。

409    _reset = Some(Reset(*sys::env::environ()));
410    *sys::env::environ() = envp.as_ptr();
411}
412
413libc::execvp(self.get_program_cstr().as_ptr(), self.get_argv().as_ptr());
414Err(io::Error::last_os_error())

242行目は環境の読み取り側ロックのみを取得しますが、410行目はプロセスグローバルのenvironを書き込みます。409行目は、execvpが413行目で失敗した場合に復元できるように、古い値を保存します。読み取りロック下でenvironを書き込むと、他のスレッドが入り込む可能性があります。env::varを呼び出すスレッドは同じ読み取りロックを取得し、新しいプログラム専用の変数を参照する可能性があります。また、2回の失敗したexec呼び出しが競合すると、environは後続のenv::vars_os()が読み取る解放済みの配列を指したままになる可能性があります。両方の概念実証は安全なRustのみを使用します。2018年の修正はここで排他ロックを保持していましたが、2021年に環境ロックが読み書きロックになった際、execは読み取り側を保持し続けました。execveを直接呼び出すことでenvironに触れないようにする修正がレビュー中です。

環境は以前にも問題を引き起こしています。2015年に始まった議論の後、2024年版ではenv::set_varがunsafeとマークされました。なぜなら、ほとんどのUnixプラットフォーム上のC関数は、Rustのロックを経由せずに環境を読み取るからです。

process::exitとスレッドローカルデストラクタ (#164243)

この境界を正しく設定するのは難しく、まだ多くの問題が未解決です。この領域を調査中に、私たちは独立して、process::exitがスレッドローカルデストラクタを通じて引き起こす可能性のある安全なコードでの二重解放に遭遇しました。これは他の誰かによって報告されましたが(#164243)、ここに言及する価値があります。libcのexitは、C++の要件として、まず呼び出しスレッドのスレッドローカルデストラクタを実行し、Rustも同様の方法でデストラクタを登録します。デストラクタがスレッドローカルの置き換え中にprocess::exitを呼び出すと、libcはそのスレッドローカルを2回ドロップします。提案された修正は、process::exitをPOSIX _exitに切り替えます。これはこれらのハンドラを実行せずにプロセスを終了します。

結論

すべてのunsafeブロックは、周囲のコードに関する仮定の上に成り立っています。この記事のバグは、信頼の置き所の誤りに起因する3つの種類から生じました。

  • コードが間違った瞬間にパニックしないこと。
  • 呼び出し元が提供した実装が正しく動作すること。
  • RustがオペレーティングシステムやCライブラリと共有するプロセス全体の状態が、コードが期待する通りであること。
よくあるパターンは依然として難しい(パターン1と2)

最初の2つのパターンはよく研究されています。Rudraは2021年に両方を調査し、標準ライブラリはすでに2015年にパニック安全性バグを修正していました(CVE-2015-20001)。これらのバグは、unsafeコード内のどの呼び出しもアンワインドしたり、呼び出し元が提供したコードを実行したりする可能性があるため、回避するのが依然として困難です。

今年私たちが目にしたことは混在していました。肯定的な側面としては、nightlyプロセスは機能しています。影響を受けるAPIがまだ不安定な間に多くの報告が捕捉され、いくつかのものは安定化前に設計を変更することで修正されました。StringPatternは現在 &strを&[u8]の代わりに格納し、Allocatorは実装者がアンワインドしないというルールで安定化されました。同時に、これらのパターンにおけるバグは依然として安定リリースに到達し、その修正は必ずしも完全ではありません。joinは2020年に修正され、最初の修正が見逃したパスのために別の修正を必要としました(2026年)。

システム境界バグが手の届く範囲に(パターン3)

3番目のパターンは異なります。そのバグは、Rustがそれ以下のレイヤー(カーネル、sigaltstackやmunmapなどのシステムコール経由、およびCライブラリ、environなどのプロセス全体の状態やlibcのexitが実行するクリーンアップ経由)と接する場所に存在します。それらを正しく設定するには、Rustの型システムの外にある知識が必要であり、これらのバグを従来の静的分析で見つけるのを困難にしてきました。それらが長持ちする理由もそれかもしれません。process::exitのシグナルスタックバグは、標準ライブラリにほぼ11年間存在し、execは2021年から読み取りロック下でenvironを書き込んでいます。最初の2つのパターンでの私たちの報告とは異なり、両方とも安定版Rustに影響します。

言語モデルは、これらのインターフェースがどのように動作するかについてすでに多くの知識を持っているため、エージェント型スキャナーは、言語だけでなく、コードが実行されるシステムに対してunsafeコードをチェックできます。私たちは、この境界がRustおよびそれ以外の分野におけるエージェント型セキュリティ研究にとって最も有望な場所の1つであると考えています。

Rustの高い基準は満たすのが難しいが、維持する価値がある

Rustは、CやC++よりも厳格な基準で安全なAPIを扱います。安全なコードは、APIをどのように使用しても、決して未定義動作を引き起こすことができません。C++では、std::sortの順序要件を破る比較関数は未定義動作を引き起こしますが、Rustのsortは任意のOrd実装でメモリ安全性を維持しなければなりません。POSIXは、他のスレッドが環境変数を読み取っている間にsetenvを呼び出すことが安全であることを保証しません。そのため、Rustのメモリ安全性バグは、他の言語のバグと1対1で比較するのが困難です。

同じ理由で、標準ライブラリの健全性バグが、それを使用するプログラムの脆弱性に自動的になるわけではありません。この記事の各バグは、パニックがちょうど間違った瞬間に発生する、意図的に誤動作する実装、または子スレッドからprocess::exitを呼び出すなど、トリガーするために異常なセットアップが必要です。それは、実際のプログラムがその方法でAPIに到達した場合にのみ、深刻な脆弱性になります。

Rustの安全性基準は厳格で満たすのが難しいですが、有用でもあります。それは健全性バグとは何かについて曖昧さのない答えを与えるため、問題はライブラリで一度修正・防止され、それを使用するすべてのプログラムで修正される必要がなくなります。Rustの安全性モデルは、システムプログラミングにおいて、制御、安全性、パフォーマンスの間の適切なバランスを取っており、多くのプロジェクトがそれを選ぶ理由です。

ラボを超えて

Microsoft FORGE Labでは、codename MDASHのような技術が、この記事のようなバグをより大規模に発見するのにどのように役立つかを研究しています。Rustの標準ライブラリは、このアプローチを適用しているいくつかの基盤となるオープンソースプロジェクトの1つです。

この研究はラボを超えて拡張されます。 それは、エージェント型脆弱性発見をMicrosoft Defenderに統合するcodename MDASHの開発に情報を提供します。これらの発見は、Microsoft Perception、私たちの新しいマルチエージェントセキュリティシステムにも入力として役立ちます。そこでは、専門のエージェントが広範なセキュリティワークフローで協力します。例えば、Web App Pen Test Agentは、codename MDASHの発見を利用して、テストの優先順位付け、ライブアプリケーションに対するエクスプロイト可能性の検証、および下流のエージェントが修正の優先順位付けとサポートに使用できる実行可能な脆弱性の生成を支援できます。これは、AIを活用したコード分析を実際のセキュリティ検証と対応に結び付け、セキュリティチームが潜在的な脆弱性の特定から実際の脅威の理解と対処へと移行するのを支援します。私たちの目標は、単により多くのバグを見つけることではなく、意味のある問題点を特定し、それらの発見を実行可能な研究に転換し、開発者や組織が依存する基盤となるソフトウェアの安全性を向上させることです。