ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
web_server_base.cpp
Go to the documentation of this file.
1#include "web_server_base.h"
2
3#include <cstring>
4
6
7#if defined(USE_NETWORK) && !defined(USE_ZEPHYR) && !defined(USE_HOST)
8
10
11WebServerBase *global_web_server_base = nullptr; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
12
13#if defined(USE_WEBSERVER_ALLOWED_ORIGINS) || !defined(USE_WEBSERVER_ALLOW_ANY_ORIGIN)
14// Not inlined, so its header copies leave the stack before the wrapped handler runs
15static bool __attribute__((noinline)) is_request_origin_allowed(AsyncWebServerRequest *request,
16 const char *const *allowed) {
17#ifdef USE_ESP32
18 // Stack copies: the IDF server only hands out header values by copy
19 char origin[MAX_ORIGIN_LENGTH + 1];
20 const size_t origin_len = request->get_header_to("Origin", origin);
21 if (origin_len == 0)
22 return true;
23 // Longer than codegen lets a configured entry be
24 if (origin_len == SIZE_MAX)
25 return false;
26 char host[MAX_ORIGIN_LENGTH + 1];
27 size_t host_len = request->get_header_to("Host", host);
28 // A Host that does not fit means an Origin longer than the buffer, already handled above
29 if (host_len == SIZE_MAX)
30 host_len = 0;
32#else
33 const AsyncWebHeader *origin = request->getHeader("Origin");
34 if (origin == nullptr)
35 return true;
36 const AsyncWebHeader *host = request->getHeader("Host");
37 return is_origin_allowed(origin->value().c_str(), origin->value().length(),
38 host != nullptr ? host->value().c_str() : nullptr,
39 host != nullptr ? host->value().length() : 0, allowed);
40#endif
41}
42#endif
43
44namespace internal {
45
46bool GuardMiddlewareHandler::check_auth_(AsyncWebServerRequest *request) {
47#ifdef USE_WEBSERVER_AUTH
49 if (!credentials.is_set())
50 return true;
51 // The scheme is chosen at build time (USE_WEBSERVER_AUTH_DIGEST); the unused path is
52 // compiled out. On ESP32 our own server picks the scheme internally.
53#if USE_ESP32 || defined(USE_WEBSERVER_AUTH_DIGEST)
54 bool success = request->authenticate(credentials.username, credentials.password);
55 if (!success)
56 request->requestAuthentication();
57#else
58 // Checked here, not with the library's authenticate()/requestAuthentication(): those also link its
59 // Digest code, since the scheme is only known at run time there
60 const String &challenge = request->authChallenge();
61 const size_t hash_len = strlen(credentials.basic_auth_hash);
62 const bool success = request->authType() == AsyncAuthType::AUTH_BASIC && challenge.length() == hash_len &&
63 constant_time_equals(reinterpret_cast<const uint8_t *>(challenge.c_str()),
64 reinterpret_cast<const uint8_t *>(credentials.basic_auth_hash), hash_len);
65 if (!success) {
66 // The challenge the library sent, with the strings kept in flash on ESP8266
67 AsyncWebServerResponse *response = request->beginResponse(401);
68 response->addHeader(String(F("WWW-Authenticate")), String(F("Basic realm=\"Login Required\"")));
69 request->send(response);
70 }
71#endif
72 return success;
73#else
74 return true;
75#endif
76}
77
78bool GuardMiddlewareHandler::check_origin_(AsyncWebServerRequest *request) {
79 // Codegen never sets both defines
80#if defined(USE_WEBSERVER_ALLOWED_ORIGINS)
81 return is_request_origin_allowed(request, global_web_server_base->allowed_origins_);
82#elif defined(USE_WEBSERVER_ALLOW_ANY_ORIGIN)
83 return true;
84#else
85 return is_request_origin_allowed(request, nullptr);
86#endif
87}
88
89bool GuardMiddlewareHandler::check_chunk_(AsyncWebServerRequest *request, size_t index) {
90 // Every chunk is gated, but only the first of a request pays for the header copies and digest.
91 // A request always starts at index 0, so a new request reusing a freed request's address is
92 // checked again; an interleaved request has another address; a rejected one never sets passed_.
93 if (index != 0 && request == this->passed_)
94 return true;
95 if (!this->check_origin_(request) || !this->check_auth_(request)) {
96 this->passed_ = nullptr;
97 return false;
98 }
99 this->passed_ = request;
100 return true;
101}
102
103void GuardMiddlewareHandler::handleRequest(AsyncWebServerRequest *request) {
104 this->passed_ = nullptr;
105 if (!this->check_origin_(request)) {
106 request->send(403);
107 return;
108 }
109 if (this->check_auth_(request))
111}
112
113void GuardMiddlewareHandler::handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index,
114 uint8_t *data, size_t len, bool final) {
115 // A handler that buffers chunks never sees one from a rejected request
116 if (!this->check_chunk_(request, index))
117 return;
118 MiddlewareHandler::handleUpload(request, filename, index, data, len, final);
119}
120
121void GuardMiddlewareHandler::handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index,
122 size_t total) {
123 if (!this->check_chunk_(request, index))
124 return;
125 MiddlewareHandler::handleBody(request, data, len, index, total);
126}
127
128} // namespace internal
129
130void WebServerBase::add_handler(AsyncWebHandler *handler) {
132}
133
134void WebServerBase::add_handler_without_auth(AsyncWebHandler *handler) {
135 this->handlers_.push_back(handler);
136 if (this->server_ != nullptr) {
137 this->server_->addHandler(handler);
138 }
139}
140
141} // namespace esphome::web_server_base
142#endif
void add_handler_without_auth(AsyncWebHandler *handler)
WARNING: Registers a handler that bypasses the auth and origin middleware.
void add_handler(AsyncWebHandler *handler)
std::vector< AsyncWebHandler * > handlers_
void handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index, uint8_t *data, size_t len, bool final) override
bool check_chunk_(AsyncWebServerRequest *request, size_t index)
void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override
void handleRequest(AsyncWebServerRequest *request) override
void handleUpload(AsyncWebServerRequest *request, const PlatformString &filename, size_t index, uint8_t *data, size_t len, bool final) override
void handleRequest(AsyncWebServerRequest *request) override
void handleBody(AsyncWebServerRequest *request, uint8_t *data, size_t len, size_t index, size_t total) override
struct @66::@67 __attribute__
Wake the main loop task from an ISR. ISR-safe.
Definition main_task.h:45
static bool const char *const * allowed
const AsyncWebHeader * origin
WebServerBase * global_web_server_base
char host[MAX_ORIGIN_LENGTH+1]
bool is_origin_allowed(const char *origin, size_t origin_len, const char *host, size_t host_len, const char *const *allowed)
Decide whether a browser request from the given Origin may reach a handler.
Definition origin.cpp:9
const void size_t len
Definition hal.h:68
bool constant_time_equals(const uint8_t *a, const uint8_t *b, size_t len)
Compare len bytes of a and b in a time that does not depend on where they first differ.
Definition helpers.h:1195
std::string PlatformString