FreeRDP
Loading...
Searching...
No Matches
TestNdrEar.c
1#include <winpr/print.h>
2#include <winpr/string.h>
3#include <winpr/ndr.h>
4
5#include <rdpear-common/rdpear_common.h>
6
7#ifndef MAX
8#define MAX(a, b) ((a) > (b)) ? (a) : (b)
9#endif
10#ifndef MIN
11#define MIN(a, b) ((a) < (b)) ? (a) : (b)
12#endif
13
14static BYTE nextValue(BYTE old, INT32 offset, char symbol, char startSymbol)
15{
16 const INT32 uold = 16 * old;
17 const INT32 diff = symbol - startSymbol;
18 const INT32 res = uold + diff + offset;
19 return (BYTE)MIN(MAX(0, res), UINT8_MAX);
20}
21
22static BYTE* parseHexBlock(const char* str, size_t* plen)
23{
24 WINPR_ASSERT(str);
25 WINPR_ASSERT(plen);
26
27 BYTE* ret = malloc(strlen(str) / 2);
28 BYTE* dest = ret;
29 const char* ptr = str;
30 BYTE tmp = 0;
31 size_t nchars = 0;
32 size_t len = 0;
33
34 for (; *ptr; ptr++)
35 {
36 switch (*ptr)
37 {
38 case ' ':
39 case '\n':
40 case '\t':
41 if (nchars)
42 {
43 WLog_ERR("", "error parsing hex block, unpaired char");
44 free(ret);
45 return nullptr;
46 }
47 break;
48 case '0':
49 case '1':
50 case '2':
51 case '3':
52 case '4':
53 case '5':
54 case '6':
55 case '7':
56 case '8':
57 case '9':
58 tmp = nextValue(tmp, 0, *ptr, '0');
59 nchars++;
60 if (nchars == 2)
61 {
62 *dest = tmp;
63 dest++;
64 len++;
65 tmp = 0;
66 nchars = 0;
67 }
68 break;
69
70 case 'a':
71 case 'b':
72 case 'c':
73 case 'd':
74 case 'e':
75 case 'f':
76 tmp = nextValue(tmp, 10, *ptr, 'a');
77 nchars++;
78 if (nchars == 2)
79 {
80 *dest = tmp;
81 dest++;
82 len++;
83 tmp = 0;
84 nchars = 0;
85 }
86 break;
87
88 case 'A':
89 case 'B':
90 case 'C':
91 case 'D':
92 case 'E':
93 case 'F':
94 tmp = nextValue(tmp, 10, *ptr, 'A');
95 nchars++;
96 if (nchars == 2)
97 {
98 *dest = tmp;
99 dest++;
100 len++;
101 tmp = 0;
102 nchars = 0;
103 }
104 break;
105 default:
106 WLog_ERR("", "invalid char in hex block");
107 free(ret);
108 return nullptr;
109 }
110 }
111
112 *plen = len;
113 return ret;
114}
115
116static int TestNdrEarWrite(int argc, char* argv[])
117{
118 WINPR_UNUSED(argc);
119 WINPR_UNUSED(argv);
120
121 int rc = -1;
122 BYTE buffer[16] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15 };
123 KERB_ASN1_DATA asn1 = { 7, { 16 }, buffer };
124
125 wStream* s = Stream_New(nullptr, 100);
126 if (!s)
127 return -1;
128
129 WinPrNdrEncoder* encoder = winpr_ndr_encoder_new(FALSE, 1);
130 if (!encoder)
131 goto fail;
132
133 if (!ndr_encoder_write_KERB_ASN1_DATA(encoder, s, nullptr, &asn1))
134 goto fail;
135 if (!winpr_ndr_encoder_treat_deferreds(encoder, s))
136 goto fail;
137
138 // winpr_HexDump("", WLOG_DEBUG, Stream_Buffer(s), Stream_GetPosition(s));
139
140 rc = 0;
141fail:
143 Stream_Free(s, TRUE);
144 return rc;
145}
146
147static int TestNdrEarRead(int argc, char* argv[])
148{
149 WINPR_UNUSED(argc);
150 WINPR_UNUSED(argv);
151
152 int retCode = -2;
153
154 /* ====================================================================== */
155 WinPrNdrDecoder* decoder = winpr_ndr_decoder_new(FALSE, 1);
156 if (!decoder)
157 return -1;
158
159 wStream staticS = WINPR_C_ARRAY_INIT;
160 wStream* s = nullptr;
161
162 /* ====================================================================== */
163 size_t sizeofPayload4 = 0;
164 BYTE* payload4 = parseHexBlock("03 01 03 01 \
165 04 00 02 00 38 9e ef 6b 0c 00 02 00 18 00 02 00 \
166 20 00 02 00 00 00 00 00 24 00 02 00 2c 00 02 00 \
167 07 00 00 00 13 8a a5 a8 12 00 00 00 20 00 00 00 \
168 08 00 02 00 20 00 00 00 c9 03 42 a8 17 8f d9 c4 \
169 9b d2 c4 6e 73 64 98 7b 90 f5 9a 28 77 8e ca de \
170 29 2e a3 8d 8a 56 36 d5 01 00 01 00 10 00 02 00 \
171 01 00 00 00 1c 00 1e 00 14 00 02 00 0f 00 00 00 \
172 00 00 00 00 0e 00 00 00 41 00 64 00 6d 00 69 00 \
173 6e 00 69 00 73 00 74 00 72 00 61 00 74 00 65 00 \
174 75 00 72 00 1c 00 1e 00 1c 00 02 00 0f 00 00 00 \
175 00 00 00 00 0e 00 00 00 48 00 41 00 52 00 44 00 \
176 45 00 4e 00 49 00 4e 00 47 00 33 00 2e 00 43 00 \
177 4f 00 4d 00 00 00 00 00 00 00 00 00 00 00 00 00 \
178 02 00 00 00 28 00 02 00 02 00 00 00 30 00 00 00 \
179 08 00 00 00 1b 00 00 00 30 00 02 00 1b 00 00 00 \
180 30 19 a0 03 02 01 07 a1 12 04 10 e4 aa ff 2b 93 \
181 97 4c f2 5c 0b 49 85 72 92 94 54 00",
182 &sizeofPayload4);
183
184 if (!payload4)
185 goto out;
186
187 CreateApReqAuthenticatorReq createApReqAuthenticatorReq = WINPR_C_ARRAY_INIT;
188 s = Stream_StaticConstInit(&staticS, payload4, sizeofPayload4);
189 if (!winpr_ndr_decoder_skip_bytes(decoder, s, 4) || /* skip union id */
190 !ndr_decoder_read_CreateApReqAuthenticatorReq(decoder, s, nullptr,
191 &createApReqAuthenticatorReq) ||
193 createApReqAuthenticatorReq.KeyUsage != 7 || !createApReqAuthenticatorReq.EncryptionKey ||
194 createApReqAuthenticatorReq.SubKey || !createApReqAuthenticatorReq.ClientName ||
195 createApReqAuthenticatorReq.ClientName->nameHints.count != 1 ||
196 !createApReqAuthenticatorReq.ClientRealm || !createApReqAuthenticatorReq.AuthData ||
197 createApReqAuthenticatorReq.AuthData->Asn1BufferHints.count != 2 ||
198 !createApReqAuthenticatorReq.SkewTime ||
199 createApReqAuthenticatorReq.SkewTime->QuadPart != 0)
200 goto out;
201 ndr_destroy_CreateApReqAuthenticatorReq(nullptr, &createApReqAuthenticatorReq);
202
203 /* ============ successful end of test =============== */
204 retCode = 0;
205out:
206 free(payload4);
208 return retCode;
209}
210
211/* the referents of the Names items come in item order after the Names array */
212static int TestNdrEarInternalNames(void)
213{
214 const BYTE payload[] = {
215 0x01, 0x00, 0x02, 0x00, /* NameType, NameCount */
216 0x00, 0x00, 0x02, 0x00, /* Names */
217 0x02, 0x00, 0x00, 0x00, /* Names: conformance */
218 0x06, 0x00, 0x06, 0x00, /* Names[0]: Length, MaximumLength */
219 0x04, 0x00, 0x02, 0x00, /* Names[0]: Buffer */
220 0x0c, 0x00, 0x0c, 0x00, /* Names[1]: Length, MaximumLength */
221 0x08, 0x00, 0x02, 0x00, /* Names[1]: Buffer */
222 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, /* Names[0] */
223 'a', 0x00, 'b', 0x00, 'c', 0x00, 0x00, 0x00, /* padding */
224 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, 0x00, /* Names[1] */
225 'd', 0x00, 'e', 0x00, 'f', 0x00, 'g', 0x00, 'h', 0x00, 'i', 0x00
226 };
227 const char* expected[] = { "abc", "defghi" };
228
229 int retCode = -1;
230 KERB_RPC_INTERNAL_NAME name = WINPR_C_ARRAY_INIT;
231 wStream staticS = WINPR_C_ARRAY_INIT;
232 wStream* s = Stream_StaticConstInit(&staticS, payload, sizeof(payload));
233
234 WinPrNdrDecoder* decoder = winpr_ndr_decoder_new(FALSE, 1);
235 if (!decoder)
236 return -1;
237
238 retCode = -2;
239 if (!ndr_decoder_read_KERB_RPC_INTERNAL_NAME(decoder, s, nullptr, &name) ||
241 goto out;
242
243 retCode = -3;
244 if ((Stream_GetRemainingLength(s) != 0) || (name.nameHints.count != ARRAYSIZE(expected)))
245 goto out;
246
247 for (UINT32 i = 0; i < name.nameHints.count; i++)
248 {
249 char* str =
250 ConvertWCharNToUtf8Alloc(name.Names[i].Buffer, name.Names[i].strLength, nullptr);
251 const BOOL match = str && (strcmp(str, expected[i]) == 0);
252 free(str);
253 if (!match)
254 goto out;
255 }
256
257 retCode = 0;
258out:
259 ndr_destroy_KERB_RPC_INTERNAL_NAME(nullptr, &name);
261 return retCode;
262}
263
264int TestNdrEar(int argc, char* argv[])
265{
266 const int rc = TestNdrEarWrite(argc, argv);
267 if (rc)
268 return rc;
269
270 const int rc2 = TestNdrEarInternalNames();
271 if (rc2)
272 return rc2;
273
274 return TestNdrEarRead(argc, argv);
275}
NDR encoder and decoder ([C706] chapter 14, [MS-RPCE] 2.2.5 and 2.2.6).
static INLINE void winpr_ndr_decoder_destroy(WinPrNdrDecoder **pcontext)
frees a decoder and resets the pointer
Definition ndr.h:657
WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_skip_bytes(WinPrNdrDecoder *context, wStream *s, size_t nbytes)
skips bytes
Definition ndr.c:1164
WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_encoder_treat_deferreds(WinPrNdrEncoder *context, wStream *s)
writes the pending deferred referents
Definition ndr.c:1075
WINPR_API WinPrNdrDecoder * winpr_ndr_decoder_new(BOOL bigEndianDrep, BYTE version)
creates a decoder
Definition ndr.c:1106
WINPR_API WinPrNdrEncoder * winpr_ndr_encoder_new(BOOL bigEndianDrep, BYTE version)
creates an encoder
Definition ndr.c:194
static INLINE void winpr_ndr_encoder_destroy(WinPrNdrEncoder **pcontext)
frees an encoder and resets the pointer
Definition ndr.h:405
UINT32 count
Definition ndr.h:554
WINPR_ATTR_NODISCARD WINPR_API BOOL winpr_ndr_decoder_treat_deferreds(WinPrNdrDecoder *context, wStream *s)
reads the pending deferred referents
Definition ndr.c:1714
2.2.2.1.4 CreateApReqAuthenticator
2.2.1.2.1 KERB_ASN1_DATA
2.2.1.2.3 KERB_RPC_INTERNAL_NAME