[openssh.git] / radix.c

/*
  radix.c

  base-64 encoding pinched from lynx2-7-2, who pinched it from rpem.
  Originally written by Mark Riordan 12 August 1990 and 17 Feb 1991
  and placed in the public domain.

  Dug Song <dugsong@UMICH.EDU>
*/
  
#include "includes.h"

#ifdef AFS
#include <krb.h>

char six2pr[64] = {
    'A','B','C','D','E','F','G','H','I','J','K','L','M',
    'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
    'a','b','c','d','e','f','g','h','i','j','k','l','m',
    'n','o','p','q','r','s','t','u','v','w','x','y','z',
    '0','1','2','3','4','5','6','7','8','9','+','/'
};

unsigned char pr2six[256];

int uuencode(unsigned char *bufin, unsigned int nbytes, char *bufcoded)
{
  /* ENC is the basic 1 character encoding function to make a char printing */
#define ENC(c) six2pr[c]
  
  register char *outptr = bufcoded;
  unsigned int i;
  
  for (i=0; i<nbytes; i += 3) {
    *(outptr++) = ENC(*bufin >> 2);            /* c1 */
    *(outptr++) = ENC(((*bufin << 4) & 060) | ((bufin[1] >> 4) & 017)); /*c2*/
    *(outptr++) = ENC(((bufin[1] << 2) & 074) | ((bufin[2] >> 6) & 03));/*c3*/
    *(outptr++) = ENC(bufin[2] & 077);         /* c4 */
    bufin += 3;
  }
  if (i == nbytes+1) {
    outptr[-1] = '=';
  } else if (i == nbytes+2) {
    outptr[-1] = '=';
    outptr[-2] = '=';
  }
  *outptr = '\0';
  return(outptr - bufcoded);
}

int uudecode(const char *bufcoded, unsigned char *bufplain, int outbufsize)
{
  /* single character decode */
#define DEC(c) pr2six[(unsigned char)c]
#define MAXVAL 63
  
  static int first = 1;
  int nbytesdecoded, j;
  const char *bufin = bufcoded;
  register unsigned char *bufout = bufplain;
  register int nprbytes;
  
  /* If this is the first call, initialize the mapping table. */
  if (first) {
    first = 0;
    for(j=0; j<256; j++) pr2six[j] = MAXVAL+1;
    for(j=0; j<64; j++) pr2six[(unsigned char)six2pr[j]] = (unsigned char)j;
  }
  
  /* Strip leading whitespace. */
  while (*bufcoded==' ' || *bufcoded == '\t') bufcoded++;
  
  /* Figure out how many characters are in the input buffer.
     If this would decode into more bytes than would fit into
     the output buffer, adjust the number of input bytes downwards. */
  bufin = bufcoded;
  while (DEC(*(bufin++)) <= MAXVAL);
  nprbytes = bufin - bufcoded - 1;
  nbytesdecoded = ((nprbytes+3)/4) * 3;
  if (nbytesdecoded > outbufsize)
    nprbytes = (outbufsize*4)/3;
  
  bufin = bufcoded;
  
  while (nprbytes > 0) {
    *(bufout++) = (unsigned char) (DEC(*bufin) << 2 | DEC(bufin[1]) >> 4);
    *(bufout++) = (unsigned char) (DEC(bufin[1]) << 4 | DEC(bufin[2]) >> 2);
    *(bufout++) = (unsigned char) (DEC(bufin[2]) << 6 | DEC(bufin[3]));
    bufin += 4;
    nprbytes -= 4;
  }
  if (nprbytes & 03) {
    if (DEC(bufin[-2]) > MAXVAL)
      nbytesdecoded -= 2;
    else 
      nbytesdecoded -= 1;
  }
  return(nbytesdecoded);
}

typedef unsigned char my_u_char;
typedef unsigned int my_u_int32_t;
typedef unsigned short my_u_short;

/* Nasty macros from BIND-4.9.2 */

#define GETSHORT(s, cp) { \
	register my_u_char *t_cp = (my_u_char*)(cp); \
	(s) = (((my_u_short)t_cp[0]) << 8) \
	    | (((my_u_short)t_cp[1])) \
	    ; \
	(cp) += 2; \
}

#define GETLONG(l, cp) { \
	register my_u_char *t_cp = (my_u_char*)(cp); \
	(l) = (((my_u_int32_t)t_cp[0]) << 24) \
	    | (((my_u_int32_t)t_cp[1]) << 16) \
	    | (((my_u_int32_t)t_cp[2]) << 8) \
	    | (((my_u_int32_t)t_cp[3])) \
	    ; \
	(cp) += 4; \
}

