#include "k5-int.h"
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include "kdb_xdr.h"
krb5_error_code
krb5_encode_princ_dbkey(context, key, principal)
krb5_context context;
krb5_data *key;
krb5_const_principal principal;
{
char *princ_name;
krb5_error_code retval;
if (!(retval = krb5_unparse_name(context, principal, &princ_name))) {
key->length = strlen(princ_name)+1;
key->data = princ_name;
}
return(retval);
}
void
krb5_free_princ_dbkey(context, key)
krb5_context context;
krb5_data *key;
{
(void) krb5_free_data_contents(context, key);
}
krb5_error_code
krb5_encode_princ_contents(context, content, entry)
krb5_context context;
krb5_data * content;
krb5_db_entry * entry;
{
int i, j;
unsigned int unparse_princ_size;
char * unparse_princ;
unsigned char * nextloc;
krb5_tl_data * tl_data;
krb5_error_code retval;
krb5_int16 psize16;
content->length = entry->len + entry->e_length;
if ((retval = krb5_unparse_name(context, entry->princ, &unparse_princ)))
return(retval);
unparse_princ_size = strlen(unparse_princ) + 1;
content->length += unparse_princ_size;
content->length += 2;
i = 0;
for (tl_data = entry->tl_data; tl_data; tl_data = tl_data->tl_data_next) {
content->length += tl_data->tl_data_length;
content->length += 4;
i++;
}
if (i != entry->n_tl_data) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto epc_error;
}
for (i = 0; i < entry->n_key_data; i++) {
content->length += 4;
for (j = 0; j < entry->key_data[i].key_data_ver; j++) {
content->length += entry->key_data[i].key_data_length[j];
content->length += 4;
}
}
if ((content->data = malloc(content->length)) == NULL) {
retval = ENOMEM;
goto epc_error;
}
nextloc = (unsigned char *)content->data;
krb5_kdb_encode_int16(entry->len, nextloc);
nextloc += 2;
krb5_kdb_encode_int32(entry->attributes, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->max_life, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->max_renewable_life, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->expiration, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->pw_expiration, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->last_success, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->last_failed, nextloc);
nextloc += 4;
krb5_kdb_encode_int32(entry->fail_auth_count, nextloc);
nextloc += 4;
krb5_kdb_encode_int16(entry->n_tl_data, nextloc);
nextloc += 2;
krb5_kdb_encode_int16(entry->n_key_data, nextloc);
nextloc += 2;
if (entry->len != KRB5_KDB_V1_BASE_LENGTH)
abort();
if (entry->e_length) {
memcpy(nextloc, entry->e_data, entry->e_length);
nextloc += entry->e_length;
}
psize16 = (krb5_int16) unparse_princ_size;
krb5_kdb_encode_int16(psize16, nextloc);
nextloc += 2;
(void) memcpy(nextloc, unparse_princ, unparse_princ_size);
nextloc += unparse_princ_size;
for (tl_data = entry->tl_data; tl_data; tl_data = tl_data->tl_data_next) {
krb5_kdb_encode_int16(tl_data->tl_data_type, nextloc);
nextloc += 2;
krb5_kdb_encode_int16(tl_data->tl_data_length, nextloc);
nextloc += 2;
memcpy(nextloc, tl_data->tl_data_contents, tl_data->tl_data_length);
nextloc += tl_data->tl_data_length;
}
for (i = 0; i < entry->n_key_data; i++) {
krb5_kdb_encode_int16(entry->key_data[i].key_data_ver, nextloc);
nextloc += 2;
krb5_kdb_encode_int16(entry->key_data[i].key_data_kvno, nextloc);
nextloc += 2;
for (j = 0; j < entry->key_data[i].key_data_ver; j++) {
krb5_int16 type = entry->key_data[i].key_data_type[j];
krb5_ui_2 length = entry->key_data[i].key_data_length[j];
krb5_kdb_encode_int16(type, nextloc);
nextloc += 2;
krb5_kdb_encode_int16(length, nextloc);
nextloc += 2;
if (length) {
memcpy(nextloc, entry->key_data[i].key_data_contents[j],length);
nextloc += length;
}
}
}
epc_error:;
free(unparse_princ);
return retval;
}
void
krb5_free_princ_contents(context, contents)
krb5_context context;
krb5_data *contents;
{
krb5_free_data_contents(context, contents);
return;
}
krb5_error_code
krb5_decode_princ_contents(context, content, entry)
krb5_context context;
krb5_data * content;
krb5_db_entry * entry;
{
int sizeleft, i;
unsigned char * nextloc;
krb5_tl_data ** tl_data;
krb5_int16 i16;
krb5_error_code retval;
memset(entry, 0, sizeof(krb5_db_entry));
nextloc = (unsigned char *)content->data;
sizeleft = content->length;
if ((sizeleft -= KRB5_KDB_V1_BASE_LENGTH) < 0)
return KRB5_KDB_TRUNCATED_RECORD;
krb5_kdb_decode_int16(nextloc, entry->len);
nextloc += 2;
krb5_kdb_decode_int32(nextloc, entry->attributes);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->max_life);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->max_renewable_life);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->expiration);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->pw_expiration);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->last_success);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->last_failed);
nextloc += 4;
krb5_kdb_decode_int32(nextloc, entry->fail_auth_count);
nextloc += 4;
krb5_kdb_decode_int16(nextloc, entry->n_tl_data);
nextloc += 2;
if (entry->n_tl_data < 0)
return KRB5_KDB_TRUNCATED_RECORD;
krb5_kdb_decode_int16(nextloc, entry->n_key_data);
nextloc += 2;
if (entry->n_key_data < 0)
return KRB5_KDB_TRUNCATED_RECORD;
if (entry->len > KRB5_KDB_V1_BASE_LENGTH) {
entry->e_length = entry->len - KRB5_KDB_V1_BASE_LENGTH;
if ((entry->e_data = (krb5_octet *)malloc(entry->e_length))) {
memcpy(entry->e_data, nextloc, entry->e_length);
nextloc += entry->e_length;
} else {
return ENOMEM;
}
}
if ((sizeleft -= 2) < 0) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
i = 0;
krb5_kdb_decode_int16(nextloc, i16);
i = (int) i16;
nextloc += 2;
if ((retval = krb5_parse_name(context, (char *)nextloc, &(entry->princ))))
goto error_out;
if (((size_t) i != (strlen((char *)nextloc) + 1)) || (sizeleft < i)) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
sizeleft -= i;
nextloc += i;
tl_data = &entry->tl_data;
for (i = 0; i < entry->n_tl_data; i++) {
if ((sizeleft -= 4) < 0) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
if ((*tl_data = (krb5_tl_data *)
malloc(sizeof(krb5_tl_data))) == NULL) {
retval = ENOMEM;
goto error_out;
}
(*tl_data)->tl_data_next = NULL;
(*tl_data)->tl_data_contents = NULL;
krb5_kdb_decode_int16(nextloc, (*tl_data)->tl_data_type);
nextloc += 2;
krb5_kdb_decode_int16(nextloc, (*tl_data)->tl_data_length);
nextloc += 2;
if ((sizeleft -= (*tl_data)->tl_data_length) < 0) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
if (((*tl_data)->tl_data_contents = (krb5_octet *)
malloc((*tl_data)->tl_data_length)) == NULL) {
retval = ENOMEM;
goto error_out;
}
memcpy((*tl_data)->tl_data_contents,nextloc,(*tl_data)->tl_data_length);
nextloc += (*tl_data)->tl_data_length;
tl_data = &((*tl_data)->tl_data_next);
}
if (entry->n_key_data && ((entry->key_data = (krb5_key_data *)
malloc(sizeof(krb5_key_data) * entry->n_key_data)) == NULL)) {
retval = ENOMEM;
goto error_out;
}
for (i = 0; i < entry->n_key_data; i++) {
krb5_key_data * key_data;
int j;
if ((sizeleft -= 4) < 0) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
key_data = entry->key_data + i;
memset(key_data, 0, sizeof(krb5_key_data));
krb5_kdb_decode_int16(nextloc, key_data->key_data_ver);
nextloc += 2;
krb5_kdb_decode_int16(nextloc, key_data->key_data_kvno);
nextloc += 2;
if (key_data->key_data_ver <= KRB5_KDB_V1_KEY_DATA_ARRAY) {
for (j = 0; j < key_data->key_data_ver; j++) {
if ((sizeleft -= 4) < 0) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
krb5_kdb_decode_int16(nextloc, key_data->key_data_type[j]);
nextloc += 2;
krb5_kdb_decode_int16(nextloc, key_data->key_data_length[j]);
nextloc += 2;
if ((sizeleft -= key_data->key_data_length[j]) < 0) {
retval = KRB5_KDB_TRUNCATED_RECORD;
goto error_out;
}
if (key_data->key_data_length[j]) {
if ((key_data->key_data_contents[j] = (krb5_octet *)
malloc(key_data->key_data_length[j])) == NULL) {
retval = ENOMEM;
goto error_out;
}
memcpy(key_data->key_data_contents[j], nextloc,
key_data->key_data_length[j]);
nextloc += key_data->key_data_length[j];
}
}
} else {
abort();
}
}
return 0;
error_out:;
krb5_dbe_free_contents(context, entry);
return retval;
}
void
krb5_dbe_free_contents(context, entry)
krb5_context context;
krb5_db_entry * entry;
{
krb5_tl_data * tl_data_next;
krb5_tl_data * tl_data;
int i, j;
if (entry->e_data)
free(entry->e_data);
if (entry->princ)
krb5_free_principal(context, entry->princ);
for (tl_data = entry->tl_data; tl_data; tl_data = tl_data_next) {
tl_data_next = tl_data->tl_data_next;
if (tl_data->tl_data_contents)
free(tl_data->tl_data_contents);
free(tl_data);
}
if (entry->key_data) {
for (i = 0; i < entry->n_key_data; i++) {
for (j = 0; j < entry->key_data[i].key_data_ver; j++) {
if (entry->key_data[i].key_data_length[j]) {
if (entry->key_data[i].key_data_contents[j]) {
memset(entry->key_data[i].key_data_contents[j],
0,
(unsigned) entry->key_data[i].key_data_length[j]);
free (entry->key_data[i].key_data_contents[j]);
}
}
entry->key_data[i].key_data_contents[j] = NULL;
entry->key_data[i].key_data_length[j] = 0;
entry->key_data[i].key_data_type[j] = 0;
}
}
free(entry->key_data);
}
memset(entry, 0, sizeof(*entry));
return;
}