← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to source3/libads/kerberos_keytab.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
source3/libads/kerberos_keytab.c
 
1
/*
 
2
   Unix SMB/CIFS implementation.
 
3
   kerberos keytab utility library
 
4
   Copyright (C) Andrew Tridgell 2001
 
5
   Copyright (C) Remus Koos 2001
 
6
   Copyright (C) Luke Howard 2003
 
7
   Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003
 
8
   Copyright (C) Guenther Deschner 2003
 
9
   Copyright (C) Rakesh Patel 2004
 
10
   Copyright (C) Dan Perry 2004
 
11
   Copyright (C) Jeremy Allison 2004
 
12
   Copyright (C) Gerald Carter 2006
 
13
 
 
14
   This program is free software; you can redistribute it and/or modify
 
15
   it under the terms of the GNU General Public License as published by
 
16
   the Free Software Foundation; either version 3 of the License, or
 
17
   (at your option) any later version.
 
18
 
 
19
   This program is distributed in the hope that it will be useful,
 
20
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
21
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
22
   GNU General Public License for more details.
 
23
 
 
24
   You should have received a copy of the GNU General Public License
 
25
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
26
*/
 
27
 
 
28
#include "includes.h"
 
29
#include "smb_krb5.h"
 
30
 
 
31
#ifdef HAVE_KRB5
 
32
 
 
33
/**********************************************************************
 
34
**********************************************************************/
 
35
 
 
36
int smb_krb5_kt_add_entry_ext(krb5_context context,
 
37
                              krb5_keytab keytab,
 
38
                              krb5_kvno kvno,
 
39
                              const char *princ_s,
 
40
                              krb5_enctype *enctypes,
 
41
                              krb5_data password,
 
42
                              bool no_salt,
 
43
                              bool keep_old_entries)
 