#define PUTSHORT(s, cp) { \
	register my_u_short t_s = (my_u_short)(s); \
	register my_u_char *t_cp = (my_u_char*)(cp); \
	*t_cp++ = t_s >> 8; \
	*t_cp   = t_s; \
	(cp) += 2; \
}

#define PUTLONG(l, cp) { \
	register my_u_int32_t t_l = (my_u_int32_t)(l); \
	register my_u_char *t_cp = (my_u_char*)(cp); \
	*t_cp++ = t_l >> 24; \
	*t_cp++ = t_l >> 16; \
	*t_cp++ = t_l >> 8; \
	*t_cp   = t_l; \
	(cp) += 4; \
}

#define GETSTRING(s, p, p_l) {			\
    register char* p_targ = (p) + p_l;		\
    register char* s_c = (s);			\
    register char* p_c = (p);			\
    while (*p_c && (p_c < p_targ)) {		\
	*s_c++ = *p_c++;			\
    }						\
    if (p_c == p_targ) {			\
	return 1;				\
    }						\
    *s_c = *p_c++;				\
    (p_l) = (p_l) - (p_c - (p));		\
    (p) = p_c;					\
}


int creds_to_radix(CREDENTIALS *creds, unsigned char *buf)
{
  char *p, *s;
  int len;
  char temp[2048];
  
  p = temp;
  *p++ = 1; /* version */
  s = creds->service;	while (*s) *p++ = *s++; *p++ = *s;
  s = creds->instance;	while (*s) *p++ = *s++; *p++ = *s;
  s = creds->realm;	while (*s) *p++ = *s++; *p++ = *s;

  s = creds->pname;	while (*s) *p++ = *s++;   *p++ = *s;
  s = creds->pinst;	while (*s) *p++ = *s++;   *p++ = *s;
  /* Null string to repeat the realm. */
  *p++ = '\0';

  PUTLONG(creds->issue_date,p);
  {
    unsigned int	endTime ;
    endTime = (unsigned int)krb_life_to_time(creds->issue_date,
					      creds->lifetime);
    PUTLONG(endTime,p);
  }

  memcpy(p,&creds->session, sizeof(creds->session));
  p += sizeof(creds->session);
  
  PUTSHORT(creds->kvno,p);
  PUTLONG(creds->ticket_st.length,p);
  
  memcpy(p,creds->ticket_st.dat, creds->ticket_st.length);
  p += creds->ticket_st.length;
  len = p - temp;

  return(uuencode(temp, len, buf));
}

int radix_to_creds(const char *buf, CREDENTIALS *creds)
{

  char *p;
  int len, tl;
  char version;
  char temp[2048];
  
  if (!(len = uudecode(buf, temp, sizeof(temp))))
    return 0;
  
  p = temp;

  /* check version and length! */
  if (len < 1) return 0;
  version = *p; p++; len--;

  GETSTRING(creds->service, p, len);
  GETSTRING(creds->instance, p, len);
  GETSTRING(creds->realm, p, len);
  
  GETSTRING(creds->pname, p, len);
  GETSTRING(creds->pinst, p, len);
  /* Ignore possibly different realm. */
  while (*p && len) p++, len--;
  if (len == 0) return 0;
  p++, len--;
  
  /* Enough space for remaining fixed-length parts? */
  if (len < (4 + 4 + sizeof(creds->session) + 2 + 4))
    return 0;
  
  GETLONG(creds->issue_date,p);
  len -= 4;
  {
    unsigned int	endTime;
    GETLONG(endTime,p);
    len -= 4;
    creds->lifetime = krb_time_to_life(creds->issue_date, endTime);
  }

  memcpy(&creds->session, p, sizeof(creds->session));
  p += sizeof(creds->session);
  len -= sizeof(creds->session);
  
  GETSHORT(creds->kvno,p);
  len -= 2;
  GETLONG(creds->ticket_st.length,p);
  len -= 4;

  tl = creds->ticket_st.length;
  if (tl < 0 || tl > len || tl > sizeof(creds->ticket_st.dat))
    return 0;
  
  memcpy(creds->ticket_st.dat, p, tl);
  p += tl;
  len -= tl;
  
  return 1;
}

