r16100: Patch from Michael Wood <mwood@icts.uct.ac.za>: s/then/than/ for correct...
[kai/samba.git] / source / heimdal / lib / krb5 / init_creds_pw.c
1 /*
2  * Copyright (c) 1997 - 2005 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden). 
4  * All rights reserved. 
5  *
6  * Redistribution and use in source and binary forms, with or without 
7  * modification, are permitted provided that the following conditions 
8  * are met: 
9  *
10  * 1. Redistributions of source code must retain the above copyright 
11  *    notice, this list of conditions and the following disclaimer. 
12  *
13  * 2. Redistributions in binary form must reproduce the above copyright 
14  *    notice, this list of conditions and the following disclaimer in the 
15  *    documentation and/or other materials provided with the distribution. 
16  *
17  * 3. Neither the name of the Institute nor the names of its contributors 
18  *    may be used to endorse or promote products derived from this software 
19  *    without specific prior written permission. 
20  *
21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
31  * SUCH DAMAGE. 
32  */
33
34 #include "krb5_locl.h"
35
36 RCSID("$Id: init_creds_pw.c,v 1.94 2006/04/24 08:49:08 lha Exp $");
37
38 typedef struct krb5_get_init_creds_ctx {
39     krb5_kdc_flags flags;
40     krb5_creds cred;
41     krb5_addresses *addrs;
42     krb5_enctype *etypes;
43     krb5_preauthtype *pre_auth_types;
44     const char *in_tkt_service;
45     unsigned nonce;
46     unsigned pk_nonce;
47
48     krb5_data req_buffer;
49     AS_REQ as_req;
50     int pa_counter;
51
52     const char *password;
53     krb5_s2k_proc key_proc;
54
55     krb5_get_init_creds_req_pac req_pac;
56
57     krb5_pk_init_ctx pk_init_ctx;
58 } krb5_get_init_creds_ctx;
59
60 static krb5_error_code
61 default_s2k_func(krb5_context context, krb5_enctype type, 
62                  krb5_const_pointer keyseed,
63                  krb5_salt salt, krb5_data *s2kparms,
64                  krb5_keyblock **key)
65 {
66     krb5_error_code ret;
67     krb5_data password;
68     krb5_data opaque;
69
70     password.data = rk_UNCONST(keyseed);
71     password.length = strlen(keyseed);
72     if (s2kparms)
73         opaque = *s2kparms;
74     else
75         krb5_data_zero(&opaque);
76         
77     *key = malloc(sizeof(**key));
78     if (*key == NULL)
79         return ENOMEM;
80     ret = krb5_string_to_key_data_salt_opaque(context, type, password,
81                                               salt, opaque, *key);
82     if (ret) {
83         free(*key);
84         *key = NULL;
85     }
86     return ret;
87 }
88
89 static void
90 free_init_creds_ctx(krb5_context context, krb5_get_init_creds_ctx *ctx)
91 {
92     if (ctx->etypes)
93         free(ctx->etypes);
94     if (ctx->pre_auth_types)
95         free (ctx->pre_auth_types);
96     free_AS_REQ(&ctx->as_req);
97     memset(&ctx->as_req, 0, sizeof(ctx->as_req));
98 }
99
100 static int
101 get_config_time (krb5_context context,
102                  const char *realm,
103                  const char *name,
104                  int def)
105 {
106     int ret;
107
108     ret = krb5_config_get_time (context, NULL,
109                                 "realms",
110                                 realm,
111                                 name,
112                                 NULL);
113     if (ret >= 0)
114         return ret;
115     ret = krb5_config_get_time (context, NULL,
116                                 "libdefaults",
117                                 name,
118                                 NULL);
119     if (ret >= 0)
120         return ret;
121     return def;
122 }
123
124 static krb5_error_code
125 init_cred (krb5_context context,
126            krb5_creds *cred,
127            krb5_principal client,
128            krb5_deltat start_time,
129            const char *in_tkt_service,
130            krb5_get_init_creds_opt *options)
131 {
132     krb5_error_code ret;
133     krb5_const_realm client_realm;
134     int tmp;
135     krb5_timestamp now;
136
137     krb5_timeofday (context, &now);
138
139     memset (cred, 0, sizeof(*cred));
140     
141     if (client)
142         krb5_copy_principal(context, client, &cred->client);
143     else {
144         ret = krb5_get_default_principal (context,
145                                           &cred->client);
146         if (ret)
147             goto out;
148     }
149
150     client_realm = krb5_principal_get_realm (context, cred->client);
151
152     if (start_time)
153         cred->times.starttime  = now + start_time;
154
155     if (options->flags & KRB5_GET_INIT_CREDS_OPT_TKT_LIFE)
156         tmp = options->tkt_life;
157     else
158         tmp = 10 * 60 * 60;
159     cred->times.endtime = now + tmp;
160
161     if ((options->flags & KRB5_GET_INIT_CREDS_OPT_RENEW_LIFE) &&
162         options->renew_life > 0) {
163         cred->times.renew_till = now + options->renew_life;
164     }
165
166     if (in_tkt_service) {
167         krb5_realm server_realm;
168
169         ret = krb5_parse_name (context, in_tkt_service, &cred->server);
170         if (ret)
171             goto out;
172         server_realm = strdup (client_realm);
173         free (*krb5_princ_realm(context, cred->server));
174         krb5_princ_set_realm (context, cred->server, &server_realm);
175     } else {
176         ret = krb5_make_principal(context, &cred->server, 
177                                   client_realm, KRB5_TGS_NAME, client_realm,
178                                   NULL);
179         if (ret)
180             goto out;
181     }
182     return 0;
183
184 out:
185     krb5_free_cred_contents (context, cred);
186     return ret;
187 }
188
189 /*
190  * Print a message (str) to the user about the expiration in `lr'
191  */
192
193 static void
194 report_expiration (krb5_context context,
195                    krb5_prompter_fct prompter,
196                    krb5_data *data,
197                    const char *str,
198                    time_t now)
199 {
200     char *p;
201             
202     asprintf (&p, "%s%s", str, ctime(&now));
203     (*prompter) (context, data, NULL, p, 0, NULL);
204     free (p);
205 }
206
207 /*
208  * Parse the last_req data and show it to the user if it's interesting
209  */
210
211 static void
212 print_expire (krb5_context context,
213               krb5_const_realm realm,
214               krb5_kdc_rep *rep,
215               krb5_prompter_fct prompter,
216               krb5_data *data)
217 {
218     int i;
219     LastReq *lr = &rep->enc_part.last_req;
220     krb5_timestamp sec;
221     time_t t;
222     krb5_boolean reported = FALSE;
223
224     krb5_timeofday (context, &sec);
225
226     t = sec + get_config_time (context,
227                                realm,
228                                "warn_pwexpire",
229                                7 * 24 * 60 * 60);
230
231     for (i = 0; i < lr->len; ++i) {
232         if (lr->val[i].lr_value <= t) {
233             switch (abs(lr->val[i].lr_type)) {
234             case LR_PW_EXPTIME :
235                 report_expiration(context, prompter, data,
236                                   "Your password will expire at ",
237                                   lr->val[i].lr_value);
238                 reported = TRUE;
239                 break;
240             case LR_ACCT_EXPTIME :
241                 report_expiration(context, prompter, data,
242                                   "Your account will expire at ",
243                                   lr->val[i].lr_value);
244                 reported = TRUE;
245                 break;
246             }
247         }
248     }
249
250     if (!reported
251         && rep->enc_part.key_expiration
252         && *rep->enc_part.key_expiration <= t) {
253         report_expiration(context, prompter, data,
254                           "Your password/account will expire at ",
255                           *rep->enc_part.key_expiration);
256     }
257 }
258
259 static krb5_error_code
260 get_init_creds_common(krb5_context context,
261                       krb5_creds *creds,
262                       krb5_principal client,
263                       krb5_deltat start_time,
264                       const char *in_tkt_service,
265                       krb5_get_init_creds_opt *options,
266                       krb5_get_init_creds_ctx *ctx)
267 {
268     krb5_get_init_creds_opt default_opt;
269     krb5_error_code ret;
270     krb5_enctype *etypes;
271     krb5_preauthtype *pre_auth_types;
272
273     memset(ctx, 0, sizeof(*ctx));
274
275     if (options == NULL) {
276         krb5_get_init_creds_opt_init (&default_opt);
277         options = &default_opt;
278     }
279
280     if (options->opt_private) {
281         ctx->password = options->opt_private->password;
282         ctx->key_proc = options->opt_private->key_proc;
283         ctx->req_pac = options->opt_private->req_pac;
284         ctx->pk_init_ctx = options->opt_private->pk_init_ctx;
285     } else
286         ctx->req_pac = KRB5_PA_PAC_DONT_CARE;
287
288     if (ctx->key_proc == NULL)
289         ctx->key_proc = default_s2k_func;
290
291     ctx->pre_auth_types = NULL;
292     ctx->flags.i = 0;
293     ctx->addrs = NULL;
294     ctx->etypes = NULL;
295     ctx->pre_auth_types = NULL;
296     ctx->in_tkt_service = in_tkt_service;
297
298     ret = init_cred (context, &ctx->cred, client, start_time,
299                      in_tkt_service, options);
300     if (ret)
301         return ret;
302
303     ctx->flags.i = 0;
304
305     if (options->flags & KRB5_GET_INIT_CREDS_OPT_FORWARDABLE)
306         ctx->flags.b.forwardable = options->forwardable;
307
308     if (options->flags & KRB5_GET_INIT_CREDS_OPT_PROXIABLE)
309         ctx->flags.b.proxiable = options->proxiable;
310
311     if (start_time)
312         ctx->flags.b.postdated = 1;
313     if (ctx->cred.times.renew_till)
314         ctx->flags.b.renewable = 1;
315     if (options->flags & KRB5_GET_INIT_CREDS_OPT_ADDRESS_LIST)
316         ctx->addrs = options->address_list;
317     if (options->flags & KRB5_GET_INIT_CREDS_OPT_ETYPE_LIST) {
318         etypes = malloc((options->etype_list_length + 1)
319                         * sizeof(krb5_enctype));
320         if (etypes == NULL) {
321             krb5_set_error_string(context, "malloc: out of memory");
322             return ENOMEM;
323         }
324         memcpy (etypes, options->etype_list,
325                 options->etype_list_length * sizeof(krb5_enctype));
326         etypes[options->etype_list_length] = ETYPE_NULL;
327         ctx->etypes = etypes;
328     }
329     if (options->flags & KRB5_GET_INIT_CREDS_OPT_PREAUTH_LIST) {
330         pre_auth_types = malloc((options->preauth_list_length + 1)
331                                 * sizeof(krb5_preauthtype));
332         if (pre_auth_types == NULL) {
333             krb5_set_error_string(context, "malloc: out of memory");
334             return ENOMEM;
335         }
336         memcpy (pre_auth_types, options->preauth_list,
337                 options->preauth_list_length * sizeof(krb5_preauthtype));
338         pre_auth_types[options->preauth_list_length] = KRB5_PADATA_NONE;
339         ctx->pre_auth_types = pre_auth_types;
340     }
341     if (options->flags & KRB5_GET_INIT_CREDS_OPT_SALT)
342         ;                       /* XXX */
343     if (options->flags & KRB5_GET_INIT_CREDS_OPT_ANONYMOUS)
344         ctx->flags.b.request_anonymous = options->anonymous;
345     return 0;
346 }
347
348 static krb5_error_code
349 change_password (krb5_context context,
350                  krb5_principal client,
351                  const char *password,
352                  char *newpw,
353                  size_t newpw_sz,
354                  krb5_prompter_fct prompter,
355                  void *data,
356                  krb5_get_init_creds_opt *old_options)
357 {
358     krb5_prompt prompts[2];
359     krb5_error_code ret;
360     krb5_creds cpw_cred;
361     char buf1[BUFSIZ], buf2[BUFSIZ];
362     krb5_data password_data[2];
363     int result_code;
364     krb5_data result_code_string;
365     krb5_data result_string;
366     char *p;
367     krb5_get_init_creds_opt options;
368
369     memset (&cpw_cred, 0, sizeof(cpw_cred));
370
371     krb5_get_init_creds_opt_init (&options);
372     krb5_get_init_creds_opt_set_tkt_life (&options, 60);
373     krb5_get_init_creds_opt_set_forwardable (&options, FALSE);
374     krb5_get_init_creds_opt_set_proxiable (&options, FALSE);
375     if (old_options && old_options->flags & KRB5_GET_INIT_CREDS_OPT_PREAUTH_LIST)
376         krb5_get_init_creds_opt_set_preauth_list (&options,
377                                                   old_options->preauth_list,
378                                                   old_options->preauth_list_length);                                          
379
380     krb5_data_zero (&result_code_string);
381     krb5_data_zero (&result_string);
382
383     ret = krb5_get_init_creds_password (context,
384                                         &cpw_cred,
385                                         client,
386                                         password,
387                                         prompter,
388                                         data,
389                                         0,
390                                         "kadmin/changepw",
391                                         &options);
392     if (ret)
393         goto out;
394
395     for(;;) {
396         password_data[0].data   = buf1;
397         password_data[0].length = sizeof(buf1);
398
399         prompts[0].hidden = 1;
400         prompts[0].prompt = "New password: ";
401         prompts[0].reply  = &password_data[0];
402         prompts[0].type   = KRB5_PROMPT_TYPE_NEW_PASSWORD;
403
404         password_data[1].data   = buf2;
405         password_data[1].length = sizeof(buf2);
406
407         prompts[1].hidden = 1;
408         prompts[1].prompt = "Repeat new password: ";
409         prompts[1].reply  = &password_data[1];
410         prompts[1].type   = KRB5_PROMPT_TYPE_NEW_PASSWORD_AGAIN;
411
412         ret = (*prompter) (context, data, NULL, "Changing password",
413                            2, prompts);
414         if (ret) {
415             memset (buf1, 0, sizeof(buf1));
416             memset (buf2, 0, sizeof(buf2));
417             goto out;
418         }
419
420         if (strcmp (buf1, buf2) == 0)
421             break;
422         memset (buf1, 0, sizeof(buf1));
423         memset (buf2, 0, sizeof(buf2));
424     }
425     
426     ret = krb5_change_password (context,
427                                 &cpw_cred,
428                                 buf1,
429                                 &result_code,
430                                 &result_code_string,
431                                 &result_string);
432     if (ret)
433         goto out;
434     asprintf (&p, "%s: %.*s\n",
435               result_code ? "Error" : "Success",
436               (int)result_string.length,
437               result_string.length > 0 ? (char*)result_string.data : "");
438
439     ret = (*prompter) (context, data, NULL, p, 0, NULL);
440     free (p);
441     if (result_code == 0) {
442         strlcpy (newpw, buf1, newpw_sz);
443         ret = 0;
444     } else {
445         krb5_set_error_string (context, "failed changing password");
446         ret = ENOTTY;
447     }
448
449 out:
450     memset (buf1, 0, sizeof(buf1));
451     memset (buf2, 0, sizeof(buf2));
452     krb5_data_free (&result_string);
453     krb5_data_free (&result_code_string);
454     krb5_free_cred_contents (context, &cpw_cred);
455     return ret;
456 }
457
458 krb5_error_code KRB5_LIB_FUNCTION
459 krb5_keyblock_key_proc (krb5_context context,
460                         krb5_keytype type,
461                         krb5_data *salt,
462                         krb5_const_pointer keyseed,
463                         krb5_keyblock **key)
464 {
465     return krb5_copy_keyblock (context, keyseed, key);
466 }
467
468 krb5_error_code KRB5_LIB_FUNCTION
469 krb5_get_init_creds_keytab(krb5_context context,
470                            krb5_creds *creds,
471                            krb5_principal client,
472                            krb5_keytab keytab,
473                            krb5_deltat start_time,
474                            const char *in_tkt_service,
475                            krb5_get_init_creds_opt *options)
476 {
477     krb5_get_init_creds_ctx ctx;
478     krb5_error_code ret;
479     krb5_keytab_key_proc_args *a;
480     
481     ret = get_init_creds_common(context, creds, client, start_time,
482                                 in_tkt_service, options, &ctx);
483     if (ret)
484         goto out;
485
486     a = malloc (sizeof(*a));
487     if (a == NULL) {
488         krb5_set_error_string(context, "malloc: out of memory");
489         ret = ENOMEM;
490         goto out;
491     }
492     a->principal = ctx.cred.client;
493     a->keytab    = keytab;
494
495     ret = krb5_get_in_cred (context,
496                             ctx.flags.i,
497                             ctx.addrs,
498                             ctx.etypes,
499                             ctx.pre_auth_types,
500                             NULL,
501                             krb5_keytab_key_proc,
502                             a,
503                             NULL,
504                             NULL,
505                             &ctx.cred,
506                             NULL);
507     free (a);
508
509     if (ret == 0 && creds)
510         *creds = ctx.cred;
511     else
512         krb5_free_cred_contents (context, &ctx.cred);
513
514  out:
515     free_init_creds_ctx(context, &ctx);
516     return ret;
517 }
518
519 /*
520  *
521  */
522
523 static krb5_error_code
524 init_creds_init_as_req (krb5_context context,
525                         krb5_kdc_flags opts,
526                         const krb5_creds *creds,
527                         const krb5_addresses *addrs,
528                         const krb5_enctype *etypes,
529                         AS_REQ *a)
530 {
531     krb5_error_code ret;
532
533     memset(a, 0, sizeof(*a));
534
535     a->pvno = 5;
536     a->msg_type = krb_as_req;
537     a->req_body.kdc_options = opts.b;
538     a->req_body.cname = malloc(sizeof(*a->req_body.cname));
539     if (a->req_body.cname == NULL) {
540         ret = ENOMEM;
541         krb5_set_error_string(context, "malloc: out of memory");
542         goto fail;
543     }
544     a->req_body.sname = malloc(sizeof(*a->req_body.sname));
545     if (a->req_body.sname == NULL) {
546         ret = ENOMEM;
547         krb5_set_error_string(context, "malloc: out of memory");
548         goto fail;
549     }
550
551     ret = _krb5_principal2principalname (a->req_body.cname, creds->client);
552     if (ret)
553         goto fail;
554     ret = copy_Realm(&creds->client->realm, &a->req_body.realm);
555     if (ret)
556         goto fail;
557
558     ret = _krb5_principal2principalname (a->req_body.sname, creds->server);
559     if (ret)
560         goto fail;
561
562     if(creds->times.starttime) {
563         a->req_body.from = malloc(sizeof(*a->req_body.from));
564         if (a->req_body.from == NULL) {
565             ret = ENOMEM;
566             krb5_set_error_string(context, "malloc: out of memory");
567             goto fail;
568         }
569         *a->req_body.from = creds->times.starttime;
570     }
571     if(creds->times.endtime){
572         ALLOC(a->req_body.till, 1);
573         *a->req_body.till = creds->times.endtime;
574     }
575     if(creds->times.renew_till){
576         a->req_body.rtime = malloc(sizeof(*a->req_body.rtime));
577         if (a->req_body.rtime == NULL) {
578             ret = ENOMEM;
579             krb5_set_error_string(context, "malloc: out of memory");
580             goto fail;
581         }
582         *a->req_body.rtime = creds->times.renew_till;
583     }
584     a->req_body.nonce = 0;
585     ret = krb5_init_etype (context,
586                            &a->req_body.etype.len,
587                            &a->req_body.etype.val,
588                            etypes);
589     if (ret)
590         goto fail;
591
592     /*
593      * This means no addresses
594      */
595
596     if (addrs && addrs->len == 0) {
597         a->req_body.addresses = NULL;
598     } else {
599         a->req_body.addresses = malloc(sizeof(*a->req_body.addresses));
600         if (a->req_body.addresses == NULL) {
601             ret = ENOMEM;
602             krb5_set_error_string(context, "malloc: out of memory");
603             goto fail;
604         }
605
606         if (addrs)
607             ret = krb5_copy_addresses(context, addrs, a->req_body.addresses);
608         else {
609             ret = krb5_get_all_client_addrs (context, a->req_body.addresses);
610             if(ret == 0 && a->req_body.addresses->len == 0) {
611                 free(a->req_body.addresses);
612                 a->req_body.addresses = NULL;
613             }
614         }
615         if (ret)
616             goto fail;
617     }
618
619     a->req_body.enc_authorization_data = NULL;
620     a->req_body.additional_tickets = NULL;
621
622     a->padata = NULL;
623
624     return 0;
625  fail:
626     free_AS_REQ(a);
627     memset(a, 0, sizeof(*a));
628     return ret;
629 }
630
631 struct pa_info_data {
632     krb5_enctype etype;
633     krb5_salt salt;
634     krb5_data *s2kparams;
635 };
636
637 static void
638 free_paid(krb5_context context, struct pa_info_data *ppaid)
639 {
640     krb5_free_salt(context, ppaid->salt);
641     if (ppaid->s2kparams)
642         krb5_data_free(ppaid->s2kparams);
643 }
644
645
646 static krb5_error_code
647 set_paid(struct pa_info_data *paid, krb5_context context,
648          krb5_enctype etype,
649          krb5_salttype salttype, void *salt_string, size_t salt_len,
650          krb5_data *s2kparams)
651 {
652     paid->etype = etype;
653     paid->salt.salttype = salttype;
654     paid->salt.saltvalue.data = malloc(salt_len + 1);
655     if (paid->salt.saltvalue.data == NULL) {
656         krb5_clear_error_string(context);
657         return ENOMEM;
658     }
659     memcpy(paid->salt.saltvalue.data, salt_string, salt_len);
660     ((char *)paid->salt.saltvalue.data)[salt_len] = '\0';
661     paid->salt.saltvalue.length = salt_len;
662     if (s2kparams) {
663         krb5_error_code ret;
664
665         ret = krb5_copy_data(context, s2kparams, &paid->s2kparams);
666         if (ret) {
667             krb5_clear_error_string(context);
668             krb5_free_salt(context, paid->salt);
669             return ret;
670         }
671     } else
672         paid->s2kparams = NULL;
673
674     return 0;
675 }
676
677 static struct pa_info_data *
678 pa_etype_info2(krb5_context context,
679                const krb5_principal client, 
680                const AS_REQ *asreq,
681                struct pa_info_data *paid, 
682                heim_octet_string *data)
683 {
684     krb5_error_code ret;
685     ETYPE_INFO2 e;
686     size_t sz;
687     int i, j;
688
689     memset(&e, 0, sizeof(e));
690     ret = decode_ETYPE_INFO2(data->data, data->length, &e, &sz);
691     if (ret)
692         goto out;
693     if (e.len == 0)
694         goto out;
695     for (j = 0; j < asreq->req_body.etype.len; j++) {
696         for (i = 0; i < e.len; i++) {
697             if (asreq->req_body.etype.val[j] == e.val[i].etype) {
698                 krb5_salt salt;
699                 if (e.val[i].salt == NULL)
700                     ret = krb5_get_pw_salt(context, client, &salt);
701                 else {
702                     salt.saltvalue.data = *e.val[i].salt;
703                     salt.saltvalue.length = strlen(*e.val[i].salt);
704                     ret = 0;
705                 }
706                 if (ret == 0)
707                     ret = set_paid(paid, context, e.val[i].etype,
708                                    KRB5_PW_SALT,
709                                    salt.saltvalue.data, 
710                                    salt.saltvalue.length,
711                                    e.val[i].s2kparams);
712                 if (e.val[i].salt == NULL)
713                     krb5_free_salt(context, salt);
714                 if (ret == 0) {
715                         free_ETYPE_INFO2(&e);
716                         return paid;
717                 }
718             }
719         }
720     }
721  out:
722     free_ETYPE_INFO2(&e);
723     return NULL;
724 }
725
726 static struct pa_info_data *
727 pa_etype_info(krb5_context context,
728               const krb5_principal client, 
729               const AS_REQ *asreq,
730               struct pa_info_data *paid,
731               heim_octet_string *data)
732 {
733     krb5_error_code ret;
734     ETYPE_INFO e;
735     size_t sz;
736     int i, j;
737
738     memset(&e, 0, sizeof(e));
739     ret = decode_ETYPE_INFO(data->data, data->length, &e, &sz);
740     if (ret)
741         goto out;
742     if (e.len == 0)
743         goto out;
744     for (j = 0; j < asreq->req_body.etype.len; j++) {
745         for (i = 0; i < e.len; i++) {
746             if (asreq->req_body.etype.val[j] == e.val[i].etype) {
747                 krb5_salt salt;
748                 salt.salttype = KRB5_PW_SALT;
749                 if (e.val[i].salt == NULL)
750                     ret = krb5_get_pw_salt(context, client, &salt);
751                 else {
752                     salt.saltvalue = *e.val[i].salt;
753                     ret = 0;
754                 }
755                 if (e.val[i].salttype)
756                     salt.salttype = *e.val[i].salttype;
757                 if (ret == 0) {
758                     ret = set_paid(paid, context, e.val[i].etype,
759                                    salt.salttype,
760                                    salt.saltvalue.data, 
761                                    salt.saltvalue.length,
762                                    NULL);
763                     if (e.val[i].salt == NULL)
764                         krb5_free_salt(context, salt);
765                 }
766                 if (ret == 0) {
767                     free_ETYPE_INFO(&e);
768                     return paid;
769                 }
770             }
771         }
772     }
773  out:
774     free_ETYPE_INFO(&e);
775     return NULL;
776 }
777
778 static struct pa_info_data *
779 pa_pw_or_afs3_salt(krb5_context context,
780                    const krb5_principal client, 
781                    const AS_REQ *asreq,
782                    struct pa_info_data *paid,
783                    heim_octet_string *data)
784 {
785     krb5_error_code ret;
786     if (paid->etype == ENCTYPE_NULL)
787         return NULL;
788     ret = set_paid(paid, context, 
789                    paid->etype,
790                    paid->salt.salttype,
791                    data->data, 
792                    data->length,
793                    NULL);
794     if (ret)
795         return NULL;
796     return paid;
797 }
798
799
800 struct pa_info {
801     krb5_preauthtype type;
802     struct pa_info_data *(*salt_info)(krb5_context,
803                                       const krb5_principal, 
804                                       const AS_REQ *,
805                                       struct pa_info_data *, 
806                                       heim_octet_string *);
807 };
808
809 static struct pa_info pa_prefs[] = {
810     { KRB5_PADATA_ETYPE_INFO2, pa_etype_info2 },
811     { KRB5_PADATA_ETYPE_INFO, pa_etype_info },
812     { KRB5_PADATA_PW_SALT, pa_pw_or_afs3_salt },
813     { KRB5_PADATA_AFS3_SALT, pa_pw_or_afs3_salt }
814 };
815     
816 static PA_DATA *
817 find_pa_data(const METHOD_DATA *md, int type)
818 {
819     int i;
820     for (i = 0; i < md->len; i++)
821         if (md->val[i].padata_type == type)
822             return &md->val[i];
823     return NULL;
824 }
825
826 static struct pa_info_data *
827 process_pa_info(krb5_context context, 
828                 const krb5_principal client, 
829                 const AS_REQ *asreq,
830                 struct pa_info_data *paid,
831                 METHOD_DATA *md)
832 {
833     struct pa_info_data *p = NULL;
834     int i;
835
836     for (i = 0; p == NULL && i < sizeof(pa_prefs)/sizeof(pa_prefs[0]); i++) {
837         PA_DATA *pa = find_pa_data(md, pa_prefs[i].type);
838         if (pa == NULL)
839             continue;
840         paid->salt.salttype = pa_prefs[i].type;
841         p = (*pa_prefs[i].salt_info)(context, client, asreq,
842                                      paid, &pa->padata_value);
843     }
844     return p;
845 }
846
847 static krb5_error_code
848 make_pa_enc_timestamp(krb5_context context, METHOD_DATA *md, 
849                       krb5_enctype etype, krb5_keyblock *key)
850 {
851     PA_ENC_TS_ENC p;
852     unsigned char *buf;
853     size_t buf_size;
854     size_t len;
855     EncryptedData encdata;
856     krb5_error_code ret;
857     int32_t usec;
858     int usec2;
859     krb5_crypto crypto;
860     
861     krb5_us_timeofday (context, &p.patimestamp, &usec);
862     usec2         = usec;
863     p.pausec      = &usec2;
864
865     ASN1_MALLOC_ENCODE(PA_ENC_TS_ENC, buf, buf_size, &p, &len, ret);
866     if (ret)
867         return ret;
868     if(buf_size != len)
869         krb5_abortx(context, "internal error in ASN.1 encoder");
870
871     ret = krb5_crypto_init(context, key, 0, &crypto);
872     if (ret) {
873         free(buf);
874         return ret;
875     }
876     ret = krb5_encrypt_EncryptedData(context, 
877                                      crypto,
878                                      KRB5_KU_PA_ENC_TIMESTAMP,
879                                      buf,
880                                      len,
881                                      0,
882                                      &encdata);
883     free(buf);
884     krb5_crypto_destroy(context, crypto);
885     if (ret)
886         return ret;
887                     
888     ASN1_MALLOC_ENCODE(EncryptedData, buf, buf_size, &encdata, &len, ret);
889     free_EncryptedData(&encdata);
890     if (ret)
891         return ret;
892     if(buf_size != len)
893         krb5_abortx(context, "internal error in ASN.1 encoder");
894
895     ret = krb5_padata_add(context, md, KRB5_PADATA_ENC_TIMESTAMP, buf, len);
896     if (ret)
897         free(buf);
898     return ret;
899 }
900
901 static krb5_error_code
902 add_enc_ts_padata(krb5_context context,
903                   METHOD_DATA *md, 
904                   krb5_principal client,
905                   krb5_s2k_proc key_proc,
906                   krb5_const_pointer keyseed,
907                   krb5_enctype *enctypes,
908                   unsigned netypes,
909                   krb5_salt *salt,
910                   krb5_data *s2kparams)
911 {
912     krb5_error_code ret;
913     krb5_salt salt2;
914     krb5_enctype *ep;
915     int i;
916     
917     if(salt == NULL) {
918         /* default to standard salt */
919         ret = krb5_get_pw_salt (context, client, &salt2);
920         salt = &salt2;
921     }
922     if (!enctypes) {
923         enctypes = context->etypes;
924         netypes = 0;
925         for (ep = enctypes; *ep != ETYPE_NULL; ep++)
926             netypes++;
927     }
928
929     for (i = 0; i < netypes; ++i) {
930         krb5_keyblock *key;
931
932         ret = (*key_proc)(context, enctypes[i], keyseed,
933                           *salt, s2kparams, &key);
934         if (ret)
935             continue;
936         ret = make_pa_enc_timestamp (context, md, enctypes[i], key);
937         krb5_free_keyblock (context, key);
938         if (ret)
939             return ret;
940     }
941     if(salt == &salt2)
942         krb5_free_salt(context, salt2);
943     return 0;
944 }
945
946 static krb5_error_code
947 pa_data_to_md_ts_enc(krb5_context context,
948                      const AS_REQ *a,
949                      const krb5_principal client,
950                      krb5_get_init_creds_ctx *ctx,
951                      struct pa_info_data *ppaid,
952                      METHOD_DATA *md)
953 {
954     if (ctx->key_proc == NULL || ctx->password == NULL)
955         return 0;
956
957     if (ppaid) {
958         add_enc_ts_padata(context, md, client, 
959                           ctx->key_proc, ctx->password,
960                           &ppaid->etype, 1,
961                           &ppaid->salt, ppaid->s2kparams);
962     } else {
963         krb5_salt salt;
964         
965         /* make a v5 salted pa-data */
966         add_enc_ts_padata(context, md, client, 
967                           ctx->key_proc, ctx->password,
968                           a->req_body.etype.val, a->req_body.etype.len, 
969                           NULL, NULL);
970         
971         /* make a v4 salted pa-data */
972         salt.salttype = KRB5_PW_SALT;
973         krb5_data_zero(&salt.saltvalue);
974         add_enc_ts_padata(context, md, client, 
975                           ctx->key_proc, ctx->password, 
976                           a->req_body.etype.val, a->req_body.etype.len, 
977                           &salt, NULL);
978     }
979     return 0;
980 }
981
982 static krb5_error_code
983 pa_data_to_key_plain(krb5_context context,
984                      const krb5_principal client,
985                      krb5_get_init_creds_ctx *ctx,
986                      krb5_salt salt,
987                      krb5_data *s2kparams,
988                      krb5_enctype etype,
989                      krb5_keyblock **key)
990 {
991     krb5_error_code ret;
992
993     ret = (*ctx->key_proc)(context, etype, ctx->password,
994                            salt, s2kparams, key);
995     return ret;
996 }
997
998
999 static krb5_error_code
1000 pa_data_to_md_pkinit(krb5_context context,
1001                      const AS_REQ *a,
1002                      const krb5_principal client,
1003                      krb5_get_init_creds_ctx *ctx,
1004                      METHOD_DATA *md)
1005 {
1006     if (ctx->pk_init_ctx == NULL)
1007         return 0;
1008 #ifdef PKINIT
1009     return _krb5_pk_mk_padata(context,
1010                              ctx->pk_init_ctx,
1011                              &a->req_body,
1012                              ctx->pk_nonce,
1013                              md);
1014 #else
1015     krb5_set_error_string(context, "no support for PKINIT compiled in");
1016     return EINVAL;
1017 #endif
1018 }
1019
1020 static krb5_error_code
1021 pa_data_add_pac_request(krb5_context context,
1022                         krb5_get_init_creds_ctx *ctx,
1023                         METHOD_DATA *md)
1024 {
1025     size_t len, length;
1026     krb5_error_code ret;
1027     PA_PAC_REQUEST req;
1028     void *buf;
1029     
1030     switch (ctx->req_pac) {
1031     case KRB5_PA_PAC_DONT_CARE:
1032         return 0; /* don't bother */
1033     case KRB5_PA_PAC_REQ_TRUE:
1034         req.include_pac = 1;
1035         break;
1036     case KRB5_PA_PAC_REQ_FALSE:
1037         req.include_pac = 0;
1038     }   
1039
1040     ASN1_MALLOC_ENCODE(PA_PAC_REQUEST, buf, length, 
1041                        &req, &len, ret);
1042     if (ret)
1043         return ret;
1044     if(len != length)
1045         krb5_abortx(context, "internal error in ASN.1 encoder");
1046
1047     ret = krb5_padata_add(context, md, KRB5_PADATA_PA_PAC_REQUEST, buf, len);
1048     if (ret)
1049         free(buf);
1050
1051     return 0;
1052 }
1053
1054 /*
1055  * Assumes caller always will free `out_md', even on error.
1056  */
1057
1058 static krb5_error_code
1059 process_pa_data_to_md(krb5_context context,
1060                       const krb5_creds *creds,
1061                       const AS_REQ *a,
1062                       krb5_get_init_creds_ctx *ctx,
1063                       METHOD_DATA *in_md,
1064                       METHOD_DATA **out_md,
1065                       krb5_prompter_fct prompter,
1066                       void *prompter_data)
1067 {
1068     krb5_error_code ret;
1069
1070     ALLOC(*out_md, 1);
1071     if (*out_md == NULL) {
1072         krb5_set_error_string(context, "malloc: out of memory");
1073         return ENOMEM;
1074     }
1075     (*out_md)->len = 0;
1076     (*out_md)->val = NULL;
1077     
1078     if (in_md->len != 0) {
1079         struct pa_info_data paid, *ppaid;
1080
1081         memset(&paid, 0, sizeof(paid));
1082
1083         paid.etype = ENCTYPE_NULL;
1084         ppaid = process_pa_info(context, creds->client, a, &paid, in_md);
1085
1086         pa_data_to_md_ts_enc(context, a, creds->client, ctx, ppaid, *out_md);
1087         if (ppaid)
1088             free_paid(context, ppaid);
1089     }
1090
1091     pa_data_add_pac_request(context, ctx, *out_md);
1092     ret = pa_data_to_md_pkinit(context, a, creds->client, ctx, *out_md);
1093     if (ret)
1094         return ret;
1095
1096     if ((*out_md)->len == 0) {
1097         free(*out_md);
1098         *out_md = NULL;
1099     }
1100
1101     return 0;
1102 }
1103
1104 static krb5_error_code
1105 process_pa_data_to_key(krb5_context context,
1106                        krb5_get_init_creds_ctx *ctx,
1107                        krb5_creds *creds,
1108                        AS_REQ *a,
1109                        krb5_kdc_rep *rep,
1110                        const krb5_krbhst_info *hi,
1111                        krb5_keyblock **key)
1112 {
1113     struct pa_info_data paid, *ppaid = NULL;
1114     krb5_error_code ret;
1115     krb5_enctype etype;
1116     PA_DATA *pa;
1117
1118     memset(&paid, 0, sizeof(paid));
1119
1120     etype = rep->kdc_rep.enc_part.etype;
1121
1122     if (rep->kdc_rep.padata) {
1123         paid.etype = etype;
1124         ppaid = process_pa_info(context, creds->client, a, &paid, 
1125                                 rep->kdc_rep.padata);
1126     }
1127     if (ppaid == NULL) {
1128         ret = krb5_get_pw_salt (context, creds->client, &paid.salt);
1129         if (ret)
1130             return ret;
1131         paid.etype = etype;
1132         paid.s2kparams = NULL;
1133     }
1134
1135     pa = NULL;
1136     if (rep->kdc_rep.padata) {
1137         int idx = 0;
1138         pa = krb5_find_padata(rep->kdc_rep.padata->val, 
1139                               rep->kdc_rep.padata->len,
1140                               KRB5_PADATA_PK_AS_REP,
1141                               &idx);
1142         if (pa == NULL) {
1143             idx = 0;
1144             pa = krb5_find_padata(rep->kdc_rep.padata->val, 
1145                                   rep->kdc_rep.padata->len,
1146                                   KRB5_PADATA_PK_AS_REP_19,
1147                                   &idx);
1148         }
1149     }
1150     if (pa && ctx->pk_init_ctx) {
1151 #ifdef PKINIT
1152         ret = _krb5_pk_rd_pa_reply(context,
1153                                    a->req_body.realm,
1154                                    ctx->pk_init_ctx,
1155                                    etype,
1156                                    hi,
1157                                    ctx->pk_nonce,
1158                                    &ctx->req_buffer,
1159                                    pa,
1160                                    key);
1161 #else
1162         krb5_set_error_string(context, "no support for PKINIT compiled in");
1163         ret = EINVAL;
1164 #endif
1165     } else if (ctx->password)
1166         ret = pa_data_to_key_plain(context, creds->client, ctx, 
1167                                    paid.salt, paid.s2kparams, etype, key);
1168     else {
1169         krb5_set_error_string(context, "No usable pa data type");
1170         ret = EINVAL;
1171     }
1172
1173     free_paid(context, &paid);
1174     return ret;
1175 }
1176
1177 static krb5_error_code
1178 init_cred_loop(krb5_context context,
1179                const krb5_get_init_creds_opt *init_cred_opts,
1180                const krb5_prompter_fct prompter,
1181                void *prompter_data,
1182                krb5_get_init_creds_ctx *ctx,
1183                krb5_creds *creds,
1184                krb5_kdc_rep *ret_as_reply)
1185 {
1186     krb5_error_code ret;
1187     krb5_kdc_rep rep;
1188     METHOD_DATA md;
1189     krb5_data resp;
1190     size_t len;
1191     size_t size;
1192     int send_to_kdc_flags = 0;
1193     krb5_krbhst_info *hi = NULL;
1194
1195
1196     memset(&md, 0, sizeof(md));
1197     memset(&rep, 0, sizeof(rep));
1198
1199     if (ret_as_reply)
1200         memset(ret_as_reply, 0, sizeof(*ret_as_reply));
1201
1202     ret = init_creds_init_as_req(context, ctx->flags, creds,
1203                                  ctx->addrs, ctx->etypes, &ctx->as_req);
1204     if (ret)
1205         return ret;
1206
1207     /* Set a new nonce. */
1208     krb5_generate_random_block (&ctx->nonce, sizeof(ctx->nonce));
1209     ctx->nonce &= 0xffffffff;
1210     /* XXX these just needs to be the same when using Windows PK-INIT */
1211     ctx->pk_nonce = ctx->nonce;
1212
1213     /*
1214      * Increase counter when we want other pre-auth types than
1215      * KRB5_PA_ENC_TIMESTAMP.
1216      */
1217 #define MAX_PA_COUNTER 3 
1218
1219     ctx->pa_counter = 0;
1220     while (ctx->pa_counter < MAX_PA_COUNTER) {
1221
1222         ctx->pa_counter++;
1223
1224         if (ctx->as_req.padata) {
1225             free_METHOD_DATA(ctx->as_req.padata);
1226             free(ctx->as_req.padata);
1227             ctx->as_req.padata = NULL;
1228         }
1229
1230         /* Set a new nonce. */
1231         ctx->as_req.req_body.nonce = ctx->nonce;
1232
1233         /* fill_in_md_data */
1234         ret = process_pa_data_to_md(context, creds, &ctx->as_req, ctx,
1235                                     &md, &ctx->as_req.padata,
1236                                     prompter, prompter_data);
1237         if (ret)
1238             goto out;
1239
1240         krb5_data_free(&ctx->req_buffer);
1241
1242         ASN1_MALLOC_ENCODE(AS_REQ, 
1243                            ctx->req_buffer.data, ctx->req_buffer.length, 
1244                            &ctx->as_req, &len, ret);
1245         if (ret)
1246             goto out;
1247         if(len != ctx->req_buffer.length)
1248             krb5_abortx(context, "internal error in ASN.1 encoder");
1249
1250         ret = krb5_sendto_kdc_flags (context, &ctx->req_buffer, 
1251                                      &creds->client->realm, &resp,
1252                                      send_to_kdc_flags);
1253         if (ret)
1254             goto out;
1255
1256         memset (&rep, 0, sizeof(rep));
1257         ret = decode_AS_REP(resp.data, resp.length, &rep.kdc_rep, &size);
1258         if (ret == 0) {
1259             krb5_data_free(&resp);
1260             krb5_clear_error_string(context);
1261             break;
1262         } else {
1263             /* let's try to parse it as a KRB-ERROR */
1264             KRB_ERROR error;
1265
1266             ret = krb5_rd_error(context, &resp, &error);
1267             if(ret && resp.data && ((char*)resp.data)[0] == 4)
1268                 ret = KRB5KRB_AP_ERR_V4_REPLY;
1269             krb5_data_free(&resp);
1270             if (ret)
1271                 goto out;
1272
1273             ret = krb5_error_from_rd_error(context, &error, creds);
1274
1275             /*
1276              * If no preauth was set and KDC requires it, give it one
1277              * more try.
1278              */
1279
1280             if (ret == KRB5KDC_ERR_PREAUTH_REQUIRED) {
1281                 free_METHOD_DATA(&md);
1282                 memset(&md, 0, sizeof(md));
1283
1284                 if (error.e_data) {
1285                     ret = decode_METHOD_DATA(error.e_data->data, 
1286                                              error.e_data->length, 
1287                                              &md, 
1288                                              NULL);
1289                     if (ret)
1290                         krb5_set_error_string(context,
1291                                               "failed to decode METHOD DATA");
1292                 } else {
1293                     /* XXX guess what the server want here add add md */
1294                 }
1295                 krb5_free_error_contents(context, &error);
1296                 if (ret)
1297                     goto out;
1298             } else if (ret == KRB5KRB_ERR_RESPONSE_TOO_BIG) {
1299                 if (send_to_kdc_flags & KRB5_KRBHST_FLAGS_LARGE_MSG) {
1300                     if (ret_as_reply)
1301                         rep.error = error;
1302                     else
1303                         krb5_free_error_contents(context, &error);
1304                     goto out;
1305                 }
1306                 krb5_free_error_contents(context, &error);
1307                 send_to_kdc_flags |= KRB5_KRBHST_FLAGS_LARGE_MSG;
1308             } else {
1309                 if (ret_as_reply)
1310                     rep.error = error;
1311                 else
1312                     krb5_free_error_contents(context, &error);
1313                 goto out;
1314             }
1315         }
1316     }
1317
1318     {
1319         krb5_keyblock *key = NULL;
1320
1321         ret = process_pa_data_to_key(context, ctx, creds, 
1322                                      &ctx->as_req, &rep, hi, &key);
1323         if (ret)
1324             goto out;
1325         
1326         ret = _krb5_extract_ticket(context,
1327                                    &rep,
1328                                    creds,
1329                                    key,
1330                                    NULL,
1331                                    KRB5_KU_AS_REP_ENC_PART,
1332                                    NULL,
1333                                    ctx->nonce,
1334                                    FALSE,
1335                                    ctx->flags.b.request_anonymous,
1336                                    NULL,
1337                                    NULL);
1338         krb5_free_keyblock(context, key);
1339     }
1340 out:
1341     krb5_data_free(&ctx->req_buffer);
1342     free_METHOD_DATA(&md);
1343     memset(&md, 0, sizeof(md));
1344
1345     if (ret == 0 && ret_as_reply)
1346         *ret_as_reply = rep;
1347     else
1348         krb5_free_kdc_rep (context, &rep);
1349     return ret;
1350 }
1351
1352 krb5_error_code KRB5_LIB_FUNCTION
1353 krb5_get_init_creds(krb5_context context,
1354                     krb5_creds *creds,
1355                     krb5_principal client,
1356                     krb5_prompter_fct prompter,
1357                     void *data,
1358                     krb5_deltat start_time,
1359                     const char *in_tkt_service,
1360                     krb5_get_init_creds_opt *options)
1361 {
1362     krb5_get_init_creds_ctx ctx;
1363     krb5_kdc_rep kdc_reply;
1364     krb5_error_code ret;
1365     char buf[BUFSIZ];
1366     int done;
1367
1368     memset(&kdc_reply, 0, sizeof(kdc_reply));
1369
1370     ret = get_init_creds_common(context, creds, client, start_time,
1371                                 in_tkt_service, options, &ctx);
1372     if (ret)
1373         goto out;
1374
1375     done = 0;
1376     while(!done) {
1377         memset(&kdc_reply, 0, sizeof(kdc_reply));
1378
1379         ret = init_cred_loop(context,
1380                              options,
1381                              prompter,
1382                              data,
1383                              &ctx,
1384                              &ctx.cred,
1385                              &kdc_reply);
1386         
1387         switch (ret) {
1388         case 0 :
1389             done = 1;
1390             break;
1391         case KRB5KDC_ERR_KEY_EXPIRED :
1392             /* try to avoid recursion */
1393
1394             /* don't try to change password where there where none */
1395             if (prompter == NULL || ctx.password == NULL)
1396                 goto out;
1397
1398             krb5_clear_error_string (context);
1399
1400             if (ctx.in_tkt_service != NULL
1401                 && strcmp (ctx.in_tkt_service, "kadmin/changepw") == 0)
1402                 goto out;
1403
1404             ret = change_password (context,
1405                                    client,
1406                                    ctx.password,
1407                                    buf,
1408                                    sizeof(buf),
1409                                    prompter,
1410                                    data,
1411                                    options);
1412             if (ret)
1413                 goto out;
1414             ctx.password = buf;
1415             break;
1416         default:
1417             goto out;
1418         }
1419     }
1420
1421     if (prompter)
1422         print_expire (context,
1423                       krb5_principal_get_realm (context, ctx.cred.client),
1424                       &kdc_reply,
1425                       prompter,
1426                       data);
1427
1428  out:
1429     memset (buf, 0, sizeof(buf));
1430     free_init_creds_ctx(context, &ctx);
1431     krb5_free_kdc_rep (context, &kdc_reply);
1432     if (ret == 0)
1433         *creds = ctx.cred;
1434     else
1435         krb5_free_cred_contents (context, &ctx.cred);
1436
1437     return ret;
1438 }
1439
1440 krb5_error_code KRB5_LIB_FUNCTION
1441 krb5_get_init_creds_password(krb5_context context,
1442                              krb5_creds *creds,
1443                              krb5_principal client,
1444                              const char *password,
1445                              krb5_prompter_fct prompter,
1446                              void *data,
1447                              krb5_deltat start_time,
1448                              const char *in_tkt_service,
1449                              krb5_get_init_creds_opt *in_options)
1450 {
1451     krb5_get_init_creds_opt *options;
1452     char buf[BUFSIZ];
1453     krb5_error_code ret;
1454
1455     if (in_options == NULL)
1456         ret = krb5_get_init_creds_opt_alloc(context, &options);
1457     else
1458         ret = _krb5_get_init_creds_opt_copy(context, in_options, &options);
1459     if (ret)
1460         return ret;
1461
1462     if (password == NULL &&
1463         options->opt_private->password == NULL &&
1464         options->opt_private->pk_init_ctx == NULL)
1465     {
1466         krb5_prompt prompt;
1467         krb5_data password_data;
1468         char *p, *q;
1469
1470         krb5_unparse_name (context, client, &p);
1471         asprintf (&q, "%s's Password: ", p);
1472         free (p);
1473         prompt.prompt = q;
1474         password_data.data   = buf;
1475         password_data.length = sizeof(buf);
1476         prompt.hidden = 1;
1477         prompt.reply  = &password_data;
1478         prompt.type   = KRB5_PROMPT_TYPE_PASSWORD;
1479
1480         ret = (*prompter) (context, data, NULL, NULL, 1, &prompt);
1481         free (q);
1482         if (ret) {
1483             memset (buf, 0, sizeof(buf));
1484             krb5_get_init_creds_opt_free(options);
1485             ret = KRB5_LIBOS_PWDINTR;
1486             krb5_clear_error_string (context);
1487             return ret;
1488         }
1489         password = password_data.data;
1490     }
1491
1492     if (options->opt_private->password == NULL) {
1493         ret = krb5_get_init_creds_opt_set_pa_password(context, options,
1494                                                       password, NULL);
1495         if (ret) {
1496             krb5_get_init_creds_opt_free(options);
1497             memset(buf, 0, sizeof(buf));
1498             return ret;
1499         }
1500     }
1501
1502     ret = krb5_get_init_creds(context, creds, client, prompter,
1503                               data, start_time, in_tkt_service, options);
1504     krb5_get_init_creds_opt_free(options);
1505     memset(buf, 0, sizeof(buf));
1506     return ret;
1507 }
1508
1509 static krb5_error_code
1510 init_creds_keyblock_key_proc (krb5_context context,
1511                               krb5_enctype type,
1512                               krb5_salt salt,
1513                               krb5_const_pointer keyseed,
1514                               krb5_keyblock **key)
1515 {
1516     return krb5_copy_keyblock (context, keyseed, key);
1517 }
1518
1519 krb5_error_code KRB5_LIB_FUNCTION
1520 krb5_get_init_creds_keyblock(krb5_context context,
1521                              krb5_creds *creds,
1522                              krb5_principal client,
1523                              krb5_keyblock *keyblock,
1524                              krb5_deltat start_time,
1525                              const char *in_tkt_service,
1526                              krb5_get_init_creds_opt *options)
1527 {
1528     struct krb5_get_init_creds_ctx ctx;
1529     krb5_error_code ret;
1530     
1531     ret = get_init_creds_common(context, creds, client, start_time,
1532                                 in_tkt_service, options, &ctx);
1533     if (ret)
1534         goto out;
1535
1536     ret = krb5_get_in_cred (context,
1537                             ctx.flags.i,
1538                             ctx.addrs,
1539                             ctx.etypes,
1540                             ctx.pre_auth_types,
1541                             NULL,
1542                             init_creds_keyblock_key_proc,
1543                             keyblock,
1544                             NULL,
1545                             NULL,
1546                             &ctx.cred,
1547                             NULL);
1548
1549     if (ret == 0 && creds)
1550         *creds = ctx.cred;
1551     else
1552         krb5_free_cred_contents (context, &ctx.cred);
1553
1554  out:
1555     free_init_creds_ctx(context, &ctx);
1556     return ret;
1557 }