Inside Bitcoin

251        HTTPRequest req;
252        LineReader reader("GET / HTTP/0.9\r\nHost: 127.0.0.1\r\n\r\n", MAX_HEADERS_SIZE);
253        BOOST_CHECK_EXCEPTION(req.LoadControlData(reader), std::runtime_error, HasReason{"HTTP bad version"});
254    }
255    {
256        // Malformed: version is out of range
257        HTTPRequest req;
258        LineReader reader("GET / HTTP/-1.0\r\nHost: 127.0.0.1\r\n\r\n", MAX_HEADERS_SIZE);
259        BOOST_CHECK_EXCEPTION(req.LoadControlData(reader), std::runtime_error, HasReason{"HTTP bad version"});
260    }
261    {
262        // Malformed: version is not exactly two integers and a dot
263        HTTPRequest req;
264        LineReader reader("GET / HTTP/1.00\r\nHost: 127.0.0.1\r\n\r\n", MAX_HEADERS_SIZE);
265        BOOST_CHECK_EXCEPTION(req.LoadControlData(reader), std::runtime_error, HasReason{"HTTP bad version"});
266    }
267    {
268        // Malformed: contains NUL
269        HTTPRequest req;
270        LineReader reader{std::string_view{"GET /safe\0/etc/passwd HTTP/1.00\r\nHost: 127.0.0.1\r\n\r\n", 50}, MAX_HEADERS_SIZE};
271        BOOST_CHECK_EXCEPTION(req.LoadControlData(reader), std::runtime_error, HasReason{"Invalid request line contains NUL"});
272    }
273    {
274        // Malformed: differing Content-Length values, case insensitive
275        constexpr std::string_view differing_length = "GET / HTTP/1.1\n"
276                                                      "Host: 127.0.0.1\n"
277                                                      "Content-Length: 8\n"
278                                                      "content-length: 9\n\n"
279                                                      "12345678";
280        HTTPRequest req;
281        util::LineReader reader{differing_length, /*max_line_length=*/MAX_HEADERS_SIZE};
282        BOOST_CHECK(req.LoadControlData(reader));
283        BOOST_CHECK(req.LoadHeaders(reader));
284        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), std::runtime_error, HasReason{"Differing Content-Length values"});
285    }
286    {
287        // Ok: multiple same Content-Length values
288        constexpr std::string_view differing_length = "GET / HTTP/1.1\n"
289                                                      "Host: 127.0.0.1\n"
290                                                      "Content-Length: 8\n"
291                                                      "content-length: 8\n\n"
292                                                      "12345678";
293        HTTPRequest req;
294        util::LineReader reader{differing_length, /*max_line_length=*/MAX_HEADERS_SIZE};
295        BOOST_CHECK(req.LoadControlData(reader));
296        BOOST_CHECK(req.LoadHeaders(reader));
297        BOOST_CHECK(req.LoadBody(reader));
298    }
299    {
300        // Ok
301        HTTPRequest req;
302        LineReader reader("GET / HTTP/1.0\r\nHost: 127.0.0.1\r\n\r\n", MAX_HEADERS_SIZE);
303        BOOST_CHECK(req.LoadControlData(reader));
304        BOOST_CHECK(req.LoadHeaders(reader));
305        BOOST_CHECK(req.LoadBody(reader));
306        BOOST_CHECK_EQUAL(req.GetRequestMethod(), HTTPRequestMethod::GET);
307        BOOST_CHECK_EQUAL(req.GetURI(), "/");
308        BOOST_CHECK_EQUAL(req.GetVersion().major, 1);
309        BOOST_CHECK_EQUAL(req.GetVersion().minor, 0);
310        BOOST_CHECK_EQUAL(req.GetHeader("Host"), "127.0.0.1");
311        // no body is OK
312        BOOST_CHECK_EQUAL(req.ReadBody(), "");
313    }
314    {
315        // Malformed: missing colon
316        HTTPRequest req;
317        LineReader reader("GET / HTTP/1.0\r\nHost=127.0.0.1\r\n\r\n", MAX_HEADERS_SIZE);
318        BOOST_CHECK(req.LoadControlData(reader));
319        BOOST_CHECK_EXCEPTION(req.LoadHeaders(reader), std::runtime_error, HasReason{"HTTP header missing colon (:)"});
320    }
321    {
322        // We might not have received enough data from the client which is not
323        // an error. We return false so the caller can try again later when the
324        // buffer has more data.
325        HTTPRequest req;
326        LineReader reader("GET / HTTP/1.0\r\nHost: ", MAX_HEADERS_SIZE);
327        BOOST_CHECK(req.LoadControlData(reader));
328        BOOST_CHECK(!req.LoadHeaders(reader));
329    }
330    {
331        // No Content-Length: body is not read
332        HTTPRequest req;
333        LineReader reader("GET / HTTP/1.0\r\n\r\n" R"({"method":"getblockcount"})", MAX_HEADERS_SIZE);
334        BOOST_CHECK(req.LoadControlData(reader));
335        BOOST_CHECK(req.LoadHeaders(reader));
336        BOOST_CHECK(req.LoadBody(reader));
337        // Don't try to read request body if Content-Length is missing
338        BOOST_CHECK_EQUAL(req.ReadBody(), "");
339    }
340    {
341        // Malformed: Content-Length is not a number
342        HTTPRequest req;
343        LineReader reader("GET / HTTP/1.0\r\nContent-Length: eleven\r\n\r\n" R"({"method":"getblockcount"})", MAX_HEADERS_SIZE);
344        BOOST_CHECK(req.LoadControlData(reader));
345        BOOST_CHECK(req.LoadHeaders(reader));
346        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), std::runtime_error, HasReason{"Cannot parse Content-Length value"});
347    }
348    {
349        // Malformed: Content-Length is negative
350        HTTPRequest req;
351        LineReader reader("GET / HTTP/1.0\r\nContent-Length: -8\r\n\r\n" R"({"method":"getblockcount"})", MAX_HEADERS_SIZE);
352        BOOST_CHECK(req.LoadControlData(reader));
353        BOOST_CHECK(req.LoadHeaders(reader));
354        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), std::runtime_error, HasReason{"Cannot parse Content-Length value"});
355    }
356    {
357        // Content-Length exceeds limit
358        constexpr auto excessive_size{MAX_BODY_SIZE + 1};
359        std::string huge_body(excessive_size, 'x');
360        const std::string request{"GET / HTTP/1.0\r\nContent-Length: " + util::ToString(excessive_size) + "\r\n\r\n" + std::move(huge_body)};
361        HTTPRequest req;
362        LineReader reader(request, MAX_HEADERS_SIZE);
363        BOOST_CHECK(req.LoadControlData(reader));
364        BOOST_CHECK(req.LoadHeaders(reader));
365        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), ContentTooLargeError, HasReason{"Max body size exceeded"});
366    }
367    {
368        // Content-Length exactly on the limit
369        std::string max_body(MAX_BODY_SIZE, 'x');
370        const std::string request{"GET / HTTP/1.0\r\nContent-Length: " + util::ToString(MAX_BODY_SIZE) + "\r\n\r\n" + std::move(max_body)};
371        HTTPRequest req;
372        LineReader reader(request, MAX_HEADERS_SIZE);
373        BOOST_CHECK(req.LoadControlData(reader));
374        BOOST_CHECK(req.LoadHeaders(reader));
375        BOOST_CHECK(req.LoadBody(reader));
376    }
377    {
378        // Content-Length indicates more data than we have in the buffer.
379        // Not an error; we wait for more data before completing the body.
380        HTTPRequest req;
381        LineReader reader("GET / HTTP/1.0\r\nContent-Length: 1024\r\n\r\n" R"({"method":"getblockcount"})", MAX_HEADERS_SIZE);
382        BOOST_CHECK(req.LoadControlData(reader));
383        BOOST_CHECK(req.LoadHeaders(reader));
384        BOOST_CHECK(!req.LoadBody(reader));
385    }
386    {
387        // Support "chunked" transfer. Chunk lengths are ascii-encoded hex integers, whitespace ignored
388        HTTPRequest req;
389        std::string_view ok_chunked = "GET / HTTP/1.0\n"
390                                      "Transfer-Encoding: chunked\n"
391                                      "\n"
392                                      "10\n"
393                                      R"({"method":"getbl)""\n"
394                                      "   a    \n"
395                                      R"(ockcount"})""\n"
396                                      "0\n"
397                                      "\n";
398        LineReader reader(ok_chunked, MAX_HEADERS_SIZE);
399        BOOST_CHECK(req.LoadControlData(reader));
400        BOOST_CHECK(req.LoadHeaders(reader));
401        BOOST_CHECK(req.LoadBody(reader));
402        BOOST_CHECK_EQUAL(req.ReadBody(), R"({"method":"getblockcount"})");
403    }
404    {
405        // Prevent "chunked" transfer from exceeding size limit
406        HTTPRequest req;
407        std::string_view excessive_chunk_size = "GET / HTTP/1.0\n"
408                                                "Transfer-Encoding: chunked\n"
409                                                "\n"
410                                                "10\n"
411                                                R"({"method":"getbl)""\n"
412                                                "20000000\n"
413                                                R"(ockcount"})""\n"
414                                                "0\n"
415                                                "\n";
416        LineReader reader(excessive_chunk_size, MAX_HEADERS_SIZE);
417        BOOST_CHECK(req.LoadControlData(reader));
418        BOOST_CHECK(req.LoadHeaders(reader));
419        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), ContentTooLargeError, HasReason{"Chunk will exceed max body size"});
420    }
421    {
422        // Allow (but ignore) Chunk Extensions
423        HTTPRequest req;
424        std::string_view ok_chunked = "GET / HTTP/1.0\n"
425                                      "Transfer-Encoding: chunked\n"
426                                      "\n"
427                                      "10;sha256=715790e8a3b09d704ac9641f42d183a5ebc5fd939663de23da548519ac2165e5\n"
428                                      R"({"method":"getbl)""\n"
429                                      "   a   ;    compressed\n"
430                                      R"(ockcount"})""\n"
431                                      "0;why;would;anyone;do;this;\n"
432                                      "Expires: Wed, 21 Oct 2026 07:28:00 GMT\n"
433                                      "\n";
434        LineReader reader(ok_chunked, MAX_HEADERS_SIZE);
435        BOOST_CHECK(req.LoadControlData(reader));
436        BOOST_CHECK(req.LoadHeaders(reader));
437        BOOST_CHECK(req.LoadBody(reader));
438        BOOST_CHECK_EQUAL(req.ReadBody(), R"({"method":"getblockcount"})");
439        // Chunk Trailer was parsed, but ignored
440        BOOST_CHECK_EQUAL(reader.Remaining(), 0);
441        BOOST_CHECK(!req.GetHeader("Expires"));
442    }
443    {
444        // Invalid "chunked" transfer, using roman numerals instead of hex for chunk length
445        HTTPRequest req;
446        std::string_view invalid_chunked = "GET / HTTP/1.0\n"
447                                           "Transfer-Encoding: chunked\n"
448                                           "\n"
449                                           "XVI\n"
450                                           R"({"method":"getbl)""\n"
451                                           "X\n"
452                                           R"(ockcount"})""\n"
453                                           "0\n"
454                                           "\n";
455        LineReader reader(invalid_chunked, MAX_HEADERS_SIZE);
456        BOOST_CHECK(req.LoadControlData(reader));
457        BOOST_CHECK(req.LoadHeaders(reader));
458        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), std::runtime_error, HasReason{"Cannot parse chunk length value"});
459    }
460    {
461        // Invalid "chunked" transfer, missing chunk termination \n
462        HTTPRequest req;
463        std::string_view invalid_chunked = "GET / HTTP/1.0\n"
464                                           "Transfer-Encoding: chunked\n"
465                                           "\n"
466                                           "10\n"
467                                           R"({"method":"getbl)"
468                                           "a\n" // interpreted as extra data at the end of `0x10`-sized chunk
469                                           R"(ockcount"})"
470                                           "0\n"
471                                           "\n";
472        LineReader reader(invalid_chunked, MAX_HEADERS_SIZE);
473        BOOST_CHECK(req.LoadControlData(reader));
474        BOOST_CHECK(req.LoadHeaders(reader));
475        BOOST_CHECK_EXCEPTION(req.LoadBody(reader), std::runtime_error, HasReason{"Improperly terminated chunk"});
476    }
477}
478
479BOOST_AUTO_TEST_CASE(http_request_state_tests)
480{
481    // For these tests we just need a receive buffer for the requests to read from.
482    class DummyClient : public HTTPRemoteClient
483    {
484    public:
485        DummyClient() : HTTPRemoteClient{/*id=*/0, /*addr=*/CService(), /*socket=*/CreateSock(0, 0, 0)} {}
486
487        void receive(std::string_view s)
488        {
489            MutateRecvBuffer().append(s);
490        }
491    };
492
493    {
494        // Step through state machine
495        std::shared_ptr<DummyClient> client{std::make_shared<DummyClient>()};
496        BOOST_CHECK(!client->GetRequest());
497
498        client->receive("POST / HTTP/1.0\n");
499        BOOST_CHECK(!HTTPRemoteClient::TryReadRequest(client));
500        BOOST_CHECK_EQUAL(client->GetRequest()->GetState(), HTTPRequest::State::NeedsHeaders);