Implements WebSocket HTTP/1.1 upgrade handshake (RFC 6455). More...

#include <websocket_handshake.h>

Collaboration diagram for kcenon::network::internal::websocket_handshake:

Static Public Member Functions
static auto	create_client_handshake (std::string_view host, std::string_view path, uint16_t port, const std::map< std::string, std::string > &extra_headers={}) -> std::string
	Creates a WebSocket handshake request (client-side).

static auto	validate_server_response (const std::string &response, const std::string &expected_key) -> ws_handshake_result
	Validates a WebSocket handshake response (client-side).

static auto	parse_client_request (const std::string &request) -> ws_handshake_result
	Parses a WebSocket handshake request (server-side).

static auto	create_server_response (const std::string &client_key) -> std::string
	Creates a WebSocket handshake response (server-side).

static auto	generate_websocket_key () -> std::string
	Generates a random Sec-WebSocket-Key (client-side).

static auto	calculate_accept_key (const std::string &client_key) -> std::string
	Calculates Sec-WebSocket-Accept from client key.

Static Private Member Functions
static auto	parse_headers (const std::string &http_message) -> std::map< std::string, std::string >
	Parses HTTP headers from a request or response.

static auto	extract_status_code (const std::string &response) -> int
	Extracts the status code from an HTTP response.

static auto	base64_encode (const std::vector< uint8_t > &data) -> std::string
	Encodes binary data to Base64.

static auto	sha1_hash (const std::string &data) -> std::vector< uint8_t >
	Computes SHA-1 hash of input data.

Detailed Description

Implements WebSocket HTTP/1.1 upgrade handshake (RFC 6455).

This class provides static methods for creating and validating WebSocket handshake requests and responses according to RFC 6455 Section 4.

Definition at line 36 of file websocket_handshake.h.

Member Function Documentation

◆ base64_encode()

auto kcenon::network::internal::websocket_handshake::base64_encode ( const std::vector< uint8_t > & data ) -> std::string

staticprivate

Encodes binary data to Base64.

Standard Base64 encoding without padding removal.

Parameters

data	The binary data to encode

Returns: Base64-encoded string

Definition at line 52 of file websocket_handshake.cpp.

    {
        std::string result;
        result.reserve(((data.size() + 2) / 3) * 4);
 
        int val = 0;
        int valb = -6;
 
        for (uint8_t c : data)
        {
            val = (val << 8) + c;
            valb += 8;
            while (valb >= 0)
            {
                result.push_back(BASE64_CHARS[(val >> valb) & 0x3F]);
                valb -= 6;
            }
        }
 
        if (valb > -6)
        {
            result.push_back(BASE64_CHARS[((val << 8) >> (valb + 8)) & 0x3F]);
        }
 
        while (result.size() % 4)
        {
            result.push_back('=');
        }
 
        return result;
    }

◆ calculate_accept_key()

auto kcenon::network::internal::websocket_handshake::calculate_accept_key ( const std::string & client_key ) -> std::string

static

Calculates Sec-WebSocket-Accept from client key.

Computes the accept value by concatenating the client key with the WebSocket GUID, hashing with SHA-1, and encoding as Base64.

Parameters

client_key The Sec-WebSocket-Key from the client

Returns: Base64-encoded SHA-1 hash

Definition at line 110 of file websocket_handshake.cpp.

    {
        // Concatenate client key with GUID
        std::string combined = client_key;
        combined.append(WEBSOCKET_GUID);
 
        // Hash with SHA-1
        auto hash = sha1_hash(combined);
 
        // Encode as Base64
        return base64_encode(hash);
    }

◆ create_client_handshake()

auto kcenon::network::internal::websocket_handshake::create_client_handshake	(	std::string_view	host,
		std::string_view	path,
		uint16_t	port,
		const std::map< std::string, std::string > &	extra_headers = {} ) -> std::string

static

Creates a WebSocket handshake request (client-side).

Generates an HTTP/1.1 upgrade request with all required WebSocket headers including a randomly generated Sec-WebSocket-Key.

Parameters

host	The target host (for Host header)
path	The request path (default: "/")
port	The target port (for Host header if non-standard)
extra_headers	Additional headers to include in the request

Returns: Complete HTTP request as a string

