macos: delegate sock_* calls to bkg daemons
[openafs.git] / src / aklog / akeyconvert.c
1 /* aklog/akeyconvert.c - migrate keys from rxkad.keytab to KeyFileExt */
2 /*
3  * Copyright (C) 2015 by the Massachusetts Institute of Technology.
4  * Copyright (C) 2016 Benjamin Kaduk.
5  * All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  *
11  * * Redistributions of source code must retain the above copyright
12  *   notice, this list of conditions and the following disclaimer.
13  *
14  * * Redistributions in binary form must reproduce the above copyright
15  *   notice, this list of conditions and the following disclaimer in
16  *   the documentation and/or other materials provided with the
17  *   distribution.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
22  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
23  * COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
24  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
25  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
26  * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
28  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
30  * OF THE POSSIBILITY OF SUCH DAMAGE.
31  */
32
33 /*
34  * Helper for migrations from OpenAFS 1.6.x to OpenAFS 1.8.x when
35  * the rxkad-k5 extension is in use.
36  *
37  * Read keys from the current rxkad.keytab and add them to the
38  * KeyFileExt, creating it if necessary.  Detect duplicated
39  * kvno/enctype keys, which are possible when attached to different
40  * principals in the rxkad.keytab, but are not possible in the
41  * KeyFileExt.
42  *
43  * The implementation reads the entire keytab contents into memory,
44  * then sorts by principal (most significant), kvno, and enctype (least
45  * significant) to facilitate selecting the newest kvno for each principal
46  * and avoiding duplicate kvno/enctype values.  The direction of sort is
47  * chosen so as to hopefully put the more often used keys at the beginning
48  * of the file.
49  *
50  * By default, only copy the latest key for each principal, but provide an
51  * option to copy all keys.
52  */
53
54 #include <afsconfig.h>
55 #include <afs/param.h>
56 #include <sys/errno.h>
57 #include <string.h>
58
59 #include <afs/cellconfig.h>
60 #include <afs/dirpath.h>
61 #include <afs/keys.h>
62 #include <afs/opr.h>
63 #include <afs/cmd.h>
64
65 #include <roken.h>
66
67 #include <stdio.h>
68
69 #define KERBEROS_APPLE_DEPRECATED(x)
70 /* krb5_free_unparsed_name() is deprecated; it's unclear why. */
71 #define KRB5_DEPRECATED_FUNCTION(x)
72 #include <krb5.h>
73 #ifdef HAVE_COM_ERR_H
74 # include <com_err.h>
75 #elif HAVE_ET_COM_ERR_H
76 # include <et/com_err.h>
77 #elif HAVE_KRB5_COM_ERR_H
78 # include <krb5/com_err.h>
79 #else
80 # error com_err is required for akeyconvert
81 #endif
82
83 #if HAVE_KRB5_KEYTAB_ENTRY_KEY
84 # define deref_entry_keylen(x)  ((x).key.length)
85 # define deref_entry_keyval(x)  ((x).key.contents)
86 # define deref_entry_enctype(x) ((x).key.enctype)
87 #elif HAVE_KRB5_KEYTAB_ENTRY_KEYBLOCK
88 # define deref_entry_keylen(x)  ((x).keyblock.keyvalue.length)
89 # define deref_entry_keyval(x)  ((x).keyblock.keyvalue.data)
90 # define deref_entry_enctype(x) ((x).keyblock.keytype)
91 #else
92 # error krb5_keytab_entry structure unknown
93 #endif
94 #ifndef HAVE_KRB5_FREE_KEYTAB_ENTRY_CONTENTS
95 # define krb5_free_keytab_entry_contents        krb5_kt_free_entry
96 #endif
97 #ifndef HAVE_KRB5_FREE_UNPARSED_NAME
98 # define krb5_free_unparsed_name(x, y)  free((y))
99 #endif
100
101 enum optionsList {
102     OPT_all,
103 };
104
105 /*
106  * Convert keytab entry to the OpenAFS typedKey format, allocating
107  * storage for the output.
108  *
109  * Returns 0 on success.
110  */
111 static afs_int32
112 ktent_to_typedKey(krb5_keytab_entry entry, struct afsconf_typedKey **out)
113 {
114     struct rx_opaque key;
115     afs_int32 enctype;
116
117     key.len = deref_entry_keylen(entry);
118     key.val = deref_entry_keyval(entry);
119     enctype = deref_entry_enctype(entry);
120     if (enctype == 1 /* ETYPE_DES_CBC_CRC */ ||
121         enctype == 2 /* ETYPE_DES_CBC_MD4 */ ||
122         enctype == 3 /* ETYPE_DES_CBC_MD5 */) {
123         *out = afsconf_typedKey_new(afsconf_rxkad, entry.vno, 0, &key);
124         if (*out == NULL)
125             return ENOMEM;
126         else
127             return 0;
128     }
129     /* else, an rxkad_krb5 key */
130     *out = afsconf_typedKey_new(afsconf_rxkad_krb5, entry.vno,
131                                 deref_entry_enctype(entry), &key);
132     if (*out == NULL)
133         return ENOMEM;
134     else
135         return 0;
136 }
137
138 static int
139 princ_sort(const void *aa, const void *bb)
140 {
141     const krb5_keytab_entry *a, *b;
142     char *name1 = NULL, *name2 = NULL;
143     krb5_boolean equal;
144     krb5_context ctx;
145     int ret;
146
147     a = aa;
148     b = bb;
149
150     opr_Verify(krb5_init_context(&ctx) == 0);
151     equal = krb5_principal_compare(ctx, a->principal, b->principal);
152     if (equal) {
153         ret = 0;
154         goto out;
155     }
156     opr_Verify(krb5_unparse_name(ctx, a->principal, &name1) == 0);
157     opr_Verify(krb5_unparse_name(ctx, b->principal, &name2) == 0);
158     ret = strcmp(name1, name2);
159     opr_Assert(ret != 0);
160
161 out:
162     krb5_free_unparsed_name(ctx, name1);
163     krb5_free_unparsed_name(ctx, name2);
164     krb5_free_context(ctx);
165     return ret;
166 }
167
168 static int
169 kvno_sort(const void *aa, const void *bb)
170 {
171     const krb5_keytab_entry *a, *b;
172
173     a = aa;
174     b = bb;
175
176     if (a->vno == b->vno)
177         return 0;
178     else if (a->vno > b->vno)
179         return -1;
180     else
181         return 1;
182 }
183
184 static int
185 etype_sort(const void *aa, const void *bb)
186 {
187     const krb5_keytab_entry *a, *b;
188
189     a = aa;
190     b = bb;
191
192     if (deref_entry_enctype(*a) == deref_entry_enctype(*b))
193         return 0;
194     else if (deref_entry_enctype(*a) > deref_entry_enctype(*b))
195         return -1;
196     else
197         return 1;
198 }
199
200 static int
201 ke_sort(const void *a, const void *b)
202 {
203     int ret;
204
205     ret = kvno_sort(a, b);
206     if (ret != 0)
207         return ret;
208     return etype_sort(a, b);
209 }
210
211 static int
212 full_sort(const void *a, const void *b)
213 {
214     int ret;
215
216     ret = princ_sort(a, b);
217     if (ret != 0)
218         return ret;
219     return ke_sort(a, b);
220 }
221
222 static afs_int32
223 slurp_keytab(krb5_context ctx, char *kt_path, krb5_keytab_entry **ents_out,
224              int *nents)
225 {
226     krb5_keytab kt = NULL;
227     krb5_keytab_entry entry, *ents = NULL;
228     krb5_kt_cursor cursor;
229     afs_int32 code;
230     int n = 0, i;
231
232     *ents_out = NULL;
233     *nents = 0;
234     memset(&cursor, 0, sizeof(cursor));
235
236     code = krb5_kt_resolve(ctx, kt_path, &kt);
237     if (code)
238         return code;
239
240     code = krb5_kt_start_seq_get(ctx, kt, &cursor);
241     if (code != 0)
242         goto out;
243     while ((code = krb5_kt_next_entry(ctx, kt, &entry, &cursor)) == 0) {
244         ++n;
245         krb5_free_keytab_entry_contents(ctx, &entry);
246     }
247     krb5_kt_end_seq_get(ctx, kt, &cursor);
248     if (code != 0 && code != KRB5_KT_END)
249         goto out;
250
251     ents = calloc(n, sizeof(*ents));
252     if (ents == NULL) {
253         code = ENOMEM;
254         goto out;
255     }
256     code = krb5_kt_start_seq_get(ctx, kt, &cursor);
257     if (code != 0)
258         goto out;
259     i = 0;
260     while ((code = krb5_kt_next_entry(ctx, kt, ents + i, &cursor)) == 0) {
261         if (i++ == n) {
262             /* Out of space; bail early */
263             fprintf(stderr, "Warning: keytab size changed during processing\n");
264             break;
265         }
266     }
267     krb5_kt_end_seq_get(ctx, kt, &cursor);
268     if (code != 0 && code != KRB5_KT_END)
269         goto out;
270
271     code = 0;
272     *nents = n;
273     *ents_out = ents;
274     ents = NULL;
275 out:
276     free(ents);
277     krb5_kt_close(ctx, kt);
278     return code;
279 }
280
281 /*
282  * Check for duplicate kvno/enctype pairs (across different principals).
283  *
284  * This is a fatal error, but emit a diagnostic for all instances before
285  * exiting.
286  *
287  * Requires the input array (ents) to be sorted by kvno and enctype.
288  */
289 static afs_int32
290 check_dups(struct afsconf_dir *dir, krb5_keytab_entry *ents, int nents)
291 {
292     int i, old_kvno = 0, old_etype = 0;
293     afs_int32 code = 0;
294
295     for (i = 0; i < nents; ++i) {
296         if (old_kvno == ents[i].vno &&
297             old_etype == deref_entry_enctype(ents[i])) {
298             fprintf(stderr, "Duplicate kvno/enctype %i/%i\n", old_kvno,
299                     old_etype);
300             code = AFSCONF_KEYINUSE;
301         }
302         old_kvno = ents[i].vno;
303         old_etype = deref_entry_enctype(ents[i]);
304     }
305     if (code)
306         fprintf(stderr, "FATAL: duplicate key identifiers found.\n");
307     return code;
308 }
309
310 /*
311  * Go through the list of keytab entries and write them to the KeyFileExt.
312  *
313  * If do_all is set, write all entries; otherwise, only write the highest
314  * kvno for each principal.
315  *
316  * Emit a diagnostic for kvno/enctype pairs which are already in the
317  * KeyFileExt (and thus cannot be added), but continue on.
318  *
319  * Requires the input array (ents) to be fully sorted, by principal, kvno,
320  * and enctype.
321  */
322 static afs_int32
323 convert_kt(struct afsconf_dir *dir, krb5_context ctx, krb5_keytab_entry *ents,
324            int nents, int do_all)
325 {
326     int i, n;
327     krb5_principal old_princ, wellknown_princ;
328     struct afsconf_typedKey *key = NULL;
329     afsconf_keyType type;
330     afs_int32 best_kvno = 0, code;
331
332     code = krb5_parse_name(ctx, "WELLKNOWN/ANONYMOUS@WELLKNOWN:ANONYMOUS",
333                            &wellknown_princ);
334     old_princ = wellknown_princ;
335     if (code)
336         goto out;
337     n = 0;
338     for (i = 0; i < nents; ++i) {
339         if (!krb5_principal_compare(ctx, old_princ, ents[i].principal)) {
340             best_kvno = ents[i].vno;
341         }
342         if (krb5_principal_compare(ctx, old_princ, ents[i].principal) &&
343             best_kvno != ents[i].vno && !do_all)
344             continue;
345         old_princ = ents[i].principal;
346         code = ktent_to_typedKey(ents[i], &key);
347         if (code)
348             goto out;
349         afsconf_typedKey_values(key, &type, NULL, NULL, NULL);
350         if (type == afsconf_rxkad) {
351             fprintf(stderr,
352                     "Cannot add single-DES keys to KeyFileExt, continuing\n");
353             afsconf_typedKey_put(&key);
354             continue;
355         }
356         code = afsconf_AddTypedKey(dir, key, 0);
357         if (code == AFSCONF_KEYINUSE) {
358             fprintf(stderr,
359                     "Key already exists for kvno %i enctype %i, continuing\n",
360                     ents[i].vno, deref_entry_enctype(ents[i]));
361             afsconf_typedKey_put(&key);
362             continue;
363         } else if (code) {
364             goto out;
365         }
366         n++;
367         afsconf_typedKey_put(&key);
368     }
369     code = 0;
370     printf("Wrote %i keys\n", n);
371 out:
372     if (key != NULL)
373         afsconf_typedKey_put(&key);
374     krb5_free_principal(ctx, wellknown_princ);
375     return code;
376 }
377
378 /*
379  * Liberate the Shepherds of the Trees from the forest that they might
380  * seek out the Entwives.
381  *
382  * Deallocate the storage for the keytab entries stored in the
383  * array ents (of length nents), and also deallocate the storage
384  * for the array itself.
385  *
386  * Safe to call with a NULL ents parameter.
387  */
388 static void
389 free_ents(krb5_context ctx, krb5_keytab_entry *ents, int nents)
390 {
391     int i;
392
393     if (ents == NULL)
394         return;
395     for(i = 0; i < nents; ++i)
396         krb5_free_keytab_entry_contents(ctx, ents + i);
397     free(ents);
398 }
399
400 static int
401 CommandProc(struct cmd_syndesc *as, void *arock)
402 {
403     char *kt_path = NULL;
404     krb5_context ctx = NULL;
405     krb5_keytab_entry *ents = NULL;
406     struct afsconf_dir *dir;
407     afs_int32 code;
408     int do_all, nents = -1;
409
410     code = krb5_init_context(&ctx);
411     if (code)
412         return -1;
413
414     dir = afsconf_Open(AFSDIR_SERVER_ETC_DIR);
415     if (dir == NULL) {
416         fprintf(stderr, "Failed to open server config directory\n");
417         code = -1;
418         goto out;
419     }
420
421     code = asprintf(&kt_path, "%s/%s", dir->name, AFSDIR_RXKAD_KEYTAB_FILE);
422     if (code < 0) {
423         kt_path = NULL;
424         code = ENOMEM;
425         goto out;
426     }
427     code = slurp_keytab(ctx, kt_path, &ents, &nents);
428     if (code) {
429         fprintf(stderr, "failed to read keytab\n");
430         goto out;
431     }
432
433     /* Sort the keytab by kvno and enctype. */
434     qsort(ents, nents, sizeof(*ents), &ke_sort);
435
436     /* Check for duplicates before sorting by principal. */
437     code = check_dups(dir, ents, nents);
438     if (code)
439         goto out;
440
441     qsort(ents, nents, sizeof(*ents), &full_sort);
442
443     do_all = cmd_OptionPresent(as, OPT_all);
444     code = convert_kt(dir, ctx, ents, nents, do_all);
445     if (code) {
446         fprintf(stderr, "Failed to convert keys, errno %i\n", errno);
447         goto out;
448     }
449
450 out:
451     free_ents(ctx, ents, nents);
452     free(kt_path);
453     krb5_free_context(ctx);
454     afsconf_Close(dir);
455     return code;
456 }
457
458 int
459 main(int argc, char *argv[])
460 {
461     struct cmd_syndesc *ts;
462     afs_int32 code;
463
464     ts = cmd_CreateSyntax(NULL, CommandProc, NULL, 0,
465                           "Convert cell keys for the 1.6->1.8 OpenAFS upgrade");
466     cmd_AddParmAtOffset(ts, OPT_all, "-all", CMD_FLAG, CMD_OPTIONAL,
467                 "convert old keys as well as the current keys");
468     code = cmd_Dispatch(argc, argv);
469     return (code != 0);
470 }