r4355: More work from the elves on Christmas eve:
[samba.git] / source4 / libcli / auth / kerberos_verify.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) Luke Howard 2003   
7    Copyright (C) Guenther Deschner 2003
8    Copyright (C) Jim McDonough (jmcd@us.ibm.com) 2003
9    
10    This program is free software; you can redistribute it and/or modify
11    it under the terms of the GNU General Public License as published by
12    the Free Software Foundation; either version 2 of the License, or
13    (at your option) any later version.
14    
15    This program is distributed in the hope that it will be useful,
16    but WITHOUT ANY WARRANTY; without even the implied warranty of
17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18    GNU General Public License for more details.
19    
20    You should have received a copy of the GNU General Public License
21    along with this program; if not, write to the Free Software
22    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 */
24
25 #include "includes.h"
26 #include "system/kerberos.h"
27 #include "libcli/auth/kerberos.h"
28 #include "asn_1.h"
29
30 #ifdef HAVE_KRB5
31
32 #if !defined(HAVE_KRB5_PRINC_COMPONENT)
33 const krb5_data *krb5_princ_component(krb5_context, krb5_principal, int );
34 #endif
35 static DATA_BLOB unwrap_pac(TALLOC_CTX *mem_ctx, DATA_BLOB *auth_data)
36 {
37         DATA_BLOB out;
38         DATA_BLOB pac_contents = data_blob(NULL, 0);
39         struct asn1_data data;
40         int data_type;
41         if (!auth_data->length) {
42                 return data_blob(NULL, 0);
43         }
44
45         asn1_load(&data, *auth_data);
46         asn1_start_tag(&data, ASN1_SEQUENCE(0));
47         asn1_start_tag(&data, ASN1_SEQUENCE(0));
48         asn1_start_tag(&data, ASN1_CONTEXT(0));
49         asn1_read_Integer(&data, &data_type);
50         asn1_end_tag(&data);
51         asn1_start_tag(&data, ASN1_CONTEXT(1));
52         asn1_read_OctetString(&data, &pac_contents);
53         asn1_end_tag(&data);
54         asn1_end_tag(&data);
55         asn1_end_tag(&data);
56         asn1_free(&data);
57
58         out = data_blob_talloc(mem_ctx, pac_contents.data, pac_contents.length);
59
60         data_blob_free(&pac_contents);
61
62         return out;
63 }
64
65 /**********************************************************************************
66  Try to verify a ticket using the system keytab... the system keytab has kvno -1 entries, so
67  it's more like what microsoft does... see comment in utils/net_ads.c in the
68  ads_keytab_add_entry function for details.
69 ***********************************************************************************/
70
71 static krb5_error_code ads_keytab_verify_ticket(TALLOC_CTX *mem_ctx, krb5_context context, 
72                                                 krb5_auth_context auth_context,
73                                                 const char *service,
74                                                 const DATA_BLOB *ticket, krb5_data *p_packet, 
75                                                 krb5_ticket **pp_tkt,
76                                                 krb5_keyblock *keyblock)
77 {
78         krb5_error_code ret = 0;
79         BOOL auth_ok = False;
80         krb5_keytab keytab = NULL;
81         char *my_fqdn;
82         fstring my_name;
83         fstring my_Fqdn, my_NAME;
84         char *p_fqdn;
85         char *host_princ_s[18];
86         krb5_principal host_princ;
87         int i;
88
89         ret = krb5_kt_default(context, &keytab);
90         if (ret) {
91                 DEBUG(1, ("ads_keytab_verify_ticket: krb5_kt_default failed (%s)\n", error_message(ret)));
92                 goto out;
93         }
94
95         /* Generate the list of principal names which we expect clients might
96          * want to use for authenticating to the file service. */
97
98         fstrcpy(my_name, lp_netbios_name());
99         strlower_m(my_name);
100
101         fstrcpy(my_NAME, lp_netbios_name());
102         strupper_m(my_NAME);
103
104         my_fqdn = name_to_fqdn(mem_ctx, lp_netbios_name());
105         strlower_m(my_fqdn);
106
107         p_fqdn = strchr_m(my_fqdn, '.');
108         fstrcpy(my_Fqdn, my_NAME);
109         if (p_fqdn) {
110                 fstrcat(my_Fqdn, p_fqdn);
111         }
112
113         asprintf(&host_princ_s[0], "%s$@%s", my_name, lp_realm());
114         asprintf(&host_princ_s[1], "%s$@%s", my_NAME, lp_realm());
115         asprintf(&host_princ_s[2], "host/%s@%s", my_name, lp_realm());
116         asprintf(&host_princ_s[3], "host/%s@%s", my_NAME, lp_realm());
117         asprintf(&host_princ_s[4], "host/%s@%s", my_fqdn, lp_realm());
118         asprintf(&host_princ_s[5], "host/%s@%s", my_Fqdn, lp_realm());
119         asprintf(&host_princ_s[6], "HOST/%s@%s", my_name, lp_realm());
120         asprintf(&host_princ_s[7], "HOST/%s@%s", my_NAME, lp_realm());
121         asprintf(&host_princ_s[8], "HOST/%s@%s", my_fqdn, lp_realm());
122         asprintf(&host_princ_s[9], "HOST/%s@%s", my_Fqdn, lp_realm());
123         asprintf(&host_princ_s[10], "%s/%s@%s", service, my_name, lp_realm());
124         asprintf(&host_princ_s[11], "%s/%s@%s", service, my_NAME, lp_realm());
125         asprintf(&host_princ_s[12], "%s/%s@%s", service, my_fqdn, lp_realm());
126         asprintf(&host_princ_s[13], "%s/%s@%s", service, my_Fqdn, lp_realm());
127         asprintf(&host_princ_s[14], "%s/%s@%s", strupper_talloc(mem_ctx, service), my_name, lp_realm());
128         asprintf(&host_princ_s[15], "%s/%s@%s", strupper_talloc(mem_ctx, service), my_NAME, lp_realm());
129         asprintf(&host_princ_s[16], "%s/%s@%s", strupper_talloc(mem_ctx, service), my_fqdn, lp_realm());
130         asprintf(&host_princ_s[17], "%s/%s@%s", strupper_talloc(mem_ctx, service), my_Fqdn, lp_realm());
131
132         /* Now try to verify the ticket using the key associated with each of
133          * the principals which we think clients will expect us to be
134          * participating as. */
135         for (i = 0; i < sizeof(host_princ_s) / sizeof(host_princ_s[0]); i++) {
136                 host_princ = NULL;
137                 ret = krb5_parse_name(context, host_princ_s[i], &host_princ);
138                 if (ret) {
139                         DEBUG(1, ("ads_keytab_verify_ticket: krb5_parse_name(%s) failed (%s)\n",
140                                 host_princ_s[i], error_message(ret)));
141                         goto out;
142                 }
143                 p_packet->length = ticket->length;
144                 p_packet->data = (krb5_pointer)ticket->data;
145                 *pp_tkt = NULL;
146                 ret = krb5_rd_req(context, &auth_context, p_packet, host_princ, keytab, NULL, pp_tkt);
147                 krb5_free_principal(context, host_princ);
148                 if (ret) {
149                         DEBUG(0, ("krb5_rd_req(%s) failed: %s\n", host_princ_s[i], error_message(ret)));
150                 } else {
151                         DEBUG(10,("krb5_rd_req succeeded for principal %s\n", host_princ_s[i]));
152                         auth_ok = True;
153                         break;
154                 }
155         }
156
157         for (i = 0; i < sizeof(host_princ_s) / sizeof(host_princ_s[0]); i++) {
158                 SAFE_FREE(host_princ_s[i]);
159         }
160
161   out:
162
163         if (keytab) {
164                 krb5_kt_close(context, keytab);
165         }
166
167         return ret;
168 }
169
170 /**********************************************************************************
171  Try to verify a ticket using the secrets.tdb.
172 ***********************************************************************************/
173
174 static krb5_error_code ads_secrets_verify_ticket(TALLOC_CTX *mem_ctx, krb5_context context, 
175                                                  krb5_auth_context auth_context,
176                                                  krb5_principal host_princ,
177                                                  const DATA_BLOB *ticket, krb5_data *p_packet, 
178                                                  krb5_ticket **pp_tkt,
179                                                  krb5_keyblock *keyblock)
180 {
181         krb5_error_code ret = 0;
182         char *password_s = NULL;
183         krb5_data password;
184         krb5_enctype *enctypes = NULL;
185         int i;
186
187         ZERO_STRUCTP(keyblock);
188
189         if (!secrets_init()) {
190                 DEBUG(1,("ads_secrets_verify_ticket: secrets_init failed\n"));
191                 return KRB5_KT_END;
192         }
193
194         password_s = secrets_fetch_machine_password(lp_workgroup());
195         if (!password_s) {
196                 DEBUG(1,("ads_secrets_verify_ticket: failed to fetch machine password\n"));
197                 return KRB5_KT_END;
198         }
199
200         password.data = password_s;
201         password.length = strlen(password_s);
202
203         /* CIFS doesn't use addresses in tickets. This would break NAT. JRA */
204
205         if ((ret = get_kerberos_allowed_etypes(context, &enctypes))) {
206                 DEBUG(1,("ads_secrets_verify_ticket: krb5_get_permitted_enctypes failed (%s)\n", 
207                          error_message(ret)));
208                 goto out;
209         }
210
211         p_packet->length = ticket->length;
212         p_packet->data = (krb5_pointer)ticket->data;
213
214         ret = KRB5_BAD_ENCTYPE;
215         /* We need to setup a auth context with each possible encoding type in turn. */
216         for (i=0;enctypes[i];i++) {
217                 krb5_error_code our_ret;
218                 our_ret = create_kerberos_key_from_string(context, host_princ, &password, keyblock, enctypes[i]);
219                 if (our_ret) {
220                         ret = our_ret;
221                         continue;
222                 }
223
224                 krb5_auth_con_setuseruserkey(context, auth_context, keyblock);
225
226                 our_ret = krb5_rd_req(context, &auth_context, p_packet, 
227                                         NULL,
228                                         NULL, NULL, pp_tkt);
229                 if (!our_ret) {
230                         DEBUG(10,("ads_secrets_verify_ticket: enc type [%u] decrypted message !\n",
231                                 (unsigned int)enctypes[i] ));
232                         ret = our_ret;
233                         break;
234                 }
235
236                 krb5_free_keyblock_contents(context, keyblock);
237
238                 DEBUG((our_ret != KRB5_BAD_ENCTYPE) ? 3 : 10,
239                                 ("ads_secrets_verify_ticket: enc type [%u] failed to decrypt with error %s\n",
240                                 (unsigned int)enctypes[i], error_message(our_ret)));
241
242                 if (our_ret !=  KRB5_BAD_ENCTYPE) {
243                         ret = our_ret;
244                 }
245         }
246
247  out:
248
249         free_kerberos_etypes(context, enctypes);
250         SAFE_FREE(password_s);
251
252         return ret;
253 }
254
255 /**********************************************************************************
256  Verify an incoming ticket and parse out the principal name and 
257  authorization_data if available.
258 ***********************************************************************************/
259
260  NTSTATUS ads_verify_ticket(TALLOC_CTX *mem_ctx, 
261                             krb5_context context,
262                             krb5_auth_context auth_context,
263                             const char *realm, const char *service, 
264                             const DATA_BLOB *ticket, 
265                             char **principal, DATA_BLOB *auth_data,
266                             DATA_BLOB *ap_rep,
267                             krb5_keyblock *keyblock)
268 {
269         NTSTATUS sret = NT_STATUS_LOGON_FAILURE;
270         krb5_data packet;
271         krb5_ticket *tkt = NULL;
272         krb5_rcache rcache = NULL;
273         int ret;
274
275         krb5_principal host_princ = NULL;
276         char *host_princ_s = NULL;
277         BOOL got_replay_mutex = False;
278
279         char *malloc_principal;
280
281         ZERO_STRUCT(packet);
282         ZERO_STRUCTP(auth_data);
283         ZERO_STRUCTP(ap_rep);
284
285         /* This whole process is far more complex than I would
286            like. We have to go through all this to allow us to store
287            the secret internally, instead of using /etc/krb5.keytab */
288
289         asprintf(&host_princ_s, "%s$", lp_netbios_name());
290         strlower_m(host_princ_s);
291         ret = krb5_parse_name(context, host_princ_s, &host_princ);
292         if (ret) {
293                 DEBUG(1,("ads_verify_ticket: krb5_parse_name(%s) failed (%s)\n",
294                                         host_princ_s, error_message(ret)));
295                 goto out;
296         }
297
298
299         /* Lock a mutex surrounding the replay as there is no locking in the MIT krb5
300          * code surrounding the replay cache... */
301
302         if (!grab_server_mutex("replay cache mutex")) {
303                 DEBUG(1,("ads_verify_ticket: unable to protect replay cache with mutex.\n"));
304                 goto out;
305         }
306
307         got_replay_mutex = True;
308
309         /*
310          * JRA. We must set the rcache here. This will prevent replay attacks.
311          */
312
313         ret = krb5_get_server_rcache(context, krb5_princ_component(context, host_princ, 0), &rcache);
314         if (ret) {
315                 DEBUG(1,("ads_verify_ticket: krb5_get_server_rcache failed (%s)\n", error_message(ret)));
316                 goto out;
317         }
318
319         ret = krb5_auth_con_setrcache(context, auth_context, rcache);
320         if (ret) {
321                 DEBUG(1,("ads_verify_ticket: krb5_auth_con_setrcache failed (%s)\n", error_message(ret)));
322                 goto out;
323         }
324
325         ret = ads_keytab_verify_ticket(mem_ctx, context, auth_context, 
326                                        service, ticket, &packet, &tkt, keyblock);
327         if (ret) {
328                 DEBUG(10, ("ads_secrets_verify_ticket: using host principal: [%s]\n", host_princ_s));
329                 ret = ads_secrets_verify_ticket(mem_ctx, context, auth_context,
330                                                 host_princ, ticket, 
331                                                 &packet, &tkt, keyblock);
332         }
333
334         release_server_mutex();
335         got_replay_mutex = False;
336
337         if (ret) {
338                 DEBUG(3,("ads_verify_ticket: krb5_rd_req with auth failed (%s)\n", 
339                          error_message(ret)));
340                 goto out;
341         }
342
343         ret = krb5_mk_rep(context, auth_context, &packet);
344         if (ret) {
345                 DEBUG(3,("ads_verify_ticket: Failed to generate mutual authentication reply (%s)\n",
346                         error_message(ret)));
347                 goto out;
348         }
349
350         *ap_rep = data_blob_talloc(mem_ctx, packet.data, packet.length);
351         SAFE_FREE(packet.data);
352         packet.length = 0;
353
354 #if 0
355         file_save("/tmp/ticket.dat", ticket->data, ticket->length);
356 #endif
357
358         *auth_data = get_auth_data_from_tkt(mem_ctx, tkt);
359
360         *auth_data = unwrap_pac(mem_ctx, auth_data);
361
362 #if 0
363         if (tkt->enc_part2) {
364                 file_save("/tmp/authdata.dat",
365                           tkt->enc_part2->authorization_data[0]->contents,
366                           tkt->enc_part2->authorization_data[0]->length);
367         }
368 #endif
369
370         if ((ret = krb5_unparse_name(context, get_principal_from_tkt(tkt),
371                                      &malloc_principal))) {
372                 DEBUG(3,("ads_verify_ticket: krb5_unparse_name failed (%s)\n", 
373                          error_message(ret)));
374                 sret = NT_STATUS_LOGON_FAILURE;
375                 goto out;
376         }
377
378         *principal = talloc_strdup(mem_ctx, malloc_principal);
379         SAFE_FREE(malloc_principal);
380         if (!principal) {
381                 DEBUG(3,("ads_verify_ticket: talloc_strdup() failed\n"));
382                 sret = NT_STATUS_NO_MEMORY;
383                 goto out;
384         }
385
386         sret = NT_STATUS_OK;
387
388  out:
389
390         if (got_replay_mutex) {
391                 release_server_mutex();
392         }
393
394         if (!NT_STATUS_IS_OK(sret)) {
395                 data_blob_free(auth_data);
396         }
397
398         if (!NT_STATUS_IS_OK(sret)) {
399                 data_blob_free(ap_rep);
400         }
401
402         if (host_princ) {
403                 krb5_free_principal(context, host_princ);
404         }
405
406         if (tkt != NULL) {
407                 krb5_free_ticket(context, tkt);
408         }
409
410         SAFE_FREE(host_princ_s);
411
412         return sret;
413 }
414
415 #endif /* HAVE_KRB5 */