From 533bdff81f76d3471b4eaca9181a1e3bea171738 Mon Sep 17 00:00:00 2001 From: Paul Park Date: Fri, 4 Aug 1995 20:31:47 +0000 Subject: [PATCH] Add new key/salt tuple handling modules git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@6413 dc483132-0cff-0310-8789-dd5450dbe970 --- src/lib/kadm/.Sanitize | 1 + src/lib/kadm/ChangeLog | 4 + src/lib/kadm/Makefile.in | 6 +- src/lib/kadm/alt_prof.c | 81 ++------------- src/lib/kadm/keysalt.c | 206 +++++++++++++++++++++++++++++++++++++++ 5 files changed, 222 insertions(+), 76 deletions(-) create mode 100644 src/lib/kadm/keysalt.c diff --git a/src/lib/kadm/.Sanitize b/src/lib/kadm/.Sanitize index 16808bd4e..5457e01bd 100644 --- a/src/lib/kadm/.Sanitize +++ b/src/lib/kadm/.Sanitize @@ -34,6 +34,7 @@ adm_kt_enc.c adm_rw.c configure.in configure +keysalt.c str_conv.c t_dbentry.c t_ktentry.c diff --git a/src/lib/kadm/ChangeLog b/src/lib/kadm/ChangeLog index c6dcb8584..7af5edab8 100644 --- a/src/lib/kadm/ChangeLog +++ b/src/lib/kadm/ChangeLog @@ -1,4 +1,8 @@ +Fri Aug 4 16:21:50 EDT 1995 Paul Park (pjpark@mit.edu) + * Makefile.in, .Sanitize, keysalt.c - Add keysalt.c modules. + + Thu Aug 3 11:51:14 EDT 1995 Paul Park (pjpark@mit.edu) * alt_prof.c - Actually pass back the parsed string value in krb5_aprof_ get_deltat(). diff --git a/src/lib/kadm/Makefile.in b/src/lib/kadm/Makefile.in index c3bac9144..88b7f1b9b 100644 --- a/src/lib/kadm/Makefile.in +++ b/src/lib/kadm/Makefile.in @@ -9,7 +9,8 @@ BASE_OBJS= adm_conn.$(OBJEXT) \ adm_kt_enc.$(OBJEXT) \ adm_rw.$(OBJEXT) \ alt_prof.$(OBJEXT) \ - str_conv.$(OBJEXT) + str_conv.$(OBJEXT) \ + keysalt.$(OBJEXT) UNIX_OBJS = logger.$(OBJEXT) @@ -26,7 +27,8 @@ SRCS= $(srcdir)/adm_conn.c \ $(srcdir)/adm_kw_enc.c \ $(srcdir)/logger.c \ $(srcdir)/alt_prof.c \ - $(srcdir)/str_conv.c + $(srcdir)/str_conv.c \ + $(srcdir)/keysalt.c all:: all-$(WHAT) $(BASE_OBJS) diff --git a/src/lib/kadm/alt_prof.c b/src/lib/kadm/alt_prof.c index 4288ba88c..10645f56a 100644 --- a/src/lib/kadm/alt_prof.c +++ b/src/lib/kadm/alt_prof.c @@ -412,80 +412,12 @@ krb5_read_realm_params(kcontext, realm, kdcprofile, kdcenv, rparamp) /* Get the value for the supported keytype/salttype matrix */ hierarchy[2] = "supported_keytypes"; if (!krb5_aprof_get_string(aprofile, hierarchy, TRUE, &svalue)) { - char *kp, *sp, *ep, *tp; - krb5_keytype ktype; - krb5_int32 stype; - krb5_key_salt_tuple *savep; - - kp = svalue; - while (kp) { - if ((ep = strchr(kp, (int) ',')) || - (ep = strchr(kp, (int) ' ')) || - (ep = strchr(kp, (int) '\t'))) { - /* Fill in trailing whitespace of kp */ - tp = ep - 1; - while (isspace(*tp) && (tp < kp)) { - *tp = '\0'; - tp--; - } - *ep = '\0'; - ep++; - /* Skip trailing whitespace of ep */ - while (isspace(*ep) && (*ep)) ep++; - } - /* - * kp points to something (hopefully) of the form: - * : - */ - if(sp = strchr(kp, (int) ':')) { - /* Separate keytype from salttype */ - *sp = '\0'; - sp++; - /* Attempt to parse keytype and salttype */ - if (!krb5_string_to_keytype(kp, &ktype) && - !krb5_string_to_salttype(sp, &stype)) { - - /* Squirrel away old keysalt array */ - savep = rparams->realm_keysalts; - - /* Get new keysalt array */ - if (rparams->realm_keysalts = - (krb5_key_salt_tuple *) - malloc((rparams->realm_num_keysalts+1) * - sizeof(krb5_key_salt_tuple))) { - - /* Copy old keysalt if appropriate */ - if (savep) { - memcpy(rparams->realm_keysalts, savep, - rparams->realm_num_keysalts * - sizeof(krb5_key_salt_tuple)); - krb5_xfree(savep); - } - - /* Save our values */ - rparams->realm_keysalts[rparams-> - realm_num_keysalts]. - ks_keytype = ktype; - rparams->realm_keysalts[rparams-> - realm_num_keysalts]. - ks_salttype = - stype; - rparams->realm_num_keysalts++; - } - else { - if (savep) - krb5_xfree(savep); - break; - } - } - } - kp = ep; - } - if (kp) { - rparams->realm_num_keysalts = 0; - krb5_xfree(rparams->realm_keysalts); - rparams->realm_keysalts = (krb5_key_salt_tuple *) NULL; - } + krb5_string_to_keysalts(svalue, + ", \t", /* Tuple separators */ + ":.-", /* Key/salt separators */ + 0, /* No duplicates */ + &rparams->realm_keysalts, + &rparams->realm_num_keysalts); krb5_xfree(svalue); } } @@ -518,3 +450,4 @@ krb5_free_realm_params(kcontext, rparams) } return(0); } + diff --git a/src/lib/kadm/keysalt.c b/src/lib/kadm/keysalt.c new file mode 100644 index 000000000..2802de261 --- /dev/null +++ b/src/lib/kadm/keysalt.c @@ -0,0 +1,206 @@ +/* + * lib/kadm/keysalt.c + * + * Copyright 1995 by the Massachusetts Institute of Technology. + * All Rights Reserved. + * + * Export of this software from the United States of America may + * require a specific license from the United States Government. + * It is the responsibility of any person or organization contemplating + * export to obtain such a license before exporting. + * + * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and + * distribute this software and its documentation for any purpose and + * without fee is hereby granted, provided that the above copyright + * notice appear in all copies and that both that copyright notice and + * this permission notice appear in supporting documentation, and that + * the name of M.I.T. not be used in advertising or publicity pertaining + * to distribution of the software without specific, written prior + * permission. M.I.T. makes no representations about the suitability of + * this software for any purpose. It is provided "as is" without express + * or implied warranty. + * + */ + +/* + * keysalt.c - Routines to handle key/salt tuples. + */ +#include "k5-int.h" +#include "adm.h" +#include "adm_proto.h" + +static const char default_tupleseps[] = ", \t"; +static const char default_ksaltseps[] = ":."; + +/* + * krb5_keysalt_is_present() - Determine if a key/salt pair is present + * in a list of key/salt tuples. + * + * Salttype may be negative to indicate a search for only a keytype. + */ +krb5_boolean +krb5_keysalt_is_present(ksaltlist, nksalts, keytype, salttype) + krb5_key_salt_tuple *ksaltlist; + krb5_int32 nksalts; + krb5_keytype keytype; + krb5_int32 salttype; +{ + krb5_boolean foundit; + int i; + + foundit = 0; + if (ksaltlist) { + for (i=0; i + * or + * + */ + sp = (char *) NULL; + /* Attempt to find a separator */ + septmp = ksseplist; + for (sp = strchr(kp, (int) *septmp); + *(++septmp) && !sp; + ep = strchr(kp, (int) *septmp)); + + if (sp) { + /* Separate keytype from salttype */ + *sp = '\0'; + sp++; + } + else + stype = -1; + + /* + * Attempt to parse keytype and salttype. If we parse well + * then make sure that it specifies a unique key/salt combo + */ + if (!krb5_string_to_keytype(kp, &ktype) && + (!sp || !krb5_string_to_salttype(sp, &stype)) && + (dups || + !krb5_keysalt_is_present(*ksaltp, *nksaltp, ktype, stype))) { + + /* Squirrel away old keysalt array */ + savep = *ksaltp; + + /* Get new keysalt array */ + if (*ksaltp = (krb5_key_salt_tuple *) + malloc(((*nksaltp)+1) * sizeof(krb5_key_salt_tuple))) { + + /* Copy old keysalt if appropriate */ + if (savep) { + memcpy(*ksaltp, savep, + (*nksaltp) * sizeof(krb5_key_salt_tuple)); + krb5_xfree(savep); + } + + /* Save our values */ + (*ksaltp)[(*nksaltp)].ks_keytype = ktype; + (*ksaltp)[(*nksaltp)].ks_salttype = stype; + (*nksaltp)++; + } + else { + *ksaltp = savep; + break; + } + } + kp = ep; + } + return(kret); +} + + -- 2.26.2