ホーム / セキュアコーディング /

油断大敵！競合状態の対策を怠ると招く悲劇と今日からできるセキュアコーディング術

2025年4月29日火曜日

セキュアコーディング

競合状態の対策、ちゃんとできていますか？

この記事では、セキュアコーディングの基本でありながら見落としがちな競合状態について、その危険性と具体的な対策を初心者向けに徹底解説していきますよ。え、競合状態って何？と思った方も大丈夫。

基礎からしっかりお伝えします。この記事を読めば、あなたのコードがもっと安全になること間違いなし！

この記事で学べること

  • 競合状態がどんな問題なのか、その仕組みがわかります。
  • 競合状態を放っておくと、どんな怖いことが起きるか理解できます。
  • 明日から使える競合状態の対策テクニックを習得できます。
  • 対策するときの注意点や、よくある失敗を知ることができます。

そもそも競合状態とは？セキュアコーディングで無視できないその危険性

まずは基本から！競合状態って、いったい何者なんでしょうか？

簡単に言うと、複数の処理が、同じデータやファイル（共有リソースと呼びます）に同時にアクセスしようとして、予期せぬ問題を引き起こす状況のことです。

まるで、一本しかない電話を二人同時に取ろうとするようなイメージですね。どちらかがちゃんと話せない、あるいは混線してしまうかもしれません。

Webサービスやアプリでは、たくさんのユーザーが同時にアクセスしたり、裏側で色々な処理が並行して動いたりしています。そんな環境では、この競合状態が発生しやすくなるんです。セキュアコーディング、つまり安全なプログラムを作る上で、この競合状態への対策は避けて通れない課題と言えるでしょう。

競合状態が発生する仕組みを図解で理解

もう少し具体的に、競合状態がどうやって起きるのか見てみましょう。

例えば、あるWebサイトの商品の在庫数を管理するシステムを考えてみてください。在庫が残り1個の時に、ユーザーAさんとユーザーBさんがほぼ同時にその商品を購入しようとしたとします。

処理の流れ（理想的でない場合）

[ユーザーA]        [ユーザーB]        [システム（在庫数: 1）]
   |                  |                  |
1. 在庫確認(1個) ---->|                  |
   |                  |<---- 在庫確認(1個)
   |<---- OK          |                  |
   |                  |          OK ---->|
2. 在庫を減らす(1 -> 0)|                  |
   |                  |                  |
   |                  | 2. 在庫を減らす(1 -> 0) ※本当はもう0なのに！
   |------------------------------------->| 在庫を0に更新
   |                  |------------------>| 在庫を0に更新（結果は同じだが…）
   |                  |                  |
   | 購入完了！       |                  | 購入完了！
   |                  |                  |
[結果] 在庫は0になったが、商品は2人に売れてしまった！(問題発生)

上の図のように、ユーザーAさんが在庫を確認してから実際に在庫を減らすまでのわずかな間に、ユーザーBさんも在庫を確認してしまうと、システムは「まだ在庫がある」と勘違いしてしまいます。

結果として、在庫が1個しかないのに2人に売ってしまう、なんていうマズい状況が生まれるわけです。これが競合状態の一例です。

処理のタイミング次第で結果が変わってしまう、とても厄介な問題だと感じませんか？

放置すると危険！競合状態が引き起こす深刻なセキュリティリスク事例

競合状態を「まあ、たまにしか起きないだろう」なんて軽く考えていると、本当に痛い目を見ることがありますよ。

実際に、競合状態が悪用されて、次のような深刻な問題につながったケースがあるんです。

  • データの不整合や破壊
    さっきの在庫数の例のように、データがおかしくなってしまうことがあります。銀行システムで残高が狂ったりしたら…想像するだけで恐ろしいですね。
  • 不正な操作の許可
    例えば、ある操作を実行する権限があるかどうかをチェックしてから実行する、という流れがあったとします。チェックと実行の間に、悪意のあるユーザーが割り込んで権限を書き換える…なんてことが競合状態によって可能になるケースも。
  • サービス停止（DoS攻撃への悪用）
    競合状態が原因でシステムが異常な状態に陥り、処理が止まってしまうことがあります。意図的に競合状態を引き起こすことで、サービス全体をダウンさせる攻撃も考えられます。

たかがタイミングの問題、と侮ってはいけません。