#endif /* AFS */
Commit	Line	Data
8efc0c15	1	/*
	2	radix.c
	3
	4	base-64 encoding pinched from lynx2-7-2, who pinched it from rpem.
	5	Originally written by Mark Riordan 12 August 1990 and 17 Feb 1991
	6	and placed in the public domain.
	7
	8	Dug Song <dugsong@UMICH.EDU>
	9	*/
	10
	11	#include "includes.h"
	12
	13	#ifdef AFS
	14	#include <krb.h>
	15
	16	char six2pr[64] = {
	17	'A','B','C','D','E','F','G','H','I','J','K','L','M',
	18	'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
	19	'a','b','c','d','e','f','g','h','i','j','k','l','m',
	20	'n','o','p','q','r','s','t','u','v','w','x','y','z',
	21	'0','1','2','3','4','5','6','7','8','9','+','/'
	22	};
	23
	24	unsigned char pr2six[256];
	25
	26	int uuencode(unsigned char bufin, unsigned int nbytes, char bufcoded)
	27	{
	28	/* ENC is the basic 1 character encoding function to make a char printing */
	29	#define ENC(c) six2pr[c]
	30
	31	register char *outptr = bufcoded;
	32	unsigned int i;
	33
	34	for (i=0; i<nbytes; i += 3) {
	35	(outptr++) = ENC(bufin >> 2); /* c1 */
	36	(outptr++) = ENC(((bufin << 4) & 060) \| ((bufin[1] >> 4) & 017)); /c2/
	37	(outptr++) = ENC(((bufin[1] << 2) & 074) \| ((bufin[2] >> 6) & 03));/c3*/
	38	(outptr++) = ENC(bufin[2] & 077); / c4 */
	39	bufin += 3;
	40	}
	41	if (i == nbytes+1) {
	42	outptr[-1] = '=';
	43	} else if (i == nbytes+2) {
	44	outptr[-1] = '=';
	45	outptr[-2] = '=';
	46	}
	47	*outptr = '\0';
	48	return(outptr - bufcoded);
	49	}
	50
	51	int uudecode(const char bufcoded, unsigned char bufplain, int outbufsize)
	52	{
	53	/* single character decode */
	54	#define DEC(c) pr2six[(unsigned char)c]
	55	#define MAXVAL 63
	56
	57	static int first = 1;
	58	int nbytesdecoded, j;
	59	const char *bufin = bufcoded;
	60	register unsigned char *bufout = bufplain;
	61	register int nprbytes;
	62
	63	/* If this is the first call, initialize the mapping table. */
	64	if (first) {
65	first = 0;
66	for(j=0; j<256; j++) pr2six[j] = MAXVAL+1;
67	for(j=0; j<64; j++) pr2six[(unsigned char)six2pr[j]] = (unsigned char)j;
68	}
69
70	/* Strip leading whitespace. */
71	while (bufcoded==' ' \|\| bufcoded == '\t') bufcoded++;
72
73	/* Figure out how many characters are in the input buffer.
74	If this would decode into more bytes than would fit into
75	the output buffer, adjust the number of input bytes downwards. */
76	bufin = bufcoded;
77	while (DEC(*(bufin++)) <= MAXVAL);
78	nprbytes = bufin - bufcoded - 1;
79	nbytesdecoded = ((nprbytes+3)/4) * 3;
80	if (nbytesdecoded > outbufsize)
81	nprbytes = (outbufsize*4)/3;
82
83	bufin = bufcoded;
84
85	while (nprbytes > 0) {
86	(bufout++) = (unsigned char) (DEC(bufin) << 2 \| DEC(bufin[1]) >> 4);
87	*(bufout++) = (unsigned char) (DEC(bufin[1]) << 4 \| DEC(bufin[2]) >> 2);
88	*(bufout++) = (unsigned char) (DEC(bufin[2]) << 6 \| DEC(bufin[3]));
89	bufin += 4;
90	nprbytes -= 4;
91	}
92	if (nprbytes & 03) {
93	if (DEC(bufin[-2]) > MAXVAL)
94	nbytesdecoded -= 2;
95	else
96	nbytesdecoded -= 1;
97	}
98	return(nbytesdecoded);
99	}
100
101	typedef unsigned char my_u_char;
102	typedef unsigned int my_u_int32_t;
103	typedef unsigned short my_u_short;
104
105	/* Nasty macros from BIND-4.9.2 */
106
107	#define GETSHORT(s, cp) { \
108	register my_u_char t_cp = (my_u_char)(cp); \
109	(s) = (((my_u_short)t_cp[0]) << 8) \
110	\| (((my_u_short)t_cp[1])) \
111	; \
112	(cp) += 2; \
113	}
114
115	#define GETLONG(l, cp) { \
116	register my_u_char t_cp = (my_u_char)(cp); \
117	(l) = (((my_u_int32_t)t_cp[0]) << 24) \
118	\| (((my_u_int32_t)t_cp[1]) << 16) \
119	\| (((my_u_int32_t)t_cp[2]) << 8) \
120	\| (((my_u_int32_t)t_cp[3])) \
121	; \
122	(cp) += 4; \
123	}
124
125	#define PUTSHORT(s, cp) { \
126	register my_u_short t_s = (my_u_short)(s); \
127	register my_u_char t_cp = (my_u_char)(cp); \
128	*t_cp++ = t_s >> 8; \
129	*t_cp = t_s; \
130	(cp) += 2; \
131	}
132
133	#define PUTLONG(l, cp) { \
134	register my_u_int32_t t_l = (my_u_int32_t)(l); \
135	register my_u_char t_cp = (my_u_char)(cp); \
136	*t_cp++ = t_l >> 24; \
137	*t_cp++ = t_l >> 16; \
138	*t_cp++ = t_l >> 8; \
139	*t_cp = t_l; \
140	(cp) += 4; \
141	}
142
143	#define GETSTRING(s, p, p_l) { \
144	register char* p_targ = (p) + p_l; \
145	register char* s_c = (s); \
146	register char* p_c = (p); \
147	while (*p_c && (p_c < p_targ)) { \
148	s_c++ = p_c++; \
149	} \
150	if (p_c == p_targ) { \
151	return 1; \
152	} \
153	s_c = p_c++; \
154	(p_l) = (p_l) - (p_c - (p)); \
155	(p) = p_c; \
156	}
157
158
159	int creds_to_radix(CREDENTIALS creds, unsigned char buf)
160	{
161	char p, s;
162	int len;
163	char temp[2048];
164
165	p = temp;
166	p++ = 1; / version */
167	s = creds->service; while (s) p++ = s++; p++ = *s;
168	s = creds->instance; while (s) p++ = s++; p++ = *s;
169	s = creds->realm; while (s) p++ = s++; p++ = *s;
170
171	s = creds->pname; while (s) p++ = s++; p++ = *s;
172	s = creds->pinst; while (s) p++ = s++; p++ = *s;
173	/* Null string to repeat the realm. */
174	*p++ = '\0';
175
176	PUTLONG(creds->issue_date,p);
177	{
178	unsigned int endTime ;
179	endTime = (unsigned int)krb_life_to_time(creds->issue_date,
180	creds->lifetime);
181	PUTLONG(endTime,p);
182	}
183
184	memcpy(p,&creds->session, sizeof(creds->session));
185	p += sizeof(creds->session);
186
187	PUTSHORT(creds->kvno,p);
188	PUTLONG(creds->ticket_st.length,p);
189
190	memcpy(p,creds->ticket_st.dat, creds->ticket_st.length);
191	p += creds->ticket_st.length;
192	len = p - temp;
193
194	return(uuencode(temp, len, buf));
195	}
196
197	int radix_to_creds(const char buf, CREDENTIALS creds)
198	{
199
200	char *p;
201	int len, tl;
202	char version;
203	char temp[2048];
204
205	if (!(len = uudecode(buf, temp, sizeof(temp))))
206	return 0;
207
208	p = temp;
209
210	/* check version and length! */
211	if (len < 1) return 0;
212	version = *p; p++; len--;
213
214	GETSTRING(creds->service, p, len);
215	GETSTRING(creds->instance, p, len);
216	GETSTRING(creds->realm, p, len);
217
218	GETSTRING(creds->pname, p, len);
219	GETSTRING(creds->pinst, p, len);
220	/* Ignore possibly different realm. */
221	while (*p && len) p++, len--;
222	if (len == 0) return 0;
223	p++, len--;
224
225	/* Enough space for remaining fixed-length parts? */
226	if (len < (4 + 4 + sizeof(creds->session) + 2 + 4))
227	return 0;
228
229	GETLONG(creds->issue_date,p);
230	len -= 4;
231	{
232	unsigned int endTime;
233	GETLONG(endTime,p);
234	len -= 4;
235	creds->lifetime = krb_time_to_life(creds->issue_date, endTime);
236	}
237
238	memcpy(&creds->session, p, sizeof(creds->session));
239	p += sizeof(creds->session);
240	len -= sizeof(creds->session);
241
242	GETSHORT(creds->kvno,p);
243	len -= 2;
244	GETLONG(creds->ticket_st.length,p);
245	len -= 4;
246
247	tl = creds->ticket_st.length;
248	if (tl < 0 \|\| tl > len \|\| tl > sizeof(creds->ticket_st.dat))
249	return 0;
250
251	memcpy(creds->ticket_st.dat, p, tl);
252	p += tl;
253	len -= tl;
254
255	return 1;
256	}
257
258	#endif /* AFS */