44
{
 
45
        krb5_error_code ret = 0;
 
46
        krb5_kt_cursor cursor;
 
47
        krb5_keytab_entry kt_entry;
 
48
        krb5_principal princ = NULL;
 
49
        int i;
 
50
        char *ktprinc = NULL;
 
51
 
 
52
        ZERO_STRUCT(kt_entry);
 
53
        ZERO_STRUCT(cursor);
 
54
        
 
55
        ret = smb_krb5_parse_name(context, princ_s, &princ);
 
56
        if (ret) {
 
57
                DEBUG(1,("smb_krb5_kt_add_entry_ext: smb_krb5_parse_name(%s) failed (%s)\n", princ_s, error_message(ret)));
 
58
                goto out;
 
59
        }
 
60
 
 
61
        /* Seek and delete old keytab entries */
 
62
        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
63
        if (ret != KRB5_KT_END && ret != ENOENT ) {
 
64
                DEBUG(3,("smb_krb5_kt_add_entry_ext: Will try to delete old keytab entries\n"));
 
65
                while(!krb5_kt_next_entry(context, keytab, &kt_entry, &cursor)) {
 
66
                        bool compare_name_ok = False;
 
67
 
 
68
                        ret = smb_krb5_unparse_name(talloc_tos(), context, kt_entry.principal, &ktprinc);
 
69
                        if (ret) {
 
70
                                DEBUG(1,("smb_krb5_kt_add_entry_ext: smb_krb5_unparse_name failed (%s)\n",
 
71
                                        error_message(ret)));
 
72
                                goto out;
 
73
                        }
 
74
 
 
75
                        /*---------------------------------------------------------------------------
 
76
                         * Save the entries with kvno - 1.   This is what microsoft does
 
77
                         * to allow people with existing sessions that have kvno - 1 to still
 
78
                         * work.   Otherwise, when the password for the machine changes, all
 
79
                         * kerberizied sessions will 'break' until either the client reboots or
 
80
                         * the client's session key expires and they get a new session ticket
 
81
                         * with the new kvno.
 
82
                         */
 
83
 
 
84
#ifdef HAVE_KRB5_KT_COMPARE
 
85
                        compare_name_ok = (krb5_kt_compare(context, &kt_entry, princ, 0, 0) == True);
 
86
#else
 
87
                        compare_name_ok = (strcmp(ktprinc, princ_s) == 0);
 
88
#endif
 
89
 
 
90
                        if (!compare_name_ok) {
 
91
                                DEBUG(10,("smb_krb5_kt_add_entry_ext: ignoring keytab entry principal %s, kvno = %d\n",
 
92
                                        ktprinc, kt_entry.vno));
 
93
                        }
 
94
 
 
95
                        TALLOC_FREE(ktprinc);
 
96
 
 
97
                        if (compare_name_ok) {
 
98
                                if (kt_entry.vno == kvno - 1) {
 
99
                                        DEBUG(5,("smb_krb5_kt_add_entry_ext: Saving previous (kvno %d) entry for principal: %s.\n",
 
100
                                                kvno - 1, princ_s));
 
101
                                } else if (!keep_old_entries) {
 
102
                                        DEBUG(5,("smb_krb5_kt_add_entry_ext: Found old entry for principal: %s (kvno %d) - trying to remove it.\n",
 
103
                                                princ_s, kt_entry.vno));
 
104
                                        ret = krb5_kt_end_seq_get(context, keytab, &cursor);
 
105
                                        ZERO_STRUCT(cursor);
 
106
                                        if (ret) {
 
107
                                                DEBUG(1,("smb_krb5_kt_add_entry_ext: krb5_kt_end_seq_get() failed (%s)\n",
 
108
                                                        error_message(ret)));
 
109
                                                goto out;
 
110
                                        }
 
111
                                        ret = krb5_kt_remove_entry(context, keytab, &kt_entry);
 
112
                                        if (ret) {
 
113
                                                DEBUG(1,("smb_krb5_kt_add_entry_ext: krb5_kt_remove_entry failed (%s)\n",
 
114
                                                        error_message(ret)));
 
115
                                                goto out;
 
116
                                        }
 
117
 
 
118
                                        DEBUG(5,("smb_krb5_kt_add_entry_ext: removed old entry for principal: %s (kvno %d).\n",
 
119
                                                princ_s, kt_entry.vno));
 
120
 
 
121
                                        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
122
                                        if (ret) {
 
123
                                                DEBUG(1,("smb_krb5_kt_add_entry_ext: krb5_kt_start_seq failed (%s)\n",
 
124
                                                        error_message(ret)));
 
125
                                                goto out;
 
126
                                        }
 
127
                                        ret = smb_krb5_kt_free_entry(context, &kt_entry);
 
128
                                        ZERO_STRUCT(kt_entry);
 
129
                                        if (ret) {
 
130
                                                DEBUG(1,("smb_krb5_kt_add_entry_ext: krb5_kt_remove_entry failed (%s)\n",
 
131
                                                        error_message(ret)));
 
132
                                                goto out;
 
133
                                        }
 
134
                                        continue;
 
135
                                }
 
136
                        }
 
137
 
 
138
                        /* Not a match, just free this entry and continue. */
 
139
                        ret = smb_krb5_kt_free_entry(context, &kt_entry);
 
140
                        ZERO_STRUCT(kt_entry);
 
141
                        if (ret) {
 
142
                                DEBUG(1,("smb_krb5_kt_add_entry_ext: smb_krb5_kt_free_entry failed (%s)\n", error_message(ret)));
 
143
                                goto out;
 
144
                        }
 
145
                }
 
146
 
 
147
                ret = krb5_kt_end_seq_get(context, keytab, &cursor);
 
148
                ZERO_STRUCT(cursor);
 
149
                if (ret) {
 
150
                        DEBUG(1,("smb_krb5_kt_add_entry_ext: krb5_kt_end_seq_get failed (%s)\n",error_message(ret)));
 
151
                        goto out;
 
152
                }
 
153
        }
 
154
 
 
155
        /* Ensure we don't double free. */
 
156
        ZERO_STRUCT(kt_entry);
 
157
        ZERO_STRUCT(cursor);
 
158
 
 
159
        /* If we get here, we have deleted all the old entries with kvno's not equal to the current kvno-1. */
 
160
 
 
161
        /* Now add keytab entries for all encryption types */
 
162
        for (i = 0; enctypes[i]; i++) {
 
163
                krb5_keyblock *keyp;
 
164
 
 
165
                keyp = KRB5_KT_KEY(&kt_entry);
 
166
 
 
167
                if (create_kerberos_key_from_string(context, princ, &password, keyp, enctypes[i], no_salt)) {
 
168
                        continue;
 
169
                }
 
170
 
 
171
                kt_entry.principal = princ;
 
172
                kt_entry.vno       = kvno;
 
173
 
 
174
                DEBUG(3,("smb_krb5_kt_add_entry_ext: adding keytab entry for (%s) with encryption type (%d) and version (%d)\n",
 
175
                        princ_s, enctypes[i], kt_entry.vno));
 
176
                ret = krb5_kt_add_entry(context, keytab, &kt_entry);
 
177
                krb5_free_keyblock_contents(context, keyp);
 
178
                ZERO_STRUCT(kt_entry);
 
179
                if (ret) {
 
180
                        DEBUG(1,("smb_krb5_kt_add_entry_ext: adding entry to keytab failed (%s)\n", error_message(ret)));
 
181
                        goto out;
 
182
                }
 
183
        }
 
184
 
 
185
 
 
186
out:
 
187
        {
 
188
                krb5_keytab_entry zero_kt_entry;
 
189
                ZERO_STRUCT(zero_kt_entry);
 
190
                if (memcmp(&zero_kt_entry, &kt_entry, sizeof(krb5_keytab_entry))) {
 
191
                        smb_krb5_kt_free_entry(context, &kt_entry);
 
192
                }
 
193
        }
 
194
        if (princ) {
 
195
                krb5_free_principal(context, princ);
 
196
        }
 
197
        
 
198
        {
 
199
                krb5_kt_cursor zero_csr;
 
200
                ZERO_STRUCT(zero_csr);
 
201
                if ((memcmp(&cursor, &zero_csr, sizeof(krb5_kt_cursor)) != 0) && keytab) {
 
202
                        krb5_kt_end_seq_get(context, keytab, &cursor);  
 
203
                }
 
204
        }
 
205
        
 
206
        return (int)ret;
 
207
}
 
