1af57ed9fSAtsushi Murai /* 2af57ed9fSAtsushi Murai * PPP PAP Module 3af57ed9fSAtsushi Murai * 4af57ed9fSAtsushi Murai * Written by Toshiharu OHNO (tony-o@iij.ad.jp) 5af57ed9fSAtsushi Murai * 6af57ed9fSAtsushi Murai * Copyright (C) 1993-94, Internet Initiative Japan, Inc. 7af57ed9fSAtsushi Murai * All rights reserverd. 8af57ed9fSAtsushi Murai * 9af57ed9fSAtsushi Murai * Redistribution and use in source and binary forms are permitted 10af57ed9fSAtsushi Murai * provided that the above copyright notice and this paragraph are 11af57ed9fSAtsushi Murai * duplicated in all such forms and that any documentation, 12af57ed9fSAtsushi Murai * advertising materials, and other materials related to such 13af57ed9fSAtsushi Murai * distribution and use acknowledge that the software was developed 14af57ed9fSAtsushi Murai * by the Internet Initiative Japan, Inc. The name of the 15af57ed9fSAtsushi Murai * IIJ may not be used to endorse or promote products derived 16af57ed9fSAtsushi Murai * from this software without specific prior written permission. 17af57ed9fSAtsushi Murai * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 18af57ed9fSAtsushi Murai * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 19af57ed9fSAtsushi Murai * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 20af57ed9fSAtsushi Murai * 2197d92980SPeter Wemm * $FreeBSD$ 22af57ed9fSAtsushi Murai * 23af57ed9fSAtsushi Murai * TODO: 24af57ed9fSAtsushi Murai */ 25972a1bcfSBrian Somers #include <sys/param.h> 2675240ed1SBrian Somers #include <netinet/in.h> 27eaa4df37SBrian Somers #include <netinet/in_systm.h> 28eaa4df37SBrian Somers #include <netinet/ip.h> 291fa665f5SBrian Somers #include <sys/un.h> 3075240ed1SBrian Somers 31f0cdd9c0SBrian Somers #include <stdlib.h> 32eb6e5e05SBrian Somers #include <string.h> /* strlen/memcpy */ 336140ba11SBrian Somers #include <termios.h> 3475240ed1SBrian Somers 355d9e6103SBrian Somers #include "layer.h" 3675240ed1SBrian Somers #include "mbuf.h" 3775240ed1SBrian Somers #include "log.h" 3875240ed1SBrian Somers #include "defs.h" 3975240ed1SBrian Somers #include "timer.h" 40af57ed9fSAtsushi Murai #include "fsm.h" 41af57ed9fSAtsushi Murai #include "lcp.h" 42e2ebb036SBrian Somers #include "auth.h" 43af57ed9fSAtsushi Murai #include "pap.h" 44879ed6faSBrian Somers #include "lqr.h" 45af57ed9fSAtsushi Murai #include "hdlc.h" 465d9e6103SBrian Somers #include "proto.h" 476140ba11SBrian Somers #include "async.h" 486140ba11SBrian Somers #include "throughput.h" 493b0f8d2eSBrian Somers #include "ccp.h" 506140ba11SBrian Somers #include "link.h" 5142d4d396SBrian Somers #include "descriptor.h" 5263b73463SBrian Somers #include "physical.h" 535828db6dSBrian Somers #include "iplist.h" 54eaa4df37SBrian Somers #include "slcompress.h" 555828db6dSBrian Somers #include "ipcp.h" 565ca5389aSBrian Somers #include "filter.h" 573b0f8d2eSBrian Somers #include "mp.h" 58972a1bcfSBrian Somers #ifndef NORADIUS 59972a1bcfSBrian Somers #include "radius.h" 60972a1bcfSBrian Somers #endif 61455aabc3SBrian Somers #include "bundle.h" 62e2ebb036SBrian Somers #include "chat.h" 63e2ebb036SBrian Somers #include "chap.h" 6492b09558SBrian Somers #include "cbcp.h" 65e2ebb036SBrian Somers #include "datalink.h" 66af57ed9fSAtsushi Murai 67182c898aSBrian Somers static const char * const papcodes[] = { 68182c898aSBrian Somers "???", "REQUEST", "SUCCESS", "FAILURE" 69182c898aSBrian Somers }; 70f0cdd9c0SBrian Somers #define MAXPAPCODE (sizeof papcodes / sizeof papcodes[0] - 1) 71af57ed9fSAtsushi Murai 72f0cdd9c0SBrian Somers static void 73f0cdd9c0SBrian Somers pap_Req(struct authinfo *authp) 74af57ed9fSAtsushi Murai { 75f0cdd9c0SBrian Somers struct bundle *bundle = authp->physical->dl->bundle; 76af57ed9fSAtsushi Murai struct fsmheader lh; 77af57ed9fSAtsushi Murai struct mbuf *bp; 78af57ed9fSAtsushi Murai u_char *cp; 79af57ed9fSAtsushi Murai int namelen, keylen, plen; 80af57ed9fSAtsushi Murai 81f0cdd9c0SBrian Somers namelen = strlen(bundle->cfg.auth.name); 82f0cdd9c0SBrian Somers keylen = strlen(bundle->cfg.auth.key); 83af57ed9fSAtsushi Murai plen = namelen + keylen + 2; 84f0cdd9c0SBrian Somers log_Printf(LogDEBUG, "pap_Req: namelen = %d, keylen = %d\n", namelen, keylen); 85f0cdd9c0SBrian Somers log_Printf(LogPHASE, "Pap Output: %s ********\n", bundle->cfg.auth.name); 86f0cdd9c0SBrian Somers if (*bundle->cfg.auth.name == '\0') 8793280d73SBrian Somers log_Printf(LogWARN, "Sending empty PAP authname!\n"); 88af57ed9fSAtsushi Murai lh.code = PAP_REQUEST; 89f0cdd9c0SBrian Somers lh.id = authp->id; 90af57ed9fSAtsushi Murai lh.length = htons(plen + sizeof(struct fsmheader)); 9126af0ae9SBrian Somers bp = m_get(plen + sizeof(struct fsmheader), MB_PAPOUT); 9275240ed1SBrian Somers memcpy(MBUF_CTOP(bp), &lh, sizeof(struct fsmheader)); 93af57ed9fSAtsushi Murai cp = MBUF_CTOP(bp) + sizeof(struct fsmheader); 94af57ed9fSAtsushi Murai *cp++ = namelen; 95f0cdd9c0SBrian Somers memcpy(cp, bundle->cfg.auth.name, namelen); 96af57ed9fSAtsushi Murai cp += namelen; 97af57ed9fSAtsushi Murai *cp++ = keylen; 98f0cdd9c0SBrian Somers memcpy(cp, bundle->cfg.auth.key, keylen); 99442f8495SBrian Somers link_PushPacket(&authp->physical->link, bp, bundle, 100442f8495SBrian Somers LINK_QUEUES(&authp->physical->link) - 1, PROTO_PAP); 101af57ed9fSAtsushi Murai } 102af57ed9fSAtsushi Murai 103af57ed9fSAtsushi Murai static void 104f0cdd9c0SBrian Somers SendPapCode(struct authinfo *authp, int code, const char *message) 105af57ed9fSAtsushi Murai { 106af57ed9fSAtsushi Murai struct fsmheader lh; 107af57ed9fSAtsushi Murai struct mbuf *bp; 108af57ed9fSAtsushi Murai u_char *cp; 109af57ed9fSAtsushi Murai int plen, mlen; 110af57ed9fSAtsushi Murai 111af57ed9fSAtsushi Murai lh.code = code; 112f0cdd9c0SBrian Somers lh.id = authp->id; 113af57ed9fSAtsushi Murai mlen = strlen(message); 114af57ed9fSAtsushi Murai plen = mlen + 1; 115af57ed9fSAtsushi Murai lh.length = htons(plen + sizeof(struct fsmheader)); 11626af0ae9SBrian Somers bp = m_get(plen + sizeof(struct fsmheader), MB_PAPOUT); 11775240ed1SBrian Somers memcpy(MBUF_CTOP(bp), &lh, sizeof(struct fsmheader)); 118af57ed9fSAtsushi Murai cp = MBUF_CTOP(bp) + sizeof(struct fsmheader); 119b5c3c9aeSBrian Somers /* 120b5c3c9aeSBrian Somers * If our message is longer than 255 bytes, truncate the length to 121b5c3c9aeSBrian Somers * 255 and send the entire message anyway. Maybe the other end will 122b5c3c9aeSBrian Somers * display it... (see pap_Input() !) 123b5c3c9aeSBrian Somers */ 124b5c3c9aeSBrian Somers *cp++ = mlen > 255 ? 255 : mlen; 12575240ed1SBrian Somers memcpy(cp, message, mlen); 126dd7e2610SBrian Somers log_Printf(LogPHASE, "Pap Output: %s\n", papcodes[code]); 127f0cdd9c0SBrian Somers 1285d9e6103SBrian Somers link_PushPacket(&authp->physical->link, bp, authp->physical->dl->bundle, 129442f8495SBrian Somers LINK_QUEUES(&authp->physical->link) - 1, PROTO_PAP); 130af57ed9fSAtsushi Murai } 131af57ed9fSAtsushi Murai 132f0cdd9c0SBrian Somers static void 133f0cdd9c0SBrian Somers pap_Success(struct authinfo *authp) 134af57ed9fSAtsushi Murai { 135f0cdd9c0SBrian Somers datalink_GotAuthname(authp->physical->dl, authp->in.name); 136f0cdd9c0SBrian Somers SendPapCode(authp, PAP_ACK, "Greetings!!"); 137f0cdd9c0SBrian Somers authp->physical->link.lcp.auth_ineed = 0; 138f0cdd9c0SBrian Somers if (Enabled(authp->physical->dl->bundle, OPT_UTMP)) 139f0cdd9c0SBrian Somers physical_Login(authp->physical, authp->in.name); 140af57ed9fSAtsushi Murai 141f0cdd9c0SBrian Somers if (authp->physical->link.lcp.auth_iwait == 0) 142455aabc3SBrian Somers /* 143455aabc3SBrian Somers * Either I didn't need to authenticate, or I've already been 144455aabc3SBrian Somers * told that I got the answer right. 145455aabc3SBrian Somers */ 146f0cdd9c0SBrian Somers datalink_AuthOk(authp->physical->dl); 147af57ed9fSAtsushi Murai } 148f0cdd9c0SBrian Somers 149f0cdd9c0SBrian Somers static void 150f0cdd9c0SBrian Somers pap_Failure(struct authinfo *authp) 151f0cdd9c0SBrian Somers { 152f0cdd9c0SBrian Somers SendPapCode(authp, PAP_NAK, "Login incorrect"); 153f0cdd9c0SBrian Somers datalink_AuthNotOk(authp->physical->dl); 154f0cdd9c0SBrian Somers } 155f0cdd9c0SBrian Somers 156f0cdd9c0SBrian Somers void 157f0cdd9c0SBrian Somers pap_Init(struct authinfo *pap, struct physical *p) 158f0cdd9c0SBrian Somers { 159f0cdd9c0SBrian Somers auth_Init(pap, p, pap_Req, pap_Success, pap_Failure); 160f0cdd9c0SBrian Somers } 161f0cdd9c0SBrian Somers 1625d9e6103SBrian Somers struct mbuf * 1635d9e6103SBrian Somers pap_Input(struct bundle *bundle, struct link *l, struct mbuf *bp) 164f0cdd9c0SBrian Somers { 1655d9e6103SBrian Somers struct physical *p = link2physical(l); 166f0cdd9c0SBrian Somers struct authinfo *authp = &p->dl->pap; 167f0cdd9c0SBrian Somers u_char nlen, klen, *key; 168b5c3c9aeSBrian Somers const char *txt; 169b5c3c9aeSBrian Somers int txtlen; 170f0cdd9c0SBrian Somers 1715d9e6103SBrian Somers if (p == NULL) { 1725d9e6103SBrian Somers log_Printf(LogERROR, "pap_Input: Not a physical link - dropped\n"); 17326af0ae9SBrian Somers m_freem(bp); 1745d9e6103SBrian Somers return NULL; 1755d9e6103SBrian Somers } 1765d9e6103SBrian Somers 1775d9e6103SBrian Somers if (bundle_Phase(bundle) != PHASE_NETWORK && 1785d9e6103SBrian Somers bundle_Phase(bundle) != PHASE_AUTHENTICATE) { 17929b873f3SBrian Somers log_Printf(LogPHASE, "Unexpected pap input - dropped !\n"); 18026af0ae9SBrian Somers m_freem(bp); 1815d9e6103SBrian Somers return NULL; 18229b873f3SBrian Somers } 18329b873f3SBrian Somers 184b7ff18adSBrian Somers if ((bp = auth_ReadHeader(authp, bp)) == NULL && 185b7ff18adSBrian Somers ntohs(authp->in.hdr.length) == 0) { 186b7ff18adSBrian Somers log_Printf(LogWARN, "Pap Input: Truncated header !\n"); 1875d9e6103SBrian Somers return NULL; 188b7ff18adSBrian Somers } 189f0cdd9c0SBrian Somers 190f0cdd9c0SBrian Somers if (authp->in.hdr.code == 0 || authp->in.hdr.code > MAXPAPCODE) { 191f0cdd9c0SBrian Somers log_Printf(LogPHASE, "Pap Input: %d: Bad PAP code !\n", authp->in.hdr.code); 19226af0ae9SBrian Somers m_freem(bp); 1935d9e6103SBrian Somers return NULL; 194f0cdd9c0SBrian Somers } 195f0cdd9c0SBrian Somers 196f0cdd9c0SBrian Somers if (authp->in.hdr.code != PAP_REQUEST && authp->id != authp->in.hdr.id && 1975d9e6103SBrian Somers Enabled(bundle, OPT_IDCHECK)) { 198f0cdd9c0SBrian Somers /* Wrong conversation dude ! */ 199f0cdd9c0SBrian Somers log_Printf(LogPHASE, "Pap Input: %s dropped (got id %d, not %d)\n", 200f0cdd9c0SBrian Somers papcodes[authp->in.hdr.code], authp->in.hdr.id, authp->id); 20126af0ae9SBrian Somers m_freem(bp); 2025d9e6103SBrian Somers return NULL; 203f0cdd9c0SBrian Somers } 20426af0ae9SBrian Somers m_settype(bp, MB_PAPIN); 205f0cdd9c0SBrian Somers authp->id = authp->in.hdr.id; /* We respond with this id */ 206f0cdd9c0SBrian Somers 207f0cdd9c0SBrian Somers if (bp) { 208f0cdd9c0SBrian Somers bp = mbuf_Read(bp, &nlen, 1); 209b5c3c9aeSBrian Somers if (authp->in.hdr.code == PAP_ACK) { 210b5c3c9aeSBrian Somers /* 211b5c3c9aeSBrian Somers * Don't restrict the length of our acknowledgement freetext to 212b5c3c9aeSBrian Somers * nlen (a one-byte length). Show the rest of the ack packet 213b5c3c9aeSBrian Somers * instead. This isn't really part of the protocol..... 214b5c3c9aeSBrian Somers */ 21526af0ae9SBrian Somers bp = m_pullup(bp); 216b5c3c9aeSBrian Somers txt = MBUF_CTOP(bp); 21726af0ae9SBrian Somers txtlen = m_length(bp); 218b5c3c9aeSBrian Somers } else { 219f0cdd9c0SBrian Somers bp = auth_ReadName(authp, bp, nlen); 220b5c3c9aeSBrian Somers txt = authp->in.name; 221b5c3c9aeSBrian Somers txtlen = strlen(authp->in.name); 222b5c3c9aeSBrian Somers } 223b5c3c9aeSBrian Somers } else { 224b5c3c9aeSBrian Somers txt = ""; 225b5c3c9aeSBrian Somers txtlen = 0; 226f0cdd9c0SBrian Somers } 227f0cdd9c0SBrian Somers 228b5c3c9aeSBrian Somers log_Printf(LogPHASE, "Pap Input: %s (%.*s)\n", 229b5c3c9aeSBrian Somers papcodes[authp->in.hdr.code], txtlen, txt); 230f0cdd9c0SBrian Somers 231f0cdd9c0SBrian Somers switch (authp->in.hdr.code) { 232f0cdd9c0SBrian Somers case PAP_REQUEST: 233f0cdd9c0SBrian Somers if (bp == NULL) { 234f0cdd9c0SBrian Somers log_Printf(LogPHASE, "Pap Input: No key given !\n"); 235af57ed9fSAtsushi Murai break; 236f0cdd9c0SBrian Somers } 237f0cdd9c0SBrian Somers bp = mbuf_Read(bp, &klen, 1); 23826af0ae9SBrian Somers if (m_length(bp) < klen) { 239f0cdd9c0SBrian Somers log_Printf(LogERROR, "Pap Input: Truncated key !\n"); 240f0cdd9c0SBrian Somers break; 241f0cdd9c0SBrian Somers } 242f0cdd9c0SBrian Somers if ((key = malloc(klen+1)) == NULL) { 243f0cdd9c0SBrian Somers log_Printf(LogERROR, "Pap Input: Out of memory !\n"); 244f0cdd9c0SBrian Somers break; 245f0cdd9c0SBrian Somers } 246f0cdd9c0SBrian Somers bp = mbuf_Read(bp, key, klen); 247f0cdd9c0SBrian Somers key[klen] = '\0'; 248f0cdd9c0SBrian Somers 249f0cdd9c0SBrian Somers #ifndef NORADIUS 2505d9e6103SBrian Somers if (*bundle->radius.cfg.file) 2515d9e6103SBrian Somers radius_Authenticate(&bundle->radius, authp, authp->in.name, 252f0cdd9c0SBrian Somers key, NULL); 253f0cdd9c0SBrian Somers else 254f0cdd9c0SBrian Somers #endif 2555d9e6103SBrian Somers if (auth_Validate(bundle, authp->in.name, key, p)) 256f0cdd9c0SBrian Somers pap_Success(authp); 257f0cdd9c0SBrian Somers else 258f0cdd9c0SBrian Somers pap_Failure(authp); 259f0cdd9c0SBrian Somers 260f0cdd9c0SBrian Somers free(key); 261f0cdd9c0SBrian Somers break; 262f0cdd9c0SBrian Somers 263af57ed9fSAtsushi Murai case PAP_ACK: 264f0cdd9c0SBrian Somers auth_StopTimer(authp); 265f0cdd9c0SBrian Somers if (p->link.lcp.auth_iwait == PROTO_PAP) { 266f0cdd9c0SBrian Somers p->link.lcp.auth_iwait = 0; 267f0cdd9c0SBrian Somers if (p->link.lcp.auth_ineed == 0) 268455aabc3SBrian Somers /* 269455aabc3SBrian Somers * We've succeeded in our ``login'' 270455aabc3SBrian Somers * If we're not expecting the peer to authenticate (or he already 271455aabc3SBrian Somers * has), proceed to network phase. 272455aabc3SBrian Somers */ 273f0cdd9c0SBrian Somers datalink_AuthOk(p->dl); 274af57ed9fSAtsushi Murai } 275af57ed9fSAtsushi Murai break; 276f0cdd9c0SBrian Somers 277af57ed9fSAtsushi Murai case PAP_NAK: 278f0cdd9c0SBrian Somers auth_StopTimer(authp); 279f0cdd9c0SBrian Somers datalink_AuthNotOk(p->dl); 280af57ed9fSAtsushi Murai break; 281af57ed9fSAtsushi Murai } 282f0cdd9c0SBrian Somers 28326af0ae9SBrian Somers m_freem(bp); 2845d9e6103SBrian Somers return NULL; 285af57ed9fSAtsushi Murai } 286