r4355: More work from the elves on Christmas eve:
[samba.git] / source4 / libcli / auth / kerberos.c
1 /* 
2    Unix SMB/CIFS implementation.
3    kerberos utility library
4    Copyright (C) Andrew Tridgell 2001
5    Copyright (C) Remus Koos 2001
6    Copyright (C) Nalin Dahyabhai 2004.
7    Copyright (C) Jeremy Allison 2004.
8
9    This program is free software; you can redistribute it and/or modify
10    it under the terms of the GNU General Public License as published by
11    the Free Software Foundation; either version 2 of the License, or
12    (at your option) any later version.
13    
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18    
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 */
23
24 #include "includes.h"
25 #include "system/kerberos.h"
26 #include "libcli/auth/kerberos.h"
27 #include "system/time.h"
28 #include "secrets.h"
29
30 #ifdef HAVE_KRB5
31
32 #define LIBADS_CCACHE_NAME "MEMORY:libads"
33
34 /*
35   we use a prompter to avoid a crash bug in the kerberos libs when 
36   dealing with empty passwords
37   this prompter is just a string copy ...
38 */
39 static krb5_error_code 
40 kerb_prompter(krb5_context ctx, void *data,
41                const char *name,
42                const char *banner,
43                int num_prompts,
44                krb5_prompt prompts[])
45 {
46         if (num_prompts == 0) return 0;
47
48         memset(prompts[0].reply->data, '\0', prompts[0].reply->length);
49         if (prompts[0].reply->length > 0) {
50                 if (data) {
51                         strncpy(prompts[0].reply->data, data, prompts[0].reply->length-1);
52                         prompts[0].reply->length = strlen(prompts[0].reply->data);
53                 } else {
54                         prompts[0].reply->length = 0;
55                 }
56         }
57         return 0;
58 }
59
60 /*
61   simulate a kinit, putting the tgt in the given credentials cache. 
62   Orignally by remus@snapserver.com
63 */
64  int kerberos_kinit_password_cc(krb5_context ctx, krb5_ccache cc, 
65                                const char *principal, const char *password, 
66                                time_t *expire_time, time_t *kdc_time)
67 {
68         krb5_error_code code = 0;
69         krb5_principal me;
70         krb5_creds my_creds;
71         krb5_get_init_creds_opt options;
72
73         if ((code = krb5_parse_name(ctx, principal, &me))) {
74                 return code;
75         }
76
77         krb5_get_init_creds_opt_init(&options);
78
79         if ((code = krb5_get_init_creds_password(ctx, &my_creds, me, password, 
80                                                  kerb_prompter, 
81                                                  NULL, 0, NULL, &options))) {
82                 krb5_free_principal(ctx, me);
83                 return code;
84         }
85         
86         if ((code = krb5_cc_initialize(ctx, cc, me))) {
87                 krb5_free_cred_contents(ctx, &my_creds);
88                 krb5_free_principal(ctx, me);
89                 return code;
90         }
91         
92         if ((code = krb5_cc_store_cred(ctx, cc, &my_creds))) {
93                 krb5_free_cred_contents(ctx, &my_creds);
94                 krb5_free_principal(ctx, me);
95                 return code;
96         }
97         
98         if (expire_time) {
99                 *expire_time = (time_t) my_creds.times.endtime;
100         }
101
102         if (kdc_time) {
103                 *kdc_time = (time_t) my_creds.times.starttime;
104         }
105
106         krb5_free_cred_contents(ctx, &my_creds);
107         krb5_free_principal(ctx, me);
108         
109         return 0;
110 }
111
112 /*
113   simulate a kinit, putting the tgt in the given credentials cache. 
114   If cache_name == NULL place in default cache location.
115
116   Orignally by remus@snapserver.com
117 */
118 int kerberos_kinit_password(const char *principal,
119                             const char *password,
120                             int time_offset,
121                             time_t *expire_time,
122                             const char *cache_name,
123                             time_t *kdc_time)
124 {
125         int code;
126         krb5_context ctx = NULL;
127         krb5_ccache cc = NULL;
128
129         if ((code = krb5_init_context(&ctx)))
130                 return code;
131
132         if (time_offset != 0) {
133                 krb5_set_real_time(ctx, time(NULL) + time_offset, 0);
134         }
135         
136         if ((code = krb5_cc_resolve(ctx, cache_name ?
137                                     cache_name : krb5_cc_default_name(ctx), &cc))) {
138                 krb5_free_context(ctx);
139                 return code;
140         }
141
142         code = kerberos_kinit_password_cc(ctx, cc, principal, password, expire_time, kdc_time);
143         
144         krb5_cc_close(ctx, cc);
145         krb5_free_context(ctx);
146
147         return code;
148 }
149
150 /* run kinit to setup our ccache */
151 int ads_kinit_password(ADS_STRUCT *ads)
152 {
153         char *s;
154         int ret;
155
156         if (asprintf(&s, "%s@%s", ads->auth.user_name, ads->auth.realm) == -1) {
157                 return KRB5_CC_NOMEM;
158         }
159
160         if (!ads->auth.password) {
161                 return KRB5_LIBOS_CANTREADPWD;
162         }
163         
164         ret = kerberos_kinit_password(s, ads->auth.password, ads->auth.time_offset,
165                         &ads->auth.expire, NULL, NULL);
166
167         if (ret) {
168                 DEBUG(0,("kerberos_kinit_password %s failed: %s\n", 
169                          s, error_message(ret)));
170         }
171         free(s);
172         return ret;
173 }
174
175 int ads_kdestroy(const char *cc_name)
176 {
177         krb5_error_code code;
178         krb5_context ctx = NULL;
179         krb5_ccache cc = NULL;
180
181         if ((code = krb5_init_context (&ctx))) {
182                 DEBUG(3, ("ads_kdestroy: kdb5_init_context failed: %s\n", 
183                         error_message(code)));
184                 return code;
185         }
186   
187         if (!cc_name) {
188                 if ((code = krb5_cc_default(ctx, &cc))) {
189                         krb5_free_context(ctx);
190                         return code;
191                 }
192         } else {
193                 if ((code = krb5_cc_resolve(ctx, cc_name, &cc))) {
194                         DEBUG(3, ("ads_kdestroy: krb5_cc_resolve failed: %s\n",
195                                   error_message(code)));
196                         krb5_free_context(ctx);
197                         return code;
198                 }
199         }
200
201         if ((code = krb5_cc_destroy (ctx, cc))) {
202                 DEBUG(3, ("ads_kdestroy: krb5_cc_destroy failed: %s\n", 
203                         error_message(code)));
204         }
205
206         krb5_free_context (ctx);
207         return code;
208 }
209
210 /************************************************************************
211  Routine to fetch the salting principal for a service.  Active
212  Directory may use a non-obvious principal name to generate the salt
213  when it determines the key to use for encrypting tickets for a service,
214  and hopefully we detected that when we joined the domain.
215  ************************************************************************/
216
217 static char *kerberos_secrets_fetch_salting_principal(const char *service, int enctype)
218 {
219         char *ret = NULL;
220
221 #if 0
222         asprintf(&key, "%s/%s/enctype=%d", SECRETS_SALTING_PRINCIPAL, service, enctype);
223         if (!key) {
224                 return NULL;
225         }
226         ret = (char *)secrets_fetch(key, NULL);
227         SAFE_FREE(key);
228 #endif
229         return ret;
230 }
231
232 /************************************************************************
233  Routine to get the salting principal for this service.  Active
234  Directory may use a non-obvious principal name to generate the salt
235  when it determines the key to use for encrypting tickets for a service,
236  and hopefully we detected that when we joined the domain.
237  Caller must free if return is not null.
238  ************************************************************************/
239
240 krb5_principal kerberos_fetch_salt_princ_for_host_princ(krb5_context context,
241                                                         krb5_principal host_princ,
242                                                         int enctype)
243 {
244         char *unparsed_name = NULL, *salt_princ_s = NULL;
245         krb5_principal ret_princ = NULL;
246
247         if (krb5_unparse_name(context, host_princ, &unparsed_name) != 0) {
248                 return (krb5_principal)NULL;
249         }
250
251         if ((salt_princ_s = kerberos_secrets_fetch_salting_principal(unparsed_name, enctype)) == NULL) {
252                 krb5_free_unparsed_name(context, unparsed_name);
253                 return (krb5_principal)NULL;
254         }
255
256         if (krb5_parse_name(context, salt_princ_s, &ret_princ) != 0) {
257                 krb5_free_unparsed_name(context, unparsed_name);
258                 SAFE_FREE(salt_princ_s);
259                 return (krb5_principal)NULL;
260         }
261         krb5_free_unparsed_name(context, unparsed_name);
262         SAFE_FREE(salt_princ_s);
263         return ret_princ;
264 }
265
266 /************************************************************************
267  Routine to set the salting principal for this service.  Active
268  Directory may use a non-obvious principal name to generate the salt
269  when it determines the key to use for encrypting tickets for a service,
270  and hopefully we detected that when we joined the domain.
271  Setting principal to NULL deletes this entry.
272  ************************************************************************/
273
274  BOOL kerberos_secrets_store_salting_principal(const char *service,
275                                               int enctype,
276                                               const char *principal)
277 {
278         char *key = NULL;
279         BOOL ret = False;
280         krb5_context context = NULL;
281         krb5_principal princ = NULL;
282         char *princ_s = NULL;
283         char *unparsed_name = NULL;
284
285         krb5_init_context(&context);
286         if (!context) {
287                 return False;
288         }
289         if (strchr_m(service, '@')) {
290                 asprintf(&princ_s, "%s", service);
291         } else {
292                 asprintf(&princ_s, "%s@%s", service, lp_realm());
293         }
294
295         if (krb5_parse_name(context, princ_s, &princ) != 0) {
296                 goto out;
297                 
298         }
299         if (krb5_unparse_name(context, princ, &unparsed_name) != 0) {
300                 goto out;
301         }
302
303         asprintf(&key, "%s/%s/enctype=%d", SECRETS_SALTING_PRINCIPAL, unparsed_name, enctype);
304         if (!key)  {
305                 goto out;
306         }
307
308 #if 0
309         if ((principal != NULL) && (strlen(principal) > 0)) {
310                 ret = secrets_store(key, principal, strlen(principal) + 1);
311         } else {
312                 ret = secrets_delete(key);
313         }
314 #endif 
315
316  out:
317
318         SAFE_FREE(key);
319         SAFE_FREE(princ_s);
320
321         if (unparsed_name) {
322                 krb5_free_unparsed_name(context, unparsed_name);
323         }
324         if (context) {
325                 krb5_free_context(context);
326         }
327
328         return ret;
329 }
330
331 /************************************************************************
332  Routine to get initial credentials as a service ticket for the local machine.
333  Returns a buffer initialized with krb5_mk_req_extended.
334  ************************************************************************/
335
336 static krb5_error_code get_service_ticket(krb5_context ctx,
337                                         krb5_ccache ccache,
338                                         const char *service_principal,
339                                         int enctype,
340                                         krb5_data *p_outbuf)
341 {
342         krb5_creds creds, *new_creds = NULL;
343         char *service_s = NULL;
344         char *machine_account = NULL, *password = NULL;
345         krb5_data in_data;
346         krb5_auth_context auth_context = NULL;
347         krb5_error_code err = 0;
348
349         ZERO_STRUCT(creds);
350
351         asprintf(&machine_account, "%s$@%s", lp_netbios_name(), lp_realm());
352         if (machine_account == NULL) {
353                 goto out;
354         }
355         password = secrets_fetch_machine_password(lp_workgroup());
356         if (password == NULL) {
357                 goto out;
358         }
359         if ((err = kerberos_kinit_password(machine_account, password, 0, NULL, LIBADS_CCACHE_NAME, NULL)) != 0) {
360                 DEBUG(0,("get_service_ticket: kerberos_kinit_password %s@%s failed: %s\n", 
361                         machine_account,
362                         lp_realm(),
363                         error_message(err)));
364                 goto out;
365         }
366
367         /* Ok - the above call has gotten a TGT. Now we need to get a service
368            ticket to ourselves. */
369
370         /* Set up the enctype and client and server principal fields for krb5_get_credentials. */
371         kerberos_set_creds_enctype(&creds, enctype);
372
373         if ((err = krb5_cc_get_principal(ctx, ccache, &creds.client))) {
374                 DEBUG(3, ("get_service_ticket: krb5_cc_get_principal failed: %s\n", 
375                         error_message(err)));
376                 goto out;
377         }
378
379         if (strchr_m(service_principal, '@')) {
380                 asprintf(&service_s, "%s", service_principal);
381         } else {
382                 asprintf(&service_s, "%s@%s", service_principal, lp_realm());
383         }
384
385         if ((err = krb5_parse_name(ctx, service_s, &creds.server))) {
386                 DEBUG(0,("get_service_ticket: krb5_parse_name %s failed: %s\n", 
387                         service_s, error_message(err)));
388                 goto out;
389         }
390
391         if ((err = krb5_get_credentials(ctx, 0, ccache, &creds, &new_creds))) {
392                 DEBUG(5,("get_service_ticket: krb5_get_credentials for %s enctype %d failed: %s\n", 
393                         service_s, enctype, error_message(err)));
394                 goto out;
395         }
396
397         memset(&in_data, '\0', sizeof(in_data));
398         if ((err = krb5_mk_req_extended(ctx, &auth_context, 0, &in_data,
399                         new_creds, p_outbuf)) != 0) {
400                 DEBUG(0,("get_service_ticket: krb5_mk_req_extended failed: %s\n", 
401                         error_message(err)));
402                 goto out;
403         }
404
405  out:
406
407         if (auth_context) {
408                 krb5_auth_con_free(ctx, auth_context);
409         }
410         if (new_creds) {
411                 krb5_free_creds(ctx, new_creds);
412         }
413         if (creds.server) {
414                 krb5_free_principal(ctx, creds.server);
415         }
416         if (creds.client) {
417                 krb5_free_principal(ctx, creds.client);
418         }
419
420         SAFE_FREE(service_s);
421         SAFE_FREE(password);
422         SAFE_FREE(machine_account);
423         return err;
424 }
425
426 /************************************************************************
427  Check if the machine password can be used in conjunction with the salting_principal
428  to generate a key which will successfully decrypt the AP_REQ already
429  gotten as a message to the local machine.
430  ************************************************************************/
431
432 static BOOL verify_service_password(krb5_context ctx,
433                                     int enctype,
434                                     const char *salting_principal,
435                                     krb5_data *in_data)
436 {
437         BOOL ret = False;
438         krb5_principal salting_kprinc = NULL;
439         krb5_ticket *ticket = NULL;
440         krb5_keyblock key;
441         krb5_data passdata;
442         char *salting_s = NULL;
443         char *machine_account = NULL, *password = NULL;
444         krb5_auth_context auth_context = NULL;
445         krb5_error_code err;
446
447         memset(&passdata, '\0', sizeof(passdata));
448         memset(&key, '\0', sizeof(key));
449
450         asprintf(&machine_account, "%s$@%s", lp_netbios_name(), lp_realm());
451         if (machine_account == NULL) {
452                 goto out;
453         }
454         password = secrets_fetch_machine_password(lp_workgroup());
455         if (password == NULL) {
456                 goto out;
457         }
458
459         if (strchr_m(salting_principal, '@')) {
460                 asprintf(&salting_s, "%s", salting_principal);
461         } else {
462                 asprintf(&salting_s, "%s@%s", salting_principal, lp_realm());
463         }
464
465         if ((err = krb5_parse_name(ctx, salting_s, &salting_kprinc))) {
466                 DEBUG(0,("verify_service_password: krb5_parse_name %s failed: %s\n", 
467                         salting_s, error_message(err)));
468                 goto out;
469         }
470
471         passdata.length = strlen(password);
472         passdata.data = (char*)password;
473         if ((err = create_kerberos_key_from_string_direct(ctx, salting_kprinc, &passdata, &key, enctype))) {
474                 DEBUG(0,("verify_service_password: create_kerberos_key_from_string %d failed: %s\n",
475                         enctype, error_message(err)));
476                 goto out;
477         }
478
479         if ((err = krb5_auth_con_init(ctx, &auth_context)) != 0) {
480                 DEBUG(0,("verify_service_password: krb5_auth_con_init failed %s\n", error_message(err)));
481                 goto out;
482         }
483
484         if ((err = krb5_auth_con_setuseruserkey(ctx, auth_context, &key)) != 0) {
485                 DEBUG(0,("verify_service_password: krb5_auth_con_setuseruserkey failed %s\n", error_message(err)));
486                 goto out;
487         }
488
489         if (!(err = krb5_rd_req(ctx, &auth_context, in_data, NULL, NULL, NULL, &ticket))) {
490                 DEBUG(10,("verify_service_password: decrypted message with enctype %u salt %s!\n",
491                                 (unsigned int)enctype, salting_s));
492                 ret = True;
493         }
494
495  out:
496
497         memset(&passdata, 0, sizeof(passdata));
498         krb5_free_keyblock_contents(ctx, &key);
499         if (ticket != NULL) {
500                 krb5_free_ticket(ctx, ticket);
501         }
502         if (salting_kprinc) {
503                 krb5_free_principal(ctx, salting_kprinc);
504         }
505         SAFE_FREE(salting_s);
506         SAFE_FREE(password);
507         SAFE_FREE(machine_account);
508         return ret;
509 }
510
511 /************************************************************************
512  *
513  * From the current draft of kerberos-clarifications:
514  *
515  *     It is not possible to reliably generate a user's key given a pass
516  *     phrase without contacting the KDC, since it will not be known
517  *     whether alternate salt or parameter values are required.
518  *
519  * And because our server has a password, we have this exact problem.  We
520  * make multiple guesses as to which principal name provides the salt which
521  * the KDC is using.
522  *
523  ************************************************************************/
524
525 static void kerberos_derive_salting_principal_for_enctype(const char *service_principal,
526                                                           krb5_context ctx,
527                                                           krb5_ccache ccache,
528                                                           krb5_enctype enctype,
529                                                           krb5_enctype *enctypes)
530 {
531         char *salting_principals[3] = {NULL, NULL, NULL}, *second_principal = NULL;
532         krb5_error_code err = 0;
533         krb5_data outbuf;
534         int i, j;
535
536         memset(&outbuf, '\0', sizeof(outbuf));
537
538         /* Check that the service_principal is useful. */
539         if ((service_principal == NULL) || (strlen(service_principal) == 0)) {
540                 return;
541         }
542
543         /* Generate our first guess -- the principal as-given. */
544         asprintf(&salting_principals[0], "%s", service_principal);
545         if ((salting_principals[0] == NULL) || (strlen(salting_principals[0]) == 0)) {
546                 return;
547         }
548
549         /* Generate our second guess -- the computer's principal, as Win2k3. */
550         asprintf(&second_principal, "host/%s.%s", lp_netbios_name(), lp_realm());
551         if (second_principal != NULL) {
552                 strlower_m(second_principal);
553                 asprintf(&salting_principals[1], "%s@%s", second_principal, lp_realm());
554                 SAFE_FREE(second_principal);
555         }
556         if ((salting_principals[1] == NULL) || (strlen(salting_principals[1]) == 0)) {
557                 goto out;
558         }
559
560         /* Generate our third guess -- the computer's principal, as Win2k. */
561         asprintf(&second_principal, "HOST/%s", lp_netbios_name());
562         if (second_principal != NULL) {
563                 strlower_m(second_principal + 5);
564                 asprintf(&salting_principals[2], "%s@%s",
565                         second_principal, lp_realm());
566                 SAFE_FREE(second_principal);
567         }
568         if ((salting_principals[2] == NULL) || (strlen(salting_principals[2]) == 0)) {
569                 goto out;
570         }
571
572         /* Get a service ticket for ourselves into our memory ccache. */
573         /* This will commonly fail if there is no principal by that name (and we're trying
574            many names). So don't print a debug 0 error. */
575
576         if ((err = get_service_ticket(ctx, ccache, service_principal, enctype, &outbuf)) != 0) {
577                 DEBUG(3, ("verify_service_password: get_service_ticket failed: %s\n", 
578                         error_message(err)));
579                 goto out;
580         }
581
582         /* At this point we have a message to ourselves, salted only the KDC knows how. We
583            have to work out what that salting is. */
584
585         /* Try and find the correct salting principal. */
586         for (i = 0; i < sizeof(salting_principals) / sizeof(salting_principals[i]); i++) {
587                 if (verify_service_password(ctx, enctype, salting_principals[i], &outbuf)) {
588                         break;
589                 }
590         }
591
592         /* If we failed to get a match, return. */
593         if (i >= sizeof(salting_principals) / sizeof(salting_principals[i])) {
594                 goto out;
595         }
596
597         /* If we succeeded, store the principal for use for all enctypes which
598          * share the same cipher and string-to-key function.  Doing this here
599          * allows servers which just pass a keytab to krb5_rd_req() to work
600          * correctly. */
601         for (j = 0; enctypes[j] != 0; j++) {
602                 if (enctype != enctypes[j]) {
603                         /* If this enctype isn't compatible with the one which
604                          * we used, skip it. */
605
606                         if (!kerberos_compatible_enctypes(ctx, enctypes[j], enctype))
607                                 continue;
608                 }
609                 /* If the principal which gives us the proper salt is the one
610                  * which we would normally guess, don't bother noting anything
611                  * in the secrets tdb. */
612                 if (strcmp(service_principal, salting_principals[i]) != 0) {
613                         kerberos_secrets_store_salting_principal(service_principal,
614                                                                 enctypes[j],
615                                                                 salting_principals[i]);
616                 }
617         }
618
619  out :
620
621         kerberos_free_data_contents(ctx, &outbuf);
622         SAFE_FREE(salting_principals[0]);
623         SAFE_FREE(salting_principals[1]);
624         SAFE_FREE(salting_principals[2]);
625         SAFE_FREE(second_principal);
626 }
627
628 /************************************************************************
629  Go through all the possible enctypes for this principal.
630  ************************************************************************/
631
632 static void kerberos_derive_salting_principal_direct(krb5_context context,
633                                         krb5_ccache ccache,
634                                         krb5_enctype *enctypes,
635                                         char *service_principal)
636 {
637         int i;
638
639         /* Try for each enctype separately, because the rules are
640          * different for different enctypes. */
641         for (i = 0; enctypes[i] != 0; i++) {
642                 /* Delete secrets entry first. */
643                 kerberos_secrets_store_salting_principal(service_principal, 0, NULL);
644 #ifdef ENCTYPE_ARCFOUR_HMAC
645                 if (enctypes[i] == ENCTYPE_ARCFOUR_HMAC) {
646                         /* Of course this'll always work, so just save
647                          * ourselves the effort. */
648                         continue;
649                 }
650 #endif
651                 /* Try to figure out what's going on with this
652                  * principal. */
653                 kerberos_derive_salting_principal_for_enctype(service_principal,
654                                                                 context,
655                                                                 ccache,
656                                                                 enctypes[i],
657                                                                 enctypes);
658         }
659 }
660
661 /************************************************************************
662  Wrapper function for the above.
663  ************************************************************************/
664
665 BOOL kerberos_derive_salting_principal(char *service_principal)
666 {
667         krb5_context context = NULL;
668         krb5_enctype *enctypes = NULL;
669         krb5_ccache ccache = NULL;
670         krb5_error_code ret = 0;
671
672         initialize_krb5_error_table();
673         if ((ret = krb5_init_context(&context)) != 0) {
674                 DEBUG(1,("kerberos_derive_cifs_salting_principals: krb5_init_context failed. %s\n",
675                         error_message(ret)));
676                 return False;
677         }
678         if ((ret = get_kerberos_allowed_etypes(context, &enctypes)) != 0) {
679                 DEBUG(1,("kerberos_derive_cifs_salting_principals: get_kerberos_allowed_etypes failed. %s\n",
680                         error_message(ret)));
681                 goto out;
682         }
683
684         if ((ret = krb5_cc_resolve(context, LIBADS_CCACHE_NAME, &ccache)) != 0) {
685                 DEBUG(3, ("get_service_ticket: krb5_cc_resolve for %s failed: %s\n", 
686                         LIBADS_CCACHE_NAME, error_message(ret)));
687                 goto out;
688         }
689
690         kerberos_derive_salting_principal_direct(context, ccache, enctypes, service_principal);
691
692   out: 
693         if (enctypes) {
694                 free_kerberos_etypes(context, enctypes);
695         }
696         if (ccache) {
697                 krb5_cc_destroy(context, ccache);
698         }
699         if (context) {
700                 krb5_free_context(context);
701         }
702
703         return ret ? False : True;
704 }
705
706 /************************************************************************
707  Core function to try and determine what salt is being used for any keytab
708  keys.
709  ************************************************************************/
710
711 BOOL kerberos_derive_cifs_salting_principals(void)
712 {
713         fstring my_fqdn;
714         char *service = NULL;
715         krb5_context context = NULL;
716         krb5_enctype *enctypes = NULL;
717         krb5_ccache ccache = NULL;
718         krb5_error_code ret = 0;
719         BOOL retval = False;
720
721         initialize_krb5_error_table();
722         if ((ret = krb5_init_context(&context)) != 0) {
723                 DEBUG(1,("kerberos_derive_cifs_salting_principals: krb5_init_context failed. %s\n",
724                         error_message(ret)));
725                 return False;
726         }
727         if ((ret = get_kerberos_allowed_etypes(context, &enctypes)) != 0) {
728                 DEBUG(1,("kerberos_derive_cifs_salting_principals: get_kerberos_allowed_etypes failed. %s\n",
729                         error_message(ret)));
730                 goto out;
731         }
732
733         if ((ret = krb5_cc_resolve(context, LIBADS_CCACHE_NAME, &ccache)) != 0) {
734                 DEBUG(3, ("get_service_ticket: krb5_cc_resolve for %s failed: %s\n", 
735                         LIBADS_CCACHE_NAME, error_message(ret)));
736                 goto out;
737         }
738
739         if (asprintf(&service, "%s$", lp_netbios_name()) != -1) {
740                 strlower_m(service);
741                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
742                 SAFE_FREE(service);
743         }
744         if (asprintf(&service, "cifs/%s", lp_netbios_name()) != -1) {
745                 strlower_m(service);
746                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
747                 SAFE_FREE(service);
748         }
749         if (asprintf(&service, "host/%s", lp_netbios_name()) != -1) {
750                 strlower_m(service);
751                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
752                 SAFE_FREE(service);
753         }
754         if (asprintf(&service, "cifs/%s.%s", lp_netbios_name(), lp_realm()) != -1) {
755                 strlower_m(service);
756                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
757                 SAFE_FREE(service);
758         }
759         if (asprintf(&service, "host/%s.%s", lp_netbios_name(), lp_realm()) != -1) {
760                 strlower_m(service);
761                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
762                 SAFE_FREE(service);
763         }
764         name_to_fqdn(my_fqdn, lp_netbios_name());
765         if (asprintf(&service, "cifs/%s", my_fqdn) != -1) {
766                 strlower_m(service);
767                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
768                 SAFE_FREE(service);
769         }
770         if (asprintf(&service, "host/%s", my_fqdn) != -1) {
771                 strlower_m(service);
772                 kerberos_derive_salting_principal_direct(context, ccache, enctypes, service);
773                 SAFE_FREE(service);
774         }
775
776         retval = True;
777
778   out: 
779         if (enctypes) {
780                 free_kerberos_etypes(context, enctypes);
781         }
782         if (ccache) {
783                 krb5_cc_destroy(context, ccache);
784         }
785         if (context) {
786                 krb5_free_context(context);
787         }
788         return retval;
789 }
790 #endif