セキュアコーディングの観点からも、競合状態はしっかり対策すべき脆弱性の一つなのです。

競合状態の具体的な対策方法を徹底解説

さて、競合状態の怖さがわかったところで、いよいよ本題の対策方法を見ていきましょう！

難しそう…と感じるかもしれませんが、大丈夫。基本的な考え方さえ押さえれば、初心者の方でも理解できますよ。

これから紹介するテクニックを身につけて、安全なコードを書くための武器を手に入れましょう。

競合状態対策の基本原則 同期制御の考え方

競合状態を防ぐための基本的な考え方が同期制御です。

これは、複数の処理が共有リソースにアクセスする際に、交通整理をしてあげるイメージです。「今は他の人が使っているから、ちょっと待ってね」「はい、あなたの番ですよ」という風に、アクセスする順番やタイミングをうまくコントロールしてあげるんです。

この同期制御の目的は、共有リソースが一度に一つの処理からしか変更されないように保証すること。

これにより、さっき見たような在庫数の例のような問題を防ぐことができるわけです。これから紹介する具体的な対策テクニックは、すべてこの同期制御の考え方に基づいています。

代表的な競合状態の対策1：排他制御（ロック）の実装

同期制御を実現するための最も代表的な方法が排他制御、通称ロックです。

これは、共有リソースを使う前に「鍵（ロック）」をかけ、使い終わったら「鍵を開ける（アンロック）」という仕組みです。鍵を持っている処理だけが共有リソースにアクセスでき、他の処理は鍵が開くまで待たされることになります。

例えば、Pythonで簡単なロックを使ってみましょう。（※スレッドを使った例です）

import threading
import time

# 共有リソース（例としてカウンター）
counter = 0
# ロックオブジェクトを作成
lock = threading.Lock()

def worker():
    global counter
    # ロックを取得しようとする（他のスレッドがロック中なら待つ）
    lock.acquire()
    print(f"{threading.current_thread().name}がロックを取得しました")
    try:
        # --- クリティカルセクション（共有リソースへのアクセス）---
        current_value = counter
        print(f"{threading.current_thread().name}がカウンター{current_value}を読み込み")
        time.sleep(0.1) # わざと少し待つ
        counter = current_value + 1
        print(f"{threading.current_thread().name}がカウンターを{counter}に更新")
        # --- クリティカルセクション終了 ---
    finally:
        # 必ずロックを解放する
        lock.release()
        print(f"{threading.current_thread().name}がロックを解放しました")

# 複数のスレッドを作成して実行
threads = []
for i in range(3):
    t = threading.Thread(target=worker, name=f"スレッド{i+1}")
    threads.append(t)
    t.start()

# すべてのスレッドが終了するのを待つ
for t in threads:
    t.join()

print(f"最終的なカウンターの値: {counter}") # 期待通り3になるはず

このコードでは、`threading.Lock()` でロックオブジェクトを作り、共有リソース `counter` にアクセスする前に `lock.acquire()` で鍵をかけ、処理が終わったら `finally` 節の中で必ず `lock.release()` で鍵を開けています。

`try...finally` を使うのは、処理中にエラーが発生しても必ずロックが解放されるようにするためです。ロックをかけ忘れたり、解放し忘れたりすると、別の問題を引き起こすので注意が必要ですよ。

代表的な競合状態の対策2：アトミック操作の活用

ロックは強力な対策ですが、場合によっては処理が少し遅くなることもあります。そんな時に検討したいのがアトミック操作です。

アトミック操作とは、処理の途中で他の処理に割り込まれることが絶対にない、一連の操作のことを言います。日本語だと「不可分操作」なんて言ったりもしますね。

「値を読み込んで、1増やして、書き込む」という一連の流れが、中断されることなく一瞬で完了するイメージです。

多くのプログラミング言語やCPUには、特定の操作をアトミックに行うための機能が備わっています。例えば、特定の条件を満たした場合にのみ値を更新する「Compare-and-Swap (CAS)」などが有名です。

Pythonでは、`threading`モジュールだけでは直接的なアトミック操作機能は限定的ですが、考え方として知っておくと良いでしょう。

ライブラリによってはアトミックな操作を提供するものもあります。ロックよりも細かい単位で制御できる場合があり、パフォーマンス面で有利になることもあります。

