1 /*
2 Unix SMB/CIFS implementation.
3
4 local testing of RPC binding string parsing
5
6 Copyright (C) Jelmer Vernooij 2004
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22 #include "includes.h"
23 #include "librpc/gen_ndr/epmapper.h"
24 #include "librpc/rpc/dcerpc.h"
25 #include "librpc/rpc/dcerpc_proto.h"
26 #include "torture/torture.h"
27 #include "torture/local/proto.h"
28 #include "lib/util/util_net.h"
29
test_BindingString(struct torture_context * tctx,const void * test_data)30 static bool test_BindingString(struct torture_context *tctx,
31 const void *test_data)
32 {
33 const char *binding = test_data;
34 struct dcerpc_binding *b, *b2;
35 char *s, *s2, *p;
36 struct epm_tower tower;
37 TALLOC_CTX *mem_ctx = tctx;
38 const char *host;
39 struct GUID object;
40
41 /* Parse */
42 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(mem_ctx, binding, &b),
43 "Error parsing binding string");
44
45 object = dcerpc_binding_get_object(b);
46
47 s = dcerpc_binding_string(mem_ctx, b);
48 torture_assert(tctx, s != NULL, "Error converting binding back to string");
49
50 torture_assert_casestr_equal(tctx, binding, s,
51 "Mismatch while comparing original and regenerated binding strings");
52
53 /* Generate protocol towers */
54 torture_assert_ntstatus_ok(tctx, dcerpc_binding_build_tower(mem_ctx, b, &tower),
55 "Error generating protocol tower");
56
57 /* Convert back to binding and then back to string and compare */
58
59 torture_assert_ntstatus_ok(tctx, dcerpc_binding_from_tower(mem_ctx, &tower, &b2),
60 "Error generating binding from tower for original binding");
61
62 /* The tower doesn't contain the object */
63 torture_assert_ntstatus_ok(tctx, dcerpc_binding_set_object(b2, object),
64 "set object on tower binding");
65
66 s = dcerpc_binding_string(mem_ctx, b);
67 torture_assert(tctx, s != NULL, "Error converting binding back to string for (stripped down)");
68
69 /*
70 * Compare to a stripped down version of the binding string because
71 * the protocol tower doesn't contain the extra option data
72 *
73 * We remove all options except of the endpoint.
74 */
75 p = strchr(s, '[');
76 if (p != NULL) {
77 char *p2;
78
79 p2 = strchr(p + 1, ',');
80 if (p2 != NULL) {
81 /*
82 * We only look at the first option,
83 * which might be the endpoint.
84 */
85 p2[0] = ']';
86 p2[1] = '\0';
87 }
88
89 p2 = strchr(p + 1, '=');
90 if (p2 != NULL) {
91 /*
92 * It's not the endpoint, so remove the
93 * whole option section.
94 */
95 *p = '\0';
96 }
97 }
98
99 s2 = dcerpc_binding_string(mem_ctx, b2);
100 torture_assert(tctx, s != NULL, "Error converting binding back to string");
101
102 host = dcerpc_binding_get_string_option(b, "host");
103 if (host && is_ipaddress_v4(host)) {
104 torture_assert_casestr_equal(tctx, s, s2, "Mismatch while comparing original and from protocol tower generated binding strings");
105 }
106
107 return true;
108 }
109
110 static const char *test_strings[] = {
111 "ncacn_np:",
112 "ncalrpc:",
113 "ncalrpc:[,Security=Sane]",
114 "ncacn_np:[rpcecho]",
115 "ncacn_np:127.0.0.1[rpcecho]",
116 "ncacn_ip_tcp:127.0.0.1",
117 "ncacn_ip_tcp:127.0.0.1[20]",
118 "ncacn_ip_tcp:127.0.0.1[20,sign]",
119 "ncacn_ip_tcp:127.0.0.1[20,sign,Security=Foobar]",
120 "ncacn_http:127.0.0.1",
121 "ncacn_http:127.0.0.1[78]",
122 "ncacn_http:127.0.0.1[78,ProxyServer=myproxy:3128]",
123 "ncacn_np:localhost[rpcecho]",
124 "ncacn_np:[/pipe/rpcecho]",
125 "ncacn_np:localhost[/pipe/rpcecho,sign,seal]",
126 "ncacn_np:[,sign]",
127 "ncadg_ip_udp:",
128 "308FB580-1EB2-11CA-923B-08002B1075A7@ncacn_np:localhost",
129 "308FB580-1EB2-11CA-923B-08002B1075A7@ncacn_ip_tcp:127.0.0.1",
130 "ncacn_unix_stream:[/tmp/epmapper]",
131 "ncalrpc:[IDENTIFIER]",
132 "ncacn_unix_stream:[/tmp/epmapper,sign]",
133 "ncacn_ip_tcp:127.0.0.1[75,target_hostname=port75.example.com,target_principal=host/port75.example.com]",
134 "ncacn_ip_tcp:127.0.0.1[75,connect,target_hostname=port75.example.com,target_principal=host/port75.example.com,assoc_group_id=0x01234567]",
135 "ncacn_ip_tcp:127.0.0.1[75,packet,target_hostname=port75.example.com,target_principal=host/port75.example.com,assoc_group_id=0x01234567]",
136 "ncacn_ip_tcp:::",
137 "ncacn_ip_tcp:::[75]",
138 "ncacn_ip_tcp:FD00::5357:5F00",
139 "ncacn_ip_tcp:FD00::5357:5F00[75]",
140 "ncacn_ip_tcp:FD00::5357:5F00[,target_hostname=port75.example.com]",
141 "ncacn_ip_tcp:FD00::5357:5F00[75,target_hostname=port75.example.com]",
142 "ncacn_ip_tcp:fe80::5357:5F00%75",
143 "ncacn_ip_tcp:fe80::5357:5F00%75[75]",
144 "ncacn_ip_tcp:fe80::5357:5F00%75[,target_hostname=port75.example.com]",
145 "ncacn_ip_tcp:fe80::5357:5F00%75[75,target_hostname=port75.example.com]",
146 };
147
test_parse_check_results(struct torture_context * tctx)148 static bool test_parse_check_results(struct torture_context *tctx)
149 {
150 struct dcerpc_binding *b;
151 struct GUID uuid;
152 struct GUID object;
153 struct ndr_syntax_id abstract;
154 enum dcerpc_transport_t transport;
155 const char *endpoint;
156 uint32_t flags;
157
158 torture_assert_ntstatus_ok(tctx,
159 GUID_from_string("308FB580-1EB2-11CA-923B-08002B1075A7", &uuid),
160 "parsing uuid");
161
162 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_np:$SERVER", &b), "parse");
163 transport = dcerpc_binding_get_transport(b);
164 torture_assert(tctx, transport == NCACN_NP, "ncacn_np expected");
165 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_ip_tcp:$SERVER", &b), "parse");
166 transport = dcerpc_binding_get_transport(b);
167 torture_assert(tctx, transport == NCACN_IP_TCP, "ncacn_ip_tcp expected");
168 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_np:$SERVER[rpcecho]", &b), "parse");
169 endpoint = dcerpc_binding_get_string_option(b, "endpoint");
170 torture_assert_str_equal(tctx, endpoint, "rpcecho", "endpoint");
171 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_np:$SERVER[/pipe/rpcecho]", &b), "parse");
172 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_np:$SERVER[/pipe/rpcecho,sign,seal]", &b), "parse");
173 flags = dcerpc_binding_get_flags(b);
174 torture_assert(tctx, flags == DCERPC_SIGN+DCERPC_SEAL, "sign+seal flags");
175 endpoint = dcerpc_binding_get_string_option(b, "endpoint");
176 torture_assert_str_equal(tctx, endpoint, "/pipe/rpcecho", "endpoint");
177 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_np:$SERVER[,sign]", &b), "parse");
178 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_ip_tcp:$SERVER[,sign]", &b), "parse");
179 endpoint = dcerpc_binding_get_string_option(b, "endpoint");
180 torture_assert(tctx, endpoint == NULL, "endpoint");
181 flags = dcerpc_binding_get_flags(b);
182 torture_assert(tctx, flags == DCERPC_SIGN, "sign flag");
183 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncalrpc:", &b), "parse");
184 transport = dcerpc_binding_get_transport(b);
185 torture_assert(tctx, transport == NCALRPC, "ncalrpc expected");
186 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx,
187 "308FB580-1EB2-11CA-923B-08002B1075A7@ncacn_np:$SERVER", &b), "parse");
188 object = dcerpc_binding_get_object(b);
189 abstract = dcerpc_binding_get_abstract_syntax(b);
190 torture_assert(tctx, GUID_equal(&object, &uuid), "object uuid");
191 torture_assert(tctx, ndr_syntax_id_equal(&abstract, &ndr_syntax_id_null),
192 "null abstract syntax");
193 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx,
194 "308FB580-1EB2-11CA-923B-08002B1075A7@ncacn_ip_tcp:$SERVER", &b), "parse");
195 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, "ncacn_ip_tcp:$SERVER[,sign,localaddress=192.168.1.1]", &b), "parse");
196 transport = dcerpc_binding_get_transport(b);
197 torture_assert(tctx, transport == NCACN_IP_TCP, "ncacn_ip_tcp expected");
198 flags = dcerpc_binding_get_flags(b);
199 torture_assert(tctx, flags == DCERPC_SIGN, "sign flag");
200 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "localaddress"),
201 "192.168.1.1", "localaddress");
202 torture_assert_str_equal(tctx, "ncacn_ip_tcp:$SERVER[,sign,localaddress=192.168.1.1]",
203 dcerpc_binding_string(tctx, b), "back to string");
204 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "host"),
205 "$SERVER", "host");
206 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_hostname"),
207 "$SERVER", "target_hostname");
208
209 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx,
210 "ncacn_ip_tcp:$HOST[,target_hostname=$HOSTNAME,target_principal=$PRINCIPAL]",
211 &b), "parse");
212 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "host"),
213 "$HOST", "host");
214 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_hostname"),
215 "$HOSTNAME", "target_hostname");
216 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_principal"),
217 "$PRINCIPAL", "target_principal");
218 torture_assert_str_equal(tctx,
219 dcerpc_binding_string(tctx, b),
220 "ncacn_ip_tcp:$HOST[,target_hostname=$HOSTNAME,target_principal=$PRINCIPAL]",
221 "back to string");
222
223 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx,
224 "ncacn_ip_tcp:$HOST[,connect,target_hostname=$HOSTNAME,target_principal=$PRINCIPAL,assoc_group_id=0x01234567]",
225 &b), "parse");
226 flags = dcerpc_binding_get_flags(b);
227 torture_assert(tctx, flags == DCERPC_CONNECT, "connect flag");
228 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "host"),
229 "$HOST", "host");
230 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_hostname"),
231 "$HOSTNAME", "target_hostname");
232 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_principal"),
233 "$PRINCIPAL", "target_principal");
234 torture_assert_int_equal(tctx, dcerpc_binding_get_assoc_group_id(b), 0x01234567,
235 "assoc_group_id");
236 torture_assert_str_equal(tctx,
237 dcerpc_binding_string(tctx, b),
238 "ncacn_ip_tcp:$HOST[,connect,target_hostname=$HOSTNAME,target_principal=$PRINCIPAL,assoc_group_id=0x01234567]",
239 "back to string");
240
241 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx,
242 "ncacn_ip_tcp:$HOST[,packet,target_hostname=$HOSTNAME,target_principal=$PRINCIPAL,assoc_group_id=0x01234567]",
243 &b), "parse");
244 flags = dcerpc_binding_get_flags(b);
245 torture_assert(tctx, flags == DCERPC_PACKET, "packet flag");
246 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "host"),
247 "$HOST", "host");
248 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_hostname"),
249 "$HOSTNAME", "target_hostname");
250 torture_assert_str_equal(tctx, dcerpc_binding_get_string_option(b, "target_principal"),
251 "$PRINCIPAL", "target_principal");
252 torture_assert_int_equal(tctx, dcerpc_binding_get_assoc_group_id(b), 0x01234567,
253 "assoc_group_id");
254 torture_assert_str_equal(tctx,
255 dcerpc_binding_string(tctx, b),
256 "ncacn_ip_tcp:$HOST[,packet,target_hostname=$HOSTNAME,target_principal=$PRINCIPAL,assoc_group_id=0x01234567]",
257 "back to string");
258
259 return true;
260 }
261
test_no_transport(struct torture_context * tctx,const void * test_data)262 static bool test_no_transport(struct torture_context *tctx, const void *test_data)
263 {
264 const char *binding = test_data;
265 struct dcerpc_binding *b;
266 enum dcerpc_transport_t transport;
267 const char *s;
268
269 /* Parse */
270 torture_assert_ntstatus_ok(tctx, dcerpc_parse_binding(tctx, binding, &b),
271 "Error parsing binding string");
272
273 transport = dcerpc_binding_get_transport(b);
274 torture_assert(tctx, transport == NCA_UNKNOWN, "invalid transport");
275
276 s = dcerpc_binding_string(tctx, b);
277 torture_assert(tctx, s != NULL, "Error converting binding back to string");
278
279 torture_assert_casestr_equal(tctx, binding, s,
280 "Mismatch while comparing original and regenerated binding strings");
281
282 return true;
283 }
284
285 static const char *test_no_strings[] = {
286 "port75.example.com",
287 "port75.example.com[75]",
288 "127.0.0.1",
289 "127.0.0.1[75]",
290 "127.0.0.1[,target_hostname=port75.example.com]",
291 "127.0.0.1[75,target_hostname=port75.example.com]",
292 "::",
293 "::[75]",
294 "::[,target_hostname=port75.example.com]",
295 "::[75,target_hostname=port75.example.com]",
296 "FD00::5357:5F00",
297 "FD00::5357:5F00[75]",
298 "FD00::5357:5F00[,target_hostname=port75.example.com]",
299 "FD00::5357:5F00[75,target_hostname=port75.example.com]",
300 "fe80::5357:5F00%75",
301 "fe80::5357:5F00%75[75]",
302 "fe80::5357:5F00%75[,target_hostname=port75.example.com]",
303 "fe80::5357:5F00%75[75,target_hostname=port75.example.com]",
304 };
305
torture_local_binding_string(TALLOC_CTX * mem_ctx)306 struct torture_suite *torture_local_binding_string(TALLOC_CTX *mem_ctx)
307 {
308 int i;
309 struct torture_suite *suite = torture_suite_create(mem_ctx, "binding");
310
311 for (i = 0; i < ARRAY_SIZE(test_strings); i++) {
312 torture_suite_add_simple_tcase_const(suite, test_strings[i],
313 test_BindingString,
314 test_strings[i]);
315 }
316
317 for (i = 0; i < ARRAY_SIZE(test_no_strings); i++) {
318 torture_suite_add_simple_tcase_const(suite, test_no_strings[i],
319 test_no_transport,
320 test_no_strings[i]);
321 }
322
323 torture_suite_add_simple_test(suite, "parsing results",
324 test_parse_check_results);
325
326 return suite;
327 }
328