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