matt/agila_open_tool
1
0 Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
23f2d29e3202de5b34ba76409a12ed058d54799f
agila_open_tool/tools/v/thirdparty/vschannel/vschannel.c
T

1757 lines
55 KiB
C
Raw Blame History

#include <vschannel.h>
#include <sspi.h>
// ALPN (RFC 7301) compatibility shim. Older toolchain headers (notably the
// ones bundled with tcc) predate the SChannel ALPN additions, so the structs,
// enums and constants below are missing there. Define them ourselves when the
// SDK headers did not. SECPKG_ATTR_APPLICATION_PROTOCOL guards the schannel.h
// types; SECBUFFER_APPLICATION_PROTOCOLS guards the sspi.h buffer constant.
#ifndef ANYSIZE_ARRAY
#define ANYSIZE_ARRAY 1
#endif
#ifndef SECPKG_ATTR_APPLICATION_PROTOCOL
#define SECPKG_ATTR_APPLICATION_PROTOCOL 35
typedef enum _SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT {
SecApplicationProtocolNegotiationExt_None,
SecApplicationProtocolNegotiationExt_NPN,
SecApplicationProtocolNegotiationExt_ALPN
} SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT, *PSEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT;
typedef struct _SEC_APPLICATION_PROTOCOL_LIST {
SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT ProtoNegoExt;
unsigned short ProtocolListSize;
unsigned char ProtocolList[ANYSIZE_ARRAY];
} SEC_APPLICATION_PROTOCOL_LIST, *PSEC_APPLICATION_PROTOCOL_LIST;
typedef struct _SEC_APPLICATION_PROTOCOLS {
unsigned long ProtocolListsSize;
SEC_APPLICATION_PROTOCOL_LIST ProtocolLists[ANYSIZE_ARRAY];
} SEC_APPLICATION_PROTOCOLS, *PSEC_APPLICATION_PROTOCOLS;
typedef enum _SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS {
SecApplicationProtocolNegotiationStatus_None,
SecApplicationProtocolNegotiationStatus_Success,
SecApplicationProtocolNegotiationStatus_SelectedClientOnly
} SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS, *PSEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS;
#define MAX_PROTOCOL_ID_SIZE 0xff
typedef struct _SecPkgContext_ApplicationProtocol {
SEC_APPLICATION_PROTOCOL_NEGOTIATION_STATUS ProtoNegoStatus;
SEC_APPLICATION_PROTOCOL_NEGOTIATION_EXT ProtoNegoExt;
unsigned char ProtocolIdSize;
unsigned char ProtocolId[MAX_PROTOCOL_ID_SIZE];
} SecPkgContext_ApplicationProtocol, *PSecPkgContext_ApplicationProtocol;
#endif // SECPKG_ATTR_APPLICATION_PROTOCOL
#ifndef SECBUFFER_APPLICATION_PROTOCOLS
#define SECBUFFER_APPLICATION_PROTOCOLS 18
#endif
// Proxy
WCHAR * psz_proxy_server = L"proxy";
INT i_proxy_port = 80;
// Options
INT port_number = 443;
BOOL use_proxy = FALSE;
DWORD protocol = 0;
ALG_ID aid_key_exch = 0;
// TODO: joe-c
// socket / tls ctx
struct TlsContext {
// SSPI
PSecurityFunctionTable sspi;
// Cred store
HCERTSTORE cert_store;
SCHANNEL_CRED schannel_cred;
// Socket
SOCKET socket;
CredHandle h_client_creds;
CtxtHandle h_context;
PCCERT_CONTEXT p_pemote_cert_context;
INT last_error_code;
BOOL validate_server_certificate;
BOOL creds_initialized;
BOOL context_initialized;
// ALPN protocol list to advertise, in the standard ALPN wire format (each
// name 1-byte length-prefixed), e.g. "\x02h2\x08http/1.1". alpn_wire_len == 0
// means "do not advertise ALPN".
unsigned char alpn_wire[256];
unsigned long alpn_wire_len;
// Negotiated application protocol name (e.g. "h2"); negotiated_alpn_len == 0
// when the server selected none.
char negotiated_alpn[256];
unsigned long negotiated_alpn_len;
// Streaming transport state, used by the keep-the-connection-open path
// (vschannel_h2_connect / vschannel_write / vschannel_read) that backs the
// HTTP/2 driver. The one-shot request() path does not touch these.
SecPkgContext_StreamSizes stream_sizes; // cached TLS record sizes
BOOL stream_sizes_valid;
// Ciphertext staging buffer: bytes recv()'d from the socket that have not yet
// been decrypted into a full record (SEC_E_INCOMPLETE_MESSAGE) plus any
// trailing SECBUFFER_EXTRA from the last DecryptMessage.
unsigned char *recv_buf;
unsigned long recv_buf_cap;
unsigned long recv_buf_len;
// Decrypted plaintext carryover: a single DecryptMessage can yield more
// application bytes than the caller's read buffer can hold, so the remainder
// is stashed here and drained on the next vschannel_read().
unsigned char *plain_buf;
unsigned long plain_buf_cap;
unsigned long plain_buf_len; // valid decrypted bytes
unsigned long plain_buf_off; // bytes already returned to caller
// Reusable encryption buffer for vschannel_write(): one full record
// (header + max message + trailer). Cached so the HTTP/2 driver's many small
// writes do not LocalAlloc/LocalFree on every call.
unsigned char *send_buf;
unsigned long send_buf_cap;
BOOL stream_eof; // close_notify / context expired seen
};
TlsContext new_tls_context() {
return (struct TlsContext) {
.cert_store = NULL,
.last_error_code = 0,
.socket = INVALID_SOCKET,
.validate_server_certificate = TRUE,
.creds_initialized = FALSE,
.context_initialized = FALSE,
.p_pemote_cert_context = NULL,
.alpn_wire_len = 0,
.negotiated_alpn_len = 0,
.stream_sizes_valid = FALSE,
.recv_buf = NULL,
.recv_buf_cap = 0,
.recv_buf_len = 0,
.plain_buf = NULL,
.plain_buf_cap = 0,
.plain_buf_len = 0,
.plain_buf_off = 0,
.send_buf = NULL,
.send_buf_cap = 0,
.stream_eof = FALSE
};
};
// vschannel_alpn_supported reports whether this Windows version's SChannel
// supports client-side ALPN, which was introduced in Windows 8.1 / Server
// 2012 R2 (version 6.3). On older versions, passing a
// SECBUFFER_APPLICATION_PROTOCOLS input buffer into the handshake can fail it
// outright, so callers should skip ALPN (and HTTP/2) entirely there. Uses
// RtlGetVersion because GetVersionEx lies on manifest-less binaries from
// Windows 8.1 onwards.
INT vschannel_alpn_supported() {
static INT cached = -1;
if (cached < 0) {
typedef LONG (WINAPI *RtlGetVersionFn)(OSVERSIONINFOW *);
OSVERSIONINFOW vi;
RtlGetVersionFn get_version = (RtlGetVersionFn)GetProcAddress(
GetModuleHandleW(L"ntdll.dll"), "RtlGetVersion");
INT supported = 0;
if (get_version != NULL) {
ZeroMemory(&vi, sizeof(vi));
vi.dwOSVersionInfoSize = sizeof(vi);
if (get_version(&vi) == 0
&& (vi.dwMajorVersion > 6
|| (vi.dwMajorVersion == 6 && vi.dwMinorVersion >= 3))) {
supported = 1;
}
}
cached = supported;
}
return cached;
}
// vschannel_set_alpn configures the ALPN protocol list to advertise during the
// next handshake. `wire` is the standard ALPN wire format (each protocol name
// preceded by a 1-byte length), e.g. "\x02h2\x08http/1.1". Passing len == 0
// disables ALPN advertisement.
void vschannel_set_alpn(TlsContext *tls_ctx, const char *wire, INT len) {
if (len < 0) {
len = 0;
}
if (len > (INT)sizeof(tls_ctx->alpn_wire)) {
len = (INT)sizeof(tls_ctx->alpn_wire);
}
if (len > 0) {
memcpy(tls_ctx->alpn_wire, wire, (size_t)len);
}
tls_ctx->alpn_wire_len = (unsigned long)len;
}
// vschannel_get_alpn copies the protocol the server selected via ALPN (e.g.
// "h2") into `out` and returns its length, or 0 if none was negotiated.
INT vschannel_get_alpn(TlsContext *tls_ctx, char *out, INT out_cap) {
unsigned long n = tls_ctx->negotiated_alpn_len;
if (out_cap < 0) {
out_cap = 0;
}
if (n > (unsigned long)out_cap) {
n = (unsigned long)out_cap;
}
if (n > 0) {
memcpy(out, tls_ctx->negotiated_alpn, (size_t)n);
}
return (INT)n;
}
// vschannel_capture_alpn queries the negotiated ALPN protocol from a completed
// handshake and stores it on the context for vschannel_get_alpn().
static void vschannel_capture_alpn(TlsContext *tls_ctx) {
SecPkgContext_ApplicationProtocol appproto;
SECURITY_STATUS st;
tls_ctx->negotiated_alpn_len = 0;
st = tls_ctx->sspi->QueryContextAttributes(&tls_ctx->h_context,
SECPKG_ATTR_APPLICATION_PROTOCOL, &appproto);
if (st == SEC_E_OK
&& appproto.ProtoNegoStatus == SecApplicationProtocolNegotiationStatus_Success
&& appproto.ProtocolIdSize > 0
&& appproto.ProtocolIdSize <= sizeof(tls_ctx->negotiated_alpn)) {
memcpy(tls_ctx->negotiated_alpn, appproto.ProtocolId, appproto.ProtocolIdSize);
tls_ctx->negotiated_alpn_len = appproto.ProtocolIdSize;
}
}
static void vschannel_clear_last_error(TlsContext *tls_ctx) {
tls_ctx->last_error_code = 0;
}
static void vschannel_set_last_error(TlsContext *tls_ctx, INT err_code) {
tls_ctx->last_error_code = err_code;
}
static INT vschannel_last_error(TlsContext *tls_ctx) {
return tls_ctx->last_error_code;
}
void vschannel_cleanup(TlsContext *tls_ctx) {
// Free the server certificate context.
if(tls_ctx->p_pemote_cert_context) {
CertFreeCertificateContext(tls_ctx->p_pemote_cert_context);
tls_ctx->p_pemote_cert_context = NULL;
}
// Free SSPI context handle.
if(tls_ctx->context_initialized) {
tls_ctx->sspi->DeleteSecurityContext(&tls_ctx->h_context);
tls_ctx->context_initialized = FALSE;
}
// Free SSPI credentials handle.
if(tls_ctx->creds_initialized) {
tls_ctx->sspi->FreeCredentialsHandle(&tls_ctx->h_client_creds);
tls_ctx->creds_initialized = FALSE;
}
// Close socket.
if(tls_ctx->socket != INVALID_SOCKET) {
closesocket(tls_ctx->socket);
tls_ctx->socket = INVALID_SOCKET;
}
// Close "MY" certificate store.
if(tls_ctx->cert_store) {
CertCloseStore(tls_ctx->cert_store, 0);
tls_ctx->cert_store = NULL;
}
// Free streaming-transport buffers.
if(tls_ctx->recv_buf) {
LocalFree(tls_ctx->recv_buf);
tls_ctx->recv_buf = NULL;
}
tls_ctx->recv_buf_cap = 0;
tls_ctx->recv_buf_len = 0;
if(tls_ctx->plain_buf) {
LocalFree(tls_ctx->plain_buf);
tls_ctx->plain_buf = NULL;
}
tls_ctx->plain_buf_cap = 0;
tls_ctx->plain_buf_len = 0;
tls_ctx->plain_buf_off = 0;
if(tls_ctx->send_buf) {
LocalFree(tls_ctx->send_buf);
tls_ctx->send_buf = NULL;
}
tls_ctx->send_buf_cap = 0;
tls_ctx->stream_sizes_valid = FALSE;
tls_ctx->stream_eof = FALSE;
}
void vschannel_init(TlsContext *tls_ctx, BOOL validate_server_certificate) {
tls_ctx->sspi = InitSecurityInterface();
tls_ctx->validate_server_certificate = validate_server_certificate;
if(tls_ctx->sspi == NULL) {
wprintf(L"Error 0x%x reading security interface.\n",
GetLastError());
vschannel_cleanup(tls_ctx);
}
// Create credentials.
if(create_credentials(tls_ctx)) {
wprintf(L"Error creating credentials\n");
vschannel_cleanup(tls_ctx);
}
tls_ctx->creds_initialized = TRUE;
}
// vschannel_open_and_handshake performs the connection setup shared by
// request(), vschannel_alpn_probe() and vschannel_h2_connect(): connect to
// host:iport, run the TLS handshake (advertising any configured ALPN), record
// the negotiated protocol, and — when verify_cert is set — validate the server
// certificate. On success the connection is left open (context_initialized) and,
// when pExtraData is non-NULL, it receives any application bytes the handshake
// bundled with its final flight (the caller then owns pExtraData->pvBuffer and
// must LocalFree it). On failure it records the error, frees any bundled extra,
// tears the connection down, and returns a non-zero SECURITY_STATUS. A connect
// failure already set last_error via connect_to_server.
static SECURITY_STATUS vschannel_open_and_handshake(TlsContext *tls_ctx, INT iport, LPWSTR host, BOOL verify_cert, SecBuffer *pExtraData) {
SecBuffer local_extra;
SecBuffer *extra = pExtraData ? pExtraData : &local_extra;
SECURITY_STATUS Status;
extra->pvBuffer = NULL;
extra->cbBuffer = 0;
protocol = SP_PROT_TLS1_2_CLIENT;
port_number = iport;
vschannel_clear_last_error(tls_ctx);
if(connect_to_server(tls_ctx, host, port_number)) {
vschannel_cleanup(tls_ctx);
return SEC_E_INTERNAL_ERROR;
}
Status = perform_client_handshake(tls_ctx, host, extra);
if(Status != SEC_E_OK) {
vschannel_set_last_error(tls_ctx, Status);
goto fail;
}
tls_ctx->context_initialized = TRUE;
// Record the ALPN protocol the server selected (if any).
vschannel_capture_alpn(tls_ctx);
if(verify_cert) {
// Get and validate the server's certificate.
Status = tls_ctx->sspi->QueryContextAttributes(&tls_ctx->h_context,
SECPKG_ATTR_REMOTE_CERT_CONTEXT, (PVOID)&tls_ctx->p_pemote_cert_context);
if(Status != SEC_E_OK) {
vschannel_set_last_error(tls_ctx, Status);
goto fail;
}
Status = verify_server_certificate(tls_ctx->p_pemote_cert_context, host, 0);
if(Status != SEC_E_OK) {
// Could not authenticate the server (possible MITM): abort.
vschannel_set_last_error(tls_ctx, Status);
goto fail;
}
CertFreeCertificateContext(tls_ctx->p_pemote_cert_context);
tls_ctx->p_pemote_cert_context = NULL;
}
// If the caller does not want the bundled application data, drop it.
if(pExtraData == NULL && local_extra.pvBuffer != NULL) {
LocalFree(local_extra.pvBuffer);
}
return SEC_E_OK;
fail:
if(extra->pvBuffer != NULL) {
LocalFree(extra->pvBuffer);
extra->pvBuffer = NULL;
}
vschannel_cleanup(tls_ctx);
return Status;
}
INT request(TlsContext *tls_ctx, INT iport, LPWSTR host, CHAR *req, DWORD req_len, CHAR **out, vschannel_allocator afn)
{
SECURITY_STATUS Status;
INT resp_length = 0;
// Connect + handshake (+ cert validation when enabled). request() does not
// consume handshake-bundled application data (HTTP/1.1 servers do not send
// before the request), so pass NULL to have it dropped.
if(vschannel_open_and_handshake(tls_ctx, iport, host,
tls_ctx->validate_server_certificate, NULL) != SEC_E_OK) {
return resp_length;
}
// Request from server
Status = https_make_request(tls_ctx, req, req_len, out, &resp_length, afn);
if(Status) {
vschannel_set_last_error(tls_ctx, Status);
vschannel_cleanup(tls_ctx);
return resp_length;
}
// Send a close_notify alert to the server and
// close down the connection.
Status = disconnect_from_server(tls_ctx);
if(Status) {
vschannel_set_last_error(tls_ctx, Status);
wprintf(L"Error disconnecting from server\n");
vschannel_cleanup(tls_ctx);
return resp_length;
}
tls_ctx->context_initialized = FALSE;
tls_ctx->socket = INVALID_SOCKET;
return resp_length;
}
// vschannel_request_on_open runs a one-shot HTTP/1.1 request over a connection
// that vschannel_h2_connect() already opened and handshaked, then closes it.
// It is the HTTP/1.1 fallback used when a server, asked for ALPN `h2`, does not
// select it: rather than reconnect, we reuse the open connection. Returns the
// response length (see request()).
INT vschannel_request_on_open(TlsContext *tls_ctx, CHAR *req, DWORD req_len, CHAR **out, vschannel_allocator afn) {
SECURITY_STATUS Status;
INT resp_length = 0;
Status = https_make_request(tls_ctx, req, req_len, out, &resp_length, afn);
if(Status) {
vschannel_set_last_error(tls_ctx, Status);
vschannel_cleanup(tls_ctx);
return resp_length;
}
Status = disconnect_from_server(tls_ctx);
if(Status) {
vschannel_set_last_error(tls_ctx, Status);
vschannel_cleanup(tls_ctx);
return resp_length;
}
tls_ctx->context_initialized = FALSE;
tls_ctx->socket = INVALID_SOCKET;
return resp_length;
}
// vschannel_alpn_probe connects to host:iport, performs the TLS handshake while
// advertising whatever ALPN list was configured via vschannel_set_alpn(),
// captures the protocol the server selected into `out` (up to out_cap bytes),
// and disconnects without sending an application request. Returns the
// negotiated protocol length (0 = handshake succeeded but no protocol selected),
// or -1 on connect/handshake failure (see vschannel_last_error). Intended for
// tests and capability checks, since request() only speaks HTTP/1.1.
INT vschannel_alpn_probe(TlsContext *tls_ctx, INT iport, LPWSTR host, char *out, INT out_cap) {
// Probe only: handshake (no cert validation, no application data) then close.
if(vschannel_open_and_handshake(tls_ctx, iport, host, FALSE, NULL) != SEC_E_OK) {
return -1;
}
disconnect_from_server(tls_ctx);
tls_ctx->context_initialized = FALSE;
tls_ctx->socket = INVALID_SOCKET;
return vschannel_get_alpn(tls_ctx, out, out_cap);
}
// ---------------------------------------------------------------------------
// Streaming transport (keep the TLS connection open and exchange raw bytes).
//
// request() above is a one-shot: connect, handshake, send the whole HTTP/1.1
// request, read the whole response, disconnect. An HTTP/2 driver instead needs
// a long-lived, byte-oriented transport. The functions below expose exactly
// that: vschannel_h2_connect() opens the connection (handshake + cert check)
// and leaves it open, vschannel_write()/vschannel_read() move application bytes
// across it, and vschannel_h2_close() shuts it down. They reuse the same SSPI
// primitives as request()/https_make_request(), but keep the encrypt/decrypt
// state on the TlsContext so reads can span calls.
// ---------------------------------------------------------------------------
// vschannel_ensure_stream_state caches the negotiated TLS record sizes and
// allocates the ciphertext/plaintext working buffers, once per connection.
static SECURITY_STATUS vschannel_ensure_stream_state(TlsContext *tls_ctx) {
if(tls_ctx->stream_sizes_valid) {
return SEC_E_OK;
}
SECURITY_STATUS scRet = tls_ctx->sspi->QueryContextAttributes(&tls_ctx->h_context,
SECPKG_ATTR_STREAM_SIZES, &tls_ctx->stream_sizes);
if(scRet != SEC_E_OK) {
return scRet;
}
// One full wire record: header + max plaintext + trailer. recv() never needs
// more than this buffered to complete a single record; trailing bytes of the
// next record are carried as SECBUFFER_EXTRA.
tls_ctx->recv_buf_cap = tls_ctx->stream_sizes.cbHeader
+ tls_ctx->stream_sizes.cbMaximumMessage + tls_ctx->stream_sizes.cbTrailer;
tls_ctx->recv_buf = (unsigned char *)LocalAlloc(LPTR, tls_ctx->recv_buf_cap);
// One record decrypts to at most cbMaximumMessage plaintext bytes.
tls_ctx->plain_buf_cap = tls_ctx->stream_sizes.cbMaximumMessage;
tls_ctx->plain_buf = (unsigned char *)LocalAlloc(LPTR, tls_ctx->plain_buf_cap);
// Reusable send buffer: one full outgoing record.
tls_ctx->send_buf_cap = tls_ctx->recv_buf_cap;
tls_ctx->send_buf = (unsigned char *)LocalAlloc(LPTR, tls_ctx->send_buf_cap);
if(tls_ctx->recv_buf == NULL || tls_ctx->plain_buf == NULL || tls_ctx->send_buf == NULL) {
return SEC_E_INTERNAL_ERROR;
}
tls_ctx->recv_buf_len = 0;
tls_ctx->plain_buf_len = 0;
tls_ctx->plain_buf_off = 0;
tls_ctx->stream_sizes_valid = TRUE;
return SEC_E_OK;
}
// vschannel_h2_connect connects to host:iport, performs the TLS handshake while
// advertising whatever ALPN list was set via vschannel_set_alpn(), validates the
// server certificate (when enabled), and leaves the connection open for
// vschannel_write()/vschannel_read(). Returns 0 on success, non-zero on failure
// (see vschannel_last_error). The negotiated protocol is available afterwards
// via vschannel_get_alpn().
INT vschannel_h2_connect(TlsContext *tls_ctx, INT iport, LPWSTR host) {
SecBuffer ExtraData;
SECURITY_STATUS Status;
// Connect + handshake + cert validation (when enabled). Unlike the one-shot
// paths, keep the handshake-bundled application data: for HTTP/2 it is the
// server's first record (SETTINGS), needed below.
if(vschannel_open_and_handshake(tls_ctx, iport, host,
tls_ctx->validate_server_certificate, &ExtraData) != SEC_E_OK) {
return -1;
}
Status = vschannel_ensure_stream_state(tls_ctx);
if(Status != SEC_E_OK) {
vschannel_set_last_error(tls_ctx, Status);
if(ExtraData.pvBuffer != NULL) {
LocalFree(ExtraData.pvBuffer);
}
vschannel_cleanup(tls_ctx);
return -1;
}
// The final handshake flight often arrives in the same TCP segment as the
// server's first application record (for HTTP/2, the SETTINGS frame), which
// the handshake hands back as SECBUFFER_EXTRA. Those bytes are already off
// the socket, so they must be carried into the read buffer; otherwise the
// first vschannel_read() would skip them and H2Conn would desync. Grow the
// staging buffer if the bundled data exceeds one record.
if(ExtraData.pvBuffer != NULL) {
if(ExtraData.cbBuffer > 0) {
if(ExtraData.cbBuffer > tls_ctx->recv_buf_cap) {
unsigned char *grown = (unsigned char *)LocalAlloc(LPTR, ExtraData.cbBuffer);
if(grown != NULL) {
LocalFree(tls_ctx->recv_buf);
tls_ctx->recv_buf = grown;
tls_ctx->recv_buf_cap = ExtraData.cbBuffer;
}
}
if(ExtraData.cbBuffer <= tls_ctx->recv_buf_cap) {
MoveMemory(tls_ctx->recv_buf, ExtraData.pvBuffer, ExtraData.cbBuffer);
tls_ctx->recv_buf_len = ExtraData.cbBuffer;
}
}
LocalFree(ExtraData.pvBuffer);
}
return 0;
}
// vschannel_write encrypts and sends `len` application bytes over the open
// connection, chunked to the negotiated maximum record size. Returns the number
// of bytes consumed (== len) on success, or -1 on error.
INT vschannel_write(TlsContext *tls_ctx, const char *buf, INT len) {
SecBufferDesc Message;
SecBuffer Buffers[4];
SECURITY_STATUS scRet;
PBYTE io;
DWORD off;
INT cbData;
if(len <= 0) {
return 0;
}
if(vschannel_ensure_stream_state(tls_ctx) != SEC_E_OK) {
return -1;
}
// Reuse the per-context send buffer (one full record) rather than allocating
// on every write; the HTTP/2 driver issues many small writes per request.
io = (PBYTE)tls_ctx->send_buf;
off = 0;
while(off < (DWORD)len) {
DWORD chunk = (DWORD)len - off;
if(chunk > tls_ctx->stream_sizes.cbMaximumMessage) {
chunk = tls_ctx->stream_sizes.cbMaximumMessage;
}
memcpy(io + tls_ctx->stream_sizes.cbHeader, buf + off, chunk);
Buffers[0].pvBuffer = io;
Buffers[0].cbBuffer = tls_ctx->stream_sizes.cbHeader;
Buffers[0].BufferType = SECBUFFER_STREAM_HEADER;
Buffers[1].pvBuffer = io + tls_ctx->stream_sizes.cbHeader;
Buffers[1].cbBuffer = chunk;
Buffers[1].BufferType = SECBUFFER_DATA;
Buffers[2].pvBuffer = io + tls_ctx->stream_sizes.cbHeader + chunk;
Buffers[2].cbBuffer = tls_ctx->stream_sizes.cbTrailer;
Buffers[2].BufferType = SECBUFFER_STREAM_TRAILER;
Buffers[3].BufferType = SECBUFFER_EMPTY;
Message.ulVersion = SECBUFFER_VERSION;
Message.cBuffers = 4;
Message.pBuffers = Buffers;
scRet = tls_ctx->sspi->EncryptMessage(&tls_ctx->h_context, 0, &Message, 0);
if(FAILED(scRet)) {
vschannel_set_last_error(tls_ctx, scRet);
return -1;
}
DWORD to_send = Buffers[0].cbBuffer + Buffers[1].cbBuffer + Buffers[2].cbBuffer;
DWORD sent = 0;
while(sent < to_send) {
cbData = send(tls_ctx->socket, (char*)io + sent, (int)(to_send - sent), 0);
if(cbData == SOCKET_ERROR || cbData == 0) {
vschannel_set_last_error(tls_ctx, WSAGetLastError());
return -1;
}
sent += (DWORD)cbData;
}
off += chunk;
}
return len;
}
// vschannel_read returns up to `cap` decrypted application bytes from the open
// connection. It returns the number of bytes written into `buf` (> 0), 0 at
// end of stream (close_notify / context expired / peer closed the socket), or
// -1 on error. Leftover decrypted plaintext that did not fit in `buf`, and
// ciphertext that did not yet form a complete record, are carried on the
// TlsContext across calls.
INT vschannel_read(TlsContext *tls_ctx, char *buf, INT cap) {
SecBufferDesc Message;
SecBuffer Buffers[4];
SecBuffer ExtraBuffer;
SecBuffer *pDataBuffer;
SecBuffer *pExtraBuffer;
SECURITY_STATUS scRet;
INT cbData;
int i;
if(cap <= 0) {
return 0;
}
if(vschannel_ensure_stream_state(tls_ctx) != SEC_E_OK) {
return -1;
}
// 1. Serve leftover decrypted plaintext from a previous record first.
if(tls_ctx->plain_buf_off < tls_ctx->plain_buf_len) {
DWORD avail = tls_ctx->plain_buf_len - tls_ctx->plain_buf_off;
DWORD n = avail < (DWORD)cap ? avail : (DWORD)cap;
memcpy(buf, tls_ctx->plain_buf + tls_ctx->plain_buf_off, n);
tls_ctx->plain_buf_off += n;
return (INT)n;
}
if(tls_ctx->stream_eof) {
return 0;
}
for(;;) {
// Try to decrypt whatever ciphertext we have buffered.
if(tls_ctx->recv_buf_len > 0) {
Buffers[0].pvBuffer = tls_ctx->recv_buf;
Buffers[0].cbBuffer = tls_ctx->recv_buf_len;
Buffers[0].BufferType = SECBUFFER_DATA;
Buffers[1].BufferType = SECBUFFER_EMPTY;
Buffers[2].BufferType = SECBUFFER_EMPTY;
Buffers[3].BufferType = SECBUFFER_EMPTY;
Message.ulVersion = SECBUFFER_VERSION;
Message.cBuffers = 4;
Message.pBuffers = Buffers;
scRet = tls_ctx->sspi->DecryptMessage(&tls_ctx->h_context, &Message, 0, NULL);
if(scRet == SEC_E_OK || scRet == SEC_I_RENEGOTIATE || scRet == SEC_I_CONTEXT_EXPIRED) {
pDataBuffer = NULL;
pExtraBuffer = NULL;
for(i = 1; i < 4; i++) {
if(pDataBuffer == NULL && Buffers[i].BufferType == SECBUFFER_DATA) {
pDataBuffer = &Buffers[i];
}
if(pExtraBuffer == NULL && Buffers[i].BufferType == SECBUFFER_EXTRA) {
pExtraBuffer = &Buffers[i];
}
}
// Copy out decrypted application data: as much as fits in the
// caller's buffer, the rest into the plaintext carryover. Both
// reads happen before the SECBUFFER_EXTRA move below, since the
// data buffer points inside recv_buf.
INT produced = 0;
if(pDataBuffer && pDataBuffer->cbBuffer > 0) {
DWORD data_len = pDataBuffer->cbBuffer;
DWORD n = data_len < (DWORD)cap ? data_len : (DWORD)cap;
memcpy(buf, pDataBuffer->pvBuffer, n);
produced = (INT)n;
DWORD rest = data_len - n;
if(rest > 0) {
memcpy(tls_ctx->plain_buf, (unsigned char*)pDataBuffer->pvBuffer + n, rest);
tls_ctx->plain_buf_len = rest;
tls_ctx->plain_buf_off = 0;
}
}
// Carry trailing ciphertext (start of the next record) to the
// front of recv_buf for the next decrypt.
if(pExtraBuffer) {
MoveMemory(tls_ctx->recv_buf, pExtraBuffer->pvBuffer, pExtraBuffer->cbBuffer);
tls_ctx->recv_buf_len = pExtraBuffer->cbBuffer;
} else {
tls_ctx->recv_buf_len = 0;
}
if(scRet == SEC_I_RENEGOTIATE) {
// The server requested a new handshake. Run it, then carry any
// extra data it left behind and keep reading.
SECURITY_STATUS rh = client_handshake_loop(tls_ctx, FALSE, &ExtraBuffer);
if(rh != SEC_E_OK) {
vschannel_set_last_error(tls_ctx, rh);
return -1;
}
if(ExtraBuffer.pvBuffer) {
if(ExtraBuffer.cbBuffer <= tls_ctx->recv_buf_cap) {
MoveMemory(tls_ctx->recv_buf, ExtraBuffer.pvBuffer, ExtraBuffer.cbBuffer);
tls_ctx->recv_buf_len = ExtraBuffer.cbBuffer;
}
LocalFree(ExtraBuffer.pvBuffer);
}
} else if(scRet == SEC_I_CONTEXT_EXPIRED) {
// Graceful close_notify from the server.
tls_ctx->stream_eof = TRUE;
if(produced > 0) {
return produced;
}
return 0;
}
if(produced > 0) {
return produced;
}
// A record with no application data (e.g. a session ticket or a
// renegotiation). Keep going.
continue;
} else if(scRet == SEC_E_INCOMPLETE_MESSAGE) {
// Need more bytes to complete the current record: fall through to
// recv() more ciphertext.
} else {
vschannel_set_last_error(tls_ctx, scRet);
return -1;
}
}
// Receive more ciphertext.
if(tls_ctx->recv_buf_len >= tls_ctx->recv_buf_cap) {
// Should not happen: a single record fits in recv_buf_cap.
vschannel_set_last_error(tls_ctx, SEC_E_INTERNAL_ERROR);
return -1;
}
cbData = recv(tls_ctx->socket, (char*)tls_ctx->recv_buf + tls_ctx->recv_buf_len,
(int)(tls_ctx->recv_buf_cap - tls_ctx->recv_buf_len), 0);
if(cbData == SOCKET_ERROR) {
vschannel_set_last_error(tls_ctx, WSAGetLastError());
return -1;
}
if(cbData == 0) {
// Peer closed the socket. Any buffered bytes are an incomplete record.
tls_ctx->stream_eof = TRUE;
return 0;
}
tls_ctx->recv_buf_len += (DWORD)cbData;
}
}
// vschannel_h2_close sends a close_notify alert and tears down the connection.
void vschannel_h2_close(TlsContext *tls_ctx) {
if(tls_ctx->context_initialized) {
disconnect_from_server(tls_ctx);
tls_ctx->context_initialized = FALSE;
tls_ctx->socket = INVALID_SOCKET;
}
vschannel_cleanup(tls_ctx);
}
static SECURITY_STATUS create_credentials(TlsContext *tls_ctx) {
TimeStamp tsExpiry;
SECURITY_STATUS Status;
DWORD cSupportedAlgs = 0;
ALG_ID rgbSupportedAlgs[16];
PCCERT_CONTEXT pCertContext = NULL;
// Open the "MY" certificate store, which is where Internet Explorer
// stores its client certificates.
if(tls_ctx->cert_store == NULL) {
tls_ctx->cert_store = CertOpenSystemStore(0, L"MY");
if(!tls_ctx->cert_store) {
wprintf(L"Error 0x%x returned by CertOpenSystemStore\n",
GetLastError());
return SEC_E_NO_CREDENTIALS;
}
}
// Build Schannel credential structure. Currently, this sample only
// specifies the protocol to be used (and optionally the certificate,
// of course). Real applications may wish to specify other parameters
// as well.
ZeroMemory(&tls_ctx->schannel_cred, sizeof(tls_ctx->schannel_cred));
tls_ctx->schannel_cred.dwVersion = SCHANNEL_CRED_VERSION;
if(pCertContext)
{
tls_ctx->schannel_cred.cCreds = 1;
tls_ctx->schannel_cred.paCred = &pCertContext;
}
tls_ctx->schannel_cred.grbitEnabledProtocols = protocol;
if(aid_key_exch)
{
rgbSupportedAlgs[cSupportedAlgs++] = aid_key_exch;
}
if(cSupportedAlgs)
{
tls_ctx->schannel_cred.cSupportedAlgs = cSupportedAlgs;
tls_ctx->schannel_cred.palgSupportedAlgs = rgbSupportedAlgs;
}
tls_ctx->schannel_cred.dwFlags |= SCH_CRED_NO_DEFAULT_CREDS;
tls_ctx->schannel_cred.dwFlags |= SCH_CRED_MANUAL_CRED_VALIDATION;
// Keep certificate validation under the caller's control. The validated
// path runs explicit hostname/chain validation after the handshake.
// Create an SSPI credential.
Status = tls_ctx->sspi->AcquireCredentialsHandle(
NULL, // Name of principal
UNISP_NAME_W, // Name of package
SECPKG_CRED_OUTBOUND, // Flags indicating use
NULL, // Pointer to logon ID
&tls_ctx->schannel_cred, // Package specific data
NULL, // Pointer to GetKey() func
NULL, // Value to pass to GetKey()
&tls_ctx->h_client_creds, // (out) Cred Handle
&tsExpiry); // (out) Lifetime (optional)
if(Status != SEC_E_OK) {
wprintf(L"Error 0x%x returned by AcquireCredentialsHandle\n", Status);
goto cleanup;
}
cleanup:
// Free the certificate context. Schannel has already made its own copy.
if(pCertContext) {
CertFreeCertificateContext(pCertContext);
}
return Status;
}
static INT connect_to_server(TlsContext *tls_ctx, LPWSTR host, INT port_number) {
SOCKET Socket;
SOCKADDR_STORAGE local_address = { 0 };
SOCKADDR_STORAGE remote_address = { 0 };
DWORD local_address_length = sizeof(local_address);
DWORD remote_address_length = sizeof(remote_address);
struct timeval tv;
tv.tv_sec = 60;
tv.tv_usec = 0;
Socket = socket(PF_INET, SOCK_STREAM, 0);
if(Socket == INVALID_SOCKET) {
INT err_code = WSAGetLastError();
vschannel_set_last_error(tls_ctx, err_code);
return err_code;
}
LPWSTR connect_name = use_proxy ? psz_proxy_server : host;
WCHAR service_name[10];
int res = wsprintf(service_name, L"%d", port_number);
if(WSAConnectByNameW(Socket,connect_name, service_name, &local_address_length,
&local_address, &remote_address_length, &remote_address, &tv, NULL) == FALSE) {
INT err_code = WSAGetLastError();
vschannel_set_last_error(tls_ctx, err_code);
closesocket(Socket);
return err_code;
}
if(use_proxy) {
BYTE pbMessage[200];
DWORD cbMessage;
// Build message for proxy server
strcpy(pbMessage, "CONNECT ");
strcat(pbMessage, host);
strcat(pbMessage, ":");
_itoa(port_number, pbMessage + strlen(pbMessage), 10);
strcat(pbMessage, " HTTP/1.0\r\nUser-Agent: webclient\r\n\r\n");
cbMessage = (DWORD)strlen(pbMessage);
// Send message to proxy server
if(send(Socket, pbMessage, cbMessage, 0) == SOCKET_ERROR) {
INT err_code = WSAGetLastError();
vschannel_set_last_error(tls_ctx, err_code);
return err_code;
}
// Receive message from proxy server
cbMessage = recv(Socket, pbMessage, 200, 0);
if(cbMessage == SOCKET_ERROR) {
INT err_code = WSAGetLastError();
vschannel_set_last_error(tls_ctx, err_code);
return err_code;
}
// this sample is limited but in normal use it
// should continue to receive until CR LF CR LF is received
}
tls_ctx->socket = Socket;
return SEC_E_OK;
}
static LONG disconnect_from_server(TlsContext *tls_ctx) {
DWORD dwType;
PBYTE pbMessage;
DWORD cbMessage;
DWORD cbData;
SecBufferDesc OutBuffer;
SecBuffer OutBuffers[1];
DWORD dwSSPIFlags;
DWORD dwSSPIOutFlags;
TimeStamp tsExpiry;
DWORD Status;
// Notify schannel that we are about to close the connection.
dwType = SCHANNEL_SHUTDOWN;
OutBuffers[0].pvBuffer = &dwType;
OutBuffers[0].BufferType = SECBUFFER_TOKEN;
OutBuffers[0].cbBuffer = sizeof(dwType);
OutBuffer.cBuffers = 1;
OutBuffer.pBuffers = OutBuffers;
OutBuffer.ulVersion = SECBUFFER_VERSION;
Status = tls_ctx->sspi->ApplyControlToken(&tls_ctx->h_context, &OutBuffer);
if(FAILED(Status)) {
wprintf(L"Error 0x%x returned by ApplyControlToken\n", Status);
goto cleanup;
}
// Build an SSL close notify message.
dwSSPIFlags = ISC_REQ_SEQUENCE_DETECT |
ISC_REQ_REPLAY_DETECT |
ISC_REQ_CONFIDENTIALITY |
ISC_RET_EXTENDED_ERROR |
ISC_REQ_ALLOCATE_MEMORY |
ISC_REQ_STREAM;
OutBuffers[0].pvBuffer = NULL;
OutBuffers[0].BufferType = SECBUFFER_TOKEN;
OutBuffers[0].cbBuffer = 0;
OutBuffer.cBuffers = 1;
OutBuffer.pBuffers = OutBuffers;
OutBuffer.ulVersion = SECBUFFER_VERSION;
Status = tls_ctx->sspi->InitializeSecurityContext(
&tls_ctx->h_client_creds, &tls_ctx->h_context, NULL, dwSSPIFlags, 0, SECURITY_NATIVE_DREP,
NULL, 0, &tls_ctx->h_context, &OutBuffer, &dwSSPIOutFlags, &tsExpiry);
if(FAILED(Status)) {
wprintf(L"Error 0x%x returned by InitializeSecurityContext\n", Status);
goto cleanup;
}
pbMessage = OutBuffers[0].pvBuffer;
cbMessage = OutBuffers[0].cbBuffer;
// Send the close notify message to the server.
if(pbMessage != NULL && cbMessage != 0) {
cbData = send(tls_ctx->socket, pbMessage, cbMessage, 0);
if(cbData == SOCKET_ERROR || cbData == 0) {
Status = WSAGetLastError();
wprintf(L"Error %d sending close notify\n", Status);
goto cleanup;
}
// Free output buffer.
tls_ctx->sspi->FreeContextBuffer(pbMessage);
}
cleanup:
// Free the security context.
tls_ctx->sspi->DeleteSecurityContext(&tls_ctx->h_context);
// Close the socket.
closesocket(tls_ctx->socket);
return Status;
}
static SECURITY_STATUS perform_client_handshake(TlsContext *tls_ctx, WCHAR *host, SecBuffer *pExtraData) {
SecBufferDesc OutBuffer;
SecBuffer OutBuffers[1];
DWORD dwSSPIFlags;
DWORD dwSSPIOutFlags;
TimeStamp tsExpiry;
SECURITY_STATUS scRet;
DWORD cbData;
dwSSPIFlags = ISC_REQ_SEQUENCE_DETECT |
ISC_REQ_REPLAY_DETECT |
ISC_REQ_CONFIDENTIALITY |
ISC_RET_EXTENDED_ERROR |
ISC_REQ_ALLOCATE_MEMORY |
ISC_REQ_STREAM;
//
// Optionally advertise ALPN protocols in the ClientHello. SChannel takes
// this as a SECBUFFER_APPLICATION_PROTOCOLS input buffer holding a
// SEC_APPLICATION_PROTOCOLS record. The backing store is a 4-byte-aligned
// unsigned long array so the struct cast is well aligned on every compiler.
//
SecBuffer InBuffers[1];
SecBufferDesc InBuffer;
SecBufferDesc *pInput = NULL;
unsigned long alpn_store[80]; // 320 bytes; alpn_wire is at most 256
if (tls_ctx->alpn_wire_len > 0) {
SEC_APPLICATION_PROTOCOLS *protos = (SEC_APPLICATION_PROTOCOLS *)alpn_store;
SEC_APPLICATION_PROTOCOL_LIST *list = &protos->ProtocolLists[0];
unsigned long wlen = tls_ctx->alpn_wire_len;
list->ProtoNegoExt = SecApplicationProtocolNegotiationExt_ALPN;
list->ProtocolListSize = (unsigned short)wlen;
memcpy(list->ProtocolList, tls_ctx->alpn_wire, (size_t)wlen);
protos->ProtocolListsSize =
(unsigned long)(FIELD_OFFSET(SEC_APPLICATION_PROTOCOL_LIST, ProtocolList) + wlen);
InBuffers[0].pvBuffer = protos;
InBuffers[0].cbBuffer =
(unsigned long)(FIELD_OFFSET(SEC_APPLICATION_PROTOCOLS, ProtocolLists) + protos->ProtocolListsSize);
InBuffers[0].BufferType = SECBUFFER_APPLICATION_PROTOCOLS;
InBuffer.cBuffers = 1;
InBuffer.pBuffers = InBuffers;
InBuffer.ulVersion = SECBUFFER_VERSION;
pInput = &InBuffer;
}
//
// Initiate a ClientHello message and generate a token.
//
OutBuffers[0].pvBuffer = NULL;
OutBuffers[0].BufferType = SECBUFFER_TOKEN;
OutBuffers[0].cbBuffer = 0;
OutBuffer.cBuffers = 1;
OutBuffer.pBuffers = OutBuffers;
OutBuffer.ulVersion = SECBUFFER_VERSION;
scRet = tls_ctx->sspi->InitializeSecurityContext(
&tls_ctx->h_client_creds,
NULL,
host,
dwSSPIFlags,
0,
SECURITY_NATIVE_DREP,
pInput,
0,
&tls_ctx->h_context,
&OutBuffer,
&dwSSPIOutFlags,
&tsExpiry);
if(scRet != SEC_I_CONTINUE_NEEDED)
{
wprintf(L"Error %d returned by InitializeSecurityContext (1)\n", scRet);
return scRet;
}
// Send response to server if there is one.
if(OutBuffers[0].cbBuffer != 0 && OutBuffers[0].pvBuffer != NULL)
{
cbData = send(tls_ctx->socket, OutBuffers[0].pvBuffer, OutBuffers[0].cbBuffer, 0);
if(cbData == SOCKET_ERROR || cbData == 0) {
wprintf(L"Error %d sending data to server (1)\n", WSAGetLastError());
tls_ctx->sspi->FreeContextBuffer(OutBuffers[0].pvBuffer);
tls_ctx->sspi->DeleteSecurityContext(&tls_ctx->h_context);
return SEC_E_INTERNAL_ERROR;
}
// Free output buffer.
tls_ctx->sspi->FreeContextBuffer(OutBuffers[0].pvBuffer);
OutBuffers[0].pvBuffer = NULL;
}
return client_handshake_loop(tls_ctx, TRUE, pExtraData);
}
static SECURITY_STATUS client_handshake_loop(TlsContext *tls_ctx, BOOL fDoInitialRead, SecBuffer *pExtraData) {
SecBufferDesc InBuffer;
SecBuffer InBuffers[2];
SecBufferDesc OutBuffer;
SecBuffer OutBuffers[1];
DWORD dwSSPIFlags;
DWORD dwSSPIOutFlags;
TimeStamp tsExpiry;
SECURITY_STATUS scRet;
DWORD cbData;
PUCHAR IoBuffer;
DWORD cbIoBuffer;
BOOL fDoRead;
dwSSPIFlags = ISC_REQ_SEQUENCE_DETECT |
ISC_REQ_REPLAY_DETECT |
ISC_REQ_CONFIDENTIALITY |
ISC_RET_EXTENDED_ERROR |
ISC_REQ_ALLOCATE_MEMORY |
ISC_REQ_STREAM;
//
// Allocate data buffer.
//
IoBuffer = LocalAlloc(LPTR, IO_BUFFER_SIZE);
if(IoBuffer == NULL)
{
wprintf(L"Out of memory (1)\n");
return SEC_E_INTERNAL_ERROR;
}
cbIoBuffer = 0;
fDoRead = fDoInitialRead;
//
// Loop until the handshake is finished or an error occurs.
//
scRet = SEC_I_CONTINUE_NEEDED;
while(scRet == SEC_I_CONTINUE_NEEDED ||
scRet == SEC_E_INCOMPLETE_MESSAGE ||
scRet == SEC_I_INCOMPLETE_CREDENTIALS) {
// Read data from server.
if(0 == cbIoBuffer || scRet == SEC_E_INCOMPLETE_MESSAGE) {
if(fDoRead) {
cbData = recv(tls_ctx->socket,
IoBuffer + cbIoBuffer,
IO_BUFFER_SIZE - cbIoBuffer,
0);
if(cbData == SOCKET_ERROR) {
wprintf(L"Error %d reading data from server\n", WSAGetLastError());
scRet = SEC_E_INTERNAL_ERROR;
break;
}
else if(cbData == 0) {
wprintf(L"Server unexpectedly disconnected\n");
scRet = SEC_E_INTERNAL_ERROR;
break;
}
cbIoBuffer += cbData;
}
else {
fDoRead = TRUE;
}
}
// Set up the input buffers. Buffer 0 is used to pass in data
// received from the server. Schannel will consume some or all
// of this. Leftover data (if any) will be placed in buffer 1 and
// given a buffer type of SECBUFFER_EXTRA.
InBuffers[0].pvBuffer = IoBuffer;
InBuffers[0].cbBuffer = cbIoBuffer;
InBuffers[0].BufferType = SECBUFFER_TOKEN;
InBuffers[1].pvBuffer = NULL;
InBuffers[1].cbBuffer = 0;
InBuffers[1].BufferType = SECBUFFER_EMPTY;
InBuffer.cBuffers = 2;
InBuffer.pBuffers = InBuffers;
InBuffer.ulVersion = SECBUFFER_VERSION;
// Set up the output buffers. These are initialized to NULL
// so as to make it less likely we'll attempt to free random
// garbage later.
OutBuffers[0].pvBuffer = NULL;
OutBuffers[0].BufferType= SECBUFFER_TOKEN;
OutBuffers[0].cbBuffer = 0;
OutBuffer.cBuffers = 1;
OutBuffer.pBuffers = OutBuffers;
OutBuffer.ulVersion = SECBUFFER_VERSION;
// Call InitializeSecurityContext.
scRet = tls_ctx->sspi->InitializeSecurityContext(
&tls_ctx->h_client_creds, &tls_ctx->h_context, NULL, dwSSPIFlags, 0, SECURITY_NATIVE_DREP,
&InBuffer, 0, NULL, &OutBuffer, &dwSSPIOutFlags, &tsExpiry);
// If InitializeSecurityContext was successful (or if the error was
// one of the special extended ones), send the contends of the output
// buffer to the server.
if(scRet == SEC_E_OK ||
scRet == SEC_I_CONTINUE_NEEDED ||
FAILED(scRet) && (dwSSPIOutFlags & ISC_RET_EXTENDED_ERROR)) {
if(OutBuffers[0].cbBuffer != 0 && OutBuffers[0].pvBuffer != NULL) {
cbData = send(tls_ctx->socket,
OutBuffers[0].pvBuffer,
OutBuffers[0].cbBuffer,
0);
if(cbData == SOCKET_ERROR || cbData == 0) {
wprintf(L"Error %d sending data to server (2)\n",
WSAGetLastError());
tls_ctx->sspi->FreeContextBuffer(OutBuffers[0].pvBuffer);
tls_ctx->sspi->DeleteSecurityContext(&tls_ctx->h_context);
return SEC_E_INTERNAL_ERROR;
}
// Free output buffer.
tls_ctx->sspi->FreeContextBuffer(OutBuffers[0].pvBuffer);
OutBuffers[0].pvBuffer = NULL;
}
}
// If InitializeSecurityContext returned SEC_E_INCOMPLETE_MESSAGE,
// then we need to read more data from the server and try again.
if(scRet == SEC_E_INCOMPLETE_MESSAGE) {
continue;
}
// If InitializeSecurityContext returned SEC_E_OK, then the
// handshake completed successfully.
if(scRet == SEC_E_OK) {
// If the "extra" buffer contains data, this is encrypted application
// protocol layer stuff. It needs to be saved. The application layer
// will later decrypt it with DecryptMessage.
if(InBuffers[1].BufferType == SECBUFFER_EXTRA)
{
pExtraData->pvBuffer = LocalAlloc(LPTR, InBuffers[1].cbBuffer);
if(pExtraData->pvBuffer == NULL) {
wprintf(L"Out of memory (2)\n");
return SEC_E_INTERNAL_ERROR;
}
MoveMemory(pExtraData->pvBuffer,
IoBuffer + (cbIoBuffer - InBuffers[1].cbBuffer),
InBuffers[1].cbBuffer);
pExtraData->cbBuffer = InBuffers[1].cbBuffer;
pExtraData->BufferType = SECBUFFER_TOKEN;
// wprintf(L"%d bytes of app data was bundled with handshake data\n", pExtraData->cbBuffer);
}
else {
pExtraData->pvBuffer = NULL;
pExtraData->cbBuffer = 0;
pExtraData->BufferType = SECBUFFER_EMPTY;
}
// Bail out to quit
break;
}
// Check for fatal error.
if(FAILED(scRet)) {
wprintf(L"Error 0x%x returned by InitializeSecurityContext (2)\n", scRet);
break;
}
// If InitializeSecurityContext returned SEC_I_INCOMPLETE_CREDENTIALS,
// then the server just requested client authentication.
if(scRet == SEC_I_INCOMPLETE_CREDENTIALS) {
// Busted. The server has requested client authentication and
// the credential we supplied didn't contain a client certificate.
// This function will read the list of trusted certificate
// authorities ("issuers") that was received from the server
// and attempt to find a suitable client certificate that
// was issued by one of these. If this function is successful,
// then we will connect using the new certificate. Otherwise,
// we will attempt to connect anonymously (using our current
// credentials).
get_new_client_credentials(tls_ctx);
// Go around again.
fDoRead = FALSE;
scRet = SEC_I_CONTINUE_NEEDED;
continue;
}
// Copy any leftover data from the "extra" buffer, and go around
// again.
if ( InBuffers[1].BufferType == SECBUFFER_EXTRA ) {
MoveMemory(IoBuffer,
IoBuffer + (cbIoBuffer - InBuffers[1].cbBuffer),
InBuffers[1].cbBuffer);
cbIoBuffer = InBuffers[1].cbBuffer;
}
else {
cbIoBuffer = 0;
}
}
// Delete the security context in the case of a fatal error.
if(FAILED(scRet)) {
tls_ctx->sspi->DeleteSecurityContext(&tls_ctx->h_context);
}
LocalFree(IoBuffer);
return scRet;
}
static SECURITY_STATUS https_make_request(TlsContext *tls_ctx, CHAR *req, DWORD req_len, CHAR **out, int *length, vschannel_allocator afn) {
SecPkgContext_StreamSizes Sizes;
SECURITY_STATUS scRet;
SecBufferDesc Message;
SecBuffer Buffers[4];
SecBuffer *pDataBuffer;
SecBuffer *pExtraBuffer;
SecBuffer ExtraBuffer;
PBYTE pbIoBuffer;
DWORD cbIoBuffer;
DWORD cbIoBufferLength;
PBYTE pbMessage;
DWORD cbMessage;
INT cbData;
INT i;
DWORD req_offset;
DWORD chunk_len;
DWORD to_send;
DWORD sent;
// Read stream encryption properties.
scRet = tls_ctx->sspi->QueryContextAttributes(&tls_ctx->h_context, SECPKG_ATTR_STREAM_SIZES, &Sizes);
if(scRet != SEC_E_OK) {
wprintf(L"Error 0x%x reading SECPKG_ATTR_STREAM_SIZES\n", scRet);
return scRet;
}
// Allocate a working buffer. The plaintext sent to EncryptMessage
// should never be more than 'Sizes.cbMaximumMessage', so a buffer
// size of this plus the header and trailer sizes should be safe enough.
cbIoBufferLength = Sizes.cbHeader + Sizes.cbMaximumMessage + Sizes.cbTrailer;
pbIoBuffer = LocalAlloc(LPTR, cbIoBufferLength);
if(pbIoBuffer == NULL) {
wprintf(L"Out of memory (2)\n");
return SEC_E_INTERNAL_ERROR;
}
// Build and send HTTP request in chunks no larger than cbMaximumMessage.
// EncryptMessage expects plaintext <= cbMaximumMessage.
pbMessage = pbIoBuffer + Sizes.cbHeader;
req_offset = 0;
while(req_offset < req_len) {
chunk_len = req_len - req_offset;
if(chunk_len > Sizes.cbMaximumMessage) {
chunk_len = Sizes.cbMaximumMessage;
}
memcpy(pbMessage, req + req_offset, chunk_len);
cbMessage = chunk_len;
Buffers[0].pvBuffer = pbIoBuffer;
Buffers[0].cbBuffer = Sizes.cbHeader;
Buffers[0].BufferType = SECBUFFER_STREAM_HEADER;
Buffers[1].pvBuffer = pbMessage;
Buffers[1].cbBuffer = cbMessage;
Buffers[1].BufferType = SECBUFFER_DATA;
Buffers[2].pvBuffer = pbMessage + cbMessage;
Buffers[2].cbBuffer = Sizes.cbTrailer;
Buffers[2].BufferType = SECBUFFER_STREAM_TRAILER;
Buffers[3].BufferType = SECBUFFER_EMPTY;
Message.ulVersion = SECBUFFER_VERSION;
Message.cBuffers = 4;
Message.pBuffers = Buffers;
scRet = tls_ctx->sspi->EncryptMessage(&tls_ctx->h_context, 0, &Message, 0);
if(FAILED(scRet)) {
wprintf(L"Error 0x%x returned by EncryptMessage\n", scRet);
return scRet;
}
// Send all encrypted bytes for this chunk.
to_send = Buffers[0].cbBuffer + Buffers[1].cbBuffer + Buffers[2].cbBuffer;
sent = 0;
while(sent < to_send) {
cbData = send(tls_ctx->socket, (char*)pbIoBuffer + sent, (int)(to_send - sent), 0);
if(cbData == SOCKET_ERROR || cbData == 0) {
wprintf(L"Error %d sending data to server (3)\n", WSAGetLastError());
tls_ctx->sspi->DeleteSecurityContext(&tls_ctx->h_context);
return SEC_E_INTERNAL_ERROR;
}
sent += (DWORD)cbData;
}
req_offset += chunk_len;
}
// Read data from server until done.
INT buff_size = vsc_init_resp_buff_size;
cbIoBuffer = 0;
while(TRUE){
// Read some data.
if(0 == cbIoBuffer || scRet == SEC_E_INCOMPLETE_MESSAGE) {
cbData = recv(tls_ctx->socket, pbIoBuffer + cbIoBuffer, cbIoBufferLength - cbIoBuffer, 0);
if(cbData == SOCKET_ERROR) {
wprintf(L"Error %d reading data from server\n", WSAGetLastError());
scRet = SEC_E_INTERNAL_ERROR;
break;
}
else if(cbData == 0) {
// Server disconnected.
if(cbIoBuffer) {
wprintf(L"Server unexpectedly disconnected\n");
scRet = SEC_E_INTERNAL_ERROR;
return scRet;
}
else {
break;
}
}
else {
cbIoBuffer += cbData;
}
}
// Attempt to decrypt the received data.
Buffers[0].pvBuffer = pbIoBuffer;
Buffers[0].cbBuffer = cbIoBuffer;
Buffers[0].BufferType = SECBUFFER_DATA;
Buffers[1].BufferType = SECBUFFER_EMPTY;
Buffers[2].BufferType = SECBUFFER_EMPTY;
Buffers[3].BufferType = SECBUFFER_EMPTY;
Message.ulVersion = SECBUFFER_VERSION;
Message.cBuffers = 4;
Message.pBuffers = Buffers;
scRet = tls_ctx->sspi->DecryptMessage(&tls_ctx->h_context, &Message, 0, NULL);
if(scRet == SEC_E_INCOMPLETE_MESSAGE) {
// The input buffer contains only a fragment of an
// encrypted record. Loop around and read some more
// data.
continue;
}
// Server signalled end of session
if(scRet == SEC_I_CONTEXT_EXPIRED) {
break;
}
if( scRet != SEC_E_OK &&
scRet != SEC_I_RENEGOTIATE &&
scRet != SEC_I_CONTEXT_EXPIRED)
{
wprintf(L"Error 0x%x returned by DecryptMessage\n", scRet);
return scRet;
}
// Locate data and (optional) extra buffers.
pDataBuffer = NULL;
pExtraBuffer = NULL;
for(i = 1; i < 4; i++) {
if(pDataBuffer == NULL && Buffers[i].BufferType == SECBUFFER_DATA)
{
pDataBuffer = &Buffers[i];
// wprintf(L"Buffers[%d].BufferType = SECBUFFER_DATA\n",i);
}
if(pExtraBuffer == NULL && Buffers[i].BufferType == SECBUFFER_EXTRA)
{
pExtraBuffer = &Buffers[i];
}
}
// increase buffer size if we need
int required_length = *length+(int)pDataBuffer->cbBuffer;
if( required_length > buff_size ) {
CHAR *a = afn(*out, required_length);
if( a == NULL ) {
scRet = SEC_E_INTERNAL_ERROR;
return scRet;
}
*out = a;
buff_size = required_length;
}
// Copy the decrypted data to our output buffer
memcpy(*out+*length, pDataBuffer->pvBuffer, (int)pDataBuffer->cbBuffer);
*length += (int)pDataBuffer->cbBuffer;
// Move any "extra" data to the input buffer.
if(pExtraBuffer) {
MoveMemory(pbIoBuffer, pExtraBuffer->pvBuffer, pExtraBuffer->cbBuffer);
cbIoBuffer = pExtraBuffer->cbBuffer;
}
else {
cbIoBuffer = 0;
}
if(scRet == SEC_I_RENEGOTIATE)
{
// The server wants to perform another handshake sequence.
scRet = client_handshake_loop(tls_ctx, FALSE, &ExtraBuffer);
if(scRet != SEC_E_OK) {
return scRet;
}
// Move any "extra" data to the input buffer.
if(ExtraBuffer.pvBuffer)
{
MoveMemory(pbIoBuffer, ExtraBuffer.pvBuffer, ExtraBuffer.cbBuffer);
cbIoBuffer = ExtraBuffer.cbBuffer;
}
}
}
return SEC_E_OK;
}
static DWORD verify_server_certificate( PCCERT_CONTEXT pServerCert, LPWSTR host, DWORD dwCertFlags) {
HTTPSPolicyCallbackData polHttps;
CERT_CHAIN_POLICY_PARA PolicyPara;
CERT_CHAIN_POLICY_STATUS PolicyStatus;
CERT_CHAIN_PARA ChainPara;
PCCERT_CHAIN_CONTEXT pChainContext = NULL;
CHAR *rgszUsages[] = { szOID_PKIX_KP_SERVER_AUTH,
szOID_SERVER_GATED_CRYPTO,
szOID_SGC_NETSCAPE };
DWORD cUsages = sizeof(rgszUsages) / sizeof(CHAR*);
PWSTR pwszServerName = NULL;
DWORD cchServerName;
DWORD Status;
if(pServerCert == NULL)
{
Status = SEC_E_WRONG_PRINCIPAL;
goto cleanup;
}
if(host == NULL || wcslen(host) == 0) {
Status = SEC_E_WRONG_PRINCIPAL;
goto cleanup;
}
// Build certificate chain.
ZeroMemory(&ChainPara, sizeof(ChainPara));
ChainPara.cbSize = sizeof(ChainPara);
ChainPara.RequestedUsage.dwType = USAGE_MATCH_TYPE_OR;
ChainPara.RequestedUsage.Usage.cUsageIdentifier = cUsages;
ChainPara.RequestedUsage.Usage.rgpszUsageIdentifier = rgszUsages;
// Best-effort TLS revocation check: detect a positively revoked leaf
// certificate, but let policy evaluation ignore unknown/offline status.
if(!CertGetCertificateChain(NULL, pServerCert, NULL, pServerCert->hCertStore, &ChainPara,
CERT_CHAIN_CACHE_END_CERT |
CERT_CHAIN_REVOCATION_CHECK_END_CERT |
CERT_CHAIN_REVOCATION_ACCUMULATIVE_TIMEOUT,
NULL, &pChainContext)) {
Status = GetLastError();
wprintf(L"Error 0x%x returned by CertGetCertificateChain!\n", Status);
goto cleanup;
}
// Validate certificate chain.
ZeroMemory(&polHttps, sizeof(HTTPSPolicyCallbackData));
polHttps.cbStruct = sizeof(HTTPSPolicyCallbackData);
polHttps.dwAuthType = AUTHTYPE_SERVER;
polHttps.fdwChecks = dwCertFlags;
polHttps.pwszServerName = host;
memset(&PolicyPara, 0, sizeof(PolicyPara));
PolicyPara.cbSize = sizeof(PolicyPara);
PolicyPara.dwFlags = CERT_CHAIN_POLICY_IGNORE_ALL_REV_UNKNOWN_FLAGS;
PolicyPara.pvExtraPolicyPara = &polHttps;
memset(&PolicyStatus, 0, sizeof(PolicyStatus));
PolicyStatus.cbSize = sizeof(PolicyStatus);
if(!CertVerifyCertificateChainPolicy(CERT_CHAIN_POLICY_SSL, pChainContext, &PolicyPara, &PolicyStatus)){
Status = GetLastError();
wprintf(L"Error 0x%x returned by CertVerifyCertificateChainPolicy!\n", Status);
goto cleanup;
}
if(PolicyStatus.dwError) {
Status = PolicyStatus.dwError;
goto cleanup;
}
Status = SEC_E_OK;
cleanup:
if(pChainContext)
{
CertFreeCertificateChain(pChainContext);
}
if(pwszServerName)
{
LocalFree(pwszServerName);
}
return Status;
}
static void get_new_client_credentials(TlsContext *tls_ctx) {
CredHandle hCreds;
SecPkgContext_IssuerListInfoEx IssuerListInfo;
PCCERT_CHAIN_CONTEXT pChainContext;
CERT_CHAIN_FIND_BY_ISSUER_PARA FindByIssuerPara;
PCCERT_CONTEXT pCertContext;
TimeStamp tsExpiry;
SECURITY_STATUS Status;
// Read list of trusted issuers from schannel.
Status = tls_ctx->sspi->QueryContextAttributes(&tls_ctx->h_context, SECPKG_ATTR_ISSUER_LIST_EX, (PVOID)&IssuerListInfo);
if(Status != SEC_E_OK) {
wprintf(L"Error 0x%x querying issuer list info\n", Status);
return;
}
// Enumerate the client certificates.
ZeroMemory(&FindByIssuerPara, sizeof(FindByIssuerPara));
FindByIssuerPara.cbSize = sizeof(FindByIssuerPara);
FindByIssuerPara.pszUsageIdentifier = szOID_PKIX_KP_CLIENT_AUTH;
FindByIssuerPara.dwKeySpec = 0;
FindByIssuerPara.cIssuer = IssuerListInfo.cIssuers;
FindByIssuerPara.rgIssuer = IssuerListInfo.aIssuers;
pChainContext = NULL;
while(TRUE) {
// Find a certificate chain.
pChainContext = CertFindChainInStore(tls_ctx->cert_store,
X509_ASN_ENCODING,
0,
CERT_CHAIN_FIND_BY_ISSUER,
&FindByIssuerPara,
pChainContext);
if(pChainContext == NULL) {
wprintf(L"Error 0x%x finding cert chain\n", GetLastError());
break;
}
// Get pointer to leaf certificate context.
pCertContext = pChainContext->rgpChain[0]->rgpElement[0]->pCertContext;
// Create schannel credential.
tls_ctx->schannel_cred.dwVersion = SCHANNEL_CRED_VERSION;
tls_ctx->schannel_cred.cCreds = 1;
tls_ctx->schannel_cred.paCred = &pCertContext;
Status = tls_ctx->sspi->AcquireCredentialsHandle(
NULL, // Name of principal
UNISP_NAME_W, // Name of package
SECPKG_CRED_OUTBOUND, // Flags indicating use
NULL, // Pointer to logon ID
&tls_ctx->schannel_cred, // Package specific data
NULL, // Pointer to GetKey() func
NULL, // Value to pass to GetKey()
&hCreds, // (out) Cred Handle
&tsExpiry); // (out) Lifetime (optional)
if(Status != SEC_E_OK) {
wprintf(L"Error 0x%x returned by AcquireCredentialsHandle\n", Status);
continue;
}
// Destroy the old credentials.
tls_ctx->sspi->FreeCredentialsHandle(&tls_ctx->h_client_creds);
tls_ctx->h_client_creds = hCreds;
//
// As you can see, this sample code maintains a single credential
// handle, replacing it as necessary. This is a little unusual.
//
// Many applications maintain a global credential handle that's
// anonymous (that is, it doesn't contain a client certificate),
// which is used to connect to all servers. If a particular server
// should require client authentication, then a new credential
// is created for use when connecting to that server. The global
// anonymous credential is retained for future connections to
// other servers.
//
// Maintaining a single anonymous credential that's used whenever
// possible is most efficient, since creating new credentials all
// the time is rather expensive.
//
break;
}
}
Reference in new issue View Git Blame Copy Permalink