# Pythonでのアトミック操作の直接的な例は難しいですが、
# イメージとしては以下のような操作が「もしアトミックなら」競合しない、という感じです。

# 例：カウンターをアトミックにインクリメントする（ hypothetical_atomic_increment がアトミック操作だと仮定 ）
# counter = hypothetical_atomic_increment(counter)

# 実際のコードでは、言語やライブラリが提供するアトミックな型や関数を使います。
# 例：JavaのAtomicIntegerクラスのincrementAndGet()メソッドなど

ただし、すべてのアトミック操作が万能というわけではありません。複数のアトミック操作を組み合わせると、その全体がアトミックでなくなる可能性もあります。使いどころを見極めるのが肝心です。

代表的な競合状態の対策3：データベーストランザクションの活用

Webアプリケーションなどでよくあるのが、データベースへのアクセスに関する競合状態です。例えば、ユーザー登録時に「ユーザー名が既に使用されていないかチェック」してから「ユーザー情報を登録する」といった処理です。

このチェックと登録の間に、別の人が同じユーザー名で登録しようとしたら問題ですよね。こういうデータベース操作における競合状態の対策として非常に有効なのがトランザクションです。

トランザクションとは、一連のデータベース操作を「ひとまとまり」として扱う仕組みのこと。この「ひとまとまり」の処理は、全部成功するか、あるいは全部失敗する（元の状態に戻る）かのどちらかになります。これを原子性（Atomicity）と言います。

また、トランザクション実行中の変更は、他のトランザクションからは見えないように隔離されます（分離性 Isolation）。

簡単なSQLのイメージを見てみましょう。

-- トランザクション開始
BEGIN TRANSACTION;

-- ユーザー名'taro'が存在しないかチェック
SELECT COUNT(*) FROM users WHERE username = 'taro';
-- (もし存在しなかったら、以下のINSERTを実行)

-- ユーザー'taro'を登録
INSERT INTO users (username, password) VALUES ('taro', 'password123');

-- 他の関連テーブルも更新するかもしれない...
UPDATE user_profiles SET nickname = 'たろう' WHERE username = 'taro';

-- すべての操作が成功したら、変更を確定
COMMIT;

-- もし途中でエラーが起きたら、変更をすべて取り消し
-- ROLLBACK;

このように `BEGIN TRANSACTION` から `COMMIT`（または `ROLLBACK`）までの一連の処理が、他の処理から邪魔されずに実行される（または、されなかったことになる）ため、データベースレベルでのデータの整合性を保つ上で非常に効果的です。

多くのWebフレームワークでは、このトランザクションを簡単に扱える仕組みが用意されていますよ。

【言語別】競合状態の対策に役立つライブラリや機能紹介

ここまで紹介したロックやアトミック操作、トランザクションは基本的な考え方ですが、実際に使うプログラミング言語やフレームワークによって、より便利に競合状態対策ができる機能が提供されていることが多いです。

  • Python
    `threading`モジュールの`Lock`, `RLock`, `Semaphore`など。`asyncio`を使う場合は非同期用のロックもあります。
  • Java
    `synchronized`キーワード、`ReentrantLock`クラス、`java.util.concurrent.atomic`パッケージのアトミッククラス群 (`AtomicInteger`など) が強力です。
  • PHP
    ファイルロック(`flock`)や、セマフォ拡張機能(`sem_get`, `sem_acquire`)などがあります。データベース操作ではPDOのトランザクションが基本です。
  • Ruby (on Rails)
    データベースのトランザクション(`ActiveRecord::Base.transaction`)がよく使われます。`Mutex`クラスもあります。
  • Go
    ゴルーチンとチャネルを使った設計が推奨されますが、`sync`パッケージに`Mutex`, `RWMutex`なども用意されています。

自分が使っている言語やフレームワークのドキュメントを調べてみると、競合状態対策のための便利な機能が見つかるはずです。積極的に活用していきましょう！

競合状態の対策を実装する上での注意点と落とし穴

よし、これで競合状態対策はバッチリ！…と、安心するのはまだ早いかもしれません。

対策を実装したつもりが、別の問題を引き起こしてしまったり、効果がなかったりすることもあるんです。ここでは、対策を実装する際に気をつけるべき点や、よくある落とし穴についてお話しします。

デッドロックとは？発生原因と回避策を理解する

