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ではなくなること
- 静的ファイルを返すサーバーには、必ずパスの検査が要ること
この記事でやること
ncで待ち受けて、ブラウザから開き、生のリクエストを4部構成として読むnetモジュール(TCP)だけでサーバーを書く(httpを使わない)。手でレスポンスを組み立ててブラウザに表示させる- リクエスト行とヘッダを分解するパーサを書く。バッファに溜めて
\r\n\r\nを待つところまで Content-Lengthをわざと間違えて、ブラウザが固まる/切れるのを見る- 1つの接続で2回リクエストを送り、Keep-Alive を確かめる
- 静的ファイルを返す。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-Alive | 1回返しても接続を切らずに使い回すこと。HTTP/1.1 ではこれが既定です |
| パストラバーサル | URLに .. を混ぜて、公開するつもりのないファイルを取りに行かれる問題 |
準備 — 8080番を開けて、作業場所を作る
新しいポートを使うので、いつもどおり開けます。
Status: active
To Action From
-- ------ ----
22/tcp ALLOW Anywhere
8080/tcp ALLOW Anywhere
記事の最後で閉じ方も書きます。
道具を確認します。
node -v が v22.x.x のように返れば大丈夫です。
8080番が「もう使われている」と言われたら、Dockerの回のコンテナが残っている可能性があります。サーバーの回でやったとおり
sudo ss -tlnp | grep 8080で犯人を探してから止めてください。ポートを変えて逃げないでください。
① まず観察する — 生のリクエストを見る
コードを書く前に、必ずこれをやってください。 これから自分でパースする相手を、先に目で見ておきます。
VMの中で:
何も出ずに止まります。 この状態で、ホストの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 の出力をファイルに落として、バイトで見ます。
もう一度ブラウザから開いて、Ctrl + 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)は、これから自分で書きます。
まず、届いたものをそのまま出す
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 すると、ただ改行されて消えてしまいます。
別のターミナルから叩きます。
=== 接続がありました ===
--- 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 の中を書き換えます。
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つ入れているのは、そのためです。
ホストのブラウザで 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 を動かしたまま、別のターミナルで:
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 を待つ
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番で待っています");
});
動かして、さっきの「途中まで」を送ってみます。
受信 25 バイト / 溜まり 25 バイト
→ まだヘッダが終わっていない。待ちます
返事をしなくなりました。 これが正しい動きです。
次に、続きを送ります。
受信 27 バイト / 溜まり 27 バイト
→ 1件そろいました
method : GET
target : /
version: HTTP/1.1
host : x
body : ""
空行が来た瞬間に、1件として成立しました。
ボディも読む
POST を送ります。
受信 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}`,
立て直して、ブラウザから開いてください。
ブラウザはぐるぐる回ったままになります。 そしてしばらくすると、勝手に何かが表示されるか、エラーになります。
curl だと、もっとはっきり出ます。
< 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}`,
立て直して:
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 では、切らないのが既定です。
まず、いまの動きを測る
* 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 にした瞬間に壊れる、典型的なバグです。
立て直して、もう一度測ります。
* 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件まとめて送る
もっと露骨に確かめられます。
サーバー側のログ:
受信 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 がやっていることの、いちばん小さい版です。
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 | ? から後ろを捨てる | クエリはファイル名ではない |
| 2 | URLデコードする | 先にデコードしないと、エンコードされた .. を見落とす |
| 3 | NUL文字を弾く | 途中で切られる細工を防ぐ |
| 4 | path.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);
}
動かします。
ホストのブラウザで 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 も同じです。
検査が効いていることを確かめる
攻撃のやり方は書きません。 塞げているかだけを確かめます。
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_size | Content-Length がいくつまでなら受けるか |
types の対応表 | 拡張子から Content-Type を決める、あの辞書 |
Express の express.json() | ボディを読んで JSON.parse するところ。 自分で書いたのはその手前まで |
413 Payload Too Large | Content-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 remaining | Content-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 を実装した瞬間に、テストの前提が変わっていました。
後片づけ
プロセスを止めます。
node の PID を確認してから止めてください。
ポートを閉じます。
ファイルは残しても害はありません。 消すならこうします。
~/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 — Computer Science
- roadmap.sh — Backend
- MDN — HTTPメッセージ
- MDN — Content-Length
- MDN — Connection
- MDN — MIME タイプ一覧
- Node.js — net モジュール
- Node.js — Buffer
- Node.js — path
- RFC 9112 — HTTP/1.1
- RFC 9110 — HTTP Semantics
- OWASP — Path Traversal
次に読む
この記事は 【番外編】roadmap.sh の外 の 28 / 35 本目です。
| 記事 | |
|---|---|
| ← 前の記事 | PCはこの512バイトから起動する — ブートセクタ自作 |
| → 次の記事 | 正規表現が固まる理由 — エンジンを100行で自作する |
ここは番外編です。 本筋から外れているので、飛ばして構いません。
全体の順路は はじめに にあります。
roadmap.sh のどこをやっているか
【番外編】既にあるものを自作して仕組みを知る回。roadmap.sh の範囲外。

コメント