208
 
 
209
static int smb_krb5_kt_add_entry(krb5_context context,
 
210
                                 krb5_keytab keytab,
 
211
                                 krb5_kvno kvno,
 
212
                                 const char *princ_s,
 
213
                                 krb5_enctype *enctypes,
 
214
                                 krb5_data password)
 
215
{
 
216
        return smb_krb5_kt_add_entry_ext(context,
 
217
                                         keytab,
 
218
                                         kvno,
 
219
                                         princ_s,
 
220
                                         enctypes,
 
221
                                         password,
 
222
                                         false,
 
223
                                         false);
 
224
}
 
225
 
 
226
/**********************************************************************
 
227
 Adds a single service principal, i.e. 'host' to the system keytab
 
228
***********************************************************************/
 
229
 
 
230
int ads_keytab_add_entry(ADS_STRUCT *ads, const char *srvPrinc)
 
231
{
 
232
        krb5_error_code ret = 0;
 
233
        krb5_context context = NULL;
 
234
        krb5_keytab keytab = NULL;
 
235
        krb5_data password;
 
236
        krb5_kvno kvno;
 
237
        krb5_enctype enctypes[4] = { ENCTYPE_DES_CBC_CRC, ENCTYPE_DES_CBC_MD5, 0, 0 };
 
238
        char *princ_s = NULL, *short_princ_s = NULL;
 
239
        char *password_s = NULL;
 
240
        char *my_fqdn;
 
241
        TALLOC_CTX *ctx = NULL;
 
242
        char *machine_name;
 
243
 
 
244
#if defined(ENCTYPE_ARCFOUR_HMAC)
 
245
        enctypes[2] = ENCTYPE_ARCFOUR_HMAC;
 
246
#endif
 
247
 
 
248
        initialize_krb5_error_table();
 
249
        ret = krb5_init_context(&context);
 
250
        if (ret) {
 
251
                DEBUG(1,("ads_keytab_add_entry: could not krb5_init_context: %s\n",error_message(ret)));
 
252
                return -1;
 
253
        }
 
254
 
 
255
        ret = smb_krb5_open_keytab(context, NULL, True, &keytab);
 
256
        if (ret) {
 
257
                DEBUG(1,("ads_keytab_add_entry: smb_krb5_open_keytab failed (%s)\n", error_message(ret)));
 
258
                goto out;
 
259
        }
 
260
 
 
261
        /* retrieve the password */
 
262
        if (!secrets_init()) {
 
263
                DEBUG(1,("ads_keytab_add_entry: secrets_init failed\n"));
 
264
                ret = -1;
 
265
                goto out;
 
266
        }
 
267
        password_s = secrets_fetch_machine_password(lp_workgroup(), NULL, NULL);
 
268
        if (!password_s) {
 
269
                DEBUG(1,("ads_keytab_add_entry: failed to fetch machine password\n"));
 
270
                ret = -1;
 
271
                goto out;
 
272
        }
 
273
        ZERO_STRUCT(password);
 
274
        password.data = password_s;
 
275
        password.length = strlen(password_s);
 
276
 
 
277
        /* we need the dNSHostName value here */
 
278
        
 
279
        if ( (ctx = talloc_init("ads_keytab_add_entry")) == NULL ) {
 
280
                DEBUG(0,("ads_keytab_add_entry: talloc() failed!\n"));
 
281
                ret = -1;
 
282
                goto out;
 
283
        }
 
284
        
 
285
        if ( (my_fqdn = ads_get_dnshostname( ads, ctx, global_myname())) == NULL ) {
 
286
                DEBUG(0,("ads_keytab_add_entry: unable to determine machine account's dns name in AD!\n"));
 
287
                ret = -1;
 
288
                goto out;       
 
289
        }
 
290
        
 
291
        if ( (machine_name = ads_get_samaccountname( ads, ctx, global_myname())) == NULL ) {
 
292
                DEBUG(0,("ads_keytab_add_entry: unable to determine machine account's short name in AD!\n"));
 
293
                ret = -1;
 
294
                goto out;       
 
295
        }
 
296
        /*strip the trailing '$' */
 
297
        machine_name[strlen(machine_name)-1] = '\0';
 
298
                
 
299
        /* Construct our principal */
 
300
 
 
301
        if (strchr_m(srvPrinc, '@')) {
 
302
                /* It's a fully-named principal. */
 
303
                if (asprintf(&princ_s, "%s", srvPrinc) == -1) {
 
304
                        ret = -1;
 
305
                        goto out;
 
306
                }
 
307
        } else if (srvPrinc[strlen(srvPrinc)-1] == '$') {
 
308
                /* It's the machine account, as used by smbclient clients. */
 
309
                if (asprintf(&princ_s, "%s@%s", srvPrinc, lp_realm()) == -1) {
 
310
                        ret = -1;
 
311
                        goto out;
 
312
                }
 
313
        } else {
 
314
                /* It's a normal service principal.  Add the SPN now so that we
 
315
                 * can obtain credentials for it and double-check the salt value
 
316
                 * used to generate the service's keys. */
 
317
                 
 
318
                if (asprintf(&princ_s, "%s/%s@%s", srvPrinc, my_fqdn, lp_realm()) == -1) {
 
319
                        ret = -1;
 
320
                        goto out;
 
321
                }
 
322
                if (asprintf(&short_princ_s, "%s/%s@%s", srvPrinc, machine_name, lp_realm()) == -1) {
 
323
                        ret = -1;
 
324
                        goto out;
 
325
                }
 
326
                
 
327
                /* According to http://support.microsoft.com/kb/326985/en-us, 
 
328
                   certain principal names are automatically mapped to the host/...
 
329
                   principal in the AD account.  So only create these in the 
 
330
                   keytab, not in AD.  --jerry */
 
331
                   
 
332
                if ( !strequal( srvPrinc, "cifs" ) && !strequal(srvPrinc, "host" ) ) {
 
333
                        DEBUG(3,("ads_keytab_add_entry: Attempting to add/update '%s'\n", princ_s));
 
334
                        
 
335
                        if (!ADS_ERR_OK(ads_add_service_principal_name(ads, global_myname(), my_fqdn, srvPrinc))) {
 
336
                                DEBUG(1,("ads_keytab_add_entry: ads_add_service_principal_name failed.\n"));
 
337
                                goto out;
 
338
                        }
 
339
                }
 
340
        }
 
341
 
 
342
        kvno = (krb5_kvno) ads_get_machine_kvno(ads, global_myname());
 
343
        if (kvno == -1) {       /* -1 indicates failure, everything else is OK */
 
344
                DEBUG(1,("ads_keytab_add_entry: ads_get_machine_kvno failed to determine the system's kvno.\n"));
 
345
                ret = -1;
 
346
                goto out;
 
347
        }
 
348
        
 
349
        /* add the fqdn principal to the keytab */
 
350
        
 
351
        ret = smb_krb5_kt_add_entry( context, keytab, kvno, princ_s, enctypes, password );
 
352
        if ( ret ) {
 
353
                DEBUG(1,("ads_keytab_add_entry: Failed to add entry to keytab file\n"));
 
354
                goto out;
 
355
        }
 
356
        
 
357
        /* add the short principal name if we have one */
 
358
        
 
359
        if ( short_princ_s ) {
 
360
                ret = smb_krb5_kt_add_entry( context, keytab, kvno, short_princ_s, enctypes, password );
 
361
                if ( ret ) {
 
362
                        DEBUG(1,("ads_keytab_add_entry: Failed to add short entry to keytab file\n"));
 
363
                        goto out;
 
364
                }
 
365
        }
 
366
 
 
367
out:
 
368
        SAFE_FREE( princ_s );
 
369
        SAFE_FREE( short_princ_s );
 
370
        TALLOC_FREE( ctx );
 
371
        
 
372
        if (keytab) {
 
373
                krb5_kt_close(context, keytab);
 
374
        }
 
375
        if (context) {
 
376
                krb5_free_context(context);
 
377
        }
 
378
        return (int)ret;
 
379
}
 
