d10794297b8fb33a42219d7bb8d7d975e875b8d0
[gd/samba-autobuild/.git] / nsswitch / libwbclient / tests / wbclient.c
1 /*
2    Unix SMB/CIFS implementation.
3    SMB torture tester
4    Copyright (C) Guenther Deschner 2009-2010
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
18 */
19
20 #include "lib/replace/replace.h"
21 #include "libcli/util/ntstatus.h"
22 #include "libcli/util/werror.h"
23 #include "lib/util/data_blob.h"
24 #include "lib/util/time.h"
25 #include "libcli/resolve/resolve.h"
26 #include "nsswitch/libwbclient/wbclient.h"
27 #include "torture/smbtorture.h"
28 #include "torture/winbind/proto.h"
29 #include "lib/util/util_net.h"
30 #include "lib/util/charset/charset.h"
31 #include "libcli/auth/libcli_auth.h"
32 #include "lib/param/param.h"
33 #include "lib/util/samba_util.h"
34 #include "lib/crypto/arcfour.h"
35 #include "auth/credentials/credentials.h"
36 #include "lib/cmdline/popt_common.h"
37
38 #define WBC_ERROR_EQUAL(x,y) (x == y)
39
40 #define torture_assert_wbc_equal(torture_ctx, got, expected, cmt, cmt_arg)      \
41         do { wbcErr __got = got, __expected = expected; \
42         if (!WBC_ERROR_EQUAL(__got, __expected)) { \
43                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: " cmt, wbcErrorString(__got), wbcErrorString(__expected), cmt_arg); \
44                 return false; \
45         } \
46         } while (0)
47
48 #define torture_assert_wbc_ok(torture_ctx,expr,cmt,cmt_arg)                     \
49         torture_assert_wbc_equal(torture_ctx,expr,WBC_ERR_SUCCESS,cmt,cmt_arg)
50
51 #define torture_assert_wbc_equal_goto_fail(torture_ctx, got, expected, cmt, cmt_arg)    \
52         do { wbcErr __got = got, __expected = expected; \
53         if (!WBC_ERROR_EQUAL(__got, __expected)) { \
54                 torture_result(torture_ctx, TORTURE_FAIL, __location__": "#got" was %s, expected %s: " cmt, wbcErrorString(__got), wbcErrorString(__expected), cmt_arg); \
55                 goto fail;                                              \
56         } \
57         } while (0)
58
59 #define torture_assert_wbc_ok_goto_fail(torture_ctx,expr,cmt,cmt_arg)                   \
60         torture_assert_wbc_equal_goto_fail(torture_ctx,expr,WBC_ERR_SUCCESS,cmt,cmt_arg)
61
62 #define torture_assert_str_equal_goto_fail(torture_ctx,got,expected,cmt)\
63         do { const char *__got = (got), *__expected = (expected); \
64         if (strcmp(__got, __expected) != 0) { \
65                 torture_result(torture_ctx, TORTURE_FAIL, \
66                         __location__": "#got" was %s, expected %s: %s", \
67                         __got, __expected, cmt); \
68                 goto fail;;                      \
69         } \
70         } while(0)
71
72 static bool test_wbc_ping(struct torture_context *tctx)
73 {
74         torture_assert_wbc_ok(tctx, wbcPing(),
75                 "%s", "wbcPing failed");
76
77         return true;
78 }
79
80 static bool test_wbc_pingdc(struct torture_context *tctx)
81 {
82         struct wbcInterfaceDetails *details = NULL;
83         wbcErr ret = false;
84
85         torture_assert_wbc_equal_goto_fail(tctx,
86                                            wbcPingDc("random_string", NULL),
87                                            WBC_ERR_DOMAIN_NOT_FOUND,
88                                            "%s",
89                                            "wbcPingDc failed");
90         torture_assert_wbc_ok_goto_fail(tctx, wbcPingDc(NULL, NULL),
91                 "%s", "wbcPingDc failed");
92
93         torture_assert_wbc_ok_goto_fail(tctx, wbcInterfaceDetails(&details),
94                 "%s", "wbcInterfaceDetails failed");
95         torture_assert_goto(tctx, details, ret, fail,
96                        "wbcInterfaceDetails returned NULL pointer");
97         torture_assert_goto(tctx, details->netbios_domain, ret, fail,
98                        "wbcInterfaceDetails returned NULL netbios_domain");
99
100         torture_assert_wbc_ok_goto_fail(tctx,
101                                         wbcPingDc(details->netbios_domain, NULL),
102                                         "wbcPingDc(%s) failed",
103                                         details->netbios_domain);
104
105         torture_assert_wbc_ok_goto_fail(tctx,
106                                         wbcPingDc("BUILTIN", NULL),
107                                         "%s",
108                                         "wbcPingDc(BUILTIN) failed");
109
110         ret = true;
111 fail:
112         wbcFreeMemory(details);
113         return ret;
114 }
115
116 static bool test_wbc_pingdc2(struct torture_context *tctx)
117 {
118         struct wbcInterfaceDetails *details = NULL;
119         char *name = NULL;
120         wbcErr ret = false;
121
122         torture_assert_wbc_equal_goto_fail(tctx,
123                                            wbcPingDc2("random_string", NULL, &name),
124                                            WBC_ERR_DOMAIN_NOT_FOUND,
125                                            "%s",
126                                            "wbcPingDc2 failed");
127         torture_assert_wbc_ok_goto_fail(tctx,
128                                         wbcPingDc2(NULL, NULL, &name),
129                                         "%s",
130                                         "wbcPingDc2 failed");
131         wbcFreeMemory(name);
132         name = NULL;
133
134         torture_assert_wbc_ok_goto_fail(tctx,
135                                         wbcInterfaceDetails(&details),
136                                         "%s",
137                                         "wbcInterfaceDetails failed");
138         torture_assert_goto(tctx,
139                             details,
140                             ret,
141                             fail,
142                             "wbcInterfaceDetails returned NULL pointer");
143         torture_assert_goto(tctx,
144                             details->netbios_domain,
145                             ret,
146                             fail,
147                             "wbcInterfaceDetails returned NULL netbios_domain");
148
149         torture_assert_wbc_ok_goto_fail(tctx,
150                                         wbcPingDc2(details->netbios_domain, NULL, &name),
151                                         "wbcPingDc2(%s) failed",
152                                         details->netbios_domain);
153         wbcFreeMemory(name);
154         name = NULL;
155
156         torture_assert_wbc_ok_goto_fail(tctx,
157                                         wbcPingDc2("BUILTIN", NULL, &name),
158                                         "%s",
159                                         "wbcPingDc2(BUILTIN) failed");
160
161         ret = true;
162 fail:
163         wbcFreeMemory(name);
164         wbcFreeMemory(details);
165
166         return ret;
167 }
168
169 static bool test_wbc_library_details(struct torture_context *tctx)
170 {
171         struct wbcLibraryDetails *details;
172
173         torture_assert_wbc_ok(tctx, wbcLibraryDetails(&details),
174                 "%s", "wbcLibraryDetails failed");
175         torture_assert(tctx, details,
176                 "wbcLibraryDetails returned NULL pointer");
177
178         wbcFreeMemory(details);
179
180         return true;
181 }
182
183 static bool test_wbc_interface_details(struct torture_context *tctx)
184 {
185         struct wbcInterfaceDetails *details;
186
187         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
188                 "%s", "wbcInterfaceDetails failed");
189         torture_assert(tctx, details,
190                        "wbcInterfaceDetails returned NULL pointer");
191
192         wbcFreeMemory(details);
193
194         return true;
195 }
196
197 static bool test_wbc_sidtypestring(struct torture_context *tctx)
198 {
199         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_USE_NONE),
200                                  "SID_NONE", "SID_NONE failed");
201         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_USER),
202                                  "SID_USER", "SID_USER failed");
203         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DOM_GRP),
204                                  "SID_DOM_GROUP", "SID_DOM_GROUP failed");
205         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DOMAIN),
206                                  "SID_DOMAIN", "SID_DOMAIN failed");
207         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_ALIAS),
208                                  "SID_ALIAS", "SID_ALIAS failed");
209         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_WKN_GRP),
210                                  "SID_WKN_GROUP", "SID_WKN_GROUP failed");
211         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_DELETED),
212                                  "SID_DELETED", "SID_DELETED failed");
213         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_INVALID),
214                                  "SID_INVALID", "SID_INVALID failed");
215         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_UNKNOWN),
216                                  "SID_UNKNOWN", "SID_UNKNOWN failed");
217         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_COMPUTER),
218                                  "SID_COMPUTER",  "SID_COMPUTER failed");
219         torture_assert_str_equal(tctx, wbcSidTypeString(WBC_SID_NAME_LABEL),
220                                  "SID_LABEL",  "SID_LABEL failed");
221         return true;
222 }
223
224 static bool test_wbc_sidtostring(struct torture_context *tctx)
225 {
226         struct wbcDomainSid sid;
227         const char *sid_string = "S-1-5-32";
228         char *sid_string2;
229
230         torture_assert_wbc_ok(tctx, wbcStringToSid(sid_string, &sid),
231                               "wbcStringToSid of %s failed", sid_string);
232         torture_assert_wbc_ok(tctx, wbcSidToString(&sid, &sid_string2),
233                               "wbcSidToString of %s failed", sid_string);
234         torture_assert_str_equal(tctx, sid_string, sid_string2,
235                 "sid strings differ");
236         wbcFreeMemory(sid_string2);
237
238         return true;
239 }
240
241 static bool test_wbc_guidtostring(struct torture_context *tctx)
242 {
243         struct wbcGuid guid;
244         const char *guid_string = "f7cf07b4-1487-45c7-824d-8b18cc580811";
245         char *guid_string2;
246
247         torture_assert_wbc_ok(tctx, wbcStringToGuid(guid_string, &guid),
248                               "wbcStringToGuid of %s failed", guid_string);
249         torture_assert_wbc_ok(tctx, wbcGuidToString(&guid, &guid_string2),
250                               "wbcGuidToString of %s failed", guid_string);
251         torture_assert_str_equal(tctx, guid_string, guid_string2,
252                                  "guid strings differ");
253         wbcFreeMemory(guid_string2);
254
255         return true;
256 }
257
258 static bool test_wbc_domain_info(struct torture_context *tctx)
259 {
260         struct wbcDomainInfo *info = NULL;
261         struct wbcInterfaceDetails *details = NULL;
262         wbcErr ret = false;
263
264         torture_assert_wbc_ok_goto_fail(tctx,
265                                         wbcInterfaceDetails(&details),
266                                         "%s",
267                                         "wbcInterfaceDetails failed");
268         torture_assert_wbc_ok_goto_fail(tctx,
269                                         wbcDomainInfo(details->netbios_domain, &info),
270                                         "%s",
271                                         "wbcDomainInfo failed");
272
273         torture_assert_goto(tctx,
274                             info,
275                             ret,
276                             fail,
277                             "wbcDomainInfo returned NULL pointer");
278
279         ret = true;
280 fail:
281         wbcFreeMemory(details);
282         wbcFreeMemory(info);
283
284         return ret;
285 }
286
287 static bool test_wbc_users(struct torture_context *tctx)
288 {
289         const char *domain_name = NULL;
290         uint32_t num_users;
291         const char **users = NULL;
292         uint32_t i;
293         struct wbcInterfaceDetails *details = NULL;
294         struct wbcDomainSid *sids = NULL;
295         char *domain = NULL;
296         char *name = NULL;
297         char *sid_string = NULL;
298         wbcErr ret = false;
299         char separator;
300
301         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
302                 "%s", "wbcInterfaceDetails failed");
303
304         domain_name = talloc_strdup(tctx, details->netbios_domain);
305         torture_assert_goto(tctx,
306                             domain_name != NULL,
307                             ret,
308                             fail,
309                             "Failed to allocate domain_name");
310         separator = details->winbind_separator;
311         wbcFreeMemory(details);
312         details = NULL;
313
314         torture_assert_wbc_ok_goto_fail(tctx,
315                                         wbcListUsers(domain_name, &num_users, &users),
316                                         "%s",
317                                         "wbcListUsers failed");
318         torture_assert_goto(tctx,
319                             !(num_users > 0 && !users),
320                             ret,
321                             fail,
322                             "wbcListUsers returned invalid results");
323
324         for (i = 0; i < MIN(num_users, 100); i++) {
325                 struct wbcDomainSid sid;
326                 enum wbcSidType name_type;
327                 uint32_t num_sids;
328                 const char *user;
329                 char *c;
330
331                 c = strchr(users[i], separator);
332
333                 if (c == NULL) {
334                         /*
335                          * NT4 DC
336                          * user name does not contain DOMAIN SEPARATOR prefix.
337                          */
338
339                         user = users[i];
340                 } else {
341                         /*
342                          * AD DC
343                          * user name starts with DOMAIN SEPARATOR prefix.
344                          */
345                         const char *dom;
346
347                         *c = '\0';
348                         dom = users[i];
349                         user = c + 1;
350
351                         torture_assert_str_equal_goto(tctx, dom, domain_name,
352                                                       ret, fail, "Domain part "
353                                                       "of user name does not "
354                                                       "match domain name.\n");
355                 }
356
357                 torture_assert_wbc_ok_goto_fail(tctx,
358                                                 wbcLookupName(domain_name, user,
359                                                               &sid, &name_type),
360                                                 "wbcLookupName of %s failed",
361                                                 users[i]);
362                 torture_assert_int_equal_goto(tctx,
363                                               name_type, WBC_SID_NAME_USER,
364                                               ret,
365                                               fail,
366                                               "wbcLookupName expected WBC_SID_NAME_USER");
367                 wbcSidToString(&sid, &sid_string);
368                 torture_assert_wbc_ok_goto_fail(tctx,
369                                                 wbcLookupSid(&sid,
370                                                              &domain,
371                                                              &name,
372                                                              &name_type),
373                                                 "wbcLookupSid of %s failed",
374                                                 sid_string);
375                 torture_assert_int_equal_goto(tctx,
376                                               name_type, WBC_SID_NAME_USER,
377                                               ret,
378                                               fail,
379                                               "wbcLookupSid of expected WBC_SID_NAME_USER");
380                 torture_assert_goto(tctx,
381                                     name,
382                                     ret,
383                                     fail,
384                                     "wbcLookupSid returned no name");
385                 wbcFreeMemory(domain);
386                 domain = NULL;
387                 wbcFreeMemory(name);
388                 name = NULL;
389
390                 torture_assert_wbc_ok_goto_fail(tctx,
391                                                 wbcLookupUserSids(&sid, true, &num_sids, &sids),
392                                                 "wbcLookupUserSids of %s failed", sid_string);
393                 torture_assert_wbc_ok_goto_fail(tctx,
394                                                 wbcGetDisplayName(&sid,
395                                                                   &domain,
396                                                                   &name,
397                                                                   &name_type),
398                                                 "wbcGetDisplayName of %s failed",
399                                                 sid_string);
400                 wbcFreeMemory(domain);
401                 domain = NULL;
402                 wbcFreeMemory(name);
403                 name = NULL;
404                 wbcFreeMemory(sids);
405                 sids = NULL;
406                 wbcFreeMemory(sid_string);
407                 sid_string = NULL;
408         }
409
410         ret = true;
411 fail:
412         wbcFreeMemory(details);
413         wbcFreeMemory(users);
414         wbcFreeMemory(domain);
415         wbcFreeMemory(name);
416         wbcFreeMemory(sids);
417         wbcFreeMemory(sid_string);
418
419         return ret;
420 }
421
422 static bool test_wbc_groups(struct torture_context *tctx)
423 {
424         wbcErr ret = false;
425         const char *domain_name = NULL;
426         uint32_t num_groups;
427         const char **groups = NULL;
428         uint32_t i;
429         struct wbcInterfaceDetails *details = NULL;
430         char *domain = NULL;
431         char *name = NULL;
432         char *sid_string = NULL;
433         char separator;
434
435         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
436                               "%s", "wbcInterfaceDetails failed");
437
438         domain_name = talloc_strdup(tctx, details->netbios_domain);
439         torture_assert_goto(tctx,
440                             domain_name != NULL,
441                             ret,
442                             fail,
443                             "Failed to allocate domain_name");
444         separator = details->winbind_separator;
445         wbcFreeMemory(details);
446         details = NULL;
447
448         torture_assert_wbc_ok_goto_fail(tctx,
449                                         wbcListGroups(domain_name, &num_groups, &groups),
450                                         "wbcListGroups in %s failed",
451                                         domain_name);
452         torture_assert_goto(tctx,
453                             !(num_groups > 0 && !groups),
454                             ret,
455                             fail,
456                             "wbcListGroups returned invalid results");
457
458         for (i=0; i < MIN(num_groups,100); i++) {
459                 struct wbcDomainSid sid;
460                 enum wbcSidType name_type;
461                 const char *group;
462                 char *c;
463
464                 c = strchr(groups[i], separator);
465
466                 if (c == NULL) {
467                         /*
468                          * NT4 DC
469                          * group name does not contain DOMAIN SEPARATOR prefix.
470                          */
471
472                         group = groups[i];
473                 } else {
474                         /*
475                          * AD DC
476                          * group name starts with DOMAIN SEPARATOR prefix.
477                          */
478                         const char *dom;
479
480
481                         *c = '\0';
482                         dom = groups[i];
483                         group = c + 1;
484
485                         torture_assert_str_equal_goto(tctx, dom, domain_name,
486                                                       ret, fail, "Domain part "
487                                                       "of group name does not "
488                                                       "match domain name.\n");
489                 }
490
491                 torture_assert_wbc_ok_goto_fail(tctx,
492                                                 wbcLookupName(domain_name,
493                                                               group,
494                                                               &sid,
495                                                               &name_type),
496                                                 "wbcLookupName for %s failed",
497                                                 domain_name);
498                 wbcSidToString(&sid, &sid_string);
499                 torture_assert_wbc_ok_goto_fail(tctx,
500                                                 wbcLookupSid(&sid,
501                                                              &domain,
502                                                              &name,
503                                                              &name_type),
504                                                 "wbcLookupSid of %s failed",
505                                                 sid_string);
506                 torture_assert_goto(tctx,
507                                     name,
508                                     ret,
509                                     fail,
510                                     "wbcLookupSid returned no name");
511
512                 wbcFreeMemory(domain);
513                 domain = NULL;
514                 wbcFreeMemory(name);
515                 name = NULL;
516                 wbcFreeMemory(sid_string);
517                 sid_string = NULL;
518         }
519
520         ret = true;
521 fail:
522         wbcFreeMemory(details);
523         wbcFreeMemory(groups);
524         wbcFreeMemory(domain);
525         wbcFreeMemory(name);
526         wbcFreeMemory(sid_string);
527
528         return ret;
529 }
530
531 static bool test_wbc_trusts(struct torture_context *tctx)
532 {
533         struct wbcDomainInfo *domains = NULL;
534         struct wbcAuthErrorInfo *error = NULL;
535         size_t num_domains;
536         uint32_t i;
537         wbcErr ret = false;
538
539         torture_assert_wbc_ok_goto_fail(tctx,
540                                         wbcListTrusts(&domains, &num_domains),
541                                         "%s",
542                                         "wbcListTrusts failed");
543         torture_assert_goto(tctx,
544                             !(num_domains > 0 && !domains),
545                             ret,
546                             fail,
547                             "wbcListTrusts returned invalid results");
548
549         for (i=0; i < MIN(num_domains,100); i++) {
550
551                 /*
552                 struct wbcDomainSid sid;
553                 enum wbcSidType name_type;
554                 char *domain;
555                 char *name;
556                 */
557                 torture_assert_wbc_ok_goto_fail(tctx,
558                                                 wbcCheckTrustCredentials(domains[i].short_name,
559                                                                          &error),
560                                                 "%s",
561                                                 "wbcCheckTrustCredentials failed");
562                 /*
563                 torture_assert_wbc_ok(tctx, wbcLookupName(domains[i].short_name, NULL, &sid, &name_type),
564                         "wbcLookupName failed");
565                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
566                         "wbcLookupName expected WBC_SID_NAME_DOMAIN");
567                 torture_assert_wbc_ok(tctx, wbcLookupSid(&sid, &domain, &name, &name_type),
568                         "wbcLookupSid failed");
569                 torture_assert_int_equal(tctx, name_type, WBC_SID_NAME_DOMAIN,
570                         "wbcLookupSid expected WBC_SID_NAME_DOMAIN");
571                 torture_assert(tctx, name,
572                         "wbcLookupSid returned no name");
573                 */
574                 wbcFreeMemory(error);
575                 error = NULL;
576         }
577
578         ret = true;
579 fail:
580         wbcFreeMemory(domains);
581         wbcFreeMemory(error);
582
583         return ret;
584 }
585
586 static bool test_wbc_lookupdc(struct torture_context *tctx)
587 {
588         const char *domain_name = NULL;
589         struct wbcInterfaceDetails *details;
590         struct wbcDomainControllerInfo *dc_info;
591
592         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
593                 "%s", "wbcInterfaceDetails failed");
594
595         domain_name = talloc_strdup(tctx, details->netbios_domain);
596         wbcFreeMemory(details);
597
598         torture_assert_wbc_ok(tctx, wbcLookupDomainController(domain_name, 0, &dc_info),
599                               "wbcLookupDomainController for %s failed", domain_name);
600         wbcFreeMemory(dc_info);
601
602         return true;
603 }
604
605 static bool test_wbc_lookupdcex(struct torture_context *tctx)
606 {
607         const char *domain_name = NULL;
608         struct wbcInterfaceDetails *details;
609         struct wbcDomainControllerInfoEx *dc_info;
610
611         torture_assert_wbc_ok(tctx, wbcInterfaceDetails(&details),
612                 "%s", "wbcInterfaceDetails failed");
613
614         domain_name = talloc_strdup(tctx, details->netbios_domain);
615         wbcFreeMemory(details);
616
617         torture_assert_wbc_ok(tctx, wbcLookupDomainControllerEx(domain_name, NULL, NULL, 0, &dc_info),
618                 "wbcLookupDomainControllerEx for %s failed", domain_name);
619         wbcFreeMemory(dc_info);
620
621         return true;
622 }
623
624 static bool test_wbc_resolve_winsbyname(struct torture_context *tctx)
625 {
626         const char *name;
627         char *ip;
628         wbcErr ret;
629
630         name = torture_setting_string(tctx, "host", NULL);
631
632         torture_comment(tctx, "test-WinsByName: host='%s'\n", name);
633
634         ret = wbcResolveWinsByName(name, &ip);
635
636         if (is_ipaddress(name)) {
637                 torture_assert_wbc_equal(tctx, ret, WBC_ERR_DOMAIN_NOT_FOUND, "wbcResolveWinsByName of %s failed", name);
638         } else {
639                 torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByName for %s failed", name);
640         }
641
642         return true;
643 }
644
645 static bool test_wbc_resolve_winsbyip(struct torture_context *tctx)
646 {
647         const char *ip;
648         const char *host;
649         struct nbt_name nbt_name;
650         char *name;
651         wbcErr ret;
652         NTSTATUS status;
653
654         host = torture_setting_string(tctx, "host", NULL);
655
656         torture_comment(tctx, "test-WinsByIp: host='%s'\n", host);
657
658         make_nbt_name_server(&nbt_name, host);
659
660         status = resolve_name_ex(lpcfg_resolve_context(tctx->lp_ctx),
661                                  0, 0, &nbt_name, tctx, &ip, tctx->ev);
662         torture_assert_ntstatus_ok(tctx, status,
663                         talloc_asprintf(tctx,"Failed to resolve %s: %s",
664                                         nbt_name.name, nt_errstr(status)));
665
666         torture_comment(tctx, "test-WinsByIp: ip='%s'\n", ip);
667
668         ret = wbcResolveWinsByIP(ip, &name);
669
670         torture_assert_wbc_ok(tctx, ret, "wbcResolveWinsByIP for %s failed", ip);
671
672         wbcFreeMemory(name);
673
674         return true;
675 }
676
677 static bool test_wbc_lookup_rids(struct torture_context *tctx)
678 {
679         struct wbcDomainSid builtin;
680         uint32_t rids[2] = { 544, 545 };
681         const char *domain_name = NULL;
682         const char **names = NULL;
683         enum wbcSidType *types;
684         wbcErr ret = false;
685
686         wbcStringToSid("S-1-5-32", &builtin);
687
688         ret = wbcLookupRids(&builtin, 2, rids, &domain_name, &names,
689                             &types);
690         torture_assert_wbc_ok_goto_fail(
691                 tctx, ret, "%s", "wbcLookupRids for 544 and 545 failed");
692
693         torture_assert_str_equal(
694                 tctx, names[0], "Administrators",
695                 "S-1-5-32-544 not mapped to 'Administrators'");
696         torture_assert_str_equal_goto_fail(
697                 tctx, names[1], "Users", "S-1-5-32-545 not mapped to 'Users'");
698
699         ret = true;
700 fail:
701         wbcFreeMemory(discard_const_p(char ,domain_name));
702         wbcFreeMemory(names);
703         wbcFreeMemory(types);
704         return ret;
705 }
706
707 static bool test_wbc_get_sidaliases(struct torture_context *tctx)
708 {
709         struct wbcDomainSid builtin;
710         struct wbcDomainInfo *info = NULL;
711         struct wbcInterfaceDetails *details = NULL;
712         struct wbcDomainSid sids[2];
713         uint32_t *rids = NULL;
714         uint32_t num_rids;
715         wbcErr ret = false;
716
717         torture_assert_wbc_ok_goto_fail(tctx,
718                                         wbcInterfaceDetails(&details),
719                                         "%s",
720                                         "wbcInterfaceDetails failed");
721         torture_assert_wbc_ok_goto_fail(tctx,
722                                         wbcDomainInfo(details->netbios_domain, &info),
723                                         "wbcDomainInfo of %s failed",
724                                         details->netbios_domain);
725
726         sids[0] = info->sid;
727         sids[0].sub_auths[sids[0].num_auths++] = 500;
728         sids[1] = info->sid;
729         sids[1].sub_auths[sids[1].num_auths++] = 512;
730
731         torture_assert_wbc_ok_goto_fail(tctx,
732                                         wbcStringToSid("S-1-5-32", &builtin),
733                                         "wbcStringToSid of %s failed",
734                                         "S-1-5-32");
735
736         ret = wbcGetSidAliases(&builtin, sids, 2, &rids, &num_rids);
737         torture_assert_wbc_ok_goto_fail(tctx,
738                                         ret,
739                                         "%s",
740                                         "wbcGetSidAliases failed");
741
742         ret = true;
743 fail:
744         wbcFreeMemory(details);
745         wbcFreeMemory(info);
746         wbcFreeMemory(rids);
747         return ret;
748 }
749
750 static bool test_wbc_authenticate_user_int(struct torture_context *tctx,
751                                            const char *correct_password)
752 {
753         struct wbcAuthUserParams params;
754         struct wbcAuthUserInfo *info = NULL;
755         struct wbcAuthErrorInfo *error = NULL;
756         wbcErr ret;
757
758         ret = wbcAuthenticateUser(cli_credentials_get_username(
759                         popt_get_cmdline_credentials()), correct_password);
760         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
761                  "wbcAuthenticateUser of %s failed",
762                  cli_credentials_get_username(popt_get_cmdline_credentials()));
763
764         ZERO_STRUCT(params);
765         params.account_name             =
766                 cli_credentials_get_username(popt_get_cmdline_credentials());
767         params.level                    = WBC_AUTH_USER_LEVEL_PLAIN;
768         params.password.plaintext       = correct_password;
769
770         ret = wbcAuthenticateUserEx(&params, &info, &error);
771         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
772                                  "wbcAuthenticateUserEx of %s failed", params.account_name);
773         wbcFreeMemory(info);
774         info = NULL;
775
776         wbcFreeMemory(error);
777         error = NULL;
778
779         params.password.plaintext       = "wrong";
780         ret = wbcAuthenticateUserEx(&params, &info, &error);
781         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
782                                  "wbcAuthenticateUserEx for %s succeeded where it "
783                                  "should have failed", params.account_name);
784         wbcFreeMemory(info);
785         info = NULL;
786
787         wbcFreeMemory(error);
788         error = NULL;
789
790         return true;
791 }
792
793 static bool test_wbc_authenticate_user(struct torture_context *tctx)
794 {
795         return test_wbc_authenticate_user_int(tctx,
796                 cli_credentials_get_password(popt_get_cmdline_credentials()));
797 }
798
799 static bool test_wbc_change_password(struct torture_context *tctx)
800 {
801         wbcErr ret;
802         const char *oldpass =
803                 cli_credentials_get_password(popt_get_cmdline_credentials());
804         const char *newpass = "Koo8irei%$";
805
806         struct samr_CryptPassword new_nt_password;
807         struct samr_CryptPassword new_lm_password;
808         struct samr_Password old_nt_hash_enc;
809         struct samr_Password old_lanman_hash_enc;
810
811         uint8_t old_nt_hash[16];
812         uint8_t old_lanman_hash[16];
813         uint8_t new_nt_hash[16];
814         uint8_t new_lanman_hash[16];
815
816         struct wbcChangePasswordParams params;
817
818         if (oldpass == NULL) {
819                 torture_skip(tctx,
820                         "skipping wbcChangeUserPassword test as old password cannot be retrieved\n");
821         }
822
823         ZERO_STRUCT(params);
824
825         E_md4hash(oldpass, old_nt_hash);
826         E_md4hash(newpass, new_nt_hash);
827
828         if (lpcfg_client_lanman_auth(tctx->lp_ctx) &&
829             E_deshash(newpass, new_lanman_hash) &&
830             E_deshash(oldpass, old_lanman_hash)) {
831
832                 /* E_deshash returns false for 'long' passwords (> 14
833                    DOS chars).  This allows us to match Win2k, which
834                    does not store a LM hash for these passwords (which
835                    would reduce the effective password length to 14) */
836
837                 encode_pw_buffer(new_lm_password.data, newpass, STR_UNICODE);
838                 arcfour_crypt(new_lm_password.data, old_nt_hash, 516);
839                 E_old_pw_hash(new_nt_hash, old_lanman_hash,
840                               old_lanman_hash_enc.hash);
841
842                 params.old_password.response.old_lm_hash_enc_length =
843                         sizeof(old_lanman_hash_enc.hash);
844                 params.old_password.response.old_lm_hash_enc_data =
845                         old_lanman_hash_enc.hash;
846                 params.new_password.response.lm_length =
847                         sizeof(new_lm_password.data);
848                 params.new_password.response.lm_data =
849                         new_lm_password.data;
850         } else {
851                 ZERO_STRUCT(new_lm_password);
852                 ZERO_STRUCT(old_lanman_hash_enc);
853         }
854
855         encode_pw_buffer(new_nt_password.data, newpass, STR_UNICODE);
856
857         arcfour_crypt(new_nt_password.data, old_nt_hash, 516);
858         E_old_pw_hash(new_nt_hash, old_nt_hash, old_nt_hash_enc.hash);
859
860         params.old_password.response.old_nt_hash_enc_length =
861                 sizeof(old_nt_hash_enc.hash);
862         params.old_password.response.old_nt_hash_enc_data =
863                 old_nt_hash_enc.hash;
864         params.new_password.response.nt_length = sizeof(new_nt_password.data);
865         params.new_password.response.nt_data = new_nt_password.data;
866
867         params.level = WBC_CHANGE_PASSWORD_LEVEL_RESPONSE;
868         params.account_name =
869                 cli_credentials_get_username(popt_get_cmdline_credentials());
870         params.domain_name =
871                 cli_credentials_get_domain(popt_get_cmdline_credentials());
872
873         ret = wbcChangeUserPasswordEx(&params, NULL, NULL, NULL);
874         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
875                                  "wbcChangeUserPassword for %s failed", params.account_name);
876
877         if (!test_wbc_authenticate_user_int(tctx, newpass)) {
878                 return false;
879         }
880
881         ret = wbcChangeUserPassword(
882                 cli_credentials_get_username(popt_get_cmdline_credentials()),
883                 newpass,
884                 cli_credentials_get_password(popt_get_cmdline_credentials()));
885         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
886                                  "wbcChangeUserPassword for %s failed", params.account_name);
887
888         return test_wbc_authenticate_user_int(tctx,
889                 cli_credentials_get_password(popt_get_cmdline_credentials()));
890 }
891
892 static bool test_wbc_logon_user(struct torture_context *tctx)
893 {
894         struct wbcLogonUserParams params;
895         struct wbcLogonUserInfo *info = NULL;
896         struct wbcAuthErrorInfo *error = NULL;
897         struct wbcUserPasswordPolicyInfo *policy = NULL;
898         struct wbcInterfaceDetails *iface;
899         struct wbcDomainSid sid;
900         enum wbcSidType sidtype;
901         char *sidstr;
902         wbcErr ret;
903
904         ZERO_STRUCT(params);
905
906         ret = wbcLogonUser(&params, &info, &error, &policy);
907         torture_assert_wbc_equal(tctx, ret, WBC_ERR_INVALID_PARAM,
908                                  "%s", "wbcLogonUser succeeded for NULL where it should "
909                                  "have failed");
910
911         params.username =
912                 cli_credentials_get_username(popt_get_cmdline_credentials());
913         params.password =
914                 cli_credentials_get_password(popt_get_cmdline_credentials());
915
916         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
917                               "foo", 0, discard_const_p(uint8_t, "bar"), 4);
918         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
919                                  "%s", "wbcAddNamedBlob failed");
920
921         ret = wbcLogonUser(&params, &info, &error, &policy);
922         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
923                                  "wbcLogonUser for %s failed", params.username);
924         wbcFreeMemory(info); info = NULL;
925         wbcFreeMemory(error); error = NULL;
926         wbcFreeMemory(policy); policy = NULL;
927
928         params.password = "wrong";
929
930         ret = wbcLogonUser(&params, &info, &error, &policy);
931         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
932                                  "wbcLogonUser for %s should have failed with "
933                                  "WBC_ERR_AUTH_ERROR", params.username);
934         wbcFreeMemory(info); info = NULL;
935         wbcFreeMemory(error); error = NULL;
936         wbcFreeMemory(policy); policy = NULL;
937
938         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
939                               "membership_of", 0,
940                               discard_const_p(uint8_t, "S-1-2-3-4"),
941                               strlen("S-1-2-3-4")+1);
942         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
943                                  "%s", "wbcAddNamedBlob failed");
944         params.password =
945                 cli_credentials_get_password(popt_get_cmdline_credentials());
946         ret = wbcLogonUser(&params, &info, &error, &policy);
947         torture_assert_wbc_equal(tctx, ret, WBC_ERR_AUTH_ERROR,
948                                  "wbcLogonUser for %s should have failed with "
949                                  "WBC_ERR_AUTH_ERROR", params.username);
950         wbcFreeMemory(info); info = NULL;
951         wbcFreeMemory(error); error = NULL;
952         wbcFreeMemory(policy); policy = NULL;
953         wbcFreeMemory(params.blobs);
954         params.blobs = NULL; params.num_blobs = 0;
955
956         ret = wbcInterfaceDetails(&iface);
957         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
958                                  "%s", "wbcInterfaceDetails failed");
959
960         ret = wbcLookupName(iface->netbios_domain,
961                 cli_credentials_get_username(popt_get_cmdline_credentials()),
962                 &sid,
963                 &sidtype);
964         wbcFreeMemory(iface);
965         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
966                 "wbcLookupName for %s failed",
967                 cli_credentials_get_username(popt_get_cmdline_credentials()));
968
969         ret = wbcSidToString(&sid, &sidstr);
970         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
971                                  "%s", "wbcSidToString failed");
972
973         ret = wbcAddNamedBlob(&params.num_blobs, &params.blobs,
974                               "membership_of", 0,
975                               (uint8_t *)sidstr, strlen(sidstr)+1);
976         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
977                                  "%s", "wbcAddNamedBlob failed");
978         wbcFreeMemory(sidstr);
979         params.password =
980                 cli_credentials_get_password(popt_get_cmdline_credentials());
981         ret = wbcLogonUser(&params, &info, &error, &policy);
982         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
983                                  "wbcLogonUser for %s failed", params.username);
984         wbcFreeMemory(info); info = NULL;
985         wbcFreeMemory(error); error = NULL;
986         wbcFreeMemory(policy); policy = NULL;
987         wbcFreeMemory(params.blobs);
988         params.blobs = NULL; params.num_blobs = 0;
989
990         return true;
991 }
992
993 static bool test_wbc_getgroups(struct torture_context *tctx)
994 {
995         wbcErr ret;
996         uint32_t num_groups;
997         gid_t *groups;
998
999         ret = wbcGetGroups(
1000                 cli_credentials_get_username(popt_get_cmdline_credentials()),
1001                 &num_groups,
1002                 &groups);
1003         torture_assert_wbc_equal(tctx, ret, WBC_ERR_SUCCESS,
1004                 "wbcGetGroups for %s failed",
1005                 cli_credentials_get_username(popt_get_cmdline_credentials()));
1006         wbcFreeMemory(groups);
1007         return true;
1008 }
1009
1010 struct torture_suite *torture_wbclient(TALLOC_CTX *ctx)
1011 {
1012         struct torture_suite *suite = torture_suite_create(ctx, "wbclient");
1013
1014         torture_suite_add_simple_test(suite, "wbcPing", test_wbc_ping);
1015         torture_suite_add_simple_test(suite, "wbcPingDc", test_wbc_pingdc);
1016         torture_suite_add_simple_test(suite, "wbcPingDc2", test_wbc_pingdc2);
1017         torture_suite_add_simple_test(suite, "wbcLibraryDetails", test_wbc_library_details);
1018         torture_suite_add_simple_test(suite, "wbcInterfaceDetails", test_wbc_interface_details);
1019         torture_suite_add_simple_test(suite, "wbcSidTypeString", test_wbc_sidtypestring);
1020         torture_suite_add_simple_test(suite, "wbcSidToString", test_wbc_sidtostring);
1021         torture_suite_add_simple_test(suite, "wbcGuidToString", test_wbc_guidtostring);
1022         torture_suite_add_simple_test(suite, "wbcDomainInfo", test_wbc_domain_info);
1023         torture_suite_add_simple_test(suite, "wbcListUsers", test_wbc_users);
1024         torture_suite_add_simple_test(suite, "wbcListGroups", test_wbc_groups);
1025         torture_suite_add_simple_test(suite, "wbcListTrusts", test_wbc_trusts);
1026         torture_suite_add_simple_test(suite, "wbcLookupDomainController", test_wbc_lookupdc);
1027         torture_suite_add_simple_test(suite, "wbcLookupDomainControllerEx", test_wbc_lookupdcex);
1028         torture_suite_add_simple_test(suite, "wbcResolveWinsByName", test_wbc_resolve_winsbyname);
1029         torture_suite_add_simple_test(suite, "wbcResolveWinsByIP", test_wbc_resolve_winsbyip);
1030         torture_suite_add_simple_test(suite, "wbcLookupRids",
1031                                       test_wbc_lookup_rids);
1032         torture_suite_add_simple_test(suite, "wbcGetSidAliases",
1033                                       test_wbc_get_sidaliases);
1034         torture_suite_add_simple_test(suite, "wbcAuthenticateUser",
1035                                       test_wbc_authenticate_user);
1036         torture_suite_add_simple_test(suite, "wbcLogonUser",
1037                                       test_wbc_logon_user);
1038         torture_suite_add_simple_test(suite, "wbcChangeUserPassword",
1039                                       test_wbc_change_password);
1040         torture_suite_add_simple_test(suite, "wbcGetGroups",
1041                                       test_wbc_getgroups);
1042
1043         return suite;
1044 }