radix.c

   1 /*
   2  * Copyright (c) 1999 Dug Song.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  23  */
  24
  25 #include "includes.h"
  26 #include "uuencode.h"
  27
  28 RCSID("$OpenBSD: radix.c,v 1.13 2000/09/07 20:27:52 deraadt Exp $");
  29
  30 #ifdef AFS
  31 #include <krb.h>
  32
  33 typedef unsigned char my_u_char;
  34 typedef unsigned int my_u_int32_t;
  35 typedef unsigned short my_u_short;
  36
  37 /* Nasty macros from BIND-4.9.2 */
  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 #define PUTLONG(l, cp) { \
  66         register my_u_int32_t t_l = (my_u_int32_t)(l); \
  67         register my_u_char *t_cp = (my_u_char*)(cp); \
  68         *t_cp++ = t_l >> 24; \
  69         *t_cp++ = t_l >> 16; \
  70         *t_cp++ = t_l >> 8; \
  71         *t_cp   = t_l; \
  72         (cp) += 4; \
  73 }
  74
  75 #define GETSTRING(s, p, p_l) {                  \
  76     register char* p_targ = (p) + p_l;          \
  77     register char* s_c = (s);                   \
  78     register char* p_c = (p);                   \
  79     while (*p_c && (p_c < p_targ)) {            \
  80         *s_c++ = *p_c++;                        \
  81     }                                           \
  82     if (p_c == p_targ) {                        \
  83         return 1;                               \
  84     }                                           \
  85     *s_c = *p_c++;                              \
  86     (p_l) = (p_l) - (p_c - (p));                \
  87     (p) = p_c;                                  \
  88 }
  89
  90
  91 int
  92 creds_to_radix(CREDENTIALS *creds, unsigned char *buf, size_t buflen)
  93 {
  94         char *p, *s;
  95         int len;
  96         char temp[2048];
  97
  98         p = temp;
  99         *p++ = 1;               /* version */
 100         s = creds->service;
 101         while (*s)
 102                 *p++ = *s++;
 103         *p++ = *s;
 104         s = creds->instance;
 105         while (*s)
 106                 *p++ = *s++;
 107         *p++ = *s;
 108         s = creds->realm;
 109         while (*s)
 110                 *p++ = *s++;
 111         *p++ = *s;
 112
 113         s = creds->pname;
 114         while (*s)
 115                 *p++ = *s++;
 116         *p++ = *s;
 117         s = creds->pinst;
 118         while (*s)
 119                 *p++ = *s++;
 120         *p++ = *s;
 121         /* Null string to repeat the realm. */
 122         *p++ = '\0';
 123
 124         PUTLONG(creds->issue_date, p);
 125         {
 126                 unsigned int endTime;
 127                 endTime = (unsigned int) krb_life_to_time(creds->issue_date,
 128                                                           creds->lifetime);
 129                 PUTLONG(endTime, p);
 130         }
 131
 132         memcpy(p, &creds->session, sizeof(creds->session));
 133         p += sizeof(creds->session);
 134
 135         PUTSHORT(creds->kvno, p);
 136         PUTLONG(creds->ticket_st.length, p);
 137
 138         memcpy(p, creds->ticket_st.dat, creds->ticket_st.length);
 139         p += creds->ticket_st.length;
 140         len = p - temp;
 141
 142         return (uuencode((unsigned char *)temp, len, (char *)buf, buflen));
 143 }
 144
 145 int
 146 radix_to_creds(const char *buf, CREDENTIALS *creds)
 147 {
 148
 149         char *p;
 150         int len, tl;
 151         char version;
 152         char temp[2048];
 153
 154         len = uudecode(buf, (unsigned char *)temp, sizeof(temp));
 155         if (len < 0)
 156                 return 0;
 157
 158         p = temp;
 159
 160         /* check version and length! */
 161         if (len < 1)
 162                 return 0;
 163         version = *p;
 164         p++;
 165         len--;
 166
 167         GETSTRING(creds->service, p, len);
 168         GETSTRING(creds->instance, p, len);
 169         GETSTRING(creds->realm, p, len);
 170
 171         GETSTRING(creds->pname, p, len);
 172         GETSTRING(creds->pinst, p, len);
 173         /* Ignore possibly different realm. */
 174         while (*p && len)
 175                 p++, len--;
 176         if (len == 0)
 177                 return 0;
 178         p++, len--;
 179
 180         /* Enough space for remaining fixed-length parts? */
 181         if (len < (4 + 4 + sizeof(creds->session) + 2 + 4))
 182                 return 0;
 183
 184         GETLONG(creds->issue_date, p);
 185         len -= 4;
 186         {
 187                 unsigned int endTime;
 188                 GETLONG(endTime, p);
 189                 len -= 4;
 190                 creds->lifetime = krb_time_to_life(creds->issue_date, endTime);
 191         }
 192
 193         memcpy(&creds->session, p, sizeof(creds->session));
 194         p += sizeof(creds->session);
 195         len -= sizeof(creds->session);
 196
 197         GETSHORT(creds->kvno, p);
 198         len -= 2;
 199         GETLONG(creds->ticket_st.length, p);
 200         len -= 4;
 201
 202         tl = creds->ticket_st.length;
 203         if (tl < 0 || tl > len || tl > sizeof(creds->ticket_st.dat))
 204                 return 0;
 205
 206         memcpy(creds->ticket_st.dat, p, tl);
 207         p += tl;
 208         len -= tl;
 209
 210         return 1;
 211 }
 212 #endif /* AFS */