Subversion Repositories planix.SVN

/*

 * p9cr, vnc - textual challenge/response authentication

 *

 * Client protocol:	[currently unimplemented]

 *	write challenge

 *	read response

 *

 * Server protocol:

 *	write user

 *	read challenge

 * 	write response

 */

#include "dat.h"

enum

{

	Maxchal=	64,

};

typedef struct State State;

struct State

{

	Key	*key;

	int	astype;

	int	asfd;

	Ticket	t;

	Ticketreq tr;

	char	chal[Maxchal];

	int	challen;

	char	resp[Maxchal];

	int	resplen;

};

enum

{

	CNeedChal,

	CHaveResp,

	SHaveChal,

	SNeedResp,

	Maxphase,

};

static char *phasenames[Maxphase] =

{

[CNeedChal]	"CNeedChal",

[CHaveResp]	"CHaveResp",

[SHaveChal]	"SHaveChal",

[SNeedResp]	"SNeedResp",

};

static void

p9crclose(Fsstate *fss)

{

	State *s;

	s = fss->ps;

	if(s->asfd >= 0){

		close(s->asfd);

		s->asfd = -1;

	}

	free(s);

}

static int getchal(State*, Fsstate*);

static int

p9crinit(Proto *p, Fsstate *fss)

{

	int iscli, ret;

	char *user;

	State *s;

	Attr *attr;

	Keyinfo ki;

	if((iscli = isclient(_strfindattr(fss->attr, "role"))) < 0)

		return failure(fss, nil);

	s = emalloc(sizeof(*s));

	s->asfd = -1;

	if(p == &p9cr){

		s->astype = AuthChal;

		s->challen = NETCHLEN;

	}else if(p == &vnc){

		s->astype = AuthVNC;

		s->challen = Maxchal;

	}else

		abort();

	if(iscli){

		fss->phase = CNeedChal;

		if(p == &p9cr)

			attr = setattr(_copyattr(fss->attr), "proto=p9sk1");

		else

			attr = nil;

		ret = findkey(&s->key, mkkeyinfo(&ki, fss, attr),

			"role=client %s", p->keyprompt);

		_freeattr(attr);

		if(ret != RpcOk){

			free(s);

			return ret;

		}

		fss->ps = s;

	}else{

		if((ret = findp9authkey(&s->key, fss)) != RpcOk){

			free(s);

			return ret;

		}

		if((user = _strfindattr(fss->attr, "user")) == nil){

			free(s);

			return failure(fss, "no user name specified in start msg");

		}

		if(strlen(user) >= sizeof s->tr.uid){

			free(s);

			return failure(fss, "user name too long");

		}

		fss->ps = s;

		strcpy(s->tr.uid, user);

		ret = getchal(s, fss);

		if(ret != RpcOk){

			p9crclose(fss);	/* frees s */

			fss->ps = nil;

		}

	}

	fss->phasename = phasenames;

	fss->maxphase = Maxphase;

	return ret;

}

static int

p9crread(Fsstate *fss, void *va, uint *n)

{

	int m;

	State *s;

	s = fss->ps;

	switch(fss->phase){

	default:

		return phaseerror(fss, "read");

	case CHaveResp:

		if(s->resplen < *n)

			*n = s->resplen;

		memmove(va, s->resp, *n);

		fss->phase = Established;

		return RpcOk;

	case SHaveChal:

		if(s->astype == AuthChal)

			m = strlen(s->chal);	/* ascii string */

		else

			m = s->challen;		/* fixed length binary */

		if(m > *n)

			return toosmall(fss, m);

		*n = m;

		memmove(va, s->chal, m);

		fss->phase = SNeedResp;

		return RpcOk;

	}

}

static int

p9response(Fsstate *fss, State *s)

{

	char key[DESKEYLEN];

	uchar buf[8];

	ulong chal;

	char *pw;

	pw = _strfindattr(s->key->privattr, "!password");

	if(pw == nil)

		return failure(fss, "vncresponse cannot happen");

	passtokey(key, pw);

	memset(buf, 0, 8);

	snprint((char*)buf, sizeof buf, "%d", atoi(s->chal));

	if(encrypt(key, buf, 8) < 0)

		return failure(fss, "can't encrypt response");

	chal = (buf[0]<<24)+(buf[1]<<16)+(buf[2]<<8)+buf[3];

	s->resplen = snprint(s->resp, sizeof s->resp, "%.8lux", chal);

	return RpcOk;

}

static uchar tab[256];

/* VNC reverses the bits of each byte before using as a des key */

static void

mktab(void)

{

	int i, j, k;

	static int once;

	if(once)

		return;

	once = 1;

	for(i=0; i<256; i++) {

		j=i;

		tab[i] = 0;

		for(k=0; k<8; k++) {

			tab[i] = (tab[i]<<1) | (j&1);

			j >>= 1;

		}

	}

}

static int

vncaddkey(Key *k, int before)

{

	uchar *p;

	char *s;

	k->priv = emalloc(8+1);

	if(s = _strfindattr(k->privattr, "!password")){

		mktab();

		memset(k->priv, 0, 8+1);

		strncpy((char*)k->priv, s, 8);

		for(p=k->priv; *p; p++)

			*p = tab[*p];

	}else{

		werrstr("no key data");

		return -1;

	}

	return replacekey(k, before);

}

static void

vncclosekey(Key *k)

{

	free(k->priv);

}

static int

vncresponse(Fsstate*, State *s)

{

	DESstate des;

	memmove(s->resp, s->chal, sizeof s->chal);

	setupDESstate(&des, s->key->priv, nil);

	desECBencrypt((uchar*)s->resp, s->challen, &des);

	s->resplen = s->challen;

	return RpcOk;

}

static int

p9crwrite(Fsstate *fss, void *va, uint n)

{

	char tbuf[TICKETLEN+AUTHENTLEN];

	State *s;

	char *data = va;

	Authenticator a;

	char resp[Maxchal];

	int ret;

	s = fss->ps;

	switch(fss->phase){

	default:

		return phaseerror(fss, "write");

	case CNeedChal:

		if(n >= sizeof(s->chal))

			return failure(fss, Ebadarg);

		memset(s->chal, 0, sizeof s->chal);

		memmove(s->chal, data, n);

		s->challen = n;

		if(s->astype == AuthChal)

			ret = p9response(fss, s);

		else

			ret = vncresponse(fss, s);

		if(ret != RpcOk)

			return ret;

		fss->phase = CHaveResp;

		return RpcOk;

	case SNeedResp:

		/* send response to auth server and get ticket */

		if(n > sizeof(resp))

			return failure(fss, Ebadarg);

		memset(resp, 0, sizeof resp);

		memmove(resp, data, n);

		if(write(s->asfd, resp, s->challen) != s->challen)

			return failure(fss, Easproto);

		/* get ticket plus authenticator from auth server */

		if(_asrdresp(s->asfd, tbuf, TICKETLEN+AUTHENTLEN) < 0)

			return failure(fss, nil);

		/* check ticket */

		convM2T(tbuf, &s->t, s->key->priv);

		if(s->t.num != AuthTs

		|| memcmp(s->t.chal, s->tr.chal, sizeof(s->t.chal)) != 0){

			if (s->key->successes == 0)

				disablekey(s->key);

			return failure(fss, Easproto);

		}

		s->key->successes++;

		convM2A(tbuf+TICKETLEN, &a, s->t.key);

		if(a.num != AuthAc

		|| memcmp(a.chal, s->tr.chal, sizeof(a.chal)) != 0

		|| a.id != 0)

			return failure(fss, Easproto);

		fss->haveai = 1;

		fss->ai.cuid = s->t.cuid;

		fss->ai.suid = s->t.suid;

		fss->ai.nsecret = 0;

		fss->ai.secret = nil;

		fss->phase = Established;

		return RpcOk;

	}

}

static int

getchal(State *s, Fsstate *fss)

{

	char trbuf[TICKREQLEN];

	int n;

	safecpy(s->tr.hostid, _strfindattr(s->key->attr, "user"), sizeof(s->tr.hostid));

	safecpy(s->tr.authdom, _strfindattr(s->key->attr, "dom"), sizeof(s->tr.authdom));

	s->tr.type = s->astype;

	convTR2M(&s->tr, trbuf);

	/* get challenge from auth server */

	s->asfd = _authdial(nil, _strfindattr(s->key->attr, "dom"));

	if(s->asfd < 0)

		return failure(fss, Easproto);

	if(write(s->asfd, trbuf, TICKREQLEN) != TICKREQLEN)

		return failure(fss, Easproto);

	n = _asrdresp(s->asfd, s->chal, s->challen);

	if(n <= 0){

		if(n == 0)

			werrstr("_asrdresp short read");

		return failure(fss, nil);

	}

	s->challen = n;

	fss->phase = SHaveChal;

	return RpcOk;

}

Proto p9cr =

{

.name=		"p9cr",

.init=		p9crinit,

.write=		p9crwrite,

.read=		p9crread,

.close=		p9crclose,

.keyprompt=	"user? !password?",

};

Proto vnc =

{

.name=		"vnc",

.init=		p9crinit,

.write=		p9crwrite,

.read=		p9crread,

.close=		p9crclose,

.keyprompt=	"!password?",

.addkey=	vncaddkey,

};