Definition at line 183 of file websocket_handshake.cpp.

    {
        std::ostringstream request;
 
        // Request line
        request << "GET " << path << " HTTP/1.1\r\n";
 
        // Host header (include port if non-standard)
        request << "Host: " << host;
        if (port != 80 && port != 443)
        {
            request << ":" << port;
        }
        request << "\r\n";
 
        // Required WebSocket headers
        request << "Upgrade: websocket\r\n";
        request << "Connection: Upgrade\r\n";
        request << "Sec-WebSocket-Key: " << generate_websocket_key() << "\r\n";
        request << "Sec-WebSocket-Version: 13\r\n";
 
        // Extra headers
        for (const auto& [name, value] : extra_headers)
        {
            request << name << ": " << value << "\r\n";
        }
 
        // Empty line to end headers
        request << "\r\n";
 
        return request.str();
    }

Referenced by kcenon::network::internal::websocket_socket::async_handshake().

Here is the caller graph for this function:

◆ create_server_response()

auto kcenon::network::internal::websocket_handshake::create_server_response ( const std::string & client_key ) -> std::string

static

Creates a WebSocket handshake response (server-side).

Generates an HTTP/1.1 101 Switching Protocols response with the computed Sec-WebSocket-Accept header.

Parameters

client_key The Sec-WebSocket-Key from the client's request

Returns: Complete HTTP response as a string

Definition at line 324 of file websocket_handshake.cpp.

    {
        std::ostringstream response;
 
        // Status line
        response << "HTTP/1.1 101 Switching Protocols\r\n";
 
        // Required headers
        response << "Upgrade: websocket\r\n";
        response << "Connection: Upgrade\r\n";
        response << "Sec-WebSocket-Accept: " << calculate_accept_key(client_key)
                 << "\r\n";
 
        // Empty line to end headers
        response << "\r\n";
 
        return response.str();
    }

Referenced by kcenon::network::internal::websocket_socket::async_accept().

Here is the caller graph for this function:

◆ extract_status_code()

auto kcenon::network::internal::websocket_handshake::extract_status_code ( const std::string & response ) -> int

staticprivate

Extracts the status code from an HTTP response.

Parses the HTTP status line to extract the numeric status code.

Parameters

response The complete HTTP response

Returns: Status code (e.g., 101, 200, 400), or 0 if parsing fails

Definition at line 163 of file websocket_handshake.cpp.

    {
        // HTTP response format: "HTTP/1.1 101 Switching Protocols\r\n"
        const auto first_line_end = response.find("\r\n");
        if (first_line_end == std::string::npos)
        {
            return 0;
        }
 
        const auto status_line = response.substr(0, first_line_end);
        std::istringstream stream(status_line);
 
        std::string http_version;
        int status_code = 0;
 
        stream >> http_version >> status_code;
        return status_code;
    }

◆ generate_websocket_key()

auto kcenon::network::internal::websocket_handshake::generate_websocket_key ( ) -> std::string

static

Generates a random Sec-WebSocket-Key (client-side).

Creates a Base64-encoded random 16-byte value for use in the client handshake request.

Returns: Base64-encoded random key (24 characters)

Definition at line 94 of file websocket_handshake.cpp.

    {
        // Generate 16 random bytes
        static thread_local std::random_device rd;
        static thread_local std::mt19937 gen(rd());
        static thread_local std::uniform_int_distribution<uint32_t> dis(0, 255);
 
        std::vector<uint8_t> random_bytes(16);
        for (auto& byte : random_bytes)
        {
            byte = static_cast<uint8_t>(dis(gen));
        }
 
        return base64_encode(random_bytes);
    }

◆ parse_client_request()

auto kcenon::network::internal::websocket_handshake::parse_client_request ( const std::string & request ) -> ws_handshake_result

static

Parses a WebSocket handshake request (server-side).

Validates that the client's request is a valid WebSocket upgrade request with all required headers.

Parameters

request The complete HTTP request from the client

Returns: Handshake result with success status and parsed headers

Definition at line 272 of file websocket_handshake.cpp.

    {
        ws_handshake_result result;
        result.success = false;
 
        // Parse headers
        result.headers = parse_headers(request);
 
        // Validate request line (should start with "GET")
        if (request.substr(0, 3) != "GET")
        {
            result.error_message = "Invalid HTTP method (expected GET)";
            return result;
        }
 
        // Validate Upgrade header
        auto it = result.headers.find("upgrade");
        if (it == result.headers.end() || to_lower(it->second) != "websocket")
        {
            result.error_message = "Missing or invalid Upgrade header";
            return result;
        }
 
        // Validate Connection header
        it = result.headers.find("connection");
        if (it == result.headers.end() || to_lower(it->second) != "upgrade")
        {
            result.error_message = "Missing or invalid Connection header";
            return result;
        }
 
        // Validate Sec-WebSocket-Key header
        it = result.headers.find("sec-websocket-key");
        if (it == result.headers.end() || it->second.empty())
        {
            result.error_message = "Missing or empty Sec-WebSocket-Key header";
            return result;
        }
 
        // Validate Sec-WebSocket-Version header
        it = result.headers.find("sec-websocket-version");
        if (it == result.headers.end() || it->second != "13")
        {
            result.error_message = "Missing or invalid Sec-WebSocket-Version header";
            return result;
        }
 
        result.success = true;
        return result;
    }

References kcenon::network::internal::ws_handshake_result::error_message, kcenon::network::internal::ws_handshake_result::headers, and kcenon::network::internal::ws_handshake_result::success.

Referenced by kcenon::network::internal::websocket_socket::async_accept().

Here is the caller graph for this function:

◆ parse_headers()

auto kcenon::network::internal::websocket_handshake::parse_headers ( const std::string & http_message ) -> std::map<std::string, std::string>

staticprivate

Parses HTTP headers from a request or response.

Extracts headers from the HTTP header section. Header names are converted to lowercase for case-insensitive lookup.

Parameters

http_message The complete HTTP message

Returns: Map of header names (lowercase) to values

Definition at line 124 of file websocket_handshake.cpp.

    {
        std::map<std::string, std::string> headers;
 
        // Find the end of headers (empty line)
        const auto header_end = http_message.find("\r\n\r\n");
        if (header_end == std::string::npos)
        {
            return headers;
        }
 
        std::istringstream stream(http_message.substr(0, header_end));
        std::string line;
 
        // Skip the first line (request/status line)
        std::getline(stream, line);
 
        // Parse headers
        while (std::getline(stream, line))
        {
            // Remove trailing \r if present
            if (!line.empty() && line.back() == '\r')
            {
                line.pop_back();
            }
 
            const auto colon_pos = line.find(':');
            if (colon_pos != std::string::npos)
            {
                auto name = to_lower(trim(line.substr(0, colon_pos)));
                auto value = trim(line.substr(colon_pos + 1));
                headers[name] = value;
            }
        }
 
        return headers;
    }

◆ sha1_hash()

auto kcenon::network::internal::websocket_handshake::sha1_hash ( const std::string & data ) -> std::vector<uint8_t>

staticprivate

Computes SHA-1 hash of input data.

Uses OpenSSL to compute the SHA-1 hash.

Parameters

data	The input data to hash

Returns: 20-byte SHA-1 hash

Definition at line 85 of file websocket_handshake.cpp.

    {
        std::vector<uint8_t> hash(SHA_DIGEST_LENGTH);
        SHA1(reinterpret_cast<const unsigned char*>(data.c_str()), data.size(),
             hash.data());
        return hash;
    }

◆ validate_server_response()

auto kcenon::network::internal::websocket_handshake::validate_server_response	(	const std::string &	response,
		const std::string &	expected_key ) -> ws_handshake_result

static

Validates a WebSocket handshake response (client-side).

Verifies that the server's response is a valid WebSocket upgrade response with the correct Sec-WebSocket-Accept value.

Parameters

response	The complete HTTP response from the server
expected_key	The Sec-WebSocket-Key that was sent in the request

Returns: Handshake result with success status and parsed headers

Definition at line 218 of file websocket_handshake.cpp.

    {
        ws_handshake_result result;
        result.success = false;
 
        // Check status code
        const int status_code = extract_status_code(response);
        if (status_code != 101)
        {
            result.error_message =
                "Invalid status code: " + std::to_string(status_code);
            return result;
        }
 
        // Parse headers
        result.headers = parse_headers(response);
 
        // Validate Upgrade header
        auto it = result.headers.find("upgrade");
        if (it == result.headers.end() || to_lower(it->second) != "websocket")
        {
            result.error_message = "Missing or invalid Upgrade header";
            return result;
        }
 
        // Validate Connection header
        it = result.headers.find("connection");
        if (it == result.headers.end() || to_lower(it->second) != "upgrade")
        {
            result.error_message = "Missing or invalid Connection header";
            return result;
        }
 
        // Validate Sec-WebSocket-Accept header
        it = result.headers.find("sec-websocket-accept");
        if (it == result.headers.end())
        {
            result.error_message = "Missing Sec-WebSocket-Accept header";
            return result;
        }
 
        const std::string expected_accept = calculate_accept_key(expected_key);
        if (it->second != expected_accept)
        {
            result.error_message = "Invalid Sec-WebSocket-Accept value";
            return result;
        }
 
        result.success = true;
        return result;
    }