* 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.
+ * Salttype may be negative to indicate a search for only a enctype.
*/
krb5_boolean
-krb5_keysalt_is_present(ksaltlist, nksalts, keytype, salttype)
+krb5_keysalt_is_present(ksaltlist, nksalts, enctype, salttype)
krb5_key_salt_tuple *ksaltlist;
krb5_int32 nksalts;
- krb5_keytype keytype;
+ krb5_enctype enctype;
krb5_int32 salttype;
{
krb5_boolean foundit;
foundit = 0;
if (ksaltlist) {
for (i=0; i<nksalts; i++) {
- if ((ksaltlist[i].ks_keytype == keytype) &&
+ if ((ksaltlist[i].ks_enctype == enctype) &&
((ksaltlist[i].ks_salttype == salttype) ||
(salttype < 0))) {
foundit = 1;
kret = 0;
for (i=0; i<nksalt; i++) {
- scratch.ks_keytype = ksaltlist[i].ks_keytype;
+ scratch.ks_enctype = ksaltlist[i].ks_enctype;
scratch.ks_salttype = (ignoresalt) ? -1 : ksaltlist[i].ks_salttype;
if (!krb5_keysalt_is_present(ksaltlist,
i,
- scratch.ks_keytype,
+ scratch.ks_enctype,
scratch.ks_salttype)) {
if (kret = (*iterator)(&scratch, arg))
break;
krb5_error_code kret;
char *kp, *sp, *ep;
char sepchar, trailchar;
- krb5_keytype ktype;
+ krb5_enctype ktype;
krb5_int32 stype;
krb5_key_salt_tuple *savep;
const char *tseplist;
}
/*
* kp points to something (hopefully) of the form:
- * <keytype><ksseplist><salttype>
+ * <enctype><ksseplist><salttype>
* or
- * <keytype>
+ * <enctype>
*/
sp = (char *) NULL;
/* Attempt to find a separator */
ep = strchr(kp, (int) *septmp));
if (sp) {
- /* Separate keytype from salttype */
+ /* Separate enctype from salttype */
sepchar = *sp;
*sp = '\0';
sp++;
stype = -1;
/*
- * Attempt to parse keytype and salttype. If we parse well
+ * Attempt to parse enctype and salttype. If we parse well
* then make sure that it specifies a unique key/salt combo
*/
- if (!krb5_string_to_keytype(kp, &ktype) &&
+ if (!krb5_string_to_enctype(kp, &ktype) &&
(!sp || !krb5_string_to_salttype(sp, &stype)) &&
(dups ||
!krb5_keysalt_is_present(*ksaltp, *nksaltp, ktype, stype))) {
}
/* Save our values */
- (*ksaltp)[(*nksaltp)].ks_keytype = ktype;
+ (*ksaltp)[(*nksaltp)].ks_enctype = ktype;
(*ksaltp)[(*nksaltp)].ks_salttype = stype;
(*nksaltp)++;
}
*
* String decoding:
* ----------------
- * krb5_string_to_keytype() - Convert string to krb5_keytype.
+ * krb5_string_to_enctype() - Convert string to krb5_enctype.
* krb5_string_to_salttype() - Convert string to salttype (krb5_int32)
* krb5_string_to_enctype() - Convert string to krb5_enctype.
* krb5_string_to_cksumtype() - Convert string to krb5_cksumtype;
*
* String encoding:
* ----------------
- * krb5_keytype_to_string() - Convert krb5_keytype to string.
+ * krb5_enctype_to_string() - Convert krb5_enctype to string.
* krb5_salttype_to_string() - Convert salttype (krb5_int32) to string.
* krb5_enctype_to_string() - Convert krb5_enctype to string.
* krb5_cksumtype_to_string() - Convert krb5_cksumtype to string.
/*
* Local data structures.
*/
-struct keytype_lookup_entry {
- krb5_keytype ktt_keytype; /* Keytype */
+struct enctype_lookup_entry {
+ krb5_enctype ktt_enctype; /* Keytype */
const char * ktt_specifier; /* How to recognize it */
const char * ktt_output; /* How to spit it out */
};
struct salttype_lookup_entry {
- krb5_int32 stt_keytype; /* Salt type */
+ krb5_int32 stt_enctype; /* Salt type */
const char * stt_specifier; /* How to recognize it */
const char * stt_output; /* How to spit it out */
};
-struct enctype_lookup_entry {
- krb5_enctype ett_enctype; /* Encryption type */
- const char * ett_specifier; /* How to recognize it */
- const char * ett_output; /* How to spit it out */
-};
-
struct cksumtype_lookup_entry {
krb5_cksumtype cst_cksumtype; /* Checksum type */
const char * cst_specifier; /* How to recognize it */
/*
* Local strings
*/
+
/* Keytype strings */
-static const char keytype_null_in[] = "null";
-static const char keytype_des_in[] = "des";
-static const char keytype_null_out[] = "Null";
-static const char keytype_des_out[] = "DES";
+static const char enctype_des_in[] = "des";
+static const char enctype_null_in[] = "null";
+static const char enctype_descbccrc_in[] = "des-cbc-crc";
+static const char enctype_descbcmd4_in[] = "des-cbc-md4";
+static const char enctype_descbcmd5_in[] = "des-cbc-md5";
+static const char enctype_descbcraw_in[] = "des-cbc-raw";
+static const char enctype_null_out[] = "Null";
+static const char enctype_descbccrc_out[] = "DES cbc mode with CRC-32";
+static const char enctype_descbcmd4_out[] = "DES cbc mode with RSA-MD4";
+static const char enctype_descbcmd5_out[] = "DES cbc mode with RSA-MD5";
+static const char enctype_descbcraw_out[] = "DES cbc mode raw";
/* Salttype strings */
static const char stype_v5_in[] = "normal";
static const char stype_olrealm_out[] = "Version 5 - Realm Only";
static const char stype_special_out[] = "Special";
-/* Encryption type strings */
-static const char etype_null_in[] = "null";
-static const char etype_descbccrc_in[] = "des-cbc-crc";
-static const char etype_descbcmd4_in[] = "des-cbc-md4";
-static const char etype_descbcmd5_in[] = "des-cbc-md5";
-static const char etype_rawdescbc_in[] = "raw-des-cbc";
-static const char etype_null_out[] = "Null";
-static const char etype_descbccrc_out[] = "DES cbc mode with CRC-32";
-static const char etype_descbcmd4_out[] = "DES cbc mode with RSA-MD4";
-static const char etype_descbcmd5_out[] = "DES cbc mode with RSA-MD5";
-static const char etype_rawdescbc_out[] = "DES cbc mode";
-
/* Checksum type strings */
static const char cstype_crc32_in[] = "crc32";
static const char cstype_md4_in[] = "md4";
/*
* Lookup tables.
*/
-static const struct keytype_lookup_entry keytype_table[] = {
-/* krb5_keytype input specifier output string */
-/*------------- ----------------------- ------------------------*/
-{ KEYTYPE_NULL, keytype_null_in, keytype_null_out },
-{ KEYTYPE_DES, keytype_des_in, keytype_des_out }
+static const struct enctype_lookup_entry enctype_table[] = {
+/* krb5_enctype input specifier output string */
+/*------------- ----------------------- ------------------------*/
+{ ENCTYPE_NULL, enctype_null_in, enctype_null_out },
+{ ENCTYPE_DES_CBC_MD5, enctype_des_in, enctype_descbcmd5_out },
+{ ENCTYPE_DES_CBC_CRC, enctype_descbccrc_in, enctype_descbccrc_out },
+{ ENCTYPE_DES_CBC_MD4, enctype_descbcmd4_in, enctype_descbcmd4_out },
+{ ENCTYPE_DES_CBC_MD5, enctype_descbcmd5_in, enctype_descbcmd5_out },
+{ ENCTYPE_DES_CBC_RAW, enctype_descbcraw_in, enctype_descbcraw_out }
};
-static const int keytype_table_nents = sizeof(keytype_table)/
- sizeof(keytype_table[0]);
+static const int enctype_table_nents = sizeof(enctype_table)/
+ sizeof(enctype_table[0]);
static const struct salttype_lookup_entry salttype_table[] = {
/* salt type input specifier output string */
static const int salttype_table_nents = sizeof(salttype_table)/
sizeof(salttype_table[0]);
-static const struct enctype_lookup_entry enctype_table[] = {
-/* krb5_enctype input specifier output string */
-/*------------------ --------------------- ------------------------*/
-{ ETYPE_NULL, etype_null_in, etype_null_out },
-{ ETYPE_DES_CBC_CRC, etype_descbccrc_in, etype_descbccrc_out },
-{ ETYPE_DES_CBC_MD4, etype_descbcmd4_in, etype_descbcmd4_out },
-{ ETYPE_DES_CBC_MD5, etype_descbcmd5_in, etype_descbcmd5_out },
-{ ETYPE_RAW_DES_CBC, etype_rawdescbc_in, etype_rawdescbc_out }
-};
-static const int enctype_table_nents = sizeof(enctype_table)/
- sizeof(enctype_table[0]);
-
static const struct cksumtype_lookup_entry cksumtype_table[] = {
/* krb5_cksumtype input specifier output string */
/*----------------------- --------------------- ------------------------*/
* These routines return 0 for success, EINVAL for invalid entry.
*/
krb5_error_code
-krb5_string_to_keytype(string, keytypep)
+krb5_string_to_enctype(string, enctypep)
char * string;
- krb5_keytype * keytypep;
+ krb5_enctype * enctypep;
{
int i;
int found;
found = 0;
- for (i=0; i<keytype_table_nents; i++) {
- if (!strcasecmp(string, keytype_table[i].ktt_specifier)) {
+ for (i=0; i<enctype_table_nents; i++) {
+ if (!strcasecmp(string, enctype_table[i].ktt_specifier)) {
found = 1;
- *keytypep = keytype_table[i].ktt_keytype;
+ *enctypep = enctype_table[i].ktt_enctype;
break;
}
}
for (i=0; i<salttype_table_nents; i++) {
if (!strcasecmp(string, salttype_table[i].stt_specifier)) {
found = 1;
- *salttypep = salttype_table[i].stt_keytype;
- break;
- }
- }
- return((found) ? 0 : EINVAL);
-}
-
-krb5_error_code
-krb5_string_to_enctype(string, enctypep)
- char * string;
- krb5_enctype * enctypep;
-{
- int i;
- int found;
-
- found = 0;
- for (i=0; i<enctype_table_nents; i++) {
- if (!strcasecmp(string, enctype_table[i].ett_specifier)) {
- found = 1;
- *enctypep = enctype_table[i].ett_enctype;
+ *salttypep = salttype_table[i].stt_enctype;
break;
}
}
* if the supplied buffer/length will not contain the output.
*/
krb5_error_code
-krb5_keytype_to_string(keytype, buffer, buflen)
- krb5_keytype keytype;
+krb5_enctype_to_string(enctype, buffer, buflen)
+ krb5_enctype enctype;
char * buffer;
size_t buflen;
{
const char *out;
out = (char *) NULL;
- for (i=0; i<keytype_table_nents; i++) {
- if (keytype == keytype_table[i].ktt_keytype) {
- out = keytype_table[i].ktt_output;
+ for (i=0; i<enctype_table_nents; i++) {
+ if (enctype == enctype_table[i].ktt_enctype) {
+ out = enctype_table[i].ktt_output;
break;
}
}
out = (char *) NULL;
for (i=0; i<salttype_table_nents; i++) {
- if (salttype == salttype_table[i].stt_keytype) {
+ if (salttype == salttype_table[i].stt_enctype) {
out = salttype_table[i].stt_output;
break;
}
return(EINVAL);
}
-krb5_error_code
-krb5_enctype_to_string(enctype, buffer, buflen)
- krb5_enctype enctype;
- char * buffer;
- size_t buflen;
-{
- int i;
- const char *out;
-
- out = (char *) NULL;
- for (i=0; i<enctype_table_nents; i++) {
- if (enctype == enctype_table[i].ett_enctype) {
- out = enctype_table[i].ett_output;
- break;
- }
- }
- if (out) {
- if (buflen > strlen(out))
- strcpy(buffer, out);
- else
- out = (char *) NULL;
- return((out) ? 0 : ENOMEM);
- }
- else
- return(EINVAL);
-}
-
krb5_error_code
krb5_cksumtype_to_string(cksumtype, buffer, buflen)
krb5_cksumtype cksumtype;
projects / krb5.git / commitdiff