marsh.c

   1 /*  $Id: marsh.c 2293 2005-12-03 19:51:13Z rra $
   2 **
   3 **  Routines to marshall/unmarshall parameters and ticket-granting tickets.
   4 */
   5
   6 #include "config.h"
   7
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <sys/types.h>
  11
  12 #ifdef HAVE_KERBEROSIV_KRB_H
  13 # include <kerberosIV/krb.h>
  14 #else
  15 # include <krb.h>
  16 #endif
  17
  18 #include "kftgt.h"
  19
  20 /*
  21  * These macros were lifted from BIND 4.9.2 sources.
  22  *
  23  */
  24
  25 /*
  26  * Inline versions of get/put short/long.  Pointer is advanced.
  27  * We also assume that a "u_short" holds 2 "chars"
  28  * and that a "u_int32_t" holds 4 "chars".
  29  *
  30  * These macros demonstrate the property of C whereby it can be
  31  * portable or it can be elegant but never both.
  32  */
  33
  34 /* these should work on all hosts I have to worry about :-) rjs */
  35 typedef unsigned char my_u_char;
  36 typedef unsigned int my_u_int32_t;
  37 typedef unsigned short my_u_short;
  38
  39 #define GETSHORT(s, cp) { \
  40         register my_u_char *t_cp = (my_u_char*)(cp); \
  41         (s) = (((my_u_short)t_cp[0]) << 8) \
  42             | (((my_u_short)t_cp[1])) \
  43             ; \
  44         (cp) += 2; \
  45 }
  46
  47 #define GETLONG(l, cp) { \
  48         register my_u_char *t_cp = (my_u_char*)(cp); \
  49         (l) = (((my_u_int32_t)t_cp[0]) << 24) \
  50             | (((my_u_int32_t)t_cp[1]) << 16) \
  51             | (((my_u_int32_t)t_cp[2]) << 8) \
  52             | (((my_u_int32_t)t_cp[3])) \
  53             ; \
  54         (cp) += 4; \
  55 }
  56
  57 #define PUTSHORT(s, cp) { \
  58         register my_u_short t_s = (my_u_short)(s); \
  59         register my_u_char *t_cp = (my_u_char*)(cp); \
  60         *t_cp++ = t_s >> 8; \
  61         *t_cp   = t_s; \
  62         (cp) += 2; \
  63 }
  64
  65 /*
  66  * Warning: PUTLONG --no-longer-- destroys its first argument.  if you
  67  * were depending on this "feature", you will lose.
  68  */
  69 #define PUTLONG(l, cp) { \
  70         register my_u_int32_t t_l = (my_u_int32_t)(l); \
  71         register my_u_char *t_cp = (my_u_char*)(cp); \
  72         *t_cp++ = t_l >> 24; \
  73         *t_cp++ = t_l >> 16; \
  74         *t_cp++ = t_l >> 8; \
  75         *t_cp   = t_l; \
  76         (cp) += 4; \
  77 }
  78
  79 /*****************************************************
  80  nobody to blame but myself for these lovely macros.
  81
  82    I could have been more paranoid about the PUT macros
  83    but I'm assuming a valid cred stucture was passed to
  84    cred_to_net.
  85
  86 ******************************************************/
  87
  88 /*
  89    put a string with length stored first, string is not null terminated
  90
  91
  92 */
  93
  94 #define PUT_COUNTED_STRING(string,dest) {       \
  95     KRB_UINT32 temp;                            \
  96     temp = strlen(string);                      \
  97     PUTLONG(temp,dest);                         \
  98     strncpy(dest,string,temp);                  \
  99     dest+= temp;                                \
 100   }
 101
 102 /* put arbitrary data */
 103
 104 #define PUT_BINARY(dest, src, len) { \
 105     memcpy(dest, src, len); \
 106     dest += len; \
 107   }
 108
 109 /* check len against max length  */
 110
 111 #define CHECK_LENGTH(len,max_len) { \
 112      if (len > max_len) return -1; \
 113   }
 114
 115 /* get a long, checking for space (in source, dest is already a long) */
 116
 117 #define GET_LONG(dest,src,cur_len,max_len) {\
 118   CHECK_LENGTH(cur_len+4, max_len); \
 119   GETLONG(dest,src);\
 120   cur_len += 4; \
 121   }
 122
 123 /* get a counted string, checking for space in source and dest */
 124
 125 #define GET_COUNTED_STRING(dest,src,dest_max, cur_len,max_len) {        \
 126     KRB_UINT32 count;                                                   \
 127     GET_LONG(count, src, cur_len, max_len);                             \
 128     CHECK_LENGTH(count, dest_max);                                      \
 129     CHECK_LENGTH(cur_len+count, max_len);                               \
 130     strncpy(dest,(char *) p,count);                                     \
 131     dest[count] = '\0';                                                 \
 132     cur_len += count;                                                   \
 133     src += count;                                                       \
 134   }
 135
 136
 137 /* get arbitrary data, checking for space in source, dest length is given */
 138
 139 #define GET_BINARY(dest,src, len, cur_len, max_len) {\
 140   CHECK_LENGTH(cur_len + len, max_len); \
 141   memcpy(dest, src, len); \
 142   cur_len += len; \
 143   src += len; \
 144   }
 145
 146 int
 147 marshall_cred (
 148        CREDENTIALS *cred,
 149        char *buffer,
 150        int max_buff)
 151 {
 152   char *p;
 153   int len;
 154   KRB_UINT32 temp;
 155
 156    p = buffer;
 157
 158    if (max_buff < sizeof(CREDENTIALS)) return -1;
 159
 160   PUTLONG(1, p); /* version */
 161   PUT_COUNTED_STRING(cred->service,p);
 162   PUT_COUNTED_STRING(cred->instance,p);
 163   PUT_COUNTED_STRING(cred->realm,p);
 164   PUT_BINARY(p, cred->session, sizeof(cred->session));
 165   temp = cred->lifetime;
 166   PUTLONG(temp,p);
 167   temp = cred->kvno;
 168   PUTLONG(temp,p);
 169   temp = cred->ticket_st.length;
 170   PUTLONG(temp,p);
 171   PUT_BINARY(p, cred->ticket_st.dat, temp);
 172   temp = cred->issue_date;
 173   PUTLONG(temp,p);
 174   PUT_COUNTED_STRING(cred->pname,p);
 175   PUT_COUNTED_STRING(cred->pinst,p);
 176
 177   len =  p-buffer;
 178
 179   return len;
 180
 181 }
 182
 183 int
 184 unmarshall_cred(
 185        CREDENTIALS *cred,
 186        unsigned char *buffer,
 187        int max_len)
 188 {
 189
 190   unsigned char *p;
 191   int len;
 192   KRB_UINT32 temp, version;
 193
 194   len = 0;
 195   p = buffer;
 196
 197   GET_LONG(version, p, len, max_len);
 198
 199   GET_COUNTED_STRING(cred->service, p, sizeof(cred->service)-1, len, max_len);
 200   GET_COUNTED_STRING(cred->instance, p, sizeof(cred->instance)-1,len, max_len);
 201   GET_COUNTED_STRING(cred->realm, p, sizeof(cred->realm)-1, len, max_len);
 202
 203   GET_BINARY(cred->session, p, sizeof(cred->session), len, max_len);
 204   GET_LONG(temp, p, len, max_len); cred->lifetime = temp;
 205   GET_LONG(temp, p, len, max_len); cred->kvno = temp;
 206   GET_LONG(temp, p, len, max_len); cred->ticket_st.length = temp;
 207   CHECK_LENGTH(temp, sizeof(cred->ticket_st.dat));
 208   GET_BINARY(cred->ticket_st.dat, p, temp, len, max_len);
 209   cred->ticket_st.mbz = 0;
 210   GET_LONG(temp, p, len, max_len); cred->issue_date = temp;
 211   GET_COUNTED_STRING(cred->pname, p, sizeof(cred->pname)-1, len, max_len);
 212   GET_COUNTED_STRING(cred->pinst, p, sizeof(cred->pinst)-1, len, max_len);
 213
 214   return len;
 215 }
 216
 217
 218 int marshall_params (
 219       char *user,
 220       char *ticketfile,
 221       char *buffer,
 222       int  max_buffer)
 223 {
 224    int ulen, tlen;
 225    char *p;
 226
 227    ulen = strlen(user);
 228    tlen = strlen(ticketfile);
 229
 230    if (  (ulen > KFTGT_MAX_USERNAME)
 231        ||(tlen > KFTGT_MAX_PATHNAME)
 232        || (ulen+tlen+8) > max_buffer) return -1;
 233
 234   p = buffer;
 235   PUT_COUNTED_STRING(user,p);
 236   PUT_COUNTED_STRING(ticketfile,p);
 237
 238   return p-buffer;
 239
 240 }
 241
 242
 243 int unmarshall_params(
 244       char *user,
 245       int max_user,
 246       char *ticketfile,
 247       int max_ticket,
 248       unsigned char *buffer,
 249       int  max_len)
 250 {
 251     unsigned char *p;
 252     int len;
 253
 254     p = buffer;
 255     len = 0;
 256     GET_COUNTED_STRING(user, p, max_user, len, max_len);
 257     GET_COUNTED_STRING(ticketfile, p, max_ticket, len, max_len);
 258     return len;
 259 }