YASD-TECH
YASD TECH
# OAuth

HTTP 401 と 403 の違い(認証と認可・404 で存在を隠すとき)

投稿日:2026/11/9

更新日:2026/11/9

ttitleImage

HTTP 401 と 403 の違い(認証と認可・404 で存在を隠すとき)

401 は「あなたが誰か分からない」、403 は「誰かは分かっているが、それはさせられない」。
401 の名前が「Unauthorized(認可されていない)」なので取り違えやすい。RFC 9110 の定義と、サーバー側・画面側それぞれでの扱いを、動くサンプルつきで整理する。

結論

  • 401 Unauthorized は認証できていない(本人確認ができていない)。正しい認証情報を付けて送り直せば通る可能性がある。返すときは WWW-Authenticate ヘッダーが必須
  • 403 Forbidden は認証はできているが権限が足りない。同じ人がログインし直しても結果は同じ
  • 権限が無いことすら知られたくない(他人の非公開データなど)ときは、403 の代わりに 404 Not Found を返してよい
  • 迷ったら「誰か分からない → 401」「誰かは分かるが権限が無い → 403」「権限が無いことすら知られたくない → 404」

確認した仕様: RFC 9110(HTTP Semantics)11.4・11.6.1・15.5.2・15.5.4・15.5.5、RFC 6750(OAuth 2.0 Bearer トークンの使い方)3・3.1(2026-11-09 時点)
サンプルの動作確認: Node.js 22.23.0


認証と認可

言葉 英語 確かめること 失敗したとき
認証 authentication 誰か(本人確認) 401
認可 authorization その人が何をしてよいか 403

RFC 9110 の 401 の定義は「対象のリソースに対する有効な認証情報が無いため、リクエストを適用しなかった」。名前は Unauthorized でも、中身は「認証されていない」。


401 と 403 の比較

401 Unauthorized 403 Forbidden
意味 認証できていない(本人確認ができていない) 認証はできているが、権限が足りない
よくある原因 ログインしていない、トークンが無い・期限切れ・不正 一般ユーザーが管理者だけの操作をした、他人のデータを触ろうとした
もう一度送れば通るか 正しい認証情報を付ければ通る可能性がある 同じ認証情報で送り直しても同じ。自動で送り直してはいけない(SHOULD NOT)
ヘッダーの決まり WWW-Authenticate で認証のしかたを伝える(MUST) 決まりは無い
画面側の扱い ログイン画面へ戻す、トークンを更新して再送する 「権限がありません」と表示する

RFC 9110 11.4 にも「有効だが、アクセスするには足りない認証情報を受け取ったサーバーは 403 を返すべき」とある。認証情報が有効かどうかが 401 と 403 の分かれ目。


判断の順番

flowchart TD
    Req["リクエストが届く"] --> Who{"誰からのリクエストか分かる?<br/>(トークンがあり、有効)"}
    Who -->|分からない| R401["401 Unauthorized<br/>WWW-Authenticate を付ける"]
    Who -->|分かる| See{"その人に存在を知られてよいデータか?"}
    See -->|知られたくない| R404["404 Not Found"]
    See -->|知られてよい| Can{"その操作をする権限がある?"}
    Can -->|無い| R403["403 Forbidden"]
    Can -->|ある| R200["200 OK など"]

404 で隠すなら、権限の確認より先に「存在を知られてよいか」を確かめる。順番を逆にすると、他人の非公開データに対する削除リクエストに 403 が返り、「そのデータはある」と分かってしまう。


最小の例:社内ブログの API

登場人物と記事はこれだけ。

人 トークン 役割
あおい token-aoi 管理者(admin)
ひかる token-hikaru 一般メンバー(member)
未ログインの人 なし —
id 書いた人 状態
1 あおい 公開済み(published)
2 あおい 下書き(draft)

ルールは3つ。

  • API はログインした人だけが使える
  • 下書きは、書いた本人と管理者しか見られない
  • 記事の削除は管理者だけができる

サーバー

server.mjs として保存し、node server.mjs で起動する(追加パッケージ不要)。

js
// node server.mjs で起動(Node.js 18 以降・追加パッケージ不要)
import http from "node:http";

// トークン → ユーザー(本来は DB やセッションストアで引く)
const users = {
  "token-aoi": { id: 1, name: "あおい", role: "admin" },
  "token-hikaru": { id: 2, name: "ひかる", role: "member" },
};

// 記事。下書き(draft)は書いた本人と管理者しか見られない
const articles = new Map([
  [1, { id: 1, authorId: 1, title: "公開済みの記事", status: "published" }],
  [2, { id: 2, authorId: 1, title: "あおいの下書き", status: "draft" }],
]);

function currentUser(req) {
  const auth = req.headers.authorization ?? "";
  const token = auth.startsWith("Bearer ") ? auth.slice("Bearer ".length) : null;
  return token ? users[token] ?? null : null;
}

function send(res, status, body = null, headers = {}) {
  res.writeHead(status, { "Content-Type": "application/json", ...headers });
  res.end(body === null ? "" : JSON.stringify(body));
}

http
  .createServer((req, res) => {
    // 1. 誰からのリクエストか分からない → 401(WWW-Authenticate は必須)
    const user = currentUser(req);
    if (!user) {
      return send(res, 401, { error: "unauthenticated" }, {
        "WWW-Authenticate": 'Bearer realm="example"',
      });
    }

    const match = req.url.match(/^\/articles\/(\d+)$/);
    const article = match ? articles.get(Number(match[1])) : undefined;

    // 2. 他人の下書き → 存在ごと隠したいので 403 ではなく 404
    const canSee =
      article &&
      (article.status === "published" || article.authorId === user.id || user.role === "admin");
    if (!canSee) {
      return send(res, 404, { error: "not_found" });
    }

    if (req.method === "GET") {
      return send(res, 200, article);
    }

    if (req.method === "DELETE") {
      // 3. 誰かは分かるが、削除は管理者だけ → 403
      if (user.role !== "admin") {
        return send(res, 403, { error: "forbidden" });
      }
      articles.delete(article.id);
      return send(res, 204);
    }

    return send(res, 405, { error: "method_not_allowed" }, { Allow: "GET, DELETE" });
  })
  .listen(3000, () => console.log("http://localhost:3000"));

結果

上から順に実行したときの結果。

bash
curl -s -o /dev/null -w '%{http_code}\n' http://localhost:3000/articles/1
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer token-expired" http://localhost:3000/articles/1
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer token-hikaru" -X DELETE http://localhost:3000/articles/1
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer token-hikaru" http://localhost:3000/articles/2
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer token-hikaru" -X DELETE http://localhost:3000/articles/2
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer token-aoi" http://localhost:3000/articles/2
curl -s -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer token-aoi" -X DELETE http://localhost:3000/articles/1
リクエスト 誰から 結果 理由
GET /articles/1 未ログイン 401 トークンが無い。誰か分からない
GET /articles/1 期限切れのトークン 401 トークンが不正。誰か分からない
DELETE /articles/1 ひかる 403 誰かは分かるが、削除の権限が無い
GET /articles/2 ひかる 404 他人の下書き。存在ごと隠す
DELETE /articles/2 ひかる 404 同上。ここで 403 を返すと下書きがあると分かってしまう
GET /articles/2 あおい 200 書いた本人
DELETE /articles/1 あおい 204 管理者

401 のレスポンスには WWW-Authenticate が付いている。

http
HTTP/1.1 401 Unauthorized
Content-Type: application/json
WWW-Authenticate: Bearer realm="example"

画面側の扱い

401 は「認証し直せば通るかもしれない」ので、トークンを更新して1回だけ送り直す。403 は送り直しても同じなので、そのまま伝える。

sequenceDiagram
    participant UI as 画面
    participant API as API サーバー
    participant Issuer as トークンの発行元

    UI->>API: GET /articles/1(期限切れのトークン)
    API-->>UI: 401 Unauthorized
    UI->>Issuer: リフレッシュトークンで新しいトークンをもらう
    Issuer-->>UI: 新しいアクセストークン
    UI->>API: GET /articles/1(新しいトークンで1回だけ再送)
    API-->>UI: 200 OK

    UI->>API: DELETE /articles/1
    API-->>UI: 403 Forbidden
    Note over UI: 再送しない。「この操作をする権限がありません」と表示

ステータスごとに分ける部分だけを書くとこうなる。上のサーバーを起動した状態で node client.mjs で試せる。

js
// client.mjs:ステータスごとに扱いを分ける
async function requestArticle(method, id, token) {
  const res = await fetch(`http://localhost:3000/articles/${id}`, {
    method,
    headers: token ? { Authorization: `Bearer ${token}` } : {},
  });

  switch (res.status) {
    case 200:
      return { kind: "ok", article: await res.json() };
    case 204:
      return { kind: "ok" };
    case 401:
      // 誰か分からない:トークンを更新して1回だけ送り直す。それでも 401 ならログイン画面へ
      return { kind: "login" };
    case 403:
      // 誰かは分かるが権限が無い:送り直しても同じなので、そのまま伝える
      return { kind: "message", text: "この操作をする権限がありません" };
    case 404:
      return { kind: "message", text: "記事が見つかりません" };
    default:
      throw new Error(`想定していないステータス: ${res.status}`);
  }
}

console.log(await requestArticle("GET", 1));                    // { kind: 'login' }
console.log(await requestArticle("DELETE", 1, "token-hikaru")); // { kind: 'message', text: 'この操作をする権限がありません' }
console.log(await requestArticle("DELETE", 2, "token-hikaru")); // { kind: 'message', text: '記事が見つかりません' }
console.log(await requestArticle("GET", 2, "token-aoi"));       // { kind: 'ok', article: { id: 2, ... } }

OAuth のアクセストークンでの使い分け(RFC 6750)

OAuth 2.0 の Bearer トークンを使う API では、RFC 6750 がエラーの種類ごとにステータスを決めている。

状況 error の値 ステータス
リクエストに認証情報が無い 付けない 401
トークンが期限切れ・失効・形式不正など invalid_token 401
トークンの権限(scope)が足りない insufficient_scope 403
パラメータが足りない・形式が不正 invalid_request 400

期限切れのトークンに対する RFC 6750 の例。

http
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer realm="example",
                  error="invalid_token",
                  error_description="The access token expired"

RFC 6750 の 3 章は「認証情報が無い、または保護されたリソースにアクセスできるトークンが無い」ときに WWW-Authenticate を付けることを MUST としている。scope が足りない 403 も「アクセスできるトークンが無い」に当たるので、error="insufficient_scope" を WWW-Authenticate で返す。


ハマりどころ

名前に引っ張られて「権限が無いなら 401」にしてしまう

401 の名前は「Unauthorized(認可されていない)」だが、中身は「認証されていない」。権限が足りないのは 403。

401 に WWW-Authenticate を付け忘れる

RFC 9110 では、401 を返すサーバーは WWW-Authenticate ヘッダー(認証のしかた)を必ず付ける(MUST)。403 にこの決まりは無い(ほかのレスポンスにも付けてよい、という MAY だけ)。

403 は「権限不足」だけの意味ではない

RFC 9110 の 403 は「サーバーはリクエストを理解したが、実行を拒否する」。認証情報と関係ない理由で拒否されることもある、と仕様にも書かれている(例: 接続元の IP アドレスで制限している)。ログインし直しても解決しない拒否と覚えておく。

403 は、権限のある別の人の認証情報で送り直せば通る可能性がある。仕様が止めているのは「同じ認証情報での自動の再送」。

401 の再送を繰り返して止まらなくなる

トークンを更新して送り直しても 401 が返るなら、それ以上は送り直さずログイン画面へ戻す。RFC 9110 も、一度認証を試したあとに前回と同じチャレンジ(WWW-Authenticate で伝える認証のしかた)の 401 が返ってきたら、レスポンスの中身をユーザーに見せるべき(SHOULD)としている。

403 を返して存在がばれる

「他人の非公開データ」に 403 を返すと、そのデータがあることは相手に伝わる。隠したいときは 404 を返してよい(RFC 9110 15.5.4 の MAY。404 の定義自体にも「存在を明かしたくない」場合が含まれている)。404 にするなら、権限の確認より先に「見せてよいか」を確かめる(#判断の順番)。


参考

Index

  • HTTP 401 と 403 の違い(認証と認可・404 で存在を隠すとき)
  • 結論
  • 認証と認可
  • 401 と 403 の比較
  • 判断の順番
  • 最小の例:社内ブログの API
  • サーバー
  • 結果
  • 画面側の扱い
  • OAuth のアクセストークンでの使い分け(RFC 6750)
  • ハマりどころ
  • 名前に引っ張られて「権限が無いなら 401」にしてしまう
  • 401 に WWW-Authenticate を付け忘れる
  • 403 は「権限不足」だけの意味ではない
  • 401 の再送を繰り返して止まらなくなる
  • 403 を返して存在がばれる
  • 参考