d823e0219dbb58f77869858fdfa82182eb37872b
[idra/samba.git] / source4 / auth / kerberos / keytab_copy.c
1 /*
2  * Copyright (c) 1997-2004 Kungliga Tekniska Högskolan
3  * (Royal Institute of Technology, Stockholm, Sweden).
4  * Copyright (c) 2011 Andrew Bartlett
5  *
6  * All rights reserved.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  *
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  *
15  * 2. Redistributions in binary form must reproduce the above copyright
16  *    notice, this list of conditions and the following disclaimer in the
17  *    documentation and/or other materials provided with the distribution.
18  *
19  * 3. Neither the name of the Institute nor the names of its contributors
20  *    may be used to endorse or promote products derived from this software
21  *    without specific prior written permission.
22  *
23  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
24  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
27  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
33  * SUCH DAMAGE.
34  */
35
36 #include "includes.h"
37 #include "system/kerberos.h"
38 #include "auth/kerberos/kerberos.h"
39
40 static krb5_boolean
41 compare_keyblock(const krb5_keyblock *a, const krb5_keyblock *b)
42 {
43     if(a->keytype != b->keytype ||
44        a->keyvalue.length != b->keyvalue.length ||
45        memcmp(a->keyvalue.data, b->keyvalue.data, a->keyvalue.length) != 0)
46         return FALSE;
47     return TRUE;
48 }
49
50 static krb5_error_code copy_one_entry(krb5_context context, 
51                                       krb5_keytab src_keytab, krb5_keytab dst_keytab, krb5_keytab_entry entry) 
52 {
53     krb5_error_code ret;
54     krb5_keytab_entry dummy;
55
56     char *name_str;
57     char *etype_str;
58     ret = krb5_unparse_name (context, entry.principal, &name_str);
59     if(ret) {
60         krb5_set_error_message(context, ret, "krb5_unparse_name");
61         name_str = NULL; /* XXX */
62         return ret;
63     }
64     ret = krb5_enctype_to_string(context, entry.keyblock.keytype, &etype_str);
65     if(ret) {
66         krb5_set_error_message(context, ret, "krb5_enctype_to_string");
67         etype_str = NULL; /* XXX */
68         return ret;
69     }
70     ret = krb5_kt_get_entry(context, dst_keytab,
71                             entry.principal,
72                             entry.vno,
73                             entry.keyblock.keytype,
74                             &dummy);
75     if(ret == 0) {
76         /* this entry is already in the new keytab, so no need to
77            copy it; if the keyblocks are not the same, something
78            is weird, so complain about that */
79         if(!compare_keyblock(&entry.keyblock, &dummy.keyblock)) {
80                 krb5_warn(context, 0, "entry with different keyvalue "
81                           "already exists for %s, keytype %s, kvno %d",
82                           name_str, etype_str, entry.vno);
83         }
84         krb5_kt_free_entry(context, &dummy);
85         krb5_kt_free_entry (context, &entry);
86         free(name_str);
87         free(etype_str);
88         return ret;
89     } else if(ret != KRB5_KT_NOTFOUND) {
90         krb5_set_error_message (context, ret, "fetching %s/%s/%u",
91                                 name_str, etype_str, entry.vno);
92         krb5_kt_free_entry (context, &entry);
93         free(name_str);
94         free(etype_str);
95         return ret;
96     } 
97     ret = krb5_kt_add_entry (context, dst_keytab, &entry);
98     krb5_kt_free_entry (context, &entry);
99     if (ret) {
100         krb5_set_error_message (context, ret, "adding %s/%s/%u",
101                                 name_str, etype_str, entry.vno);
102         free(name_str);
103         free(etype_str);
104         return ret;
105     }
106     free(name_str);
107     free(etype_str);
108     return ret;
109 }
110
111 krb5_error_code kt_copy (krb5_context context, const char *from, const char *to)
112 {
113     krb5_error_code ret;
114     krb5_keytab src_keytab, dst_keytab;
115     krb5_kt_cursor cursor;
116     krb5_keytab_entry entry;
117
118     ret = krb5_kt_resolve (context, from, &src_keytab);
119     if (ret) {
120         krb5_set_error_message (context, ret, "resolving src keytab `%s'", from);
121         return ret;
122     }
123
124     ret = krb5_kt_resolve (context, to, &dst_keytab);
125     if (ret) {
126         krb5_kt_close (context, src_keytab);
127         krb5_set_error_message (context, ret, "resolving dst keytab `%s'", to);
128         return ret;
129     }
130
131     ret = krb5_kt_start_seq_get (context, src_keytab, &cursor);
132     if (ret) {
133         krb5_set_error_message (context, ret, "krb5_kt_start_seq_get %s", from);
134         goto out;
135     }
136
137     while((ret = krb5_kt_next_entry(context, src_keytab,
138                                     &entry, &cursor)) == 0) {
139         ret = copy_one_entry(context, src_keytab, dst_keytab, entry);
140         if (ret) {
141             break;
142         }
143     }
144     krb5_kt_end_seq_get (context, src_keytab, &cursor);
145
146   out:
147     krb5_kt_close (context, src_keytab);
148     krb5_kt_close (context, dst_keytab);
149     if (ret == KRB5_KT_END) {
150         return 0;
151     } else if (ret == 0) {
152         return EINVAL;
153     }
154     return ret;
155 }
156
157 krb5_error_code kt_copy_one_principal (krb5_context context, const char *from, const char *to, 
158                                        const char *principal, krb5_kvno kvno, krb5_enctype *enctypes)
159 {
160     krb5_error_code ret;
161     krb5_keytab src_keytab, dst_keytab;
162     krb5_keytab_entry entry;
163     krb5_principal princ;
164     int i;
165     bool found_one = false;
166
167     ret = krb5_parse_name (context, principal, &princ);
168     if(ret) {
169             krb5_set_error_message(context, ret, "krb5_unparse_name");
170             return ret;
171     }
172
173     ret = krb5_kt_resolve (context, from, &src_keytab);
174     if (ret) {
175         krb5_set_error_message(context, ret, "resolving src keytab `%s'", from);
176         return ret;
177     }
178
179     ret = krb5_kt_resolve (context, to, &dst_keytab);
180     if (ret) {
181         krb5_kt_close (context, src_keytab);
182         krb5_set_error_message(context, ret, "resolving dst keytab `%s'", to);
183         return ret;
184     }
185
186     for (i=0; enctypes[i]; i++) {
187         ret = krb5_kt_get_entry(context, src_keytab,
188                                 princ,
189                                 kvno,
190                                 enctypes[i],
191                                 &entry);
192         if (ret == KRB5_KT_NOTFOUND) {
193             continue;
194         } else if (ret) {
195             break;
196         }
197         found_one = true;
198         ret = copy_one_entry(context, src_keytab, dst_keytab, entry);
199         if (ret) {
200             break;
201         }
202     }
203     if (ret == KRB5_KT_NOTFOUND) {
204         if (!found_one) {
205             char *princ_string;
206             int ret2 = krb5_unparse_name (context, princ, &princ_string);
207             if (ret2) {
208                 krb5_set_error_message(context, ret, "failed to fetch principal %s", princ_string);
209             }
210         } else {
211             /* Not finding an enc type is not an error, as long as we copied one for the principal */
212             ret = 0;
213         }
214     }
215
216     krb5_kt_close (context, src_keytab);
217     krb5_kt_close (context, dst_keytab);
218     return ret;
219 }