mirror of
https://github.com/yhirose/cpp-httplib.git
synced 2026-11-18 19:40:57 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7800c3dc5b | ||
|
|
baba35b8d3 | ||
|
|
92435b31b3 | ||
|
|
5a956da084 | ||
|
|
cd446a4e01 | ||
|
|
eb364f1167 | ||
|
|
748dbfade6 | ||
|
|
d7b0d4bedb | ||
|
|
4af42e1907 | ||
|
|
1b40ce850b | ||
|
|
f57672b390 | ||
|
|
654fd3546c | ||
|
|
546e821c65 | ||
|
|
53a7f4964e | ||
|
|
8c5fd6aa08 | ||
|
|
a2ebab183d | ||
|
|
a39e081386 | ||
|
|
07142256ed | ||
|
|
cc7a30f12f | ||
|
|
cdcd2ac6e6 | ||
|
|
bd23a7b179 | ||
|
|
6d8dec3c3e | ||
|
|
7e5d0683ac | ||
|
|
6df971434e | ||
|
|
39c98d4671 | ||
|
|
a1ba73a256 | ||
|
|
453b1b8613 | ||
|
|
a18895f42e |
No files matched your search
+1
-1
@@ -568,7 +568,7 @@ Choose sizes that account for both your expected HTTP load and the maximum numbe
|
||||
|
||||
A single `WebSocket` (server-side) or `WebSocketClient` handle is shared by three potential callers: the thread running your handler (or holding the client), the heartbeat thread, and, if your code does its own thing, a separate thread calling `send()`/`close()` while another thread is blocked in `read()`.
|
||||
|
||||
**Supported**: calling `read()` from one thread while calling `send()`/`close()` from another. This is the common pattern for a client that reads incoming messages in a loop on one thread and sends from elsewhere (e.g. a UI thread). A message that is in flight when `close()` is called still arrives intact; `close()` sends the Close frame and returns, leaving the connection's read side to the thread that owns it, so it does not block waiting for the peer's Close reply in that case. The heartbeat thread's automatic pings use the same `send()` path internally, so they are safe to run concurrently with your `read()` loop too — for `wss://` this requires every TLS call on a connection to be serialized internally, which cpp-httplib does for you.
|
||||
**Supported**: calling `read()` from one thread while calling `send()`/`close()` from another. This is the common pattern for a client that reads incoming messages in a loop on one thread and sends from elsewhere (e.g. a UI thread). A message that is in flight when `close()` is called still arrives intact; `close()` sends the Close frame and returns, leaving the connection's read side to the thread that owns it, so it does not block waiting for the peer's Close reply in that case. That thread's `read()` keeps waiting for the reply until its own read timeout (by default none on a client, 300 seconds on a server); to bound it, set one with `set_read_timeout()` before the read starts. The heartbeat thread's automatic pings use the same `send()` path internally, so they are safe to run concurrently with your `read()` loop too — for `wss://` this requires every TLS call on a connection to be serialized internally, which cpp-httplib does for you.
|
||||
|
||||
**Not supported**: calling `read()` from two threads at the same time on the same handle. The calls are serialized rather than left to corrupt each other, but which thread receives which message is unspecified, so there is nothing useful to build on it.
|
||||
|
||||
|
||||
@@ -1172,7 +1172,7 @@ cli.set_default_headers({
|
||||
auto res = cli.Get("/hi");
|
||||
```
|
||||
|
||||
A `Content-Length` among these headers is sent in place of the one the library would send, so it has to match the body as written. A `Transfer-Encoding` is sent in addition to the library's own framing, so leave it out. Leave both out when passing on the headers of another message, as a proxy does.
|
||||
A `Content-Length` among these headers is sent in place of the one the library would send, so it has to match the body as written. One passed with the request is dropped when the library compresses the body or sends it chunked. A `Transfer-Encoding` is sent in addition to the library's own framing, so leave it out. Leave both out when passing on the headers of another message, as a proxy does.
|
||||
|
||||
### POST
|
||||
|
||||
@@ -1716,6 +1716,8 @@ cli.set_address_family(AF_UNIX);
|
||||
|
||||
This library automatically sets the Host header to "localhost" for Unix socket connections, similar to curl's behavior.
|
||||
|
||||
With `set_follow_location(true)`, a redirect is followed over the same socket, whatever host the `Location` names, as curl's `--unix-socket` does. A host mapped with `set_direct_hostname_addr_map` goes to its mapped socket instead. Only a `Location` naming `localhost` counts as the same host; any other host is treated as cross-host, so `Authorization` and `Cookie` are not sent to it.
|
||||
|
||||
|
||||
URI Encoding/Decoding Utilities
|
||||
-------------------------------
|
||||
|
||||
@@ -4,7 +4,7 @@ langs = ["en", "ja"]
|
||||
|
||||
[site]
|
||||
title = "cpp-httplib"
|
||||
version = "0.64.0"
|
||||
version = "0.67.0"
|
||||
hostname = "https://yhirose.github.io"
|
||||
base_path = "/cpp-httplib"
|
||||
footer_message = "© 2026 Yuji Hirose. All rights reserved."
|
||||
|
||||
@@ -56,4 +56,4 @@ When you call `stop()`, new connections are refused, but handlers that are alrea
|
||||
|
||||
> **Warning:** There's a wait between calling `stop()` and `listen()` returning — it's the time in-flight requests take to finish. To enforce a timeout, you'll need to add your own shutdown timer in application code.
|
||||
|
||||
> **Note:** `stop()` doesn't interrupt WebSocket handlers. A handler looping on `read()` keeps running as long as its peer stays connected, and `listen()` doesn't return until it ends. Keep track of open WebSocket connections and `close()` them on shutdown, e.g. with `CloseStatus::GoingAway`.
|
||||
> **Note:** `stop()` doesn't interrupt WebSocket handlers. A handler looping on `read()` keeps running as long as its peer stays connected, and `listen()` doesn't return until it ends. Keep track of open WebSocket connections and `close()` them on shutdown, e.g. with `CloseStatus::GoingAway`. The handler's `read()` then waits for the peer's Close reply up to its read timeout (300 seconds by default). To shorten that, call `set_read_timeout()` in the handler before the loop; `read()` then also returns `Timeout` whenever the peer stays idle that long, so the loop has to handle it.
|
||||
@@ -56,4 +56,4 @@ int main() {
|
||||
|
||||
> **Warning:** `stop()`を呼んでから`listen()`が戻るまでには、処理中のリクエストが終わるのを待つ時間がかかります。タイムアウトを強制したい場合は、シャットダウン用のタイマーを別途用意するなど、アプリケーション側の工夫が必要です。
|
||||
|
||||
> **Note:** `stop()`はWebSocketハンドラを中断しません。`read()`をループで回しているハンドラは相手がつながっている限り動き続け、それが終わるまで`listen()`も戻りません。開いているWebSocket接続を記録しておき、シャットダウン時に`close()`(`CloseStatus::GoingAway`など)で閉じてください。
|
||||
> **Note:** `stop()`はWebSocketハンドラを中断しません。`read()`をループで回しているハンドラは相手がつながっている限り動き続け、それが終わるまで`listen()`も戻りません。開いているWebSocket接続を記録しておき、シャットダウン時に`close()`(`CloseStatus::GoingAway`など)で閉じてください。そのあとハンドラの`read()`は、相手のClose応答を読み込みタイムアウト(既定は300秒)まで待ちます。短くしたい場合は、ループの前に`set_read_timeout()`を呼んでください。その場合、相手が黙っている間は`read()`が`Timeout`を返すので、ループ側で扱う必要があります。
|
||||
+2
-7
@@ -37,11 +37,6 @@ file(
|
||||
)
|
||||
|
||||
if(HTTPLIB_IS_USING_OPENSSL)
|
||||
if (OPENSSL_VERSION VERSION_LESS "3.2.0")
|
||||
set(OPENSSL_X509_FLAG "-x509")
|
||||
else()
|
||||
set(OPENSSL_X509_FLAG "-x509v1")
|
||||
endif()
|
||||
find_program(OPENSSL_COMMAND
|
||||
NAMES openssl
|
||||
PATHS ${OPENSSL_INCLUDE_DIR}/../bin
|
||||
@@ -61,7 +56,7 @@ if(HTTPLIB_IS_USING_OPENSSL)
|
||||
COMMAND_ERROR_IS_FATAL ANY
|
||||
)
|
||||
execute_process(
|
||||
COMMAND ${OPENSSL_COMMAND} req ${OPENSSL_X509_FLAG} -new -config ${CMAKE_CURRENT_LIST_DIR}/test.conf -key key.pem -sha256 -days 3650 -nodes -out cert2.pem -extensions SAN
|
||||
COMMAND ${OPENSSL_COMMAND} req -x509 -new -config ${CMAKE_CURRENT_LIST_DIR}/test.conf -key key.pem -sha256 -days 3650 -nodes -out cert2.pem -extensions SAN
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
|
||||
COMMAND_ERROR_IS_FATAL ANY
|
||||
)
|
||||
@@ -72,7 +67,7 @@ if(HTTPLIB_IS_USING_OPENSSL)
|
||||
COMMAND_ERROR_IS_FATAL ANY
|
||||
)
|
||||
execute_process(
|
||||
COMMAND ${OPENSSL_COMMAND} req ${OPENSSL_X509_FLAG} -new -batch -config ${CMAKE_CURRENT_LIST_DIR}/test.rootCA.conf -key rootCA.key.pem -days 1024
|
||||
COMMAND ${OPENSSL_COMMAND} req -x509 -new -batch -config ${CMAKE_CURRENT_LIST_DIR}/test.rootCA.conf -key rootCA.key.pem -days 1024
|
||||
OUTPUT_FILE rootCA.cert.pem
|
||||
WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
|
||||
COMMAND_ERROR_IS_FATAL ANY
|
||||
|
||||
+1
-1
@@ -260,7 +260,7 @@ endif
|
||||
test_benchmark : test_benchmark.cc ../httplib.h Makefile
|
||||
$(CXX) -o $@ -I.. $(CXXFLAGS) test_benchmark.cc gtest/src/gtest-all.cc gtest/src/gtest_main.cc -Igtest -Igtest/include $(BENCHMARK_LIBS)
|
||||
|
||||
test_websocket_heartbeat : test_websocket_heartbeat.cc ../httplib.h Makefile
|
||||
test_websocket_heartbeat : test_websocket_heartbeat.cc ../httplib.h Makefile cert.pem
|
||||
$(CXX) -o $@ -I.. $(CXXFLAGS) test_websocket_heartbeat.cc $(TEST_ARGS)
|
||||
@file $@
|
||||
|
||||
|
||||
+13
-2
@@ -13,14 +13,15 @@ ZLIB_SUPPORT = -DCPPHTTPLIB_ZLIB_SUPPORT -lz
|
||||
BROTLI_DIR = /usr/local/opt/brotli
|
||||
# BROTLI_SUPPORT = -DCPPHTTPLIB_BROTLI_SUPPORT -I$(BROTLI_DIR)/include -L$(BROTLI_DIR)/lib -lbrotlicommon -lbrotlienc -lbrotlidec
|
||||
|
||||
FUZZERS = server_fuzzer url_parser_fuzzer header_parser_fuzzer client_fuzzer multipart_parser_fuzzer
|
||||
FUZZERS = server_fuzzer url_parser_fuzzer header_parser_fuzzer client_fuzzer multipart_parser_fuzzer websocket_fuzzer sse_parser_fuzzer server_mount_fuzzer
|
||||
|
||||
# Runs all the tests and also fuzz tests against seed corpus.
|
||||
all : $(FUZZERS)
|
||||
./server_fuzzer corpus/*
|
||||
./server_mount_fuzzer corpus_mount/*
|
||||
|
||||
# Fuzz target, so that you can choose which $(LIB_FUZZING_ENGINE) to use.
|
||||
server_fuzzer : server_fuzzer.cc ../../httplib.h
|
||||
server_fuzzer : server_fuzzer.cc fuzzed_stream.h ../../httplib.h
|
||||
# $(CXX) $(CXXFLAGS) -o $@ $< -Wl,-Bstatic $(OPENSSL_SUPPORT) -Wl,-Bdynamic -ldl $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread
|
||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||
zip -q -r server_fuzzer_seed_corpus.zip corpus
|
||||
@@ -38,5 +39,15 @@ url_parser_fuzzer : url_parser_fuzzer.cc ../../httplib.h
|
||||
multipart_parser_fuzzer : multipart_parser_fuzzer.cc ../../httplib.h
|
||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||
|
||||
websocket_fuzzer : websocket_fuzzer.cc ../../httplib.h
|
||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||
|
||||
sse_parser_fuzzer : sse_parser_fuzzer.cc ../../httplib.h
|
||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||
|
||||
server_mount_fuzzer : server_mount_fuzzer.cc fuzzed_stream.h ../../httplib.h
|
||||
$(CXX) $(CXXFLAGS) -o $@ $< $(ZLIB_SUPPORT) $(LIB_FUZZING_ENGINE) -pthread -lanl
|
||||
zip -q -r server_mount_fuzzer_seed_corpus.zip corpus_mount
|
||||
|
||||
clean:
|
||||
rm -f server_fuzzer pem *.0 *.o *.1 *.srl *.zip
|
||||
@@ -0,0 +1,3 @@
|
||||
HEAD /mnt/a.txt HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
GET /mnt/a.txt HTTP/1.1
|
||||
Host: x
|
||||
If-Modified-Since: Mon, 01 Jan 2024 00:00:00 GMT
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/index.html HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
GET /mnt/index.html HTTP/1.1
|
||||
Host: x
|
||||
If-None-Match: W/"bogusetag"
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/link-in.txt HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/link-out.txt HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/link-sibling.txt HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/missing.txt HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,4 @@
|
||||
GET /mnt/a.txt HTTP/1.1
|
||||
Host: x
|
||||
Range: bytes=0-3
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/sub/ HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/../../../../etc/passwd HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
GET /mnt/%2e%2e/secret.txt HTTP/1.1
|
||||
Host: x
|
||||
|
||||
@@ -0,0 +1,84 @@
|
||||
#pragma once
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
#include <httplib.h>
|
||||
|
||||
class FuzzedStream : public httplib::Stream {
|
||||
public:
|
||||
FuzzedStream(const uint8_t *data, size_t size)
|
||||
: data_(data), size_(size), read_pos_(0) {}
|
||||
|
||||
ssize_t read(char *ptr, size_t size) override {
|
||||
if (size + read_pos_ > size_) { size = size_ - read_pos_; }
|
||||
memcpy(ptr, data_ + read_pos_, size);
|
||||
read_pos_ += size;
|
||||
// Like SocketStream, pull in more than was asked for, which the line
|
||||
// reader then takes through buffered_data(), so both of its paths run.
|
||||
buffered_end_ =
|
||||
(std::max)(buffered_end_, (std::min)(size_, read_pos_ + 4096));
|
||||
return static_cast<ssize_t>(size);
|
||||
}
|
||||
|
||||
const char *buffered_data(size_t &size) const override {
|
||||
size = buffered_end_ > read_pos_ ? buffered_end_ - read_pos_ : 0;
|
||||
return size ? reinterpret_cast<const char *>(data_ + read_pos_) : nullptr;
|
||||
}
|
||||
|
||||
void consume_buffered(size_t size) override { read_pos_ += size; }
|
||||
|
||||
ssize_t write(const char *ptr, size_t size) override {
|
||||
response_.append(ptr, size);
|
||||
return static_cast<int>(size);
|
||||
}
|
||||
|
||||
ssize_t write(const char *ptr) { return write(ptr, strlen(ptr)); }
|
||||
|
||||
ssize_t write(const std::string &s) { return write(s.data(), s.size()); }
|
||||
|
||||
bool is_readable() const override { return true; }
|
||||
|
||||
bool wait_readable() const override { return true; }
|
||||
|
||||
bool wait_writable() const override { return true; }
|
||||
|
||||
void get_remote_ip_and_port(std::string &ip, int &port) const override {
|
||||
ip = "127.0.0.1";
|
||||
port = 8080;
|
||||
}
|
||||
|
||||
void get_local_ip_and_port(std::string &ip, int &port) const override {
|
||||
ip = "127.0.0.1";
|
||||
port = 8080;
|
||||
}
|
||||
|
||||
socket_t socket() const override { return 0; }
|
||||
|
||||
time_t duration() const override { return 0; };
|
||||
|
||||
const std::string &response() const { return response_; }
|
||||
|
||||
private:
|
||||
const uint8_t *data_;
|
||||
size_t size_;
|
||||
size_t read_pos_;
|
||||
size_t buffered_end_ = 0;
|
||||
std::string response_;
|
||||
};
|
||||
|
||||
class FuzzableServer : public httplib::Server {
|
||||
public:
|
||||
// A server that is not listening counts as shutting down, and then writes
|
||||
// no file. The socket is never used.
|
||||
void MarkAsRunning() { svr_sock_ = 0; }
|
||||
|
||||
void ProcessFuzzedRequest(FuzzedStream &stream) {
|
||||
bool connection_close = false;
|
||||
process_request(stream,
|
||||
/*remote_addr=*/"",
|
||||
/*remote_port =*/0,
|
||||
/*local_addr=*/"",
|
||||
/*local_port =*/0,
|
||||
/*last_connection=*/false, connection_close, nullptr);
|
||||
}
|
||||
};
|
||||
@@ -1,79 +1,4 @@
|
||||
#include <cstdint>
|
||||
|
||||
#include <httplib.h>
|
||||
|
||||
class FuzzedStream : public httplib::Stream {
|
||||
public:
|
||||
FuzzedStream(const uint8_t *data, size_t size)
|
||||
: data_(data), size_(size), read_pos_(0) {}
|
||||
|
||||
ssize_t read(char *ptr, size_t size) override {
|
||||
if (size + read_pos_ > size_) { size = size_ - read_pos_; }
|
||||
memcpy(ptr, data_ + read_pos_, size);
|
||||
read_pos_ += size;
|
||||
// Like SocketStream, pull in more than was asked for, which the line
|
||||
// reader then takes through buffered_data(), so both of its paths run.
|
||||
buffered_end_ =
|
||||
(std::max)(buffered_end_, (std::min)(size_, read_pos_ + 4096));
|
||||
return static_cast<ssize_t>(size);
|
||||
}
|
||||
|
||||
const char *buffered_data(size_t &size) const override {
|
||||
size = buffered_end_ > read_pos_ ? buffered_end_ - read_pos_ : 0;
|
||||
return size ? reinterpret_cast<const char *>(data_ + read_pos_) : nullptr;
|
||||
}
|
||||
|
||||
void consume_buffered(size_t size) override { read_pos_ += size; }
|
||||
|
||||
ssize_t write(const char *ptr, size_t size) override {
|
||||
response_.append(ptr, size);
|
||||
return static_cast<int>(size);
|
||||
}
|
||||
|
||||
ssize_t write(const char *ptr) { return write(ptr, strlen(ptr)); }
|
||||
|
||||
ssize_t write(const std::string &s) { return write(s.data(), s.size()); }
|
||||
|
||||
bool is_readable() const override { return true; }
|
||||
|
||||
bool wait_readable() const override { return true; }
|
||||
|
||||
bool wait_writable() const override { return true; }
|
||||
|
||||
void get_remote_ip_and_port(std::string &ip, int &port) const override {
|
||||
ip = "127.0.0.1";
|
||||
port = 8080;
|
||||
}
|
||||
|
||||
void get_local_ip_and_port(std::string &ip, int &port) const override {
|
||||
ip = "127.0.0.1";
|
||||
port = 8080;
|
||||
}
|
||||
|
||||
socket_t socket() const override { return 0; }
|
||||
|
||||
time_t duration() const override { return 0; };
|
||||
|
||||
private:
|
||||
const uint8_t *data_;
|
||||
size_t size_;
|
||||
size_t read_pos_;
|
||||
size_t buffered_end_ = 0;
|
||||
std::string response_;
|
||||
};
|
||||
|
||||
class FuzzableServer : public httplib::Server {
|
||||
public:
|
||||
void ProcessFuzzedRequest(FuzzedStream &stream) {
|
||||
bool connection_close = false;
|
||||
process_request(stream,
|
||||
/*remote_addr=*/"",
|
||||
/*remote_port =*/0,
|
||||
/*local_addr=*/"",
|
||||
/*local_port =*/0,
|
||||
/*last_connection=*/false, connection_close, nullptr);
|
||||
}
|
||||
};
|
||||
#include "fuzzed_stream.h"
|
||||
|
||||
static FuzzableServer g_server;
|
||||
|
||||
|
||||
@@ -0,0 +1,117 @@
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <fstream>
|
||||
#include <random>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
#include <sys/stat.h>
|
||||
#include <unistd.h>
|
||||
#include <utime.h>
|
||||
|
||||
#include "fuzzed_stream.h"
|
||||
|
||||
// Fixture layout, with <token> unknown to the fuzzer:
|
||||
// root/mnt/{index.html,a.txt,data.bin,sub/index.html} served at /mnt
|
||||
// root/mnt/link-in.txt -> a.txt (stays inside, may be served)
|
||||
// root/mnt/link-out.txt -> ../outside.txt (escapes, must be refused)
|
||||
// root/mnt/link-sibling.txt -> ../mnt_secret/secret.txt (shares the "mnt"
|
||||
// prefix, must be refused)
|
||||
// The response must never contain <token>.
|
||||
|
||||
namespace {
|
||||
|
||||
FuzzableServer g_server;
|
||||
std::string g_root;
|
||||
std::string g_token;
|
||||
std::vector<std::string> g_paths; // In creation order
|
||||
|
||||
void check(bool ok, const char *what) {
|
||||
if (!ok) {
|
||||
fprintf(stderr, "fixture setup failed: %s\n", what);
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
void make_dir(const std::string &path) {
|
||||
check(mkdir(path.c_str(), 0755) == 0, path.c_str());
|
||||
g_paths.push_back(path);
|
||||
}
|
||||
|
||||
void make_file(const std::string &path, const std::string &content) {
|
||||
{
|
||||
std::ofstream out(path, std::ios::binary);
|
||||
out << content;
|
||||
check(out.good(), path.c_str());
|
||||
}
|
||||
// Fixed, so that conditional requests behave the same in every run
|
||||
utimbuf times = {1700000000, 1700000000};
|
||||
check(utime(path.c_str(), ×) == 0, path.c_str());
|
||||
g_paths.push_back(path);
|
||||
}
|
||||
|
||||
void make_link(const std::string &target, const std::string &path) {
|
||||
check(symlink(target.c_str(), path.c_str()) == 0, path.c_str());
|
||||
g_paths.push_back(path);
|
||||
}
|
||||
|
||||
std::string serve(const uint8_t *data, size_t size) {
|
||||
FuzzedStream stream{data, size};
|
||||
g_server.ProcessFuzzedRequest(stream);
|
||||
return stream.response();
|
||||
}
|
||||
|
||||
void check_served(const char *path) {
|
||||
auto req = std::string("GET ") + path + " HTTP/1.1\r\nHost: x\r\n\r\n";
|
||||
auto res = serve(reinterpret_cast<const uint8_t *>(req.data()), req.size());
|
||||
// Without this, a fuzzer that serves nothing would pass its check forever
|
||||
check(res.find("abcdef") != std::string::npos, path);
|
||||
}
|
||||
|
||||
void remove_fixture() {
|
||||
for (auto it = g_paths.rbegin(); it != g_paths.rend(); ++it) {
|
||||
if (unlink(it->c_str()) != 0) { rmdir(it->c_str()); }
|
||||
}
|
||||
rmdir(g_root.c_str());
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
extern "C" int LLVMFuzzerInitialize(int * /*argc*/, char *** /*argv*/) {
|
||||
std::random_device rd;
|
||||
char token[33];
|
||||
snprintf(token, sizeof(token), "%08x%08x%08x%08x", rd(), rd(), rd(), rd());
|
||||
g_token = token;
|
||||
|
||||
auto tmpdir = getenv("TMPDIR");
|
||||
auto tmpl = std::string(tmpdir && *tmpdir ? tmpdir : "/tmp") +
|
||||
"/httplib-mount-XXXXXX";
|
||||
check(mkdtemp(&tmpl[0]) != nullptr, tmpl.c_str());
|
||||
g_root = tmpl;
|
||||
atexit(remove_fixture);
|
||||
|
||||
auto mnt = g_root + "/mnt";
|
||||
make_dir(mnt);
|
||||
make_dir(mnt + "/sub");
|
||||
make_dir(g_root + "/mnt_secret");
|
||||
make_file(mnt + "/index.html", "<html>index</html>");
|
||||
make_file(mnt + "/a.txt", "abcdef");
|
||||
make_file(mnt + "/data.bin", std::string("\x01\x02\x03\x04\x05\x06", 6));
|
||||
make_file(mnt + "/sub/index.html", "<html>sub</html>");
|
||||
make_file(g_root + "/outside.txt", g_token);
|
||||
make_file(g_root + "/mnt_secret/secret.txt", g_token);
|
||||
make_link("a.txt", mnt + "/link-in.txt");
|
||||
make_link("../outside.txt", mnt + "/link-out.txt");
|
||||
make_link("../mnt_secret/secret.txt", mnt + "/link-sibling.txt");
|
||||
|
||||
g_server.MarkAsRunning();
|
||||
check(g_server.set_mount_point("/mnt", mnt), "set_mount_point");
|
||||
check_served("/mnt/a.txt");
|
||||
check_served("/mnt/link-in.txt");
|
||||
return 0;
|
||||
}
|
||||
|
||||
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
if (serve(data, size).find(g_token) != std::string::npos) { abort(); }
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,24 @@
|
||||
"GET"
|
||||
"HEAD"
|
||||
"HTTP/1.1"
|
||||
|
||||
"/mnt/"
|
||||
"/mnt/index.html"
|
||||
"/mnt/a.txt"
|
||||
"/mnt/data.bin"
|
||||
"/mnt/sub/"
|
||||
"/mnt/link-in.txt"
|
||||
"/mnt/link-out.txt"
|
||||
"/mnt/link-sibling.txt"
|
||||
".."
|
||||
"%2e%2e"
|
||||
"%2f"
|
||||
"//"
|
||||
|
||||
"Range: bytes=0-"
|
||||
"Range: bytes=0-3,5-"
|
||||
"If-None-Match: "
|
||||
"W/"
|
||||
"If-Modified-Since: "
|
||||
"If-Range: "
|
||||
"Accept-Encoding: gzip"
|
||||
@@ -0,0 +1,49 @@
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstdlib>
|
||||
#include <string>
|
||||
|
||||
#include <httplib.h>
|
||||
|
||||
namespace {
|
||||
|
||||
// Feeds the stream in chunks and records every handler call in order
|
||||
std::string parse_in_chunks(const std::string &stream, size_t chunk,
|
||||
size_t max_event_length) {
|
||||
std::string trace;
|
||||
httplib::detail::SSEParser parser(
|
||||
[&](const httplib::sse::SSEMessage &msg) {
|
||||
trace += "event[" + msg.event + "|" + msg.data + "|" + msg.id + "]";
|
||||
},
|
||||
[&](const std::string &id) { trace += "id[" + id + "]"; },
|
||||
[&](int retry_ms) { trace += "retry[" + std::to_string(retry_ms) + "]"; },
|
||||
max_event_length);
|
||||
|
||||
for (size_t off = 0; off < stream.size(); off += chunk) {
|
||||
if (!parser.parse(stream.data() + off,
|
||||
std::min(chunk, stream.size() - off))) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return trace;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
if (size < 2 || size > 65536) { return 0; }
|
||||
|
||||
// First byte selects the chunk size, the rest is the event stream
|
||||
auto chunk = static_cast<size_t>(data[0]) + 1;
|
||||
std::string stream(reinterpret_cast<const char *>(data + 1), size - 1);
|
||||
|
||||
// Without a length limit, chunking must not change what is reported
|
||||
auto whole = parse_in_chunks(stream, stream.size(), 0);
|
||||
auto chunked = parse_in_chunks(stream, chunk, 0);
|
||||
if (whole != chunked) { std::abort(); }
|
||||
|
||||
// With a limit, only check that the parser stops cleanly
|
||||
parse_in_chunks(stream, chunk, 64);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -13,7 +13,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
size_t payload_size = size - 1;
|
||||
std::string input(payload, payload_size);
|
||||
|
||||
switch (selector % 6) {
|
||||
switch (selector % 13) {
|
||||
case 0: {
|
||||
// parse_query_text
|
||||
httplib::Params params;
|
||||
@@ -46,6 +46,48 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
httplib::detail::is_valid_path(input);
|
||||
break;
|
||||
}
|
||||
case 6: {
|
||||
// parse_url
|
||||
httplib::detail::UrlComponents uc;
|
||||
httplib::detail::parse_url(input, uc);
|
||||
break;
|
||||
}
|
||||
case 7: {
|
||||
// remove_dot_segments
|
||||
httplib::detail::remove_dot_segments(input);
|
||||
break;
|
||||
}
|
||||
case 8: {
|
||||
// resolve_relative_location, with the input as "<location>\n<base>"
|
||||
auto nl = input.find('\n');
|
||||
auto location = input.substr(0, nl);
|
||||
auto base = nl == std::string::npos ? std::string("/index.html")
|
||||
: input.substr(nl + 1);
|
||||
httplib::detail::resolve_relative_location(location, base);
|
||||
break;
|
||||
}
|
||||
case 9: {
|
||||
// encode_path
|
||||
httplib::detail::encode_path(input);
|
||||
break;
|
||||
}
|
||||
case 10: {
|
||||
// encode_uri_component, encode_uri
|
||||
httplib::encode_uri_component(input);
|
||||
httplib::encode_uri(input);
|
||||
break;
|
||||
}
|
||||
case 11: {
|
||||
// decode_uri_component, decode_uri
|
||||
httplib::decode_uri_component(input);
|
||||
httplib::decode_uri(input);
|
||||
break;
|
||||
}
|
||||
case 12: {
|
||||
// sanitize_filename
|
||||
httplib::sanitize_filename(input);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
@@ -0,0 +1,54 @@
|
||||
#include <cstdint>
|
||||
#include <string>
|
||||
|
||||
#include <httplib.h>
|
||||
|
||||
extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
|
||||
if (size < 2) { return 0; }
|
||||
|
||||
auto selector = data[0];
|
||||
std::string input(reinterpret_cast<const char *>(data + 1), size - 1);
|
||||
|
||||
switch (selector % 4) {
|
||||
case 0: {
|
||||
// read_websocket_frame. WebSocket::read passes the macro, close() passes
|
||||
// 125, and 0 means no limit
|
||||
static const size_t max_lens[] = {0, 125,
|
||||
CPPHTTPLIB_WEBSOCKET_MAX_PAYLOAD_LENGTH};
|
||||
auto expect_masked = (selector / 4) % 2 != 0;
|
||||
auto max_len = max_lens[(selector / 8) % 3];
|
||||
httplib::detail::BufferStream strm;
|
||||
strm.write(input.data(), input.size());
|
||||
auto opcode = httplib::ws::Opcode::Text;
|
||||
std::string payload;
|
||||
auto fin = false;
|
||||
httplib::ws::impl::read_websocket_frame(strm, opcode, payload, fin,
|
||||
expect_masked, max_len);
|
||||
break;
|
||||
}
|
||||
case 1: {
|
||||
// is_valid_utf8
|
||||
httplib::ws::impl::is_valid_utf8(input);
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
// is_valid_close_payload
|
||||
httplib::ws::impl::is_valid_close_payload(input);
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
// read_websocket_upgrade_response, with a fixed key since
|
||||
// perform_websocket_handshake draws a random one
|
||||
static const auto expected_accept =
|
||||
httplib::detail::websocket_accept_key("dGhlIHNhbXBsZSBub25jZQ==");
|
||||
httplib::detail::BufferStream strm;
|
||||
strm.write(input.data(), input.size());
|
||||
httplib::detail::WebSocketUpgradeResponse upgrade;
|
||||
httplib::detail::read_websocket_upgrade_response(strm, expected_accept,
|
||||
"chat, stream", upgrade);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
[libfuzzer]
|
||||
max_len = 70000
|
||||
+5
-7
@@ -1,15 +1,9 @@
|
||||
#!/usr/bin/env bash
|
||||
if [[ $(openssl version) =~ 3\.[2-9]\.[0-9]+ ]]; then
|
||||
OPENSSL_X509_FLAG='-x509v1'
|
||||
else
|
||||
OPENSSL_X509_FLAG='-x509'
|
||||
fi
|
||||
|
||||
openssl genrsa 2048 > key.pem
|
||||
openssl req -new -batch -config test.conf -key key.pem | openssl x509 -days 3650 -req -signkey key.pem > cert.pem
|
||||
openssl req -x509 -config test.conf -key key.pem -sha256 -days 3650 -nodes -out cert2.pem -extensions SAN
|
||||
openssl genrsa 2048 > rootCA.key.pem
|
||||
openssl req $OPENSSL_X509_FLAG -new -batch -config test.rootCA.conf -key rootCA.key.pem -days 1024 > rootCA.cert.pem
|
||||
openssl req -x509 -new -batch -config test.rootCA.conf -key rootCA.key.pem -days 1024 > rootCA.cert.pem
|
||||
openssl genrsa 2048 > client.key.pem
|
||||
openssl req -new -batch -config test.conf -key client.key.pem | openssl x509 -days 370 -req -CA rootCA.cert.pem -CAkey rootCA.key.pem -CAcreateserial > client.cert.pem
|
||||
openssl genrsa -passout pass:test123! 2048 > key_encrypted.pem
|
||||
@@ -47,3 +41,7 @@ openssl req -x509 -key key.pem -sha256 -days 3650 -nodes -subj "/CN=localhost" -
|
||||
# "*.leftmost.example.test" matches a single label; the
|
||||
# wildcard in "www.*.example.test" must not be honoured.
|
||||
openssl req -x509 -key key.pem -sha256 -days 3650 -nodes -subj "/CN=wildcard-san" -addext "subjectAltName=DNS:*.leftmost.example.test,DNS:www.*.example.test" -out cert_wildcard_san.pem
|
||||
|
||||
# The client certs must chain to a root that openssl accepts as a CA; a root
|
||||
# without basicConstraints CA:TRUE makes every client-cert test fail.
|
||||
openssl verify -CAfile rootCA.cert.pem client.cert.pem client_encrypted.cert.pem
|
||||
+1267
-256
File diff suppressed because it is too large.
Load diff
@@ -2,6 +2,7 @@
|
||||
default_bits = 2048
|
||||
distinguished_name = req_distinguished_name
|
||||
attributes = req_attributes
|
||||
x509_extensions = v3_ca
|
||||
prompt = no
|
||||
output_password = mypass
|
||||
|
||||
@@ -16,3 +17,8 @@ emailAddress = test@email.address
|
||||
|
||||
[req_attributes]
|
||||
challengePassword = 1234
|
||||
|
||||
# Mark the root as a CA explicitly. Relying on the openssl version to emit a
|
||||
# v1 certificate (or CA:TRUE by default) breaks when the default changes.
|
||||
[v3_ca]
|
||||
basicConstraints = critical,CA:TRUE
|
||||
@@ -1,10 +1,10 @@
|
||||
// Standalone test for WebSocket automatic heartbeat.
|
||||
// Compiled with a 1-second ping interval so we can verify heartbeat behavior
|
||||
// without waiting 30 seconds.
|
||||
// Standalone test for WebSocket heartbeat and close() timing, compiled with
|
||||
// short intervals and timeouts so the tests don't wait for the defaults.
|
||||
|
||||
#define CPPHTTPLIB_WEBSOCKET_PING_INTERVAL_SECOND 1
|
||||
#define CPPHTTPLIB_WEBSOCKET_CLIENT_READ_TIMEOUT_SECOND 3
|
||||
#define CPPHTTPLIB_WEBSOCKET_SERVER_READ_TIMEOUT_SECOND 3
|
||||
#define CPPHTTPLIB_WEBSOCKET_CLOSE_TIMEOUT_SECOND 1
|
||||
#include <httplib.h>
|
||||
|
||||
#include "gtest/gtest.h"
|
||||
@@ -289,3 +289,139 @@ TEST_F(WebSocketHeartbeatTest, MultipleHeartbeatCycles) {
|
||||
|
||||
client.close();
|
||||
}
|
||||
|
||||
// A raw client never answers the server's close() and sends `bytes`, `chunk`
|
||||
// bytes at a time `gap` apart; close() must still return at its 1 s timeout.
|
||||
static void expect_close_bounded(bool use_tls, const std::string &bytes,
|
||||
size_t chunk, std::chrono::milliseconds gap) {
|
||||
std::unique_ptr<Server> svr;
|
||||
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||
if (use_tls) { svr.reset(new SSLServer("cert.pem", "key.pem")); }
|
||||
#endif
|
||||
if (!svr) { svr.reset(new Server); }
|
||||
svr->set_websocket_ping_interval(0);
|
||||
|
||||
std::atomic<bool> upgraded{false};
|
||||
std::atomic<bool> closed{false};
|
||||
std::chrono::steady_clock::duration close_took{};
|
||||
svr->WebSocket("/ws", [&](const Request &, ws::WebSocket &ws) {
|
||||
while (!upgraded) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(1));
|
||||
}
|
||||
auto start = std::chrono::steady_clock::now();
|
||||
ws.close();
|
||||
close_took = std::chrono::steady_clock::now() - start;
|
||||
closed = true;
|
||||
});
|
||||
auto port = svr->bind_to_any_port("127.0.0.1");
|
||||
ASSERT_GT(port, 0);
|
||||
std::thread t([&] { svr->listen_after_bind(); });
|
||||
auto se = detail::scope_exit([&] {
|
||||
upgraded = true; // Releases the handler when an assertion bails out early
|
||||
svr->stop();
|
||||
t.join();
|
||||
});
|
||||
svr->wait_until_ready();
|
||||
|
||||
auto sock = ::socket(AF_INET, SOCK_STREAM, 0);
|
||||
ASSERT_NE(INVALID_SOCKET, sock);
|
||||
auto sock_se = detail::scope_exit([&] { detail::close_socket(sock); });
|
||||
sockaddr_in addr{};
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_port = htons(static_cast<uint16_t>(port));
|
||||
::inet_pton(AF_INET, "127.0.0.1", &addr.sin_addr);
|
||||
ASSERT_EQ(0,
|
||||
::connect(sock, reinterpret_cast<sockaddr *>(&addr), sizeof(addr)));
|
||||
|
||||
std::unique_ptr<Stream> strm;
|
||||
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||
tls::ctx_t ctx = nullptr;
|
||||
tls::session_t session = nullptr;
|
||||
auto tls_se = detail::scope_exit([&] {
|
||||
if (session) { tls::free_session(session); }
|
||||
if (ctx) { tls::free_context(ctx); }
|
||||
});
|
||||
if (use_tls) {
|
||||
ctx = tls::create_client_context();
|
||||
tls::set_verify_client(ctx, false); // The test certificate is self-signed
|
||||
session = tls::create_session(ctx, sock);
|
||||
ASSERT_TRUE(tls::connect_nonblocking(session, sock, 5, 0, nullptr));
|
||||
strm.reset(new detail::SSLSocketStream(sock, session, 5, 0, 5, 0));
|
||||
}
|
||||
#endif
|
||||
if (!strm) { strm.reset(new detail::SocketStream(sock, 5, 0, 5, 0)); }
|
||||
|
||||
const std::string upgrade = "GET /ws HTTP/1.1\r\n"
|
||||
"Host: 127.0.0.1\r\n"
|
||||
"Upgrade: websocket\r\n"
|
||||
"Connection: Upgrade\r\n"
|
||||
"Sec-WebSocket-Key: AAAAAAAAAAAAAAAAAAAAAA==\r\n"
|
||||
"Sec-WebSocket-Version: 13\r\n"
|
||||
"\r\n";
|
||||
ASSERT_EQ(static_cast<ssize_t>(upgrade.size()),
|
||||
strm->write(upgrade.data(), upgrade.size()));
|
||||
std::string response;
|
||||
char c;
|
||||
while (response.find("\r\n\r\n") == std::string::npos &&
|
||||
strm->read(&c, 1) == 1) {
|
||||
response += c;
|
||||
}
|
||||
ASSERT_NE(std::string::npos, response.find(" 101 "));
|
||||
upgraded = true;
|
||||
|
||||
// Without the bound, close() would wait as long as the client sends
|
||||
auto give_up = std::chrono::steady_clock::now() + std::chrono::seconds(4);
|
||||
while (!closed && std::chrono::steady_clock::now() < give_up) {
|
||||
for (size_t off = 0; off < bytes.size() && !closed;) {
|
||||
auto n = strm->write(bytes.data() + off,
|
||||
(std::min)(chunk, bytes.size() - off));
|
||||
if (n <= 0) { break; }
|
||||
off += static_cast<size_t>(n);
|
||||
auto next = std::chrono::steady_clock::now() + gap;
|
||||
while (!closed && std::chrono::steady_clock::now() < next) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
||||
}
|
||||
}
|
||||
}
|
||||
while (!closed) {
|
||||
std::this_thread::sleep_for(std::chrono::milliseconds(10));
|
||||
}
|
||||
EXPECT_LT(close_took, std::chrono::milliseconds(2500));
|
||||
}
|
||||
|
||||
// Empty masked Ping frames, enough to keep the socket full
|
||||
static std::string ping_flood() {
|
||||
const std::string ping("\x89\x80\0\0\0\0", 6);
|
||||
std::string bytes;
|
||||
while (bytes.size() < 64 * 1024) {
|
||||
bytes += ping;
|
||||
}
|
||||
return bytes;
|
||||
}
|
||||
|
||||
// A masked 20-byte Ping; sent a byte at a time, it outlasts the close timeout
|
||||
static std::string ping_with_payload() {
|
||||
return std::string("\x89\x8e\0\0\0\0", 6) + std::string(14, 'x');
|
||||
}
|
||||
|
||||
TEST(WebSocketCloseTest, BoundedAgainstPeerThatKeepsSending) {
|
||||
expect_close_bounded(/*use_tls=*/false, ping_flood(), ping_flood().size(),
|
||||
std::chrono::milliseconds(0));
|
||||
}
|
||||
|
||||
TEST(WebSocketCloseTest, BoundedAgainstPeerThatTricklesAFrame) {
|
||||
expect_close_bounded(/*use_tls=*/false, ping_with_payload(), 1,
|
||||
std::chrono::milliseconds(300));
|
||||
}
|
||||
|
||||
#ifdef CPPHTTPLIB_SSL_ENABLED
|
||||
TEST(WebSocketCloseTest, SSLBoundedAgainstPeerThatKeepsSending) {
|
||||
expect_close_bounded(/*use_tls=*/true, ping_flood(), ping_flood().size(),
|
||||
std::chrono::milliseconds(0));
|
||||
}
|
||||
|
||||
TEST(WebSocketCloseTest, SSLBoundedAgainstPeerThatTricklesAFrame) {
|
||||
expect_close_bounded(/*use_tls=*/true, ping_with_payload(), 1,
|
||||
std::chrono::milliseconds(300));
|
||||
}
|
||||
#endif
|
||||
Reference in new issue
Block a user