380
 
 
381
/**********************************************************************
 
382
 Flushes all entries from the system keytab.
 
383
***********************************************************************/
 
384
 
 
385
int ads_keytab_flush(ADS_STRUCT *ads)
 
386
{
 
387
        krb5_error_code ret = 0;
 
388
        krb5_context context = NULL;
 
389
        krb5_keytab keytab = NULL;
 
390
        krb5_kt_cursor cursor;
 
391
        krb5_keytab_entry kt_entry;
 
392
        krb5_kvno kvno;
 
393
 
 
394
        ZERO_STRUCT(kt_entry);
 
395
        ZERO_STRUCT(cursor);
 
396
 
 
397
        initialize_krb5_error_table();
 
398
        ret = krb5_init_context(&context);
 
399
        if (ret) {
 
400
                DEBUG(1,("ads_keytab_flush: could not krb5_init_context: %s\n",error_message(ret)));
 
401
                return ret;
 
402
        }
 
403
 
 
404
        ret = smb_krb5_open_keytab(context, NULL, True, &keytab);
 
405
        if (ret) {
 
406
                DEBUG(1,("ads_keytab_flush: smb_krb5_open_keytab failed (%s)\n", error_message(ret)));
 
407
                goto out;
 
408
        }
 
409
 
 
410
        kvno = (krb5_kvno) ads_get_machine_kvno(ads, global_myname());
 
411
        if (kvno == -1) {       /* -1 indicates a failure */
 
412
                DEBUG(1,("ads_keytab_flush: Error determining the system's kvno.\n"));
 
413
                goto out;
 
414
        }
 
415
 
 
416
        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
417
        if (ret != KRB5_KT_END && ret != ENOENT) {
 
418
                while (!krb5_kt_next_entry(context, keytab, &kt_entry, &cursor)) {
 
419
                        ret = krb5_kt_end_seq_get(context, keytab, &cursor);
 
420
                        ZERO_STRUCT(cursor);
 
421
                        if (ret) {
 
422
                                DEBUG(1,("ads_keytab_flush: krb5_kt_end_seq_get() failed (%s)\n",error_message(ret)));
 
423
                                goto out;
 
424
                        }
 
425
                        ret = krb5_kt_remove_entry(context, keytab, &kt_entry);
 
426
                        if (ret) {
 
427
                                DEBUG(1,("ads_keytab_flush: krb5_kt_remove_entry failed (%s)\n",error_message(ret)));
 
428
                                goto out;
 
429
                        }
 
430
                        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
431
                        if (ret) {
 
432
                                DEBUG(1,("ads_keytab_flush: krb5_kt_start_seq failed (%s)\n",error_message(ret)));
 
433
                                goto out;
 
434
                        }
 
435
                        ret = smb_krb5_kt_free_entry(context, &kt_entry);
 
436
                        ZERO_STRUCT(kt_entry);
 
437
                        if (ret) {
 
438
                                DEBUG(1,("ads_keytab_flush: krb5_kt_remove_entry failed (%s)\n",error_message(ret)));
 
439
                                goto out;
 
440
                        }
 
441
                }
 
442
        }
 
443
 
 
444
        /* Ensure we don't double free. */
 
445
        ZERO_STRUCT(kt_entry);
 
446
        ZERO_STRUCT(cursor);
 
447
 
 
448
        if (!ADS_ERR_OK(ads_clear_service_principal_names(ads, global_myname()))) {
 
449
                DEBUG(1,("ads_keytab_flush: Error while clearing service principal listings in LDAP.\n"));
 
450
                goto out;
 
451
        }
 
452
 
 
453
out:
 
454
 
 
455
        {
 
456
                krb5_keytab_entry zero_kt_entry;
 
457
                ZERO_STRUCT(zero_kt_entry);
 
458
                if (memcmp(&zero_kt_entry, &kt_entry, sizeof(krb5_keytab_entry))) {
 
459
                        smb_krb5_kt_free_entry(context, &kt_entry);
 
460
                }
 
461
        }
 
462
        {
 
463
                krb5_kt_cursor zero_csr;
 
464
                ZERO_STRUCT(zero_csr);
 
465
                if ((memcmp(&cursor, &zero_csr, sizeof(krb5_kt_cursor)) != 0) && keytab) {
 
466
                        krb5_kt_end_seq_get(context, keytab, &cursor);  
 
467
                }
 
468
        }
 
469
        if (keytab) {
 
470
                krb5_kt_close(context, keytab);
 
471
        }
 
472
        if (context) {
 
473
                krb5_free_context(context);
 
474
        }
 
475
        return ret;
 
476
}
 