ロックを使う上で最も注意したいのがデッドロックです。
これは、複数の処理が、お互いが持っているロックを解放するのを待ち続けてしまい、全ての処理が永久に停止してしまう状態のこと。まるで、二人が一本道で向かい合ってしまい、お互いが道を譲るのを待っているうちに、どちらも動けなくなってしまうような状況です。

デッドロックの例:

処理A:                処理B:
1. リソースXのロック取得   1. リソースYのロック取得
2. リソースYのロック取得待ち 2. リソースXのロック取得待ち
   (処理BがYを解放待ち)   (処理AがXを解放待ち)

   ---> お互いを待ち続けて、どちらも進めない！ <---

デッドロックを防ぐための基本的な方法は、ロックを取得する順序を常に一定にすることです。

例えば、全ての処理で必ず「リソースXのロックを先に取得し、次にリソースYのロックを取得する」というルールを徹底すれば、上の例のようなデッドロックは発生しません。他にも、ロックのタイムアウトを設定するなどの方法があります。

パフォーマンスへの影響を考慮した対策選びの重要性

競合状態を防ぐためにロックを使うと、処理が順番待ちをする必要が出てくるため、システム全体のパフォーマンスが低下する可能性があります。

特に、ロックをかける範囲（クリティカルセクション）が広すぎたり、ロックを保持する時間が長すぎたりすると、他の処理が待たされる時間が長くなり、ボトルネックになってしまうことがあります。「とりあえず全部ロックしちゃえ！」というのは、安全かもしれませんが、非常に遅いシステムを生み出す原因になりかねません。

対策を選ぶ際には、本当にロックが必要な箇所を見極め、ロックの範囲をできるだけ小さくすることを意識しましょう。

場合によっては、ロックを使わずにアトミック操作で済ませられないか、あるいは設計自体を見直して競合が発生しにくい構造にできないかを検討することも求められます。

テストで競合状態を発見する方法とツール

競合状態は、特定のタイミングでしか発生しないことが多く、通常の機能テストではなかなか見つけにくいのが厄介な点です。

「テストでは問題なかったのに、本番環境で時々データがおかしくなる…」なんてこと、実は競合状態が原因だったりします。

競合状態を発見するためには、意図的にシステムに高い負荷をかけて、複数の処理が同時に実行される状況を作り出すストレステストが有効な場合があります。また、わざとシステムの一部を不安定にさせて挙動を見る「カオスエンジニアリング」的なアプローチも、隠れた競合問題の発見につながる可能性があります。

静的コード解析ツールの中には、ロックのかけ忘れやデッドロックの可能性などを検出してくれるものもあります。

動的な解析ツールを使って、実際の動作中のスレッドの状態を監視するのも一つの手です。発見が難しいバグだからこそ、様々な角度からテストや解析を行う意識を持つことが肝心です。

【まとめ】セキュアコーディングで競合状態のリスクを未然に防ごう

今回は、セキュアコーディングにおける競合状態の対策について、基礎から具体的な方法、注意点まで解説してきました。ちょっと難しかったかもしれませんが、要点を押さえておけば大丈夫！

最後に、今回のポイントをおさらいしておきましょう。

  • 競合状態は複数の処理が共有リソースに同時アクセスして起こる問題です。
  • 放置するとデータの不整合やセキュリティリスクにつながる可能性があります。
  • 対策の基本は同期制御で、ロック、アトミック操作、トランザクションが代表的です。
  • ロックを使う際はデッドロックに注意し、取得順序を統一しましょう。
  • パフォーマンスも考慮し、ロック範囲は最小限にするのがベターです。
  • テストで見つけにくいので、ストレステストなども試してみると良いかもしれません。

競合状態の対策は、安全で安定したシステムを作るための基礎体力のようなもの。最初は少し戸惑うかもしれませんが、意識してコードを書く習慣をつけることが、あなたのエンジニアとしてのレベルを確実に上げてくれます。

ぜひ、今日から自分のコードを見直したり、新しいコードを書く際に競合状態の可能性がないか考えてみてくださいね。

このブログを検索
  • ()

自己紹介

自分の写真
リモートワークでエンジニア兼Webディレクターとして活動しています。プログラミングやAIなど、日々の業務や学びの中で得た知識や気づきをわかりやすく発信し、これからITスキルを身につけたい人にも役立つ情報をお届けします。 note → https://note.com/yurufuri X → https://x.com/mnao111

QooQ