Beast ನ CONNECT ಬಫರ್ ಅನ್ನು TLS ಹ್ಯಾಂಡ್‌ಶೇಕ್‌ಗೆ ಒಯ್ಯಿರಿ

Beast ಪ್ರಾಕ್ಸಿಯ CONNECT ಪ್ರತಿಕ್ರಿಯೆ ಹೆಡರ್ ಓದಿದ ನಂತರ ಪ್ರತಿಕ್ರಿಯೆ ಸ್ಥಿತಿ ಮತ್ತು ಕ್ರಿಯಾತ್ಮಕ ಬಫರ್ ಎರಡನ್ನೂ ಪರಿಶೀಲಿಸಿ. ಓದುವ ಕಾರ್ಯಾಚರಣೆ ಹೆಡರ್‌ನ ಅಂತ್ಯದ ಆಚೆಗಿನ ಬೈಟ್‌ಗಳನ್ನು ತರಬಹುದು ಮತ್ತು ಅವನ್ನು ನೀಡಿದ ಬಫರ್‌ನಲ್ಲಿ ಉಳಿಸಬಹುದು. ಕೇವಲ ಸಾಕೆಟ್ ಓದುವ ಓವರ್‌ಲೋಡ್‌ನಿಂದ TLS ಪ್ರಾರಂಭಿಸಿದರೆ ಆ ಉಳಿಸಿದ ಬೈಟ್‌ಗಳು TLS ಇನ್‌ಪುಟ್ ಮಾರ್ಗದ ಹೊರಗೆ ಉಳಿಯುತ್ತವೆ.

ಮುಂದಿನ ಪದರ SSL ಸ್ಟ್ರೀಮ್ ಆಗಿರುವ WebSocket ಸ್ಟ್ರೀಮ್‌ಗೆ ಬಫರ್ ಮಾಡಿದ ಹ್ಯಾಂಡ್‌ಶೇಕ್ ಓವರ್‌ಲೋಡ್ ಬಳಸಿ. ಇರುವ yield_context ಸೆಷನ್‌ನಲ್ಲಿ, ಎಲ್ಲಾ ಕಾರ್ಯಾಚರಣೆಗಳ ಉದ್ದಕ್ಕೂ buffer ಅನ್ನು ಜೀವಂತವಾಗಿಟ್ಟು:

http::response_parser<http::empty_body> response;
http::async_read_header(
    beast::get_lowest_layer(ws), buffer, response, yield[ec]);
if (ec) return;

auto status = response.get().result_int();
if (status < 200 || status >= 300) return;

std::size_t used = ws.next_layer().async_handshake(
    ssl::stream_base::client, buffer.data(), yield[ec]);
if (ec) return;
buffer.consume(used);

ಆರಂಭಿಕ ರಿಟರ್ನ್‌ಗಳು ಸೆಷನ್‌ನ ವೈಫಲ್ಯ ನಿರ್ಗಮನಗಳು; ಅಲ್ಲಿ ಸಾಮಾನ್ಯ ದೋಷ ವರದಿ ಮತ್ತು ಸ್ವಚ್ಛಗೊಳಿಸುವಿಕೆಯನ್ನು ಜೋಡಿಸಿ. ಯಶಸ್ವಿ CONNECT ಪ್ರತಿಕ್ರಿಯೆಯೇ ಸುರಂಗವನ್ನು ಸ್ಥಾಪಿಸುತ್ತದೆ. ತಿರಸ್ಕಾರ ಪುಟ TLS ಇನ್‌ಪುಟ್ ಆಗಬಾರದು.

ಬಫರ್ ಮಾಡಿದ ಓವರ್‌ಲೋಡ್ ದೋಷ ಕೋಡ್ ಮತ್ತು ಬೈಟ್ ಎಣಿಕೆಯೊಂದಿಗೆ ಪೂರ್ಣಗೊಳ್ಳುತ್ತದೆ. ಆ ಎಣಿಕೆ ನೀಡಿದ ಬಫರ್‌ಗಳಿಂದ ಎಷ್ಟು ಬೈಟ್ ಬಳಸಿತು ಎಂಬುದನ್ನು ವಿವರಿಸುತ್ತದೆ. ಪೂರ್ಣಗೊಂಡ ನಂತರ consume(used) ಬಳಸಿ ಅದೇ ಪೂರ್ವಪ್ರತ್ಯಯವನ್ನು ನಿಖರವಾಗಿ ತೆಗೆದುಹಾಕಿ. ಕಾರ್ಯಾಚರಣೆ ಪ್ರಾರಂಭಿಸುವ ಮೊದಲು ಬಫರ್ ಖಾಲಿ ಮಾಡಬೇಡಿ, ಹ್ಯಾಂಡ್‌ಶೇಕ್ ಬಾಕಿ ಇರುವಾಗ ಅದರ ಸಂಗ್ರಹವನ್ನು ಬದಲಿಸಬೇಡಿ ಮತ್ತು ಕಾರ್ಯಾಚರಣೆ ನೀಡಿದ ಪ್ರತಿ ಬೈಟ್ ಬಳಸಿದೆ ಎಂದು ಭಾವಿಸಬೇಡಿ.

CONNECT ನಂತರ ತಕ್ಷಣ ಕ್ಲೈಂಟ್ ಪ್ರಾರಂಭಿಸುವ ಸಾಮಾನ್ಯ TLS ನಲ್ಲಿ ಬಫರ್ ಖಾಲಿ ಇರಬಹುದು. ಓವರ್‌ಲೋಡ್ ಆ ಸಂದರ್ಭವನ್ನೂ ನಿರ್ವಹಿಸುತ್ತದೆ. ಅದರ ಉದ್ದೇಶ ಸ್ಟ್ರೀಮ್ ಗಡಿಗಳನ್ನು ಸಂರಕ್ಷಿಸುವುದು; ಅದು ಯಾವುದೇ ಹೆಚ್ಚುವರಿ ಪ್ರಾಕ್ಸಿ ಡೇಟಾವನ್ನು ಮಾನ್ಯ TLS ಆಗಿಸುವುದಿಲ್ಲ. ಹ್ಯಾಂಡ್‌ಶೇಕ್‌ಗೆ ಮೊದಲು SSL ಪದರದಲ್ಲಿ ಗಮ್ಯಸ್ಥಾನ ಹೋಸ್ಟ್‌ಹೆಸರು ಪರಿಶೀಲನೆ ಮತ್ತು SNI ಸಂರಚನೆಯನ್ನು ಇಟ್ಟುಕೊಳ್ಳಿ, ಮತ್ತು TLS ಯಶಸ್ವಿಯಾದ ನಂತರವೇ WebSocket ಅಪ್‌ಗ್ರೇಡ್ ಪ್ರಾರಂಭಿಸಿ.