477
 
 
478
/**********************************************************************
 
479
 Adds all the required service principals to the system keytab.
 
480
***********************************************************************/
 
481
 
 
482
int ads_keytab_create_default(ADS_STRUCT *ads)
 
483
{
 
484
        krb5_error_code ret = 0;
 
485
        krb5_context context = NULL;
 
486
        krb5_keytab keytab = NULL;
 
487
        krb5_kt_cursor cursor;
 
488
        krb5_keytab_entry kt_entry;
 
489
        krb5_kvno kvno;
 
490
        int i, found = 0;
 
491
        char *sam_account_name, *upn;
 
492
        char **oldEntries = NULL, *princ_s[26];
 
493
        TALLOC_CTX *ctx = NULL;
 
494
        fstring machine_name;
 
495
 
 
496
        memset(princ_s, '\0', sizeof(princ_s));
 
497
 
 
498
        fstrcpy( machine_name, global_myname() );
 
499
 
 
500
        /* these are the main ones we need */
 
501
        
 
502
        if ( (ret = ads_keytab_add_entry(ads, "host") ) != 0 ) {
 
503
                DEBUG(1,("ads_keytab_create_default: ads_keytab_add_entry failed while adding 'host'.\n"));
 
504
                return ret;
 
505
        }
 
506
 
 
507
 
 
508
#if 0   /* don't create the CIFS/... keytab entries since no one except smbd 
 
509
           really needs them and we will fall back to verifying against secrets.tdb */
 
510
           
 
511
        if ( (ret = ads_keytab_add_entry(ads, "cifs")) != 0 ) {
 
512
                DEBUG(1,("ads_keytab_create_default: ads_keytab_add_entry failed while adding 'cifs'.\n"));
 
513
                return ret;
 
514
        }
 
515
#endif
 
516
 
 
517
        if ( (ctx = talloc_init("ads_keytab_create_default")) == NULL ) {
 
518
                DEBUG(0,("ads_keytab_create_default: talloc() failed!\n"));
 
519
                return -1;
 
520
        }
 
521
 
 
522
        /* now add the userPrincipalName and sAMAccountName entries */
 
523
 
 
524
        if ( (sam_account_name = ads_get_samaccountname( ads, ctx, machine_name)) == NULL ) {
 
525
                DEBUG(0,("ads_keytab_add_entry: unable to determine machine account's name in AD!\n"));
 
526
                TALLOC_FREE( ctx );
 
527
                return -1;      
 
528
        }
 
529
 
 
530
        /* upper case the sAMAccountName to make it easier for apps to 
 
531
           know what case to use in the keytab file */
 
532
 
 
533
        strupper_m( sam_account_name ); 
 
534
 
 
535
        if ( (ret = ads_keytab_add_entry(ads, sam_account_name )) != 0 ) {
 
536
                DEBUG(1,("ads_keytab_create_default: ads_keytab_add_entry failed while adding sAMAccountName (%s)\n",
 
537
                        sam_account_name));
 
538
                return ret;
 
539
        }
 
540
        
 
541
        /* remember that not every machine account will have a upn */
 
542
                
 
543
        upn = ads_get_upn( ads, ctx, machine_name);
 
544
        if ( upn ) {
 
545
                if ( (ret = ads_keytab_add_entry(ads, upn)) != 0 ) {
 
546
                        DEBUG(1,("ads_keytab_create_default: ads_keytab_add_entry failed while adding UPN (%s)\n",
 
547
                                upn));
 
548
                        TALLOC_FREE( ctx );
 
549
                        return ret;
 
550
                }
 
551
        }
 
552
 
 
553
        /* Now loop through the keytab and update any other existing entries... */
 
554
        
 
555
        kvno = (krb5_kvno) ads_get_machine_kvno(ads, machine_name);
 
556
        if (kvno == -1) {
 
557
                DEBUG(1,("ads_keytab_create_default: ads_get_machine_kvno failed to determine the system's kvno.\n"));
 
558
                TALLOC_FREE(ctx);
 
559
                return -1;
 
560
        }
 
561
        
 
562
        DEBUG(3,("ads_keytab_create_default: Searching for keytab entries to "
 
563
                "preserve and update.\n"));
 
564
 
 
565
        ZERO_STRUCT(kt_entry);
 
566
        ZERO_STRUCT(cursor);
 
567
 
 
568
        initialize_krb5_error_table();
 
569
        ret = krb5_init_context(&context);
 
570
        if (ret) {
 
571
                DEBUG(1,("ads_keytab_create_default: could not krb5_init_context: %s\n",error_message(ret)));
 
572
                TALLOC_FREE(ctx);
 
573
                return ret;
 
574
        }
 
575
 
 
576
        ret = smb_krb5_open_keytab(context, NULL, True, &keytab);
 
577
        if (ret) {
 
578
                DEBUG(1,("ads_keytab_create_default: smb_krb5_open_keytab failed (%s)\n", error_message(ret)));
 
579
                goto done;
 
580
        }
 
581
 
 
582
        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
583
        if (ret != KRB5_KT_END && ret != ENOENT ) {
 
584
                while ((ret = krb5_kt_next_entry(context, keytab, &kt_entry, &cursor)) == 0) {
 
585
                        smb_krb5_kt_free_entry(context, &kt_entry);
 
586
                        ZERO_STRUCT(kt_entry);
 
587
                        found++;
 
588
                }
 
589
        }
 
590
        krb5_kt_end_seq_get(context, keytab, &cursor);
 
591
        ZERO_STRUCT(cursor);
 
592
 
 
593
        /*
 
594
         * Hmmm. There is no "rewind" function for the keytab. This means we have a race condition
 
595
         * where someone else could add entries after we've counted them. Re-open asap to minimise
 
596
         * the race. JRA.
 
597
         */
 
598
        
 
599
        DEBUG(3, ("ads_keytab_create_default: Found %d entries in the keytab.\n", found));
 
600
        if (!found) {
 
601
                goto done;
 
602
        }
 
603
        oldEntries = talloc_array(ctx, char *, found );
 
604
        if (!oldEntries) {
 
605
                DEBUG(1,("ads_keytab_create_default: Failed to allocate space to store the old keytab entries (malloc failed?).\n"));
 
606
                ret = -1;
 
607
                goto done;
 
608
        }
 
609
        memset(oldEntries, '\0', found * sizeof(char *));
 
610
 
 
611
        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
612
        if (ret != KRB5_KT_END && ret != ENOENT ) {
 
613
                while (krb5_kt_next_entry(context, keytab, &kt_entry, &cursor) == 0) {
 
614
                        if (kt_entry.vno != kvno) {
 
615
                                char *ktprinc = NULL;
 
616
                                char *p;
 
617
 
 
618
                                /* This returns a malloc'ed string in ktprinc. */
 
619
                                ret = smb_krb5_unparse_name(oldEntries, context, kt_entry.principal, &ktprinc);
 
620
                                if (ret) {
 
621
                                        DEBUG(1,("smb_krb5_unparse_name failed (%s)\n", error_message(ret)));
 
622
                                        goto done;
 
623
                                }
 
624
                                /*
 
625
                                 * From looking at the krb5 source they don't seem to take locale
 
626
                                 * or mb strings into account. Maybe this is because they assume utf8 ?
 
627
                                 * In this case we may need to convert from utf8 to mb charset here ? JRA.
 
628
                                 */
 
629
                                p = strchr_m(ktprinc, '@');
 
630
                                if (p) {
 
631
                                        *p = '\0';
 
632
                                }
 
633
 
 
634
                                p = strchr_m(ktprinc, '/');
 
635
                                if (p) {
 
636
                                        *p = '\0';
 
637
                                }
 
638
                                for (i = 0; i < found; i++) {
 
639
                                        if (!oldEntries[i]) {
 
640
                                                oldEntries[i] = ktprinc;
 
641
                                                break;
 
642
                                        }
 
643
                                        if (!strcmp(oldEntries[i], ktprinc)) {
 
644
                                                TALLOC_FREE(ktprinc);
 
645
                                                break;
 
646
                                        }
 
647
                                }
 
648
                                if (i == found) {
 
649
                                        TALLOC_FREE(ktprinc);
 
650
                                }
 
651
                        }
 
652
                        smb_krb5_kt_free_entry(context, &kt_entry);
 
653
                        ZERO_STRUCT(kt_entry);
 
654
                }
 
655
                ret = 0;
 
656
                for (i = 0; oldEntries[i]; i++) {
 
657
                        ret |= ads_keytab_add_entry(ads, oldEntries[i]);
 
658
                        TALLOC_FREE(oldEntries[i]);
 
659
                }
 
660
                krb5_kt_end_seq_get(context, keytab, &cursor);
 
661
        }
 
662
        ZERO_STRUCT(cursor);
 
663
 
 
664
done:
 
665
 
 
666
        TALLOC_FREE(oldEntries);
 
667
        TALLOC_FREE(ctx);
 
668
 
 
669
        {
 
670
                krb5_keytab_entry zero_kt_entry;
 
671
                ZERO_STRUCT(zero_kt_entry);
 
672
                if (memcmp(&zero_kt_entry, &kt_entry, sizeof(krb5_keytab_entry))) {
 
673
                        smb_krb5_kt_free_entry(context, &kt_entry);
 
674
                }
 
675
        }
 
676
        {
 
677
                krb5_kt_cursor zero_csr;
 
678
                ZERO_STRUCT(zero_csr);
 
679
                if ((memcmp(&cursor, &zero_csr, sizeof(krb5_kt_cursor)) != 0) && keytab) {
 
680
                        krb5_kt_end_seq_get(context, keytab, &cursor);  
 
681
                }
 
682
        }
 
683
        if (keytab) {
 
684
                krb5_kt_close(context, keytab);
 
685
        }
 
686
        if (context) {
 
687
                krb5_free_context(context);
 
688
        }
 
689
        return ret;
 
690
}
 
691
 
 
692
/**********************************************************************
 
693
 List system keytab.
 
694
***********************************************************************/
 
695
 
 
696
int ads_keytab_list(const char *keytab_name)
 
697
{
 
698
        krb5_error_code ret = 0;
 
699
        krb5_context context = NULL;
 
700
        krb5_keytab keytab = NULL;
 
701
        krb5_kt_cursor cursor;
 
702
        krb5_keytab_entry kt_entry;
 
703
 
 
704
        ZERO_STRUCT(kt_entry);
 
705
        ZERO_STRUCT(cursor);
 
706
 
 
707
        initialize_krb5_error_table();
 
708
        ret = krb5_init_context(&context);
 
709
        if (ret) {
 
710
                DEBUG(1,("ads_keytab_list: could not krb5_init_context: %s\n",error_message(ret)));
 
711
                return ret;
 
712
        }
 
713
 
 
714
        ret = smb_krb5_open_keytab(context, keytab_name, False, &keytab);
 
715
        if (ret) {
 
716
                DEBUG(1,("ads_keytab_list: smb_krb5_open_keytab failed (%s)\n", error_message(ret)));
 
717
                goto out;
 
718
        }
 
719
 
 
720
        ret = krb5_kt_start_seq_get(context, keytab, &cursor);
 
721
        if (ret) {
 
722
                goto out;
 
723
        }
 
724
 
 
725
        printf("Vno  Type        Principal\n");
 
726
 
 
727
        while (krb5_kt_next_entry(context, keytab, &kt_entry, &cursor) == 0) {
 
728
        
 
729
                char *princ_s = NULL;
 
730
                char *etype_s = NULL;
 
731
                krb5_enctype enctype = 0;
 
732
 
 
733
                ret = smb_krb5_unparse_name(talloc_tos(), context, kt_entry.principal, &princ_s);
 
734
                if (ret) {
 
735
                        goto out;
 
736
                }
 
737
 
 
738
                enctype = smb_get_enctype_from_kt_entry(&kt_entry);
 
739
 
 
740
                ret = smb_krb5_enctype_to_string(context, enctype, &etype_s);
 
741
                if (ret) {
 
742
                        if (asprintf(&etype_s, "UNKNOWN: %d\n", enctype) == -1)
 
743
                        {
 
744
                                TALLOC_FREE(princ_s);
 
745
                                goto out;
 
746
                        }
 
747
                }
 
748
 
 
749
                printf("%3d  %s\t\t %s\n", kt_entry.vno, etype_s, princ_s);
 
750
 
 
751
                TALLOC_FREE(princ_s);
 
752
                SAFE_FREE(etype_s);
 
753
 
 
754
                ret = smb_krb5_kt_free_entry(context, &kt_entry);
 
755
                if (ret) {
 
756
                        goto out;
 
757
                }
 
758
        }
 
759
 
 
760
        ret = krb5_kt_end_seq_get(context, keytab, &cursor);
 
761
        if (ret) {
 
762
                goto out;
 
763
        }
 
764
 
 
765
        /* Ensure we don't double free. */
 
766
        ZERO_STRUCT(kt_entry);
 
767
        ZERO_STRUCT(cursor);
 
768
out:
 
769
 
 
770
        {
 
771
                krb5_keytab_entry zero_kt_entry;
 
772
                ZERO_STRUCT(zero_kt_entry);
 
773
                if (memcmp(&zero_kt_entry, &kt_entry, sizeof(krb5_keytab_entry))) {
 
774
                        smb_krb5_kt_free_entry(context, &kt_entry);
 
775
                }
 
776
        }
 
777
        {
 
778
                krb5_kt_cursor zero_csr;
 
779
                ZERO_STRUCT(zero_csr);
 
780
                if ((memcmp(&cursor, &zero_csr, sizeof(krb5_kt_cursor)) != 0) && keytab) {
 
781
                        krb5_kt_end_seq_get(context, keytab, &cursor);  
 
782
                }
 
783
        }
 
784
 
 
785
        if (keytab) {
 
786
                krb5_kt_close(context, keytab);
 
787
        }
 
788
        if (context) {
 
789
                krb5_free_context(context);
 
790
        }
 
791
        return ret;
 
792
}
 
793
 
 
794
#endif /* HAVE_KRB5 */