1 /*
2 Unix SMB/CIFS implementation.
3
4 dcerpc connect functions
5
6 Copyright (C) Andrew Tridgell 2003
7 Copyright (C) Jelmer Vernooij 2004
8 Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005-2007
9 Copyright (C) Rafal Szczesniak 2005
10
11 This program is free software; you can redistribute it and/or modify
12 it under the terms of the GNU General Public License as published by
13 the Free Software Foundation; either version 3 of the License, or
14 (at your option) any later version.
15
16 This program is distributed in the hope that it will be useful,
17 but WITHOUT ANY WARRANTY; without even the implied warranty of
18 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 GNU General Public License for more details.
20
21 You should have received a copy of the GNU General Public License
22 along with this program. If not, see <http://www.gnu.org/licenses/>.
23 */
24
25
26 #include "includes.h"
27 #include "libcli/composite/composite.h"
28 #include "lib/events/events.h"
29 #include "librpc/rpc/dcerpc.h"
30 #include "librpc/rpc/dcerpc_proto.h"
31 #include "auth/credentials/credentials.h"
32 #include "param/param.h"
33 #include "libcli/resolve/resolve.h"
34 #include "lib/util/util_net.h"
35
36 struct sec_conn_state {
37 struct dcerpc_pipe *pipe;
38 struct dcerpc_pipe *pipe2;
39 struct dcerpc_binding *binding;
40 };
41
42
43 static void continue_open_smb(struct composite_context *ctx);
44 static void continue_open_tcp(struct composite_context *ctx);
45 static void continue_open_ncalrpc(struct composite_context *ctx);
46 static void continue_open_ncacn_unix(struct composite_context *ctx);
47 static void continue_pipe_open(struct composite_context *c);
48
49
50 /*
51 Send request to create a secondary dcerpc connection from a primary
52 connection
53 */
dcerpc_secondary_connection_send(struct dcerpc_pipe * p,const struct dcerpc_binding * b)54 _PUBLIC_ struct composite_context* dcerpc_secondary_connection_send(struct dcerpc_pipe *p,
55 const struct dcerpc_binding *b)
56 {
57 struct composite_context *c;
58 struct sec_conn_state *s;
59 struct composite_context *pipe_smb_req;
60 struct composite_context *pipe_tcp_req;
61 const char *localaddress = NULL;
62 struct composite_context *pipe_ncalrpc_req;
63 const char *ncalrpc_dir = NULL;
64 struct composite_context *pipe_unix_req;
65 const char *host;
66 const char *target_hostname;
67 const char *endpoint;
68
69 /* composite context allocation and setup */
70 c = composite_create(p, p->conn->event_ctx);
71 if (c == NULL) return NULL;
72
73 s = talloc_zero(c, struct sec_conn_state);
74 if (composite_nomem(s, c)) return c;
75 c->private_data = s;
76
77 s->pipe = p;
78 s->binding = dcerpc_binding_dup(s, b);
79 if (composite_nomem(s->binding, c)) return c;
80
81 /* initialise second dcerpc pipe based on primary pipe's event context */
82 s->pipe2 = dcerpc_pipe_init(c, s->pipe->conn->event_ctx);
83 if (composite_nomem(s->pipe2, c)) return c;
84
85 if (DEBUGLEVEL >= 10)
86 s->pipe2->conn->packet_log_dir = s->pipe->conn->packet_log_dir;
87
88 host = dcerpc_binding_get_string_option(s->binding, "host");
89 if (host == NULL) {
90 /*
91 * We may fallback to the host of the given connection
92 */
93 host = dcerpc_binding_get_string_option(s->pipe->binding,
94 "host");
95 }
96 target_hostname = dcerpc_binding_get_string_option(s->binding, "target_hostname");
97 if (target_hostname == NULL) {
98 /*
99 * We may fallback to the target_hostname of the given connection
100 */
101 target_hostname = dcerpc_binding_get_string_option(s->pipe->binding,
102 "target_hostname");
103 }
104 endpoint = dcerpc_binding_get_string_option(s->binding, "endpoint");
105 if (endpoint == NULL) {
106 /*
107 * We may fallback to the endpoint of the given connection
108 */
109 endpoint = dcerpc_binding_get_string_option(s->pipe->binding, "endpoint");
110 }
111 if (endpoint == NULL) {
112 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
113 return c;
114 }
115
116 /* open second dcerpc pipe using the same transport as for primary pipe */
117 switch (s->pipe->conn->transport.transport) {
118 case NCACN_NP:
119 pipe_smb_req = dcerpc_secondary_smb_send(s->pipe->conn,
120 s->pipe2->conn,
121 endpoint);
122 composite_continue(c, pipe_smb_req, continue_open_smb, c);
123 return c;
124
125 case NCACN_IP_TCP:
126 if (host == NULL) {
127 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
128 return c;
129 }
130
131 if (!is_ipaddress(host)) {
132 /*
133 * We may fallback to the host of the given connection
134 */
135 host = dcerpc_binding_get_string_option(s->pipe->binding,
136 "host");
137 if (host == NULL) {
138 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
139 return c;
140 }
141 if (!is_ipaddress(host)) {
142 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
143 return c;
144 }
145 }
146
147 localaddress = dcerpc_binding_get_string_option(s->binding,
148 "localaddress");
149 if (localaddress == NULL) {
150 /*
151 * We may fallback to the localaddress of the given connection
152 */
153 localaddress = dcerpc_binding_get_string_option(s->pipe->binding,
154 "localaddress");
155 }
156
157 pipe_tcp_req = dcerpc_pipe_open_tcp_send(s->pipe2->conn,
158 localaddress,
159 host,
160 target_hostname,
161 atoi(endpoint),
162 resolve_context_init(s));
163 composite_continue(c, pipe_tcp_req, continue_open_tcp, c);
164 return c;
165
166 case NCALRPC:
167 ncalrpc_dir = dcerpc_binding_get_string_option(s->binding,
168 "ncalrpc_dir");
169 if (ncalrpc_dir == NULL) {
170 ncalrpc_dir = dcerpc_binding_get_string_option(s->pipe->binding,
171 "ncalrpc_dir");
172 }
173 if (ncalrpc_dir == NULL) {
174 composite_error(c, NT_STATUS_INVALID_PARAMETER_MIX);
175 return c;
176 }
177
178 pipe_ncalrpc_req = dcerpc_pipe_open_pipe_send(s->pipe2->conn,
179 ncalrpc_dir,
180 endpoint);
181 composite_continue(c, pipe_ncalrpc_req, continue_open_ncalrpc, c);
182 return c;
183
184 case NCACN_UNIX_STREAM:
185 pipe_unix_req = dcerpc_pipe_open_unix_stream_send(s->pipe2->conn,
186 endpoint);
187 composite_continue(c, pipe_unix_req, continue_open_ncacn_unix, c);
188 return c;
189
190 default:
191 /* looks like a transport we don't support */
192 composite_error(c, NT_STATUS_NOT_SUPPORTED);
193 }
194
195 return c;
196 }
197
198
199 /*
200 Stage 2 of secondary_connection: Receive result of pipe open request on smb
201 */
continue_open_smb(struct composite_context * ctx)202 static void continue_open_smb(struct composite_context *ctx)
203 {
204 struct composite_context *c = talloc_get_type(ctx->async.private_data,
205 struct composite_context);
206
207 c->status = dcerpc_secondary_smb_recv(ctx);
208 if (!composite_is_ok(c)) return;
209
210 continue_pipe_open(c);
211 }
212
213
214 /*
215 Stage 2 of secondary_connection: Receive result of pipe open request on tcp/ip
216 */
continue_open_tcp(struct composite_context * ctx)217 static void continue_open_tcp(struct composite_context *ctx)
218 {
219 struct composite_context *c = talloc_get_type(ctx->async.private_data,
220 struct composite_context);
221 struct sec_conn_state *s = talloc_get_type_abort(c->private_data,
222 struct sec_conn_state);
223 char *localaddr = NULL;
224 char *remoteaddr = NULL;
225
226 c->status = dcerpc_pipe_open_tcp_recv(ctx, s, &localaddr, &remoteaddr);
227 if (!composite_is_ok(c)) return;
228
229 c->status = dcerpc_binding_set_string_option(s->binding,
230 "localaddress",
231 localaddr);
232 if (!composite_is_ok(c)) return;
233
234 c->status = dcerpc_binding_set_string_option(s->binding,
235 "host",
236 remoteaddr);
237 if (!composite_is_ok(c)) return;
238
239 continue_pipe_open(c);
240 }
241
242 /*
243 Stage 2 of secondary_connection: Receive result of pipe open request on ncalrpc
244 */
continue_open_ncalrpc(struct composite_context * ctx)245 static void continue_open_ncalrpc(struct composite_context *ctx)
246 {
247 struct composite_context *c = talloc_get_type(ctx->async.private_data,
248 struct composite_context);
249
250 c->status = dcerpc_pipe_open_pipe_recv(ctx);
251 if (!composite_is_ok(c)) return;
252
253 continue_pipe_open(c);
254 }
255
256 /*
257 Stage 2 of secondary_connection: Receive result of pipe open request on ncacn_unix
258 */
continue_open_ncacn_unix(struct composite_context * ctx)259 static void continue_open_ncacn_unix(struct composite_context *ctx)
260 {
261 struct composite_context *c = talloc_get_type(ctx->async.private_data,
262 struct composite_context);
263
264 c->status = dcerpc_pipe_open_unix_stream_recv(ctx);
265 if (!composite_is_ok(c)) return;
266
267 continue_pipe_open(c);
268 }
269
270
271 /*
272 Stage 3 of secondary_connection: Get binding data and flags from primary pipe
273 and say if we're done ok.
274 */
continue_pipe_open(struct composite_context * c)275 static void continue_pipe_open(struct composite_context *c)
276 {
277 struct sec_conn_state *s;
278
279 s = talloc_get_type(c->private_data, struct sec_conn_state);
280
281 s->pipe2->conn->flags = s->pipe->conn->flags;
282 s->pipe2->binding = dcerpc_binding_dup(s->pipe2, s->binding);
283 if (composite_nomem(s->pipe2->binding, c)) {
284 return;
285 }
286
287 composite_done(c);
288 }
289
290
291 /*
292 Receive result of secondary rpc connection request and return
293 second dcerpc pipe.
294 */
dcerpc_secondary_connection_recv(struct composite_context * c,struct dcerpc_pipe ** p2)295 _PUBLIC_ NTSTATUS dcerpc_secondary_connection_recv(struct composite_context *c,
296 struct dcerpc_pipe **p2)
297 {
298 NTSTATUS status = composite_wait(c);
299 struct sec_conn_state *s;
300
301 s = talloc_get_type(c->private_data, struct sec_conn_state);
302
303 if (NT_STATUS_IS_OK(status)) {
304 *p2 = talloc_steal(s->pipe, s->pipe2);
305 }
306
307 talloc_free(c);
308 return status;
309 }
310
311 /*
312 Create a secondary DCERPC connection, then bind (and possibly
313 authenticate) using the supplied credentials.
314
315 This creates a second connection, to the same host (and on ncacn_np on the same connection) as the first
316 */
317 struct sec_auth_conn_state {
318 struct dcerpc_pipe *pipe2;
319 const struct dcerpc_binding *binding;
320 const struct ndr_interface_table *table;
321 struct cli_credentials *credentials;
322 struct composite_context *ctx;
323 struct loadparm_context *lp_ctx;
324 };
325
326 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx);
327 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx);
328
dcerpc_secondary_auth_connection_send(struct dcerpc_pipe * p,const struct dcerpc_binding * binding,const struct ndr_interface_table * table,struct cli_credentials * credentials,struct loadparm_context * lp_ctx)329 _PUBLIC_ struct composite_context* dcerpc_secondary_auth_connection_send(struct dcerpc_pipe *p,
330 const struct dcerpc_binding *binding,
331 const struct ndr_interface_table *table,
332 struct cli_credentials *credentials,
333 struct loadparm_context *lp_ctx)
334 {
335
336 struct composite_context *c, *secondary_conn_ctx;
337 struct sec_auth_conn_state *s;
338
339 /* composite context allocation and setup */
340 c = composite_create(p, p->conn->event_ctx);
341 if (c == NULL) return NULL;
342
343 s = talloc_zero(c, struct sec_auth_conn_state);
344 if (composite_nomem(s, c)) return c;
345 c->private_data = s;
346 s->ctx = c;
347
348 s->binding = binding;
349 s->table = table;
350 s->credentials = credentials;
351 s->lp_ctx = lp_ctx;
352
353 secondary_conn_ctx = dcerpc_secondary_connection_send(p, binding);
354
355 if (composite_nomem(secondary_conn_ctx, s->ctx)) {
356 talloc_free(c);
357 return NULL;
358 }
359
360 composite_continue(s->ctx, secondary_conn_ctx, dcerpc_secondary_auth_connection_bind,
361 s);
362 return c;
363 }
364
365 /*
366 Stage 2 of secondary_auth_connection:
367 Having made the secondary connection, we will need to do an (authenticated) bind
368 */
dcerpc_secondary_auth_connection_bind(struct composite_context * ctx)369 static void dcerpc_secondary_auth_connection_bind(struct composite_context *ctx)
370 {
371 struct composite_context *secondary_auth_ctx;
372 struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
373 struct sec_auth_conn_state);
374
375 s->ctx->status = dcerpc_secondary_connection_recv(ctx, &s->pipe2);
376 if (!composite_is_ok(s->ctx)) return;
377
378 secondary_auth_ctx = dcerpc_pipe_auth_send(s->pipe2, s->binding, s->table, s->credentials,
379 s->lp_ctx);
380 composite_continue(s->ctx, secondary_auth_ctx, dcerpc_secondary_auth_connection_continue, s);
381
382 }
383
384 /*
385 Stage 3 of secondary_auth_connection: Receive result of authenticated bind request
386 */
dcerpc_secondary_auth_connection_continue(struct composite_context * ctx)387 static void dcerpc_secondary_auth_connection_continue(struct composite_context *ctx)
388 {
389 struct sec_auth_conn_state *s = talloc_get_type(ctx->async.private_data,
390 struct sec_auth_conn_state);
391
392 s->ctx->status = dcerpc_pipe_auth_recv(ctx, s, &s->pipe2);
393 if (!composite_is_ok(s->ctx)) return;
394
395 composite_done(s->ctx);
396 }
397
398 /*
399 Receive an authenticated pipe, created as a secondary connection
400 */
dcerpc_secondary_auth_connection_recv(struct composite_context * c,TALLOC_CTX * mem_ctx,struct dcerpc_pipe ** p)401 _PUBLIC_ NTSTATUS dcerpc_secondary_auth_connection_recv(struct composite_context *c,
402 TALLOC_CTX *mem_ctx,
403 struct dcerpc_pipe **p)
404 {
405 NTSTATUS status = composite_wait(c);
406 struct sec_auth_conn_state *s;
407
408 s = talloc_get_type(c->private_data, struct sec_auth_conn_state);
409
410 if (NT_STATUS_IS_OK(status)) {
411 *p = talloc_steal(mem_ctx, s->pipe2);
412 }
413
414 talloc_free(c);
415 return status;
416 }
417
dcerpc_secondary_auth_connection(struct dcerpc_pipe * p,const struct dcerpc_binding * binding,const struct ndr_interface_table * table,struct cli_credentials * credentials,struct loadparm_context * lp_ctx,TALLOC_CTX * mem_ctx,struct dcerpc_pipe ** p2)418 _PUBLIC_ NTSTATUS dcerpc_secondary_auth_connection(struct dcerpc_pipe *p,
419 const struct dcerpc_binding *binding,
420 const struct ndr_interface_table *table,
421 struct cli_credentials *credentials,
422 struct loadparm_context *lp_ctx,
423 TALLOC_CTX *mem_ctx,
424 struct dcerpc_pipe **p2)
425 {
426 struct composite_context *c;
427
428 c = dcerpc_secondary_auth_connection_send(p, binding, table,
429 credentials, lp_ctx);
430 return dcerpc_secondary_auth_connection_recv(c, mem_ctx, p2);
431 }
432