289 lines
13 KiB
C
289 lines
13 KiB
C
/* MS-W32T 2.2.17 / opnum 6 and MS-RPCE connection-oriented packet privacy.
|
|
* Keep the status RPC on the same local pipe handle whose server PID we verify
|
|
* against the Service Control Manager, before exchanging any auth tokens.
|
|
* SSPI performs the NTLM exchange and protects the RPC headers and payloads.
|
|
*/
|
|
#define _WIN32_WINNT 0x0a00
|
|
#define SECURITY_WIN32
|
|
#include <windows.h>
|
|
#include <rpc.h>
|
|
#include <security.h>
|
|
#include <string.h>
|
|
#include "clock_status.h"
|
|
|
|
enum {
|
|
RPC_HEADER = 16, CALL_HEADER = 24, SECURITY_TRAILER = 8, SIGNATURE = 16,
|
|
FIRST_LAST = 3, HEADER_SIGN = 4, FRAME_LIMIT = 4280, TOKEN_LIMIT = 16384,
|
|
STATUS_LAYOUT = 120, STATUS_FIXED_WIRE = 112, STATUS_SOURCE_PTR = 60,
|
|
};
|
|
enum { REQUEST = 0, RESPONSE = 2, BIND = 11, BIND_ACK = 12, AUTH3 = 16 };
|
|
enum { BIND_CALL_ID = 1, STATUS_CALL_ID = 2, AUTH_CONTEXT_ID = 1, STATUS_OPNUM = 6 };
|
|
|
|
static DWORD w32time_pid(void) {
|
|
SC_HANDLE manager = OpenSCManagerW(NULL, NULL, SC_MANAGER_CONNECT);
|
|
if (!manager) return 0;
|
|
SC_HANDLE service = OpenServiceW(manager, L"W32Time", SERVICE_QUERY_STATUS);
|
|
SERVICE_STATUS_PROCESS status = {0};
|
|
DWORD needed = 0;
|
|
BOOL ok = service && QueryServiceStatusEx(service, SC_STATUS_PROCESS_INFO,
|
|
(BYTE *)&status, sizeof status, &needed);
|
|
if (service) CloseServiceHandle(service);
|
|
CloseServiceHandle(manager);
|
|
return ok && status.dwCurrentState == SERVICE_RUNNING ? status.dwProcessId : 0;
|
|
}
|
|
|
|
static BOOL is_w32time(HANDLE pipe, DWORD expected_pid) {
|
|
ULONG peer_pid = 0;
|
|
return expected_pid != 0 && GetNamedPipeServerProcessId(pipe, &peer_pid)
|
|
&& peer_pid == expected_pid && w32time_pid() == expected_pid;
|
|
}
|
|
|
|
static DWORD pipe_io(HANDLE pipe, BYTE *buffer, DWORD capacity, BOOL writing,
|
|
DWORD *count, ULONGLONG deadline) {
|
|
ULONGLONG now = GetTickCount64();
|
|
if (now >= deadline) return ERROR_TIMEOUT;
|
|
OVERLAPPED io = {0};
|
|
io.hEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
|
|
if (!io.hEvent) return GetLastError();
|
|
BOOL ok = writing ? WriteFile(pipe, buffer, capacity, NULL, &io)
|
|
: ReadFile(pipe, buffer, capacity, NULL, &io);
|
|
DWORD error = ok ? ERROR_SUCCESS : GetLastError();
|
|
if (error == ERROR_IO_PENDING) {
|
|
if (WaitForSingleObject(io.hEvent, (DWORD)(deadline - now)) != WAIT_OBJECT_0) {
|
|
CancelIoEx(pipe, &io);
|
|
/* Finish cancellation before releasing the stack buffer. */
|
|
GetOverlappedResult(pipe, &io, count, TRUE);
|
|
error = ERROR_TIMEOUT;
|
|
} else {
|
|
error = GetOverlappedResult(pipe, &io, count, FALSE)
|
|
? ERROR_SUCCESS : GetLastError();
|
|
}
|
|
} else if (ok) {
|
|
error = GetOverlappedResult(pipe, &io, count, FALSE)
|
|
? ERROR_SUCCESS : GetLastError();
|
|
}
|
|
CloseHandle(io.hEvent);
|
|
return error;
|
|
}
|
|
|
|
static void put16(BYTE *p, uint16_t v) { memcpy(p, &v, sizeof v); }
|
|
static void put32(BYTE *p, uint32_t v) { memcpy(p, &v, sizeof v); }
|
|
static uint16_t get16(const BYTE *p) { uint16_t v; memcpy(&v, p, sizeof v); return v; }
|
|
static uint32_t get32(const BYTE *p) { uint32_t v; memcpy(&v, p, sizeof v); return v; }
|
|
static uint64_t get64(const BYTE *p) { uint64_t v; memcpy(&v, p, sizeof v); return v; }
|
|
static int64_t get_i64(const BYTE *p) { int64_t v; memcpy(&v, p, sizeof v); return v; }
|
|
static DWORD align4(DWORD offset) { return (offset + 3) & ~3u; }
|
|
|
|
static void write_header(BYTE *p, BYTE type, BYTE flags, WORD length, WORD auth_length, DWORD call) {
|
|
memset(p, 0, RPC_HEADER);
|
|
p[0] = 5;
|
|
p[2] = type;
|
|
p[3] = flags;
|
|
p[4] = 0x10; /* little-endian NDR */
|
|
put16(p + 8, length);
|
|
put16(p + 10, auth_length);
|
|
put32(p + 12, call);
|
|
}
|
|
|
|
static void write_security_trailer(BYTE *p) {
|
|
memset(p, 0, SECURITY_TRAILER);
|
|
p[0] = RPC_C_AUTHN_WINNT;
|
|
p[1] = RPC_C_AUTHN_LEVEL_PKT_PRIVACY;
|
|
put32(p + 4, AUTH_CONTEXT_ID);
|
|
}
|
|
|
|
static BOOL valid_security_trailer(const BYTE *p) {
|
|
return p[0] == RPC_C_AUTHN_WINNT && p[1] == RPC_C_AUTHN_LEVEL_PKT_PRIVACY
|
|
&& p[3] == 0 && get32(p + 4) == AUTH_CONTEXT_ID;
|
|
}
|
|
|
|
static DWORD send_frame(HANDLE pipe, BYTE *frame, ULONGLONG deadline) {
|
|
DWORD length = get16(frame + 8);
|
|
DWORD count = 0;
|
|
DWORD error = pipe_io(pipe, frame, length, TRUE, &count, deadline);
|
|
return !error && count != length ? ERROR_INVALID_DATA : error;
|
|
}
|
|
|
|
static DWORD read_frame(HANDLE pipe, BYTE *frame, DWORD *length, BYTE type, DWORD call,
|
|
ULONGLONG deadline) {
|
|
DWORD error = pipe_io(pipe, frame, FRAME_LIMIT, FALSE, length, deadline);
|
|
if (error) return error;
|
|
if (*length < RPC_HEADER || frame[0] != 5 || frame[1] != 0 || frame[2] != type
|
|
|| (frame[3] & FIRST_LAST) != FIRST_LAST || get32(frame + 4) != 0x10
|
|
|| get16(frame + 8) != *length || get32(frame + 12) != call) {
|
|
return ERROR_INVALID_DATA;
|
|
}
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
static DWORD bind_status_rpc(HANDLE pipe, CredHandle *credentials, CtxtHandle *context,
|
|
ULONGLONG deadline) {
|
|
static const BYTE interface_v4_1[20] = {0x84,0xd8,0xb6,0x8f,0x88,0x23,0xd0,0x11,
|
|
0x8c,0x35,0,0xc0,0x4f,0xda,0x27,0x95,4,0,1,0};
|
|
static const BYTE ndr32_v2[20] = {0x04,0x5d,0x88,0x8a,0xeb,0x1c,0xc9,0x11,
|
|
0x9f,0xe8,0x08,0,0x2b,0x10,0x48,0x60,2};
|
|
const ULONG required = ISC_REQ_USE_DCE_STYLE | ISC_REQ_CONFIDENTIALITY
|
|
| ISC_REQ_INTEGRITY | ISC_REQ_REPLAY_DETECT | ISC_REQ_SEQUENCE_DETECT;
|
|
ULONG attributes = 0;
|
|
BYTE out[TOKEN_LIMIT] = {0};
|
|
BYTE reply[FRAME_LIMIT] = {0};
|
|
SecBuffer token = {sizeof out - 80, SECBUFFER_TOKEN, out + 80};
|
|
SecBufferDesc output = {SECBUFFER_VERSION, 1, &token};
|
|
SECURITY_STATUS status = InitializeSecurityContextW(credentials, NULL, L"", required, 0,
|
|
SECURITY_NATIVE_DREP, NULL, 0, context, &output, &attributes, NULL);
|
|
if (status != SEC_I_CONTINUE_NEEDED) return status ? (DWORD)status : ERROR_INVALID_DATA;
|
|
if (!token.cbBuffer || token.cbBuffer > sizeof out - 80) return ERROR_INVALID_DATA;
|
|
|
|
write_header(out, BIND, FIRST_LAST | HEADER_SIGN, (WORD)(80 + token.cbBuffer),
|
|
(WORD)token.cbBuffer, BIND_CALL_ID);
|
|
put16(out + 16, FRAME_LIMIT);
|
|
put16(out + 18, FRAME_LIMIT);
|
|
out[24] = 1; /* one bind context */
|
|
out[30] = 1; /* one transfer syntax */
|
|
memcpy(out + 32, interface_v4_1, sizeof interface_v4_1);
|
|
memcpy(out + 52, ndr32_v2, sizeof ndr32_v2);
|
|
write_security_trailer(out + 72);
|
|
DWORD error = send_frame(pipe, out, deadline);
|
|
if (error) return error;
|
|
|
|
DWORD length = 0;
|
|
error = read_frame(pipe, reply, &length, BIND_ACK, BIND_CALL_ID, deadline);
|
|
if (error) return error;
|
|
DWORD challenge_length = get16(reply + 10);
|
|
if (reply[3] != (FIRST_LAST | HEADER_SIGN) || length < 56
|
|
|| !challenge_length || challenge_length > length - 56) return ERROR_INVALID_DATA;
|
|
DWORD verdict = align4(26 + get16(reply + 24));
|
|
DWORD trailer = length - SECURITY_TRAILER - challenge_length;
|
|
if (verdict > trailer || trailer - verdict < 28 || reply[verdict] != 1
|
|
|| get16(reply + verdict + 4) != 0 || get16(reply + verdict + 6) != 0
|
|
|| memcmp(reply + verdict + 8, ndr32_v2, sizeof ndr32_v2)
|
|
|| !valid_security_trailer(reply + trailer)) return ERROR_INVALID_DATA;
|
|
|
|
SecBuffer challenge = {challenge_length, SECBUFFER_TOKEN, reply + trailer + SECURITY_TRAILER};
|
|
SecBufferDesc input = {SECBUFFER_VERSION, 1, &challenge};
|
|
token.pvBuffer = out + 28;
|
|
token.cbBuffer = sizeof out - 28;
|
|
status = InitializeSecurityContextW(credentials, context, L"", required, 0,
|
|
SECURITY_NATIVE_DREP, &input, 0, context, &output, &attributes, NULL);
|
|
if (status == SEC_I_COMPLETE_NEEDED) status = CompleteAuthToken(context, &output);
|
|
if (status) return (DWORD)status;
|
|
if (!token.cbBuffer || token.cbBuffer > sizeof out - 28
|
|
|| !(attributes & ISC_RET_CONFIDENTIALITY) || !(attributes & ISC_RET_INTEGRITY)) {
|
|
return ERROR_INVALID_DATA;
|
|
}
|
|
|
|
write_header(out, AUTH3, FIRST_LAST, (WORD)(28 + token.cbBuffer),
|
|
(WORD)token.cbBuffer, BIND_CALL_ID);
|
|
memset(out + RPC_HEADER, 0, 4);
|
|
write_security_trailer(out + 20);
|
|
return send_frame(pipe, out, deadline);
|
|
}
|
|
|
|
static DWORD decode_status(const BYTE *body, DWORD length, RmmClockStatus *out) {
|
|
/* Unique NDR32 status pointer, x64 MS-W32T layout ID, no auxiliary entries. */
|
|
if (length < STATUS_FIXED_WIRE + 4 || !get32(body) || get32(body + 8) != STATUS_LAYOUT
|
|
|| get32(body + 104) || get32(body + 108)) return RPC_X_BAD_STUB_DATA;
|
|
DWORD result_offset = STATUS_FIXED_WIRE;
|
|
if (get32(body + STATUS_SOURCE_PTR)) {
|
|
/* Skip the optional conformant UTF-16 string without allocating or logging it. */
|
|
if (length - result_offset < 16) return RPC_X_BAD_STUB_DATA;
|
|
DWORD maximum = get32(body + result_offset);
|
|
DWORD offset = get32(body + result_offset + 4);
|
|
DWORD count = get32(body + result_offset + 8);
|
|
if (offset || !count || count > maximum || count > (length - result_offset - 16) / 2)
|
|
return RPC_X_BAD_STUB_DATA;
|
|
result_offset += 12 + 2 * count;
|
|
if (get16(body + result_offset - 2)) return RPC_X_BAD_STUB_DATA;
|
|
result_offset = align4(result_offset);
|
|
}
|
|
if (length - 4 != result_offset) return RPC_X_BAD_STUB_DATA;
|
|
DWORD result = get32(body + result_offset);
|
|
if (result) return result;
|
|
*out = (RmmClockStatus){
|
|
.leap = get32(body + 12), .stratum = get32(body + 16), .size = STATUS_LAYOUT,
|
|
.last_sync = get64(body + 32), .root_delay = get_i64(body + 40),
|
|
.root_dispersion = get64(body + 48), .phase = get_i64(body + 64),
|
|
.state = get32(body + 72), .flags = get32(body + 76),
|
|
.last_result = get32(body + 88), .sync_age = get64(body + 96),
|
|
};
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
static DWORD request_status(HANDLE pipe, CtxtHandle *context, ULONGLONG deadline,
|
|
DWORD expected_pid, RmmClockStatus *out) {
|
|
SecPkgContext_Sizes sizes = {0};
|
|
SECURITY_STATUS security = QueryContextAttributesW(context, SECPKG_ATTR_SIZES, &sizes);
|
|
if (security) return (DWORD)security;
|
|
if (sizes.cbSecurityTrailer != SIGNATURE) return ERROR_INVALID_DATA;
|
|
BYTE frame[CALL_HEADER + SECURITY_TRAILER + SIGNATURE] = {0};
|
|
write_header(frame, REQUEST, FIRST_LAST, sizeof frame, SIGNATURE, STATUS_CALL_ID);
|
|
put16(frame + 22, STATUS_OPNUM); /* only the read-only operation has an encoding */
|
|
write_security_trailer(frame + CALL_HEADER);
|
|
SecBuffer parts[] = {
|
|
{CALL_HEADER, SECBUFFER_DATA | SECBUFFER_READONLY_WITH_CHECKSUM, frame},
|
|
{0, SECBUFFER_DATA, frame + CALL_HEADER},
|
|
{SECURITY_TRAILER, SECBUFFER_DATA | SECBUFFER_READONLY_WITH_CHECKSUM, frame + CALL_HEADER},
|
|
{SIGNATURE, SECBUFFER_TOKEN, frame + CALL_HEADER + SECURITY_TRAILER},
|
|
};
|
|
SecBufferDesc message = {SECBUFFER_VERSION, 4, parts};
|
|
security = EncryptMessage(context, 0, &message, 0);
|
|
if (security) return (DWORD)security;
|
|
if (parts[3].cbBuffer != SIGNATURE) return ERROR_INVALID_DATA;
|
|
DWORD error = send_frame(pipe, frame, deadline);
|
|
if (error) return error;
|
|
|
|
BYTE reply[FRAME_LIMIT] = {0};
|
|
DWORD length = 0;
|
|
error = read_frame(pipe, reply, &length, RESPONSE, STATUS_CALL_ID, deadline);
|
|
if (error) return error;
|
|
if (reply[3] != FIRST_LAST || get16(reply + 10) != SIGNATURE || get16(reply + 20) != 0
|
|
|| length < sizeof frame) return ERROR_INVALID_DATA;
|
|
DWORD trailer = length - SECURITY_TRAILER - SIGNATURE;
|
|
BYTE padding = reply[trailer + 2];
|
|
if (padding > 15 || padding > trailer - CALL_HEADER
|
|
|| !valid_security_trailer(reply + trailer)) return ERROR_INVALID_DATA;
|
|
parts[0].pvBuffer = reply;
|
|
parts[1].pvBuffer = reply + CALL_HEADER;
|
|
parts[1].cbBuffer = trailer - CALL_HEADER;
|
|
parts[2].pvBuffer = reply + trailer;
|
|
parts[3].pvBuffer = reply + trailer + SECURITY_TRAILER;
|
|
ULONG qop = 0;
|
|
security = DecryptMessage(context, &message, 0, &qop);
|
|
if (security) return (DWORD)security;
|
|
if (qop != 0) return ERROR_INVALID_DATA;
|
|
if (!is_w32time(pipe, expected_pid)) return ERROR_ACCESS_DENIED;
|
|
return decode_status(reply + CALL_HEADER, trailer - CALL_HEADER - padding, out);
|
|
}
|
|
|
|
uint32_t rmm_local_clock_query(RmmClockStatus *out) {
|
|
memset(out, 0, sizeof *out);
|
|
DWORD expected_pid = w32time_pid();
|
|
if (!expected_pid) return ERROR_SERVICE_NOT_ACTIVE;
|
|
ULONGLONG deadline = GetTickCount64() + 750;
|
|
HANDLE pipe = CreateFileW(L"\\\\.\\pipe\\W32TIME_ALT", FILE_READ_DATA | FILE_WRITE_DATA
|
|
| FILE_WRITE_ATTRIBUTES | SYNCHRONIZE, 0, NULL, OPEN_EXISTING,
|
|
FILE_FLAG_OVERLAPPED | SECURITY_SQOS_PRESENT | SECURITY_IDENTIFICATION, NULL);
|
|
if (pipe == INVALID_HANDLE_VALUE) return GetLastError();
|
|
DWORD mode = PIPE_READMODE_MESSAGE;
|
|
DWORD error;
|
|
if (!is_w32time(pipe, expected_pid)) {
|
|
error = ERROR_ACCESS_DENIED;
|
|
} else if (!SetNamedPipeHandleState(pipe, &mode, NULL, NULL)) {
|
|
error = GetLastError();
|
|
} else {
|
|
CredHandle credentials;
|
|
CtxtHandle context;
|
|
SecInvalidateHandle(&context);
|
|
error = (DWORD)AcquireCredentialsHandleW(NULL, L"NTLM", SECPKG_CRED_OUTBOUND,
|
|
NULL, NULL, NULL, NULL, &credentials, NULL);
|
|
if (!error) {
|
|
error = bind_status_rpc(pipe, &credentials, &context, deadline);
|
|
if (!error) error = request_status(pipe, &context, deadline, expected_pid, out);
|
|
if (SecIsValidHandle(&context)) DeleteSecurityContext(&context);
|
|
FreeCredentialsHandle(&credentials);
|
|
}
|
|
}
|
|
CloseHandle(pipe);
|
|
return error;
|
|
}
|