/* * CHAP, MSCHAP * * The client does not authenticate the server, hence no CAI * * Client protocol: * write Chapchal * read response Chapreply or MSchaprely structure * * Server protocol: * read challenge: 8 bytes binary * write user: utf8 * write response: Chapreply or MSchapreply structure */ #include #include "dat.h" enum { ChapChallen = 8, ChapResplen = 16, MSchapResplen = 24, }; static int dochal(State*); static int doreply(State*, void*, int); static void doLMchap(char *, uchar [ChapChallen], uchar [MSchapResplen]); static void doNTchap(char *, uchar [ChapChallen], uchar [MSchapResplen]); static void dochap(char *, int, char [ChapChallen], uchar [ChapResplen]); struct State { char *protoname; int astype; int asfd; Key *key; Ticket t; Ticketreq tr; char chal[ChapChallen]; MSchapreply mcr; char cr[ChapResplen]; char err[ERRMAX]; char user[64]; uchar secret[16]; /* for mschap */ int nsecret; }; enum { CNeedChal, CHaveResp, SHaveChal, SNeedUser, SNeedResp, SHaveZero, SHaveCAI, Maxphase }; static char *phasenames[Maxphase] = { [CNeedChal] "CNeedChal", [CHaveResp] "CHaveResp", [SHaveChal] "SHaveChal", [SNeedUser] "SNeedUser", [SNeedResp] "SNeedResp", [SHaveZero] "SHaveZero", [SHaveCAI] "SHaveCAI", }; static int chapinit(Proto *p, Fsstate *fss) { int iscli, ret; State *s; if((iscli = isclient(_strfindattr(fss->attr, "role"))) < 0) return failure(fss, nil); s = emalloc(sizeof *s); fss->phasename = phasenames; fss->maxphase = Maxphase; s->asfd = -1; if(p == &chap){ s->astype = AuthChap; s->protoname = "chap"; }else{ s->astype = AuthMSchap; s->protoname = "mschap"; } if(iscli) fss->phase = CNeedChal; else{ if((ret = findp9authkey(&s->key, fss)) != RpcOk){ free(s); return ret; } if(dochal(s) < 0){ free(s); return failure(fss, nil); } fss->phase = SHaveChal; } fss->ps = s; return RpcOk; } static void chapclose(Fsstate *fss) { State *s; s = fss->ps; if(s->asfd >= 0){ close(s->asfd); s->asfd = -1; } free(s); } static int chapwrite(Fsstate *fss, void *va, uint n) { int ret, nreply; char *a, *v; void *reply; Key *k; Keyinfo ki; State *s; Chapreply cr; MSchapreply mcr; OChapreply ocr; OMSchapreply omcr; s = fss->ps; a = va; switch(fss->phase){ default: return phaseerror(fss, "write"); case CNeedChal: ret = findkey(&k, mkkeyinfo(&ki, fss, nil), "%s", fss->proto->keyprompt); if(ret != RpcOk) return ret; v = _strfindattr(k->privattr, "!password"); if(v == nil) return failure(fss, "key has no password"); setattrs(fss->attr, k->attr); switch(s->astype){ default: abort(); case AuthMSchap: doLMchap(v, (uchar *)a, (uchar *)s->mcr.LMresp); doNTchap(v, (uchar *)a, (uchar *)s->mcr.NTresp); break; case AuthChap: dochap(v, *a, a+1, (uchar *)s->cr); break; } closekey(k); fss->phase = CHaveResp; return RpcOk; case SNeedUser: if(n >= sizeof s->user) return failure(fss, "user name too long"); memmove(s->user, va, n); s->user[n] = '\0'; fss->phase = SNeedResp; return RpcOk; case SNeedResp: switch(s->astype){ default: return failure(fss, "chap internal botch"); case AuthChap: if(n != sizeof(Chapreply)) return failure(fss, "did not get Chapreply"); memmove(&cr, va, sizeof cr); ocr.id = cr.id; memmove(ocr.resp, cr.resp, sizeof ocr.resp); memset(omcr.uid, 0, sizeof(omcr.uid)); strecpy(ocr.uid, ocr.uid+sizeof ocr.uid, s->user); reply = &ocr; nreply = sizeof ocr; break; case AuthMSchap: if(n != sizeof(MSchapreply)) return failure(fss, "did not get MSchapreply"); memmove(&mcr, va, sizeof mcr); memmove(omcr.LMresp, mcr.LMresp, sizeof omcr.LMresp); memmove(omcr.NTresp, mcr.NTresp, sizeof omcr.NTresp); memset(omcr.uid, 0, sizeof(omcr.uid)); strecpy(omcr.uid, omcr.uid+sizeof omcr.uid, s->user); reply = &omcr; nreply = sizeof omcr; break; } if(doreply(s, reply, nreply) < 0) return failure(fss, nil); fss->phase = Established; fss->ai.cuid = s->t.cuid; fss->ai.suid = s->t.suid; fss->ai.secret = s->secret; fss->ai.nsecret = s->nsecret; fss->haveai = 1; return RpcOk; } } static int chapread(Fsstate *fss, void *va, uint *n) { State *s; s = fss->ps; switch(fss->phase){ default: return phaseerror(fss, "read"); case CHaveResp: switch(s->astype){ default: phaseerror(fss, "write"); break; case AuthMSchap: if(*n > sizeof(MSchapreply)) *n = sizeof(MSchapreply); memmove(va, &s->mcr, *n); break; case AuthChap: if(*n > ChapResplen) *n = ChapResplen; memmove(va, s->cr, ChapResplen); break; } fss->phase = Established; fss->haveai = 0; return RpcOk; case SHaveChal: if(*n > sizeof s->chal) *n = sizeof s->chal; memmove(va, s->chal, *n); fss->phase = SNeedUser; return RpcOk; } } static int dochal(State *s) { char *dom, *user; char trbuf[TICKREQLEN]; s->asfd = -1; /* send request to authentication server and get challenge */ if((dom = _strfindattr(s->key->attr, "dom")) == nil || (user = _strfindattr(s->key->attr, "user")) == nil){ werrstr("chap/dochal cannot happen"); goto err; } s->asfd = _authdial(nil, dom); if(s->asfd < 0) goto err; memset(&s->tr, 0, sizeof(s->tr)); s->tr.type = s->astype; safecpy(s->tr.authdom, dom, sizeof s->tr.authdom); safecpy(s->tr.hostid, user, sizeof(s->tr.hostid)); convTR2M(&s->tr, trbuf); if(write(s->asfd, trbuf, TICKREQLEN) != TICKREQLEN) goto err; /* readn, not _asrdresp. needs to match auth.srv.c. */ if(readn(s->asfd, s->chal, sizeof s->chal) != sizeof s->chal) goto err; return 0; err: if(s->asfd >= 0) close(s->asfd); s->asfd = -1; return -1; } static int doreply(State *s, void *reply, int nreply) { char ticket[TICKETLEN+AUTHENTLEN]; int n; Authenticator a; if((n=write(s->asfd, reply, nreply)) != nreply){ if(n >= 0) werrstr("short write to auth server"); goto err; } if(_asrdresp(s->asfd, ticket, TICKETLEN+AUTHENTLEN) < 0){ /* leave connection open so we can try again */ return -1; } s->nsecret = readn(s->asfd, s->secret, sizeof s->secret); if(s->nsecret < 0) s->nsecret = 0; close(s->asfd); s->asfd = -1; convM2T(ticket, &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); werrstr(Easproto); return -1; } s->key->successes++; convM2A(ticket+TICKETLEN, &a, s->t.key); if(a.num != AuthAc || memcmp(a.chal, s->tr.chal, sizeof(a.chal)) != 0 || a.id != 0){ werrstr(Easproto); return -1; } return 0; err: if(s->asfd >= 0) close(s->asfd); s->asfd = -1; return -1; } Proto chap = { .name= "chap", .init= chapinit, .write= chapwrite, .read= chapread, .close= chapclose, .addkey= replacekey, .keyprompt= "!password?" }; Proto mschap = { .name= "mschap", .init= chapinit, .write= chapwrite, .read= chapread, .close= chapclose, .addkey= replacekey, .keyprompt= "!password?" }; static void hash(uchar pass[16], uchar c8[ChapChallen], uchar p24[MSchapResplen]) { int i; uchar p21[21]; ulong schedule[32]; memset(p21, 0, sizeof p21 ); memmove(p21, pass, 16); for(i=0; i<3; i++) { key_setup(p21+i*7, schedule); memmove(p24+i*8, c8, 8); block_cipher(schedule, p24+i*8, 0); } } static void doNTchap(char *pass, uchar chal[ChapChallen], uchar reply[MSchapResplen]) { Rune r; int i, n; uchar digest[MD4dlen]; uchar *w, unipass[256]; /* Standard says unlimited length, experience says 128 max */ if ((n = strlen(pass)) > 128) n = 128; /* assume 16 bit Rune */ for(i=0, w=unipass; i < n; i++) { pass += chartorune(&r, pass); *w++ = r & 0xff; *w++ = r >> 8; } memset(digest, 0, sizeof digest); md4(unipass, w-unipass, digest, nil); memset(unipass, 0, sizeof unipass); hash(digest, chal, reply); } static void doLMchap(char *pass, uchar chal[ChapChallen], uchar reply[MSchapResplen]) { int i; ulong schedule[32]; uchar p14[15], p16[16]; uchar s8[8] = {0x4b, 0x47, 0x53, 0x21, 0x40, 0x23, 0x24, 0x25}; int n = strlen(pass); if(n > 14){ // let prudent people avoid the LM vulnerability // and protect the loop below from buffer overflow memset(reply, 0, MSchapResplen); return; } // Spec says space padded, experience says otherwise memset(p14, 0, sizeof p14 -1); p14[sizeof p14 - 1] = '\0'; // NT4 requires uppercase, Win XP doesn't care for (i = 0; pass[i]; i++) p14[i] = islower(pass[i])? toupper(pass[i]): pass[i]; for(i=0; i<2; i++) { key_setup(p14+i*7, schedule); memmove(p16+i*8, s8, 8); block_cipher(schedule, p16+i*8, 0); } memset(p14, 0, sizeof p14); hash(p16, chal, reply); } static void dochap(char *pass, int id, char chal[ChapChallen], uchar resp[ChapResplen]) { char buf[1+ChapChallen+MAXNAMELEN+1]; int n = strlen(pass); *buf = id; if (n > MAXNAMELEN) n = MAXNAMELEN-1; memset(buf, 0, sizeof buf); strncpy(buf+1, pass, n); memmove(buf+1+n, chal, ChapChallen); md5((uchar*)buf, 1+n+ChapChallen, resp, nil); }