Line data Source code
1 : /*
2 : Unix SMB/CIFS implementation.
3 : Test suite for libnet calls.
4 :
5 : Copyright (C) Rafal Szczesniak 2005
6 :
7 : This program is free software; you can redistribute it and/or modify
8 : it under the terms of the GNU General Public License as published by
9 : the Free Software Foundation; either version 3 of the License, or
10 : (at your option) any later version.
11 :
12 : This program is distributed in the hope that it will be useful,
13 : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : GNU General Public License for more details.
16 :
17 : You should have received a copy of the GNU General Public License
18 : along with this program. If not, see <http://www.gnu.org/licenses/>.
19 : */
20 :
21 : #include "includes.h"
22 : #include "lib/cmdline/cmdline.h"
23 : #include "libnet/libnet.h"
24 : #include "libcli/security/security.h"
25 : #include "librpc/gen_ndr/ndr_lsa.h"
26 : #include "librpc/gen_ndr/ndr_samr.h"
27 : #include "librpc/gen_ndr/ndr_srvsvc.h"
28 : #include "torture/rpc/torture_rpc.h"
29 : #include "torture/libnet/proto.h"
30 : #include "param/param.h"
31 :
32 :
33 25 : static bool test_connect_service(struct torture_context *tctx,
34 : struct libnet_context *ctx,
35 : const struct ndr_interface_table *iface,
36 : const char *binding_string,
37 : const char *hostname,
38 : const enum libnet_RpcConnect_level level,
39 : bool badcreds, NTSTATUS expected_status)
40 : {
41 0 : NTSTATUS status;
42 0 : struct libnet_RpcConnect connect_r;
43 25 : ZERO_STRUCT(connect_r);
44 :
45 25 : connect_r.level = level;
46 25 : connect_r.in.binding = binding_string;
47 25 : connect_r.in.name = hostname;
48 25 : connect_r.in.dcerpc_iface = iface;
49 :
50 : /* if bad credentials are needed, set baduser%badpassword instead
51 : of default commandline-passed credentials */
52 25 : if (badcreds) {
53 10 : cli_credentials_set_username(ctx->cred, "baduser", CRED_SPECIFIED);
54 10 : cli_credentials_set_password(ctx->cred, "badpassword", CRED_SPECIFIED);
55 : }
56 :
57 25 : status = libnet_RpcConnect(ctx, ctx, &connect_r);
58 :
59 25 : if (!NT_STATUS_EQUAL(status, expected_status)) {
60 0 : torture_comment(tctx, "Connecting to rpc service %s on %s.\n\tFAILED. Expected: %s."
61 : "Received: %s\n",
62 0 : connect_r.in.dcerpc_iface->name, connect_r.in.binding, nt_errstr(expected_status),
63 : nt_errstr(status));
64 :
65 0 : return false;
66 : }
67 :
68 25 : torture_comment(tctx, "PASSED. Expected: %s, received: %s\n", nt_errstr(expected_status),
69 : nt_errstr(status));
70 :
71 25 : if (connect_r.level == LIBNET_RPC_CONNECT_DC_INFO && NT_STATUS_IS_OK(status)) {
72 3 : torture_comment(tctx, "Domain Controller Info:\n");
73 3 : torture_comment(tctx, "\tDomain Name:\t %s\n", connect_r.out.domain_name);
74 3 : torture_comment(tctx, "\tDomain SID:\t %s\n", dom_sid_string(ctx, connect_r.out.domain_sid));
75 3 : torture_comment(tctx, "\tRealm:\t\t %s\n", connect_r.out.realm);
76 3 : torture_comment(tctx, "\tGUID:\t\t %s\n", GUID_string(ctx, connect_r.out.guid));
77 :
78 22 : } else if (!NT_STATUS_IS_OK(status)) {
79 10 : torture_comment(tctx, "Error string: %s\n", connect_r.out.error_string);
80 : }
81 :
82 25 : return true;
83 : }
84 :
85 :
86 5 : static bool torture_rpc_connect(struct torture_context *torture,
87 : const enum libnet_RpcConnect_level level,
88 : const char *bindstr, const char *hostname)
89 : {
90 0 : struct libnet_context *ctx;
91 :
92 5 : ctx = libnet_context_init(torture->ev, torture->lp_ctx);
93 5 : ctx->cred = samba_cmdline_get_creds();
94 :
95 5 : torture_comment(torture, "Testing connection to LSA interface\n");
96 :
97 5 : if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
98 5 : hostname, level, false, NT_STATUS_OK)) {
99 0 : torture_comment(torture, "failed to connect LSA interface\n");
100 0 : return false;
101 : }
102 :
103 5 : torture_comment(torture, "Testing connection to SAMR interface\n");
104 5 : if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
105 5 : hostname, level, false, NT_STATUS_OK)) {
106 0 : torture_comment(torture, "failed to connect SAMR interface\n");
107 0 : return false;
108 : }
109 :
110 5 : torture_comment(torture, "Testing connection to SRVSVC interface\n");
111 5 : if (!test_connect_service(torture, ctx, &ndr_table_srvsvc, bindstr,
112 5 : hostname, level, false, NT_STATUS_OK)) {
113 0 : torture_comment(torture, "failed to connect SRVSVC interface\n");
114 0 : return false;
115 : }
116 :
117 5 : torture_comment(torture, "Testing connection to LSA interface with wrong credentials\n");
118 5 : if (!test_connect_service(torture, ctx, &ndr_table_lsarpc, bindstr,
119 5 : hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
120 0 : torture_comment(torture, "failed to test wrong credentials on LSA interface\n");
121 0 : return false;
122 : }
123 :
124 5 : torture_comment(torture, "Testing connection to SAMR interface with wrong credentials\n");
125 5 : if (!test_connect_service(torture, ctx, &ndr_table_samr, bindstr,
126 5 : hostname, level, true, NT_STATUS_LOGON_FAILURE)) {
127 0 : torture_comment(torture, "failed to test wrong credentials on SAMR interface\n");
128 0 : return false;
129 : }
130 :
131 5 : talloc_free(ctx);
132 :
133 5 : return true;
134 : }
135 :
136 :
137 1 : bool torture_rpc_connect_srv(struct torture_context *torture)
138 : {
139 1 : const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_SERVER;
140 0 : NTSTATUS status;
141 0 : struct dcerpc_binding *binding;
142 0 : const char *host;
143 :
144 1 : status = torture_rpc_binding(torture, &binding);
145 1 : if (!NT_STATUS_IS_OK(status)) {
146 0 : return false;
147 : }
148 :
149 1 : host = dcerpc_binding_get_string_option(binding, "host");
150 :
151 1 : return torture_rpc_connect(torture, level, NULL, host);
152 : }
153 :
154 :
155 1 : bool torture_rpc_connect_pdc(struct torture_context *torture)
156 : {
157 1 : const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_PDC;
158 0 : NTSTATUS status;
159 0 : struct dcerpc_binding *binding;
160 0 : const char *domain_name;
161 :
162 1 : status = torture_rpc_binding(torture, &binding);
163 1 : if (!NT_STATUS_IS_OK(status)) {
164 0 : return false;
165 : }
166 :
167 : /* we're accessing domain controller so the domain name should be
168 : passed (it's going to be resolved to dc name and address) instead
169 : of specific server name. */
170 1 : domain_name = lpcfg_workgroup(torture->lp_ctx);
171 1 : return torture_rpc_connect(torture, level, NULL, domain_name);
172 : }
173 :
174 :
175 1 : bool torture_rpc_connect_dc(struct torture_context *torture)
176 : {
177 1 : const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_DC;
178 0 : NTSTATUS status;
179 0 : struct dcerpc_binding *binding;
180 0 : const char *domain_name;
181 :
182 1 : status = torture_rpc_binding(torture, &binding);
183 1 : if (!NT_STATUS_IS_OK(status)) {
184 0 : return false;
185 : }
186 :
187 : /* we're accessing domain controller so the domain name should be
188 : passed (it's going to be resolved to dc name and address) instead
189 : of specific server name. */
190 1 : domain_name = lpcfg_workgroup(torture->lp_ctx);
191 1 : return torture_rpc_connect(torture, level, NULL, domain_name);
192 : }
193 :
194 :
195 1 : bool torture_rpc_connect_dc_info(struct torture_context *torture)
196 : {
197 1 : const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_DC_INFO;
198 0 : NTSTATUS status;
199 0 : struct dcerpc_binding *binding;
200 0 : const char *domain_name;
201 :
202 1 : status = torture_rpc_binding(torture, &binding);
203 1 : if (!NT_STATUS_IS_OK(status)) {
204 0 : return false;
205 : }
206 :
207 : /* we're accessing domain controller so the domain name should be
208 : passed (it's going to be resolved to dc name and address) instead
209 : of specific server name. */
210 1 : domain_name = lpcfg_workgroup(torture->lp_ctx);
211 1 : return torture_rpc_connect(torture, level, NULL, domain_name);
212 : }
213 :
214 :
215 1 : bool torture_rpc_connect_binding(struct torture_context *torture)
216 : {
217 1 : const enum libnet_RpcConnect_level level = LIBNET_RPC_CONNECT_BINDING;
218 0 : NTSTATUS status;
219 0 : struct dcerpc_binding *binding;
220 0 : const char *bindstr;
221 :
222 1 : status = torture_rpc_binding(torture, &binding);
223 1 : if (!NT_STATUS_IS_OK(status)) {
224 0 : return false;
225 : }
226 :
227 1 : bindstr = dcerpc_binding_string(torture, binding);
228 :
229 1 : return torture_rpc_connect(torture, level, bindstr, NULL);
230 : }
|
