HTTPはただのテキストだった — サーバー自作

HTTPサーバーを自作する。サーバーとテキストの書類、往復する通信の封筒。

HTTPは、ただのテキストのやり取りです。生のリクエストを読んで応答を返すサーバーを自作します。

前回: BIOSの画面出力が消える — 32bitモードとキーボード これは【番外編】です。 このサイトの本筋は roadmap.sh に沿った第0〜第8段階で、HTTPサーバーの自作はそこに載っていません。 読まなくても順路は繋がります。飛ばして構いません。 それでも書いているのは、第5段階で毎回打っていた http.createServer の中身を、一度も見ていないからです。 この記事のコマンドは、すべて Ubuntu Server の中(VM)で打ちます。

サーバーの回から、ずっとこの1行を書いてきました。

const server = http.createServer((req, res) => { ... });

15行でWebサーバーが動きました。 APIの回ではこれを Express に置き換えて、さらに短くなりました。

そのとき、当たり前のように req.method と req.url を読んで、res.writeHead() で返しました。でも、誰が req.method に "GET" という文字列を入れたのでしょうか。

この記事は、その1行が代わりにやっていることを、全部自分で書きます。

そしてもう1つ、私はこのサイトで同じことを何度も書いてきました。

HTTPは、ただのテキストです。

サーバーの回では nc でHTTPを手打ちして、ブラウザに文字を出しました。OSI参照モデルの回では tcpdump でパケットの中身を見ました。どちらも「テキストだ」で終わっています。

本当にただのテキストなら、テキストを読んで、テキストを書くだけで、Webサーバーは作れるはずです。

作れます。 ただし、「ただのテキスト」で済まない部分が3つあります。そこが、この記事の山場です。

対象レベル: 中級 / 区分: 必要に応じて読む

目次

この記事でわかること

  • http.createServer がやっているのは「TCPで届いたバイト列を、決まった形として読む」ことだけだということ
  • HTTPの改行は \n ではなく \r\n(CRLF)だということ。片方だけだと通らない
  • TCPはストリームで、データは1回で全部は来ないこと。「1回の受信=1リクエスト」だと思って書くと、必ず壊れる
  • Content-Length を間違えると、ブラウザは黙って待ち続けるか、途中で切れること。エラーは出ない
  • Keep-Alive は「速さのため」ではなく「接続を作り直さないため」で、接続と リクエストが 1対1ではなくなること
  • 静的ファイルを返すサーバーには、必ずパスの検査が要ること

この記事でやること

  1. nc で待ち受けて、ブラウザから開き、生のリクエストを4部構成として読む
  2. net モジュール(TCP)だけでサーバーを書く(http を使わない)。手でレスポンスを組み立ててブラウザに表示させる
  3. リクエスト行とヘッダを分解するパーサを書く。バッファに溜めて \r\n\r\n を待つところまで
  4. Content-Length をわざと間違えて、ブラウザが固まる/切れるのを見る
  5. 1つの接続で2回リクエストを送り、Keep-Alive を確かめる
  6. 静的ファイルを返す。Content-Type を拡張子から決め、.. を弾く

先に知る言葉

この記事で初めて出てくる言葉です。 基本的な言葉は用語集にもまとめてあります。

言葉意味
net モジュールNode.js に最初から入っている、TCPだけを扱うモジュール。HTTPのことは何も知りません
ソケット繋がった相手との通信路そのもの。書けば相手に届き、相手が書けば data として届きます
ストリーム境界のない、流れてくるだけのデータ。「ここまでが1件」という区切りは入っていません
バイト列 / Buffer文字ではなく数値の並び。Node.js では Buffer という型で扱います
CRLF(\r\n)復帰(CR)と改行(LF)の2文字。HTTPはこの2文字で1行を区切ると決められています
リクエスト行リクエストの1行目。GET /path HTTP/1.1 の形。メソッド・パス・バージョンが空白区切りで並びます
Content-Length本文が何バイトあるかを先に伝えるヘッダ。受け取る側はこの数字だけ読みます
Keep-Alive1回返しても接続を切らずに使い回すこと。HTTP/1.1 ではこれが既定です
パストラバーサルURLに .. を混ぜて、公開するつもりのないファイルを取りに行かれる問題

準備 — 8080番を開けて、作業場所を作る

新しいポートを使うので、いつもどおり開けます。

bash
$ sudo ufw allow 8080/tcp
$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
22/tcp                     ALLOW       Anywhere
8080/tcp                   ALLOW       Anywhere

記事の最後で閉じ方も書きます。

道具を確認します。

bash
$ which nc || sudo apt install -y netcat-openbsd
$ node -v
$ mkdir -p ~/myhttp
$ cd ~/myhttp

node -v が v22.x.x のように返れば大丈夫です。

8080番が「もう使われている」と言われたら、Dockerの回のコンテナが残っている可能性があります。サーバーの回でやったとおり sudo ss -tlnp | grep 8080 で犯人を探してから止めてください。ポートを変えて逃げないでください。

① まず観察する — 生のリクエストを見る

コードを書く前に、必ずこれをやってください。 これから自分でパースする相手を、先に目で見ておきます。

VMの中で:

bash
$ nc -l 8080

何も出ずに止まります。 この状態で、ホストのWindowsのブラウザから開きます。

http://192.168.226.50:8080/hello?name=obmes

IPは自分のVMの値に読み替えてください(VMの中で ip a)。

ブラウザはぐるぐる回ったままになり、nc の画面に文字が流れてきます。

GET /hello?name=obmes HTTP/1.1
Host: 192.168.226.50:8080
Connection: keep-alive
Upgrade-Insecure-Requests: 1
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ...
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,...
Accept-Encoding: gzip, deflate
Accept-Language: ja,en-US;q=0.9

Ctrl + C で nc を止めてください。

[スクリーンショット: 01_ncで生のリクエスト.png] nc -l 8080 を実行したターミナルに、ブラウザからのリクエストが流れてきた画面を撮ってください。1行目の GET /hello?name=obmes HTTP/1.1 が読めるようにしてください。

この4つしかない

HTTPリクエストは、必ずこの4部構成です。 例外はありません。

#部分中身
①リクエスト行GET /hello?name=obmes HTTP/1.1。空白2つで3つに割れる
②ヘッダ名前: 値 が何行でも。0行でもよい
③空行ここでヘッダが終わるという唯一の合図
④ボディGET には普通ありません。POST のときにここへ入ります

③の空行が、サーバーの回で「この形の心臓」と書いたものです。 今回は、その空行を自分で探すコードを書きます。

目に見えない2文字を見る

上の画面はテキストに見えます。 でも、行の終わりに何が入っているかは、目では分かりません。

nc の出力をファイルに落として、バイトで見ます。

bash
$ nc -l 8080 > /tmp/req.txt

もう一度ブラウザから開いて、Ctrl + C で止めてから:

bash
$ head -c 60 /tmp/req.txt | od -c
0000000   G   E   T       /   h   e   l   l   o   ?   n   a   m   e   =
0000020   o   b   m   e   s       H   T   T   P   /   1   .   1  \r  \n
0000040   H   o   s   t   :       1   9   2   .   1   6   8   .   2   2
0000060   6   .   5   0   :   8   0   8   0  \r  \n   C   o   n   n   e

od -c は「1バイトずつ、文字として表示する」コマンドです。 目に見えない文字も \r \n のように出してくれます。

行の終わりが \r\n の2文字になっています。\n だけではありません。

  • \r = CR(キャリッジリターン)。文字コード 13
  • \n = LF(ラインフィード)。文字コード 10

HTTPは「1行の終わりは CR と LF の2文字」と決めています。 これは仕様であって、好みではありません。ここを \n だけで書くと、相手によっては通りません。 この記事で一番よく踏む罠です。

② net モジュールだけでサーバーを書く

ここから http モジュールを封印します。 使うのは net だけです。

net は、TCPしか知らないモジュールです。 「繋がった」「バイト列が届いた」「切れた」しか教えてくれません。HTTPという言葉は1文字も出てきません。 OSI参照モデルの回の言葉でいえば、L4までしか面倒を見ないということです。L7(HTTP)は、これから自分で書きます。

まず、届いたものをそのまま出す

bash
$ cd ~/myhttp
$ nano raw.js
const net = require("node:net");

const server = net.createServer((socket) => {
  console.log("=== 接続がありました ===");

  socket.on("data", (chunk) => {
    console.log(`--- ${chunk.length} バイト届きました ---`);
    console.log(JSON.stringify(chunk.toString("latin1")));
  });

  socket.on("close", () => {
    console.log("=== 切れました ===");
  });
});

server.listen(8080, "0.0.0.0", () => {
  console.log("8080番で待っています");
});

JSON.stringify で囲んでいるのは、\r\n を目に見える形で出すためです。 そのまま console.log すると、ただ改行されて消えてしまいます。

bash
$ node raw.js

別のターミナルから叩きます。

bash
$ curl http://localhost:8080/hello
=== 接続がありました ===
--- 82 バイト届きました ---
"GET /hello HTTP/1.1\r\nHost: localhost:8080\r\nUser-Agent: curl/8.5.0\r\nAccept: */*\r\n\r\n"

curl 側は返事が来ないので止まったままです。 Ctrl + C で抜けてください。

注目すべきは末尾です。

...Accept: */*\r\n\r\n

\r\n が2回続いています。 最後のヘッダ行の終わりの \r\n と、空行そのものの \r\n です。

つまり、ヘッダの終わりは \r\n\r\n という4バイトを探せば見つかります。 これがパーサの出発点です。 「空行を探す」を、コードにするとこうなります。

手でレスポンスを組み立てて返す

次に、返事を書きます。 raw.js の data の中を書き換えます。

bash
$ nano raw.js
const net = require("node:net");

const server = net.createServer((socket) => {
  socket.on("data", (chunk) => {
    console.log(JSON.stringify(chunk.toString("latin1")));

    const body = "<h1>net モジュールだけで返しました</h1>\n";
    const bodyBuf = Buffer.from(body, "utf8");

    const head = [
      "HTTP/1.1 200 OK",
      "Content-Type: text/html; charset=UTF-8",
      `Content-Length: ${bodyBuf.length}`,
      "Connection: close",
      "",
      "",
    ].join("\r\n");

    socket.write(head);
    socket.write(bodyBuf);
    socket.end();
  });
});

server.listen(8080, "0.0.0.0", () => {
  console.log("8080番で待っています");
});

配列の最後に空文字列が2つ並んでいるのが分かりにくいところです。 join("\r\n") で繋ぐと、こうなります。

HTTP/1.1 200 OK\r\nContent-Type: ...\r\nContent-Length: 53\r\nConnection: close\r\n\r\n

最後の \r\n\r\n が「ヘッダ終わり」の空行です。 空文字列を2つ入れているのは、そのためです。

bash
$ node raw.js

ホストのブラウザで http://192.168.226.50:8080/ を開いてください。

表示されます。

[スクリーンショット: 02_netだけで返す.png] 左にVMのターミナル(node raw.js のログ)、右にホストのブラウザ(「net モジュールだけで返しました」が表示されている)を並べて撮ってください。

いま何を自分でやったか

HTTPの部品誰が作ったか
ステータス行 HTTP/1.1 200 OK自分
ヘッダ自分
ヘッダと本文を区切る空行自分(\r\n\r\n)
Content-Length の計算自分
本文自分

サーバーの回で res.writeHead() と res.end() が代わりにやっていたのは、この5つです。

Content-Length は「文字数」ではなく「バイト数」です。 body.length と書くと文字数になります。日本語はUTF-8で1文字3バイトなので、<h1>net モジュールだけで返しました</h1>\n は文字数27に対してバイト数は53です。 body.length を送ると、ブラウザは53バイト来ているのに27バイトで打ち切ります。 日本語が途中で切れます。 だから Buffer.byteLength(body) か、Buffer.from(body).length を使います。 これはこの先ずっと効く話です。

③ パーサを書く

ここからが本番です。 届いたバイト列を、リクエスト行とヘッダに分解します。

最初に、一番大事なことを書きます

さっきのコードには、致命的な間違いがあります。 動いていたのはたまたまです。

socket.on("data", (chunk) => {
  // ここに来た時点で、リクエストが全部届いていると思っている
});

この前提が、間違いです。

TCPはストリームです。「1回の data = 1リクエスト」ではありません。

TCPが約束しているのは、たった2つだけです。

  • 送った順番どおりに届く
  • 欠けたり化けたりしない

「どこまでが1件か」は、TCPは1ミリも知りません。 だから、こうなります。

起きること例
1リクエストが2回以上に分かれて届くヘッダの途中で data が呼ばれる
2リクエストが1回で届くKeep-Alive で立て続けに送られたとき
ボディだけ遅れて届くPOST の本文が大きいとき

これがこの記事で一番の学びです。 そして、手元の curl では滅多に再現しません。 小さいリクエストは1回で届いてしまうからです。だから「動いた」と思ってしまいます。

実際に分かれるところを見る

わざと分けて送ってみます。 raw.js を動かしたまま、別のターミナルで:

bash
$ printf 'GET / HTTP/1.1\r\nHost: x\r\n' | nc -q 3 localhost 8080

printf を使うのは、echo では \r がそのまま文字として出る環境があるからです。 -q 3 は「送り終わってから3秒待ってから切る」指定です。

わざと空行を送っていません。 raw.js のログを見てください。

"GET / HTTP/1.1\r\nHost: x\r\n"

data は呼ばれました。 でも、リクエストはまだ終わっていません。 さっきのコードは、この時点で 200 を返してしまいます。 これが間違いです。

正しい動きは「まだ \r\n\r\n が来ていないので、待つ」です。

バッファに溜めて、\r\n\r\n を待つ

bash
$ nano parse.js
const net = require("node:net");

const CRLF2 = Buffer.from("\r\n\r\n");

function parseHead(text) {
  const lines = text.split("\r\n");
  const [method, target, version] = lines[0].split(" ");

  const headers = {};
  for (const line of lines.slice(1)) {
    const i = line.indexOf(":");
    if (i === -1) continue;
    const name = line.slice(0, i).trim().toLowerCase();
    const value = line.slice(i + 1).trim();
    headers[name] = value;
  }

  return { method, target, version, headers };
}

const server = net.createServer((socket) => {
  let buffer = Buffer.alloc(0);

  socket.on("data", (chunk) => {
    buffer = Buffer.concat([buffer, chunk]);
    console.log(`受信 ${chunk.length} バイト / 溜まり ${buffer.length} バイト`);

    const sep = buffer.indexOf(CRLF2);
    if (sep === -1) {
      console.log("  → まだヘッダが終わっていない。待ちます");
      return;
    }

    const head = buffer.slice(0, sep).toString("latin1");
    const req = parseHead(head);
    const length = Number(req.headers["content-length"] || 0);
    const bodyStart = sep + 4;

    if (buffer.length - bodyStart < length) {
      console.log(`  → ボディが足りない(${buffer.length - bodyStart}/${length})。待ちます`);
      return;
    }

    const body = buffer.slice(bodyStart, bodyStart + length).toString("utf8");
    buffer = buffer.slice(bodyStart + length);

    console.log("  → 1件そろいました");
    console.log("     method :", req.method);
    console.log("     target :", req.target);
    console.log("     version:", req.version);
    console.log("     host   :", req.headers["host"]);
    console.log("     body   :", JSON.stringify(body));

    respond(socket, 200, "OK", "text/plain; charset=UTF-8",
      `${req.method} ${req.target} を受け取りました\n`);
  });

  socket.on("error", (e) => console.log("ソケットのエラー:", e.message));
});

function respond(socket, status, reason, type, body) {
  const bodyBuf = Buffer.from(body, "utf8");
  const head = [
    `HTTP/1.1 ${status} ${reason}`,
    `Content-Type: ${type}`,
    `Content-Length: ${bodyBuf.length}`,
    "Connection: close",
    "",
    "",
  ].join("\r\n");
  socket.write(head);
  socket.write(bodyBuf);
  socket.end();
}

server.listen(8080, "0.0.0.0", () => {
  console.log("8080番で待っています");
});

動かして、さっきの「途中まで」を送ってみます。

bash
$ node parse.js
bash
$ printf 'GET / HTTP/1.1\r\nHost: x\r\n' | nc -q 3 localhost 8080
受信 25 バイト / 溜まり 25 バイト
  → まだヘッダが終わっていない。待ちます

返事をしなくなりました。 これが正しい動きです。

次に、続きを送ります。

bash
$ printf 'GET / HTTP/1.1\r\nHost: x\r\n\r\n' | nc -q 3 localhost 8080
受信 27 バイト / 溜まり 27 バイト
  → 1件そろいました
     method : GET
     target : /
     version: HTTP/1.1
     host   : x
     body   : ""

空行が来た瞬間に、1件として成立しました。

ボディも読む

POST を送ります。

bash
$ curl -X POST -H 'Content-Type: text/plain' --data 'こんにちは' http://localhost:8080/submit
受信 145 バイト / 溜まり 145 バイト
  → 1件そろいました
     method : POST
     target : /submit
     version: HTTP/1.1
     host   : localhost:8080
     body   : "こんにちは"

Content-Length の数字だけ読んで、その長さだけ取っています。 それ以上でも以下でもありません。

Content-Length が無く、本文もない場合はどうなるのか。 Number(undefined || 0) で 0 になります。GET には普通ボディが無いので、これで正しく動きます。 HTTPは「ボディがどこで終わるか」を、必ず送り側が教える決まりになっています。教え方は Content-Length か、chunked という別の方式のどちらかです。chunked は今回は作りません(後述)。

なぜ latin1 で文字列にしているのか

ヘッダを読むところで toString("latin1") を使っています。 これは意図的です。

  • ヘッダは基本的にASCIIの範囲で書かれます
  • latin1 は1バイト=1文字に固定されるので、バイト位置と文字位置がズレません
  • utf8 で読むと、途中で切れたマルチバイト文字が � に化けて、バイト数がズレます

ボディだけは utf8 で読んでいます。 ここには日本語が入るからです。「ヘッダはバイトとして、ボディは文字として」という使い分けです。

④ Content-Length を間違えると何が起きるか

わざと壊します。 ここは実際にやってください。エラーが出ないことが怖いので、目で見る価値があります。

多すぎるとき — 相手は待ち続ける

parse.js の respond の中を、1文字だけ変えます。

    `Content-Length: ${bodyBuf.length + 100}`,

立て直して、ブラウザから開いてください。

bash
$ node parse.js

ブラウザはぐるぐる回ったままになります。 そしてしばらくすると、勝手に何かが表示されるか、エラーになります。

curl だと、もっとはっきり出ます。

bash
$ curl -v http://localhost:8080/
< HTTP/1.1 200 OK
< Content-Length: 131
<
GET / を受け取りました
* transfer closed with 100 bytes remaining to read
curl: (18) transfer closed with 100 bytes remaining to read

「あと100バイト残っているのに、接続が閉じられた」と言われています。

受け取る側は、Content-Length の数字を信じます。 131と言われたら、131バイト受け取るまで待ちます。 31バイトしか来なくても、「まだ途中だ」としか思いません。 接続を切ったから、curl は異常だと気づけました。 Keep-Alive で接続を切らなかった場合、相手はタイムアウトまで待ち続けます。

少なすぎるとき — 途中で切れる

    `Content-Length: ${bodyBuf.length - 5}`,

立て直して:

bash
$ curl -i http://localhost:8080/
HTTP/1.1 200 OK
Content-Type: text/plain; charset=UTF-8
Content-Length: 26
Connection: close

GET / を受け取りま

末尾が消えました。(26バイト目は「し」の3バイトの途中なので、端末によっては末尾に化けた文字が1つ付きます) そして、curl は何のエラーも出しません。

[スクリーンショット: 03_content-length不足.png] curl -i の結果で、Content-Length の数字と、途中で切れた本文が両方見えている画面を撮ってください。

これが一番怖い壊れ方です。 ステータスは 200、エラーも無し、中身だけが静かに欠ける。 本物のサーバーは、この数字を絶対に手で書きません。 res.end(body) に渡された長さから機械的に計算します。人間が数える仕事ではないから、ライブラリがやっています。

確認できたら、Content-Length の行を元に戻してください。

    `Content-Length: ${bodyBuf.length}`,

⑤ Keep-Alive — 1つの接続で何回も

ここまで、返すたびに socket.end() で接続を切っていました。 HTTP/1.0 の作法です。

HTTP/1.1 では、切らないのが既定です。

まず、いまの動きを測る

bash
$ curl -v http://localhost:8080/one http://localhost:8080/two 2>&1 | grep -E 'Connected|Closing|Re-using'
* Connected to localhost (127.0.0.1) port 8080
* Closing connection
* Connected to localhost (127.0.0.1) port 8080
* Closing connection

2回とも、繋ぎ直しています。 Connection: close を送っているからです。

切らないようにする

parse.js を書き換えます。respond から socket.end() を外し、Connection を相手の希望に合わせます。

function respond(socket, status, reason, type, body, keepAlive) {
  const bodyBuf = Buffer.from(body, "utf8");
  const head = [
    `HTTP/1.1 ${status} ${reason}`,
    `Content-Type: ${type}`,
    `Content-Length: ${bodyBuf.length}`,
    `Connection: ${keepAlive ? "keep-alive" : "close"}`,
    "",
    "",
  ].join("\r\n");
  socket.write(head);
  socket.write(bodyBuf);
  if (!keepAlive) socket.end();
}

呼び出し側も直します。

    const wantsClose = (req.headers["connection"] || "").toLowerCase() === "close";
    const keepAlive = req.version === "HTTP/1.1" && !wantsClose;

    respond(socket, 200, "OK", "text/plain; charset=UTF-8",
      `${req.method} ${req.target} を受け取りました\n`, keepAlive);

ここで、③で書いたコードが効いてきます。

    buffer = buffer.slice(bodyStart + length);

1件処理したあと、バッファから消したのは「その1件ぶんだけ」です。 残りはそのまま置いてあります。 だから、同じ接続で2件目が来ても、そのまま続きとして処理できます。

もしここで buffer = Buffer.alloc(0) と全部消していたら、1回の data に2件まとめて届いたときに、2件目が黙って消えます。 Keep-Alive にした瞬間に壊れる、典型的なバグです。

立て直して、もう一度測ります。

bash
$ node parse.js
bash
$ curl -v http://localhost:8080/one http://localhost:8080/two 2>&1 | grep -E 'Connected|Closing|Re-using'
* Connected to localhost (127.0.0.1) port 8080
* Re-using existing connection with host localhost
* Closing connection

Re-using existing connection。 繋ぎ直していません。 1本の接続で2件処理しました。

[スクリーンショット: 04_keep-alive.png] Re-using existing connection の行が見えている curl -v の画面を撮ってください。

手で2件まとめて送る

もっと露骨に確かめられます。

bash
$ printf 'GET /a HTTP/1.1\r\nHost: x\r\n\r\nGET /b HTTP/1.1\r\nHost: x\r\n\r\n' | nc -q 3 localhost 8080

サーバー側のログ:

受信 56 バイト / 溜まり 56 バイト
  → 1件そろいました
     target : /a

1件しか処理していません。 2件目が残っているのに、data はもう呼ばれないからです。

これも定番のバグです。 data が呼ばれるのは「新しくデータが届いたとき」だけ。バッファに残っている続きは、誰も処理しに来ません。 直し方は「1件処理したら、続きがあるかもう一度見る」——つまり while で回すことです。

  socket.on("data", (chunk) => {
    buffer = Buffer.concat([buffer, chunk]);

    while (true) {
      const sep = buffer.indexOf(CRLF2);
      if (sep === -1) break;

      const head = buffer.slice(0, sep).toString("latin1");
      const req = parseHead(head);
      const length = Number(req.headers["content-length"] || 0);
      const bodyStart = sep + 4;
      if (buffer.length - bodyStart < length) break;

      const body = buffer.slice(bodyStart, bodyStart + length).toString("utf8");
      buffer = buffer.slice(bodyStart + length);

      handle(req, body, socket);
    }
  });

while (true) と break の3箇所。これだけです。 立て直して、もう一度2件まとめて送ってください。/a と /b の両方が処理されます。

Keep-Alive は「速いから」使うのではありません。 OSI参照モデルの回で見た3ウェイハンドシェイクを、毎回やらなくて済むから使います。HTTPSならさらにTLSの挨拶も付きます。1回の往復を省くために、接続を使い回しています。 そして代償が、いま書いた while ループです。接続とリクエストが 1対1 でなくなったので、区切りを自分で見つける必要が出ました。

⑥ 静的ファイルを返す

最後に、ファイルを読んで返します。 nginx がやっていることの、いちばん小さい版です。

bash
$ mkdir -p ~/myhttp/public
$ cd ~/myhttp/public
$ printf '<h1>自作サーバーが返した index.html</h1>\n<p>スタイルも当たります。</p>\n' > index.html
$ printf 'h1 { color: teal; }\n' > style.css

index.html に読み込み行を足します。

bash
$ nano ~/myhttp/public/index.html
<link rel="stylesheet" href="/style.css">
<h1>自作サーバーが返した index.html</h1>
<p>スタイルも当たります。</p>

サーバー側です。 parse.js の先頭に追加します。

const fs = require("node:fs");
const path = require("node:path");

const ROOT = path.resolve(process.env.HOME, "myhttp/public");

const TYPES = {
  ".html": "text/html; charset=UTF-8",
  ".css": "text/css; charset=UTF-8",
  ".js": "text/javascript; charset=UTF-8",
  ".json": "application/json; charset=UTF-8",
  ".txt": "text/plain; charset=UTF-8",
  ".png": "image/png",
  ".jpg": "image/jpeg",
  ".svg": "image/svg+xml",
  ".ico": "image/x-icon",
};

パスを安全に解決する関数です。

function resolveSafe(target) {
  let urlPath = target.split("?")[0];

  try {
    urlPath = decodeURIComponent(urlPath);
  } catch {
    return null;
  }

  if (urlPath.includes("\0")) return null;
  if (urlPath.endsWith("/")) urlPath += "index.html";

  const resolved = path.resolve(ROOT, "." + urlPath);

  if (resolved !== ROOT && !resolved.startsWith(ROOT + path.sep)) return null;

  return resolved;
}

この関数の順番が全てです。

順やることなぜ
1? から後ろを捨てるクエリはファイル名ではない
2URLデコードする先にデコードしないと、エンコードされた .. を見落とす
3NUL文字を弾く途中で切られる細工を防ぐ
4path.resolve で正規化する.. や // を、実際に指す場所に潰す
5結果が ROOT の下かを確かめるここが本体。潰した後の答えで判断する

やってはいけないのは「.. という文字列が含まれていたら弾く」だけの実装です。 文字列を検査しても、書き方はいくらでもあります。 だから文字列を見ずに、path.resolve で「結局どこを指すのか」を確定させてから、それが公開ディレクトリの下かどうかだけを見ます。 resolved !== ROOT && !resolved.startsWith(ROOT + path.sep) の path.sep が地味に効きます。単に startsWith(ROOT) にすると、public-secret のような隣の名前が通ってしまいます。

ハンドラです。

function handle(req, body, socket) {
  const wantsClose = (req.headers["connection"] || "").toLowerCase() === "close";
  const keepAlive = req.version === "HTTP/1.1" && !wantsClose;

  if (req.method !== "GET") {   // HEAD は本文を付けずに返す必要があるので、ここでは受け付けない
    respond(socket, 405, "Method Not Allowed", "text/plain; charset=UTF-8",
      "この方法は受け付けていません\n", keepAlive);
    return;
  }

  const file = resolveSafe(req.target);
  if (file === null) {
    console.log("拒否しました:", req.target);
    respond(socket, 400, "Bad Request", "text/plain; charset=UTF-8",
      "そのパスは受け付けません\n", keepAlive);
    return;
  }

  fs.readFile(file, (err, data) => {
    if (err) {
      respond(socket, 404, "Not Found", "text/plain; charset=UTF-8",
        "見つかりません\n", keepAlive);
      return;
    }

    const type = TYPES[path.extname(file).toLowerCase()] || "application/octet-stream";
    respondBuffer(socket, 200, "OK", type, data, keepAlive);
  });
}

バイト列をそのまま返す版も要ります。 画像は文字列にできないからです。

function respondBuffer(socket, status, reason, type, bodyBuf, keepAlive) {
  const head = [
    `HTTP/1.1 ${status} ${reason}`,
    `Content-Type: ${type}`,
    `Content-Length: ${bodyBuf.length}`,
    `Connection: ${keepAlive ? "keep-alive" : "close"}`,
    "",
    "",
  ].join("\r\n");
  socket.write(head);
  socket.write(bodyBuf);
  if (!keepAlive) socket.end();
}

function respond(socket, status, reason, type, body, keepAlive) {
  respondBuffer(socket, status, reason, type, Buffer.from(body, "utf8"), keepAlive);
}

動かします。

bash
$ cd ~/myhttp
$ node parse.js

ホストのブラウザで http://192.168.226.50:8080/ を開いてください。

見出しが teal 色で表示されます。 つまり、index.html と style.css の2ファイルが、別々のリクエストで取りに来られて、両方返っているということです。

開発者ツールの回の Network タブを開いてください。 2件並んでいます。そして style.css の Content-Type が text/css になっていることを確認してください。

Content-Type を間違えると、CSSは当たりません。 試しに TYPES から ".css" の行を消して立て直すと、application/octet-stream で返るようになり、ブラウザはそれをスタイルシートとして解釈しません。 見出しは黒いままです。 「ファイルは200で返っているのにスタイルが効かない」の正体は、たいていこれです。 拡張子とMIMEタイプの対応表を持っているのは、nginx も同じです。

検査が効いていることを確かめる

攻撃のやり方は書きません。 塞げているかだけを確かめます。

bash
$ curl -i --path-as-is 'http://localhost:8080/../parse.js'
HTTP/1.1 400 Bad Request
Content-Type: text/plain; charset=UTF-8
Content-Length: 37

そのパスは受け付けません

サーバー側のログにも 拒否しました: /../parse.js と出ます。

--path-as-is を付けているのは、curl が親切に .. を先に潰してしまうからです。 潰されるとサーバーまで届きません。サーバー側の検査を試したいので、そのまま送らせています。 逆に言えば、curl やブラウザは普通このパスを送りません。 送ってくるのは、わざとやっている相手だけです。 だからサーバー側で必ず見る必要があります。 この話はセキュリティ点検の回の「入力は全部疑う」と同じ形です。

作らなかったもの

ここまでで、HTTPサーバーとして動くものができました。 でも、本物と比べると、ごっそり抜けています。

作らなかったもの何が起きるか
chunked(Transfer-Encoding: chunked)長さが先に分からない応答を送れない。 生成しながら流す配信ができない。受け取る側としても、chunked で送られたリクエストを読めない
HTTP/2・HTTP/3テキストではなくバイナリのフレームになり、1本の接続に複数のやりとりが同時に流れます。今回のパーサは1文字も通用しません
gzip・br による圧縮Accept-Encoding を無視しているので、常に無圧縮。転送量が数倍になります
TLS(HTTPS)暗号化なし。平文で流れます。 OSI参照モデルの回で tcpdump に丸見えだったとおりです
ヘッダ数・行長の上限巨大なヘッダを延々と送られると、バッファが無限に膨らみます
タイムアウト繋いだまま黙っている相手を、永遠に待ちます
Range(部分取得)動画のシークや、ダウンロードの再開ができません
キャッシュのヘッダETag も Last-Modified も付けていないので、毎回全部送り直します(キャッシュの回)
複数ヘッダの重複同じ名前のヘッダが2回来ると、後ろで上書きしています(Set-Cookie などは本来まとめる必要があります)

8つ以上あります。 そして、http.createServer はこれを全部やっています。

「作らなかったもの」を数えるのが、この番外編の目的です。 シェル自作の回でパイプもリダイレクトも作らなかったのと同じで、動くものを作ると、動かないものが数えられるようになります。

これで何が変わるか

コードが1行も速くならないのに、読めるものが増えます。

「リクエストが来る」の解像度が変わる

これまでは、こう見えていました。

ブラウザがリクエストを送る → サーバーが受け取る

いまは、こう見えます。

ブラウザがTCP接続を張る → バイト列が何回かに分かれて届く → \r\n\r\n が来るまで溜める → 1行目を空白で3つに割る → 名前: 値 を辞書にする → Content-Length の数だけボディを読む → 接続はまだ切れていない

「リクエスト」という単語の中に、これだけ入っていました。

設定ファイルのオプションが読める

いままで意味が分からずコピペしていた設定に、意味が付きます。

設定いま分かること
nginx の client_header_buffer_sizeヘッダを溜めるバッファの大きさ。 自分で Buffer.concat していたあれ
nginx の large_client_header_buffers溜まりきらなかったときに、どこまで伸ばすか
nginx の keepalive_timeout接続を使い回すために、次のリクエストを何秒待つか。 作らなかった「タイムアウト」そのもの
nginx の client_max_body_sizeContent-Length がいくつまでなら受けるか
types の対応表拡張子から Content-Type を決める、あの辞書
Express の express.json()ボディを読んで JSON.parse するところ。 自分で書いたのはその手前まで
413 Payload Too LargeContent-Length を見て、読む前に断っている
431 Request Header Fields Too Largeヘッダを溜めている途中で諦めた

nginxの回やリバースプロキシの回で書いた設定を、いま開き直してみてください。 読み方が変わっているはずです。

ApacheとCaddyの回で「どれも同じことをしている」と書いたのも、ここで腑に落ちます。 どのWebサーバーも、いま書いたのと同じ処理を、桁違いに丁寧にやっているだけです。

「ぐるぐる回ったまま」の原因が絞れる

ブラウザが固まったとき、原因の候補が具体的になりました。

  • 空行(\r\n\r\n)を送っていない
  • Content-Length が実際より大きい
  • Content-Length を付けず、接続も切っていない

どれも「サーバーが終わりを伝えていない」の別の顔です。

つまずいたところ

症状原因
curl では動くのに、ブラウザだと途中で止まる改行を \n だけで書いていた。 \r\n にする
日本語の末尾が消えるContent-Length に文字数を入れていた。バイト数(Buffer.byteLength)にする
2件目のリクエストが無視される1件処理したあと while で続きを見ていない
2件目が消える処理後にバッファを全消ししていた。使った分だけ削る
ヘッダの位置がズレるヘッダを toString("utf8") で読んでいた。latin1 にする
curl が transfer closed with N bytes remainingContent-Length が実際より大きい
CSSが当たらない(200は返っている)Content-Type が text/css になっていない
curl で .. を試してもサーバーに届かないcurl が先に潰している。--path-as-is を付ける
EADDRINUSE前の node が残っている。sudo ss -tlnp | grep 8080 で探す

一番時間を溶かしたのは「2件目が消える」です。 curl で1件ずつ叩いている限り、永遠に再現しません。 ブラウザで開いたときだけ、たまに画像が1枚出ない。Keep-Alive を実装した瞬間に、テストの前提が変わっていました。

後片づけ

プロセスを止めます。

bash
$ sudo ss -tlnp | grep 8080

node の PID を確認してから止めてください。

ポートを閉じます。

bash
$ sudo ufw delete allow 8080/tcp
$ sudo ufw status

ファイルは残しても害はありません。 消すならこうします。

bash
$ rm -rf ~/myhttp /tmp/req.txt

~/server(本筋で使っている3000番のAPI)には触っていません。 そちらはそのままです。

まとめ

  • http.createServer は、TCPで届いたバイト列を「決まった形のテキスト」として読んでいるだけ。 魔法は無い
  • HTTPリクエストは4部構成。 リクエスト行 / ヘッダ / 空行 / ボディ。空行が唯一の区切り
  • 改行は \r\n の2文字。 \n だけでは仕様外。od -c で目に見える
  • TCPはストリーム。「1回の受信=1リクエスト」は成り立たない。 バッファに溜めて \r\n\r\n を待つ
  • ヘッダは latin1 で、ボディは utf8 で読む。 バイト位置と文字位置をズラさないため
  • Content-Length はバイト数であって文字数ではない。 日本語で必ず事故る
  • Content-Length が多すぎると相手は待ち続け、少なすぎると黙って切れる。 どちらもエラーにならない
  • Keep-Alive にすると、接続とリクエストが1対1でなくなる。 処理後は使った分だけバッファを削り、while で続きを見る
  • Content-Type は拡張子から決める。 間違えると200なのにCSSが当たらない
  • パスの検査は、文字列で .. を探すのではなく、path.resolve で潰してから公開ディレクトリの下かを見る
  • chunked・HTTP/2・圧縮・TLS・タイムアウト・ヘッダ上限は、1つも作っていない。 本物はそれを全部やっている
  • 設定ファイルのオプションが読めるようになる。 client_header_buffer_size も keepalive_timeout も、自分が書いた行のことだった

参考リンク


次に読む

この記事は 【番外編】roadmap.sh の外 の 28 / 35 本目です。

記事
← 前の記事PCはこの512バイトから起動する — ブートセクタ自作
→ 次の記事正規表現が固まる理由 — エンジンを100行で自作する

ここは番外編です。 本筋から外れているので、飛ばして構いません。

全体の順路は はじめに にあります。

roadmap.sh のどこをやっているか

【番外編】既にあるものを自作して仕組みを知る回。roadmap.sh の範囲外。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!

コメント

コメントする

目次