From 45afdb408f5837a9869b77b3d552c83088bf642a Mon Sep 17 00:00:00 2001 From: deraadt Date: Thu, 20 Feb 1997 01:07:26 +0000 Subject: [PATCH] IPSEC package by John Ioannidis and Angelos D. Keromytis. Written in Greece. From ftp.funet.fi:/pub/unix/security/net/ip/BSDipsec.tar.gz --- sys/conf/files | 19 +- sys/kern/uipc_domain.c | 5 +- sys/miscfs/kernfs/kernfs_vnops.c | 17 +- sys/net/encap.c | 393 +++++++++++++++ sys/net/encap.h | 230 +++++++++ sys/net/if_enc.c | 247 ++++++++++ sys/net/if_types.h | 1 + sys/net/route.c | 18 +- sys/netinet/in.h | 4 +- sys/netinet/in_proto.c | 34 +- sys/netinet/ip_ah.c | 160 ++++++ sys/netinet/ip_ah.h | 162 +++++++ sys/netinet/ip_ahhmacmd5.c | 459 ++++++++++++++++++ sys/netinet/ip_ahhmacsha1.c | 463 ++++++++++++++++++ sys/netinet/ip_ahmd5.c | 353 ++++++++++++++ sys/netinet/ip_esp.c | 158 ++++++ sys/netinet/ip_esp.h | 179 +++++++ sys/netinet/ip_esp3desmd5.c | 749 ++++++++++++++++++++++++++++ sys/netinet/ip_espdes.c | 516 ++++++++++++++++++++ sys/netinet/ip_espdesmd5.c | 805 +++++++++++++++++++++++++++++++ sys/netinet/ip_ip4.c | 222 +++++++++ sys/netinet/ip_ip4.h | 40 ++ sys/netinet/ip_ipsp.c | 259 ++++++++++ sys/netinet/ip_ipsp.h | 139 ++++++ sys/netinet/ip_md5.h | 71 +++ sys/netinet/ip_md5c.c | 383 +++++++++++++++ sys/netinet/ip_mroute.c | 23 +- sys/netinet/ip_output.c | 182 ++++++- sys/netinet/ip_sha1.c | 166 +++++++ sys/netinet/ip_sha1.h | 16 + sys/netinet/ip_var.h | 6 +- sys/sys/malloc.h | 11 +- sys/sys/socket.h | 9 +- 33 files changed, 6481 insertions(+), 18 deletions(-) create mode 100644 sys/net/encap.c create mode 100644 sys/net/encap.h create mode 100644 sys/net/if_enc.c create mode 100644 sys/netinet/ip_ah.c create mode 100644 sys/netinet/ip_ah.h create mode 100644 sys/netinet/ip_ahhmacmd5.c create mode 100644 sys/netinet/ip_ahhmacsha1.c create mode 100644 sys/netinet/ip_ahmd5.c create mode 100644 sys/netinet/ip_esp.c create mode 100644 sys/netinet/ip_esp.h create mode 100644 sys/netinet/ip_esp3desmd5.c create mode 100644 sys/netinet/ip_espdes.c create mode 100644 sys/netinet/ip_espdesmd5.c create mode 100644 sys/netinet/ip_ip4.c create mode 100644 sys/netinet/ip_ip4.h create mode 100644 sys/netinet/ip_ipsp.c create mode 100644 sys/netinet/ip_ipsp.h create mode 100644 sys/netinet/ip_md5.h create mode 100644 sys/netinet/ip_md5c.c create mode 100644 sys/netinet/ip_sha1.c create mode 100644 sys/netinet/ip_sha1.h diff --git a/sys/conf/files b/sys/conf/files index dbcb9628c28..f3c3d77442b 100644 --- a/sys/conf/files +++ b/sys/conf/files @@ -1,4 +1,4 @@ -# $OpenBSD: files,v 1.49 1996/12/23 02:42:23 deraadt Exp $ +# $OpenBSD: files,v 1.50 1997/02/20 01:07:37 deraadt Exp $ # $NetBSD: files,v 1.87 1996/05/19 17:17:50 jonathan Exp $ # @(#)files.newconf 7.5 (Berkeley) 5/10/93 @@ -86,6 +86,7 @@ pseudo-device tun: ifnet pseudo-device bpfilter: ifnet pseudo-device strip: ifnet pseudo-device random +pseudo-device enc: ifnet # XXX machine-independent SCSI files should live somewhere here, maybe @@ -252,6 +253,8 @@ file net/raw_usrreq.c file net/route.c file net/rtsock.c file net/slcompress.c sl | ppp | strip +file net/if_enc.c inet +file net/encap.c inet file netccitt/ccitt_proto.c ccitt file netccitt/hd_debug.c hdlc file netccitt/hd_input.c hdlc @@ -294,6 +297,20 @@ file netinet/fil.c ipfilter file netinet/ip_nat.c ipfilter file netinet/ip_frag.c ipfilter file netinet/ip_state.c ipfilter +file netinet/ip_ah.c inet | ipsec +file netinet/ip_esp.c inet | ipsec +file netinet/ip_espdes.c inet | ipsec +file netinet/ip_espdesmd5.c inet | ipsec +file netinet/ip_ipsp.c inet | ipsec +file netinet/ip_ahmd5.c inet | ipsec +file netinet/ip_ip4.c inet | ipsec +file netinet/ip_ahhmacmd5.c inet | ipsec +file netinet/ip_ahhmacsha1.c inet | ipsec +file netinet/ip_sha1.c inet | ipsec +file netinet/ip_md5c.c inet | ipsec +file netinet/libdeslite/ecb_enc.c inet | ipsec +file netinet/libdeslite/set_key.c inet | ipsec +file netinet/ip_esp3desmd5.c inet | ipsec file netiso/clnp_debug.c iso file netiso/clnp_er.c iso file netiso/clnp_frag.c iso diff --git a/sys/kern/uipc_domain.c b/sys/kern/uipc_domain.c index 406a420d352..790eceafddf 100644 --- a/sys/kern/uipc_domain.c +++ b/sys/kern/uipc_domain.c @@ -1,4 +1,4 @@ -/* $OpenBSD: uipc_domain.c,v 1.3 1996/04/27 13:21:06 mickey Exp $ */ +/* $OpenBSD: uipc_domain.c,v 1.4 1997/02/20 01:07:26 deraadt Exp $ */ /* $NetBSD: uipc_domain.c,v 1.14 1996/02/09 19:00:44 christos Exp $ */ /* @@ -69,6 +69,9 @@ domaininit() ADDDOMAIN(route); #ifdef INET ADDDOMAIN(inet); +#ifdef IPSEC + ADDDOMAIN(encap); +#endif #endif #ifdef IPX ADDDOMAIN(ipx); diff --git a/sys/miscfs/kernfs/kernfs_vnops.c b/sys/miscfs/kernfs/kernfs_vnops.c index f77a606a13e..0a94d88248b 100644 --- a/sys/miscfs/kernfs/kernfs_vnops.c +++ b/sys/miscfs/kernfs/kernfs_vnops.c @@ -1,4 +1,4 @@ -/* $OpenBSD: kernfs_vnops.c,v 1.6 1997/01/15 03:06:28 kstailey Exp $ */ +/* $OpenBSD: kernfs_vnops.c,v 1.7 1997/02/20 01:08:12 deraadt Exp $ */ /* $NetBSD: kernfs_vnops.c,v 1.43 1996/03/16 23:52:47 christos Exp $ */ /* @@ -75,6 +75,10 @@ static int ncpu = 1; /* XXX */ extern char machine[], cpu_model[]; extern char ostype[], osrelease[]; +#ifdef IPSEC +extern int ipsp_kern __P((int, char **, int)); +#endif + struct kern_target { u_char kt_type; u_char kt_namlen; @@ -90,6 +94,9 @@ struct kern_target { #define KTT_MSGBUF 89 #define KTT_USERMEM 91 #define KTT_DOMAIN 95 +#ifdef IPSEC +#define KTT_IPSECSPI 107 +#endif u_char kt_tag; u_char kt_vtype; mode_t kt_mode; @@ -124,6 +131,9 @@ struct kern_target { { DT_REG, N("time"), 0, KTT_TIME, VREG, READ_MODE }, { DT_REG, N("usermem"), 0, KTT_USERMEM, VREG, READ_MODE }, { DT_REG, N("version"), version, KTT_STRING, VREG, READ_MODE }, +#ifdef IPSEC + { DT_REG, N("ipsec"), 0, KTT_IPSECSPI, VREG, READ_MODE }, +#endif #undef N }; static int nkern_targets = sizeof(kern_targets) / sizeof(kern_targets[0]); @@ -304,7 +314,10 @@ kernfs_xread(kt, off, bufp, len) case KTT_USERMEM: sprintf(*bufp, "%u\n", physmem - cnt.v_wire_count); break; - +#ifdef IPSEC + case KTT_IPSECSPI: + return(ipsp_kern(off, bufp, len)); +#endif default: return (0); } diff --git a/sys/net/encap.c b/sys/net/encap.c new file mode 100644 index 00000000000..a8e1de64073 --- /dev/null +++ b/sys/net/encap.c @@ -0,0 +1,393 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +#ifdef INET +#include +#endif + +#include +#include + +extern struct ifnet loif; + +extern int ipspkernfs_dirty; + +void encap_init(void); +int encap_output __P((struct mbuf *, ...)); +int encap_usrreq(struct socket *, int, struct mbuf *, struct mbuf *, struct mbuf *); + +extern int tdb_init(struct tdb *, struct mbuf *); + +extern struct domain encapdomain; + +struct sockaddr encap_dst = { 2, PF_ENCAP, }; +struct sockaddr encap_src = { 2, PF_ENCAP, }; +struct sockproto encap_proto = { PF_ENCAP, }; + +struct protosw encapsw[] = { +{ SOCK_RAW, &encapdomain, 0, PR_ATOMIC|PR_ADDR, + raw_input, encap_output, raw_ctlinput, 0, + encap_usrreq, + encap_init, 0, 0, 0, +}, +}; + +struct domain encapdomain = + { AF_ENCAP, "encapsulation", 0, 0, 0, + encapsw, &encapsw[sizeof(encapsw)/sizeof(encapsw[0])], 0, + rn_inithead, 16, sizeof(struct sockaddr_encap)}; + + +void +encap_init() +{ + struct xformsw *xsp; + + for (xsp = xformsw; xsp < xformswNXFORMSW; xsp++) + { + printf("encap_init: attaching <%s>\n", xsp->xf_name); + (*(xsp->xf_attach))(); + } +} + +/*ARGSUSED*/ +int +encap_usrreq(register struct socket *so, int req, struct mbuf *m, struct mbuf *nam, struct mbuf *control) +{ + register int error = 0; + register struct rawcb *rp = sotorawcb(so); + int s; + + if (req == PRU_ATTACH) + { + MALLOC(rp, struct rawcb *, sizeof(*rp), M_PCB, M_WAITOK); + if ((so->so_pcb = (caddr_t)rp)) + bzero(so->so_pcb, sizeof(*rp)); + + } + s = splnet(); + error = raw_usrreq(so, req, m, nam, control); + rp = sotorawcb(so); + if ((req == PRU_ATTACH) && rp) + { + /* int af = rp->rcb_proto.sp_protocol; */ + + if (error) + { + free((caddr_t)rp, M_PCB); + splx(s); + return error; + } + rp->rcb_faddr = &encap_src; + soisconnected(so); + so->so_options |= SO_USELOOPBACK; + } + splx(s); + return error; +} + +int +#ifdef __STDC__ +encap_output(struct mbuf *m, ...) +#else +encap_output(m, va_alist) + register struct mbuf *m; + va_dcl +#endif +{ +#define SENDERR(e) do { error = e; goto flush;} while (0) + struct socket *so; + int len, emlen, error = 0, nspis, i; + struct encap_msghdr *emp; + struct ifnet *ifp; + struct ifaddr *ifa; + struct sockaddr_encap *sen, *sen2; + struct sockaddr_in *sin; + struct tdb *tdbp, *tprev; + va_list ap; + + va_start(ap, m); + so = va_arg(ap, struct socket *); + va_end(ap); + + if ((m == 0) || ((m->m_len < sizeof(long)) && + (m = m_pullup(m, sizeof(long))) == 0)) + return ENOBUFS; + + if ((m->m_flags & M_PKTHDR) == 0) + panic("encap_output"); + + len = m->m_pkthdr.len; + emp = mtod(m, struct encap_msghdr *); + emlen = emp->em_msglen; + if ((len < emlen)) + SENDERR(EINVAL); + + if (m->m_len < emlen) + { + m = m_pullup(m, emlen); + if (m == NULL) + SENDERR(ENOBUFS); + + emp = mtod(m, struct encap_msghdr *); + } + + switch (emp->em_type) + { + case EMT_IFADDR: + /* + * Set the default source address for an encap interface + */ + + ifp = &(enc_softc[emp->em_ifn].enc_if); + + if ((ifp->if_addrlist.tqh_first == NULL) || + (ifp->if_addrlist.tqh_first->ifa_addr == NULL) || + (ifp->if_addrlist.tqh_first->ifa_addr->sa_family != AF_ENCAP)) + { + MALLOC(ifa, struct ifaddr *, sizeof (struct ifaddr) + 2*SENT_DEFIF_LEN, M_IFADDR, M_WAITOK); + if (ifa == NULL) + SENDERR(ENOBUFS); + bzero((caddr_t)ifa, sizeof (struct ifaddr) + 2*SENT_DEFIF_LEN); + sen = (struct sockaddr_encap *)(ifa + 1); + sen2 = (struct sockaddr_encap *)((caddr_t)sen + SENT_DEFIF_LEN); + ifa->ifa_addr = (struct sockaddr *)sen; + ifa->ifa_dstaddr = (struct sockaddr *)sen2; + ifa->ifa_ifp = ifp; + TAILQ_INSERT_HEAD(&(ifp->if_addrlist), ifa, ifa_list); + } + else + { + sen = (struct sockaddr_encap *)((&(ifp->if_addrlist))->tqh_first->ifa_addr); + sen2 = (struct sockaddr_encap *)((&(ifp->if_addrlist))->tqh_first->ifa_dstaddr); + } + + sen->sen_family = AF_ENCAP; + sen->sen_len = SENT_DEFIF_LEN; + sen->sen_type = SENT_DEFIF; + sin = (struct sockaddr_in *) &(sen->sen_dfl); + sin->sin_len = sizeof(*sin); + sin->sin_family = AF_INET; + sin->sin_addr = emp->em_ifa; + + *sen2 = *sen; + + break; + + case EMT_SETSPI: + if (emp->em_if >= nencap) + SENDERR(ENODEV); + + tdbp = gettdb(emp->em_spi, emp->em_dst); + if (tdbp == NULL) + { + MALLOC(tdbp, struct tdb *, sizeof (*tdbp), M_TDB, M_WAITOK); + if (tdbp == NULL) + SENDERR(ENOBUFS); + + bzero((caddr_t)tdbp, sizeof(*tdbp)); + + tdbp->tdb_spi = emp->em_spi; + tdbp->tdb_dst = emp->em_dst; + tdbp->tdb_rcvif = &(enc_softc[emp->em_if].enc_if); + puttdb(tdbp); + } + else + (*tdbp->tdb_xform->xf_zeroize)(tdbp); + + error = tdb_init(tdbp, m); + ipspkernfs_dirty = 1; + break; + + case EMT_DELSPI: + if (emp->em_if >= nencap) + SENDERR(ENODEV); + + tdbp = gettdb(emp->em_spi, emp->em_dst); + if (tdbp == NULL) + { + error = EINVAL; + break; + } + + if (emp->em_alg != tdbp->tdb_xform->xf_type) + { + error = EINVAL; + break; + } + + error = tdb_delete(tdbp, 0); + break; + + case EMT_DELSPICHAIN: + if (emp->em_if >= nencap) + SENDERR(ENODEV); + + tdbp = gettdb(emp->em_spi, emp->em_dst); + if (tdbp == NULL) + { + error = EINVAL; + break; + } + + if (emp->em_alg != tdbp->tdb_xform->xf_type) + { + error = EINVAL; + break; + } + + error = tdb_delete(tdbp, 1); + break; + + case EMT_GRPSPIS: + nspis = (emlen - 4) / 12; + if (nspis * 12 + 4 != emlen) + { + SENDERR(EINVAL); + break; + } + + for (i = 0; i < nspis; i++) + if ((tdbp = gettdb(emp->em_rel[i].emr_spi, emp->em_rel[i].emr_dst)) == NULL) + SENDERR(ENOENT); + else + emp->em_rel[i].emr_tdb = tdbp; + tprev = emp->em_rel[0].emr_tdb; + tprev->tdb_inext = NULL; + for (i = 1; i < nspis; i++) + { + tdbp = emp->em_rel[i].emr_tdb; + tprev->tdb_onext = tdbp; + tdbp->tdb_inext = tprev; + tprev = tdbp; + } + tprev->tdb_onext = NULL; + ipspkernfs_dirty = 1; + error = 0; + break; + + default: + SENDERR(EINVAL); + } + + return error; + + flush: + if (m) + m_freem(m); + return error; +} + +struct ifaddr * +encap_findgwifa(struct sockaddr *gw) +{ + struct sockaddr_encap *egw = (struct sockaddr_encap *)gw; + u_char *op = (u_char *)gw; + int i, j; + struct ifaddr *retval = loif.if_addrlist.tqh_first; + union + { + struct in_addr ia; + u_char io[4]; + } iao; + + switch (egw->sen_type) + { + case SENT_IPSP: + return enc_softc[egw->sen_ipsp_ifn].enc_if.if_addrlist.tqh_first; + break; + + case SENT_IP4: + /* + * Pretty-much standard options walking code. + * Repeated elsewhere as necessary + */ + + for (i = SENT_IP4_LEN; i < egw->sen_len;) + switch (op[i]) + { + case SENO_EOL: + goto opt_done; + + case SENO_NOP: + i++; + continue; + + case SENO_IFN: + if (op[i+1] != 3) + { + return NULL; + } + retval = enc_softc[op[i+2]].enc_if.if_addrlist.tqh_first; + goto opt_done; + + case SENO_IFIP4A: + if (op[i+1] != 6) /* XXX -- IPv4 address */ + { + return NULL; + } + iao.io[0] = op[i+2]; + iao.io[1] = op[i+3]; + iao.io[2] = op[i+4]; + iao.io[3] = op[i+5]; + + for (j = 0; j < nencap; j++) + { + struct ifaddr *ia = (struct ifaddr *)enc_softc[j].enc_if.if_addrlist.tqh_first; + + struct sockaddr_in *si = (struct sockaddr_in *)ia->ifa_addr; + + if ((si->sin_family == AF_INET) && (si->sin_addr.s_addr == iao.ia.s_addr)) + { + retval = ia; + goto opt_done; + } + } + i += 6; + break; + + default: + if (op[i+1] == 0) + return NULL; + i += op[i+i]; + } + opt_done: + break; + } + return retval; +} diff --git a/sys/net/encap.h b/sys/net/encap.h new file mode 100644 index 00000000000..4d105db0cd7 --- /dev/null +++ b/sys/net/encap.h @@ -0,0 +1,230 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * encap.h + * + * Declarations useful in the encapsulation code. + */ + +/* + * Definitions for encapsulation-related phenomena. + * + * A lot of encapsulation protocols (ipip, swipe, ip_encap, ipsp, etc.) + * select their tunnel based on the destination (and sometimes the source) + * of the packet. The encap address/protocol family provides a generic + * mechanism for specifying tunnels. + */ + +/* + * A tunnel is characterized by which source/destination address pairs + * (with netmasks) it is valid for (the "destination" as far as the + * routing code is concerned), and what the source (local) and destination + * (remote) endpoints of the tunnel, and the SPI, should be (the "gateway" + * as far as the routing code is concerned. + */ + + +struct sockaddr_encap +{ + u_int8_t sen_len; /* length */ + u_int8_t sen_family; /* AF_ENCAP */ + u_int16_t sen_type; /* see SENT_* */ + union + { + u_int8_t Data[16]; /* other stuff mapped here */ + struct sockaddr Dfl; /* SENT_DEFIF */ + struct /* SENT_SA */ + { + struct sockaddr Src; + struct sockaddr Dst; + } Sa; +#ifdef INET + struct /* SENT_SAIN */ + { + struct sockaddr_in Src; + struct sockaddr_in Dst; + } Sin; + struct /* SENT_IP4 */ + { + struct in_addr Src; + struct in_addr Dst; + u_int16_t Sport; + u_int16_t Dport; + u_int8_t Proto; + u_int8_t Filler[3]; + } Sip4; + struct /* SENT_IPSP */ + { + struct in_addr Src; + struct in_addr Dst; + u_int32_t Spi; + u_int8_t Ifn; + u_int8_t Filler[3]; + } Sipsp; +#endif + } Sen; +}; + +#define sen_data Sen.Data +#define sen_dfl Sen.Dfl +#define sen_sa_src Sen.Sa.Src +#define sen_sa_dst Sen.Sa.Dst +#ifdef INET +#define sen_sin_src Sen.Sin.Src +#define sen_sin_dst Sen.Sin.Dst +#define sen_ip_src Sen.Sip4.Src +#define sen_ip_dst Sen.Sip4.Dst +#define sen_ipsp_src Sen.Sipsp.Src +#define sen_ipsp_dst Sen.Sipsp.Dst +#define sen_ipsp_spi Sen.Sipsp.Spi +#define sen_ipsp_ifn Sen.Sipsp.Ifn +#define sen_proto Sen.Sip4.Proto +#define sen_sport Sen.Sip4.Sport +#define sen_dport Sen.Sip4.Dport +#endif + +/* + * The "type" is really part of the address as far as the routing + * system is concerned. By using only one bit in the type field + * for each type, we sort-of make sure that different types of + * encapsulation addresses won't be matched against the wrong type. + * + */ + +#define SENT_DEFIF 0x0001 /* data is a default sockaddr for if */ +#define SENT_SA 0x0002 /* data is two struct sockaddr */ +#define SENT_SAIN 0x0004 /* data is two struct sockaddr_in */ +#define SENT_IP4 0x0008 /* data is two struct in_addr */ +#define SENT_IPSP 0x0010 /* data as in IP4 plus SPI and if# */ + +/* + * SENT_HDRLEN is the length of the "header" + * SENT_*_LEN are the lengths of various forms of sen_data + * SENT_*_OFF are the offsets in the sen_data array of various fields + */ + +#define SENT_HDRLEN (2*sizeof(u_int8_t)+sizeof(u_int16_t)) + +#define SENT_DEFIF_LEN (SENT_HDRLEN + sizeof (struct sockaddr_in)) + +#define SENT_IP4_SRCOFF (0) +#define SENT_IP4_DSTOFF (sizeof (struct in_addr)) +#define SENT_IP4_OPTOFF (2*sizeof(struct in_addr)+2*sizeof(u_int16_t)+sizeof(u_int8_t)+3*sizeof(u_int8_t)) + +#define SENT_IP4_LEN (SENT_HDRLEN + SENT_IP4_OPTOFF) + +#define SENT_IPSP_LEN (SENT_HDRLEN + 2 * sizeof (struct in_addr) + sizeof (u_int32_t) + 4) + +/* + * Options 0x00 and 01 are 1-byte options (no arguments). + * The rest of the options are T-L-V fields, where the L includes + * the T and L bytes; thus, the minimum length for an option with + * no arguments is 2. An option of length less than 2 causes en EINVAL + */ + + +#define SENO_EOL 0x00 /* End of Options, or placeholder */ +#define SENO_NOP 0x01 /* No Operation. Skip */ +#define SENO_NAME 0x02 /* tunnel name, NUL-terminated */ +#define SENO_SPI 0x03 /* Security Parameters Index */ +#define SENO_IFN 0x04 /* Encap interface number */ +#define SENO_IFIP4A 0x05 /* Encap interface IPv4 address */ +#define SENO_IPSA 0x06 /* Encap interface generic sockaddr */ + +struct enc_softc +{ + struct ifnet enc_if; +}; + +/* + * Tunnel descriptors are setup and torn down using a socket of the + * AF_ENCAP domain. The following defines the messages that can + * be sent down that socket. + */ + +#define EM_MAXRELSPIS 4 /* at most five chained xforms */ + + +struct encap_msghdr +{ + u_int16_t em_msglen; /* message length */ + u_int8_t em_version; /* for future expansion */ + u_int8_t em_type; /* message type */ + union + { + struct + { + struct in_addr Ia; + u_int8_t Ifn; + u_int8_t xxx[3]; /* makes life a lot easier */ + } Ifa; + + struct + { + u_int32_t Spi; /* SPI */ + struct in_addr Dst; /* Destination address */ + int32_t If; /* enc i/f for input */ + int32_t Alg; /* Algorithm to use */ + u_int8_t Dat[1]; /* Data */ + } Xfm; + + struct + { + u_int32_t emr_spi; /* SPI */ + struct in_addr emr_dst; /* Dest */ + struct tdb * emr_tdb; /* used internally! */ + + } Rel[EM_MAXRELSPIS]; + } Eu; +}; + +#define em_ifa Eu.Ifa.Ia +#define em_ifn Eu.Ifa.Ifn + +#define em_spi Eu.Xfm.Spi +#define em_dst Eu.Xfm.Dst +#define em_if Eu.Xfm.If +#define em_alg Eu.Xfm.Alg +#define em_dat Eu.Xfm.Dat + +#define em_rel Eu.Rel + +#define EMT_IFADDR 1 /* set enc if addr */ +#define EMT_SETSPI 2 /* Set SPI properties */ +#define EMT_GRPSPIS 3 /* Group SPIs (output order) */ +#define EMT_DELSPI 4 /* delete an SPI */ +#define EMT_DELSPICHAIN 5 /* delete an SPI chain starting from */ + +#define EM_MINLEN 8 /* count!!! */ +#define EMT_IFADDR_LEN 12 +#define EMT_SETSPI_FLEN 20 +#define EMT_GRPSPIS_FLEN 4 +#define EMT_DELSPI_FLEN 20 +#define EMT_DELSPICHAIN_FLEN 20 + +#ifdef _KERNEL +extern struct ifaddr *encap_findgwifa(struct sockaddr *); +extern struct enc_softc *enc_softc; +extern int32_t nencap; +#endif diff --git a/sys/net/if_enc.c b/sys/net/if_enc.c new file mode 100644 index 00000000000..5cecd2dfaaf --- /dev/null +++ b/sys/net/if_enc.c @@ -0,0 +1,247 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Encapsulation interface driver. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include + +#ifdef INET +#include +#include +#include +#include +#endif + +#ifdef ISO +extern struct ifqueue clnlintrq; +#endif + +#ifdef NS +extern struct ifqueue nsintrq; +#endif + +#include "bpfilter.h" + +#define ENCMTU (1024+512) + +/* + * Called from boot code to establish enc interfaces. + */ + +struct enc_softc +{ + struct ifnet enc_if; +} ; + +struct enc_softc *enc_softc; + +int nencap; + +int encoutput(struct ifnet *, struct mbuf *, struct sockaddr *, struct rtentry *); +int encioctl(struct ifnet *, u_long, caddr_t); +void encrtrequest(int, struct rtentry *, struct sockaddr *); + +void +encattach(int nenc) +{ + register struct enc_softc *enc; + register int i = 0; + + nencap = nenc; + + enc_softc = malloc(nenc * sizeof (*enc_softc), M_DEVBUF, M_WAIT); + bzero(enc_softc, nenc * sizeof (*enc_softc)); + for (enc = enc_softc; i < nenc; enc++) + { + enc->enc_if.if_index = i; + sprintf(enc->enc_if.if_xname, "enc%d", i++); + enc->enc_if.if_list.tqe_next = NULL; + enc->enc_if.if_mtu = ENCMTU; + enc->enc_if.if_flags = IFF_LOOPBACK; + enc->enc_if.if_type = IFT_ENC; + enc->enc_if.if_ioctl = encioctl; + enc->enc_if.if_output = encoutput; + enc->enc_if.if_hdrlen = 0; + enc->enc_if.if_addrlen = 0; + if_attach(&enc->enc_if); + bpfattach(&enc->enc_if.if_bpf, &enc->enc_if, DLT_NULL, sizeof(u_int)); + } +} + +/* + * Shamelessly stolen from looutput() + */ +int +encoutput(ifp, m, dst, rt) +struct ifnet *ifp; +register struct mbuf *m; +struct sockaddr *dst; +register struct rtentry *rt; +{ + int s, isr; + register struct ifqueue *ifq = 0; + + /* register struct enc_softc *ec = &enc_softc[ifp->if_index]; */ + + if ((m->m_flags & M_PKTHDR) == 0) + panic("encoutput no HDR"); + ifp->if_lastchange = time; + if (ifp->if_bpf) { + /* + * We need to prepend the address family as + * a four byte field. Cons up a dummy header + * to pacify bpf. This is safe because bpf + * will only read from the mbuf (i.e., it won't + * try to free it or keep a pointer a to it). + */ + struct mbuf m0; + u_int af = dst->sa_family; + + m0.m_next = m; + m0.m_len = 4; + m0.m_data = (char *)⁡ + + bpf_mtap(ifp->if_bpf, &m0); + } + m->m_pkthdr.rcvif = ifp; + + if (rt && rt->rt_flags & (RTF_REJECT|RTF_BLACKHOLE)) { + m_freem(m); + return (rt->rt_flags & RTF_BLACKHOLE ? 0 : + rt->rt_flags & RTF_HOST ? EHOSTUNREACH : ENETUNREACH); + } + ifp->if_opackets++; + ifp->if_obytes += m->m_pkthdr.len; + switch (dst->sa_family) { + +#ifdef INET + case AF_INET: + ifq = &ipintrq; + isr = NETISR_IP; + break; +#endif +#ifdef NS + case AF_NS: + ifq = &nsintrq; + isr = NETISR_NS; + break; +#endif +#ifdef ISO + case AF_ISO: + ifq = &clnlintrq; + isr = NETISR_ISO; + break; +#endif + default: + m_freem(m); + return (EAFNOSUPPORT); + } + s = splimp(); + if (IF_QFULL(ifq)) { + IF_DROP(ifq); + m_freem(m); + splx(s); + return (ENOBUFS); + } + IF_ENQUEUE(ifq, m); + schednetisr(isr); + ifp->if_ipackets++; + ifp->if_ibytes += m->m_pkthdr.len; + splx(s); + return (0); +} + +/* ARGSUSED */ +void +encrtrequest(cmd, rt, sa) + int cmd; + struct rtentry *rt; + struct sockaddr *sa; +{ + + if (rt) + rt->rt_rmx.rmx_mtu = ENCMTU; +} + +/* + * Process an ioctl request. + * Also shamelessly stolen from loioctl() + */ + +/* ARGSUSED */ +int +encioctl(ifp, cmd, data) + register struct ifnet *ifp; + u_long cmd; + caddr_t data; +{ + register struct ifaddr *ifa; + register struct ifreq *ifr; + register int error = 0; + + switch (cmd) + { + case SIOCSIFADDR: + ifp->if_flags |= IFF_UP; + ifa = (struct ifaddr *)data; + /* + * Everything else is done at a higher level. + */ + break; + + switch (ifr->ifr_addr.sa_family) { + +#ifdef INET + case AF_INET: + break; +#endif + case AF_ENCAP: + break; + + default: + error = EAFNOSUPPORT; + break; + } + break; + + default: + error = EINVAL; + } + return error; +} diff --git a/sys/net/if_types.h b/sys/net/if_types.h index fc3e749edac..4b8fe650a59 100644 --- a/sys/net/if_types.h +++ b/sys/net/if_types.h @@ -95,3 +95,4 @@ #define IFT_SMDSICIP 0x34 /* SMDS InterCarrier Interface */ #define IFT_PROPVIRTUAL 0x35 /* Proprietary Virtual/internal */ #define IFT_PROPMUX 0x36 /* Proprietary Multiplexing */ +#define IFT_ENC 0x37 /* Encapsulation */ diff --git a/sys/net/route.c b/sys/net/route.c index 59f83f1d4a8..05ef2994fa7 100644 --- a/sys/net/route.c +++ b/sys/net/route.c @@ -1,4 +1,4 @@ -/* $OpenBSD: route.c,v 1.2 1996/03/03 21:07:19 niklas Exp $ */ +/* $OpenBSD: route.c,v 1.3 1997/02/20 01:07:43 deraadt Exp $ */ /* $NetBSD: route.c,v 1.14 1996/02/13 22:00:46 christos Exp $ */ /* @@ -57,6 +57,10 @@ #include #endif +#ifdef IPSEC +#include +#endif + #define SA(p) ((struct sockaddr *)(p)) int rttrash; /* routes not in table but not freed */ @@ -283,6 +287,18 @@ ifa_ifwithroute(flags, dst, gateway) struct sockaddr *dst, *gateway; { register struct ifaddr *ifa; + +#ifdef IPSEC + /* + * If the destination is a AF_ENCAP address, we'll look + * for the existence of a encap interface number or address + * in the options list of the gateway. By default, we'll return + * encap0. + */ + if (dst && (dst->sa_family == AF_ENCAP)) + return encap_findgwifa(gateway); +#endif + if ((flags & RTF_GATEWAY) == 0) { /* * If we are adding a route to an interface, diff --git a/sys/netinet/in.h b/sys/netinet/in.h index 7e9c0fa0dc4..d69dbcef7c9 100644 --- a/sys/netinet/in.h +++ b/sys/netinet/in.h @@ -1,4 +1,4 @@ -/* $OpenBSD: in.h,v 1.6 1996/07/29 02:34:29 downsj Exp $ */ +/* $OpenBSD: in.h,v 1.7 1997/02/20 01:07:45 deraadt Exp $ */ /* $NetBSD: in.h,v 1.20 1996/02/13 23:41:47 christos Exp $ */ /* @@ -58,6 +58,8 @@ #define IPPROTO_UDP 17 /* user datagram protocol */ #define IPPROTO_IDP 22 /* xns idp */ #define IPPROTO_TP 29 /* tp-4 w/ class negotiation */ +#define IPPROTO_ESP 50 /* Encap. Security Payload */ +#define IPPROTO_AH 51 /* Authentication header */ #define IPPROTO_EON 80 /* ISO cnlp */ #define IPPROTO_ENCAP 98 /* encapsulation header */ diff --git a/sys/netinet/in_proto.c b/sys/netinet/in_proto.c index 295ca096960..66c5ddd6047 100644 --- a/sys/netinet/in_proto.c +++ b/sys/netinet/in_proto.c @@ -1,4 +1,4 @@ -/* $OpenBSD: in_proto.c,v 1.6 1996/10/08 07:33:25 niklas Exp $ */ +/* $OpenBSD: in_proto.c,v 1.7 1997/02/20 01:07:46 deraadt Exp $ */ /* $NetBSD: in_proto.c,v 1.14 1996/02/18 18:58:32 christos Exp $ */ /* @@ -94,6 +94,18 @@ void iplinit __P((void)); #define ip_init iplinit #endif +#ifdef IPSEC +#include +#include + +extern void ah_input __P((struct mbuf *, ...)); +extern void esp_input __P((struct mbuf *, ...)); +extern int ah_output __P((struct mbuf *, struct sockaddr_encap *, + struct tdb *, struct mbuf **)); +extern int esp_output __P((struct mbuf *, struct sockaddr_encap *, + struct tdb *, struct mbuf **)); +#endif + extern struct domain inetdomain; struct protosw inetsw[] = { @@ -128,7 +140,13 @@ struct protosw inetsw[] = { rip_usrreq, /* XXX */ 0, 0, 0, 0, }, -#endif /* MROUTING */ +#elif defined(IPSEC) +{ SOCK_RAW, &inetdomain, IPPROTO_IPIP, PR_ATOMIC|PR_ADDR, + ipe4_input, rip_output, 0, rip_ctloutput, + rip_usrreq, /* XXX */ + 0, 0, 0, 0, +}, +#endif /* MROUTING/IPSEC */ { SOCK_RAW, &inetdomain, IPPROTO_IGMP, PR_ATOMIC|PR_ADDR, igmp_input, rip_output, 0, rip_ctloutput, rip_usrreq, @@ -163,6 +181,18 @@ struct protosw inetsw[] = { 0, 0, 0, 0, }, #endif /* NSIP */ +#ifdef IPSEC +{ SOCK_RAW, &inetdomain, IPPROTO_AH, PR_ATOMIC|PR_ADDR, + ah_input, rip_output, 0, rip_ctloutput, + rip_usrreq, + 0, 0, 0, 0, +}, +{ SOCK_RAW, &inetdomain, IPPROTO_ESP, PR_ATOMIC|PR_ADDR, + esp_input, rip_output, 0, rip_ctloutput, + rip_usrreq, + 0, 0, 0, 0, +}, +#endif /* raw wildcard */ { SOCK_RAW, &inetdomain, 0, PR_ATOMIC|PR_ADDR, rip_input, rip_output, 0, rip_ctloutput, diff --git a/sys/netinet/ip_ah.c b/sys/netinet/ip_ah.c new file mode 100644 index 00000000000..e08f4c22fdb --- /dev/null +++ b/sys/netinet/ip_ah.c @@ -0,0 +1,160 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Authentication Header Processing + * Per RFC1826 (Atkinson, 1995) + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + + +/* + * ah_input gets called when we receive an packet with an AH. + */ + +void +ah_input(register struct mbuf *m, int iphlen) +{ + struct ip *ipo; + struct ah *ahp; + struct tdb *tdbp; + struct ifqueue *ifq = NULL; + int s; + + /* + * Strip IP options, if any. + */ + + if (iphlen > sizeof (struct ip)) + { + ip_stripoptions(m, (struct mbuf *)0); + iphlen = sizeof (struct ip); + } + + /* + * Make sure that at least the fixed part of the AH header is + * in the first mbuf. + */ + + ipo = mtod(m, struct ip *); + if (m->m_len < iphlen + AH_FLENGTH) + { + if ((m = m_pullup(m, iphlen + AH_FLENGTH)) == 0) + { + ahstat.ahs_hdrops++; + return; + } + ipo = mtod(m, struct ip *); + } + ahp = (struct ah *)((caddr_t)ipo + iphlen); + + /* + * Find tunnel control block and (indirectly) call the appropriate + * tranform routine. The resulting mbuf chain is a valid + * IP packet ready to go through input processing. + */ + + tdbp = gettdb(ahp->ah_spi, ipo->ip_dst); + if (tdbp == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ah_input: no tdb for spi=%x\n", ahp->ah_spi); +#endif ENCDEBUG + m_freem(m); + ahstat.ahs_notdb++; + return; + } + + if (tdbp->tdb_xform == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ah_input: no xform for spi=%x\n", ahp->ah_spi); +#endif ENCDEBUG + m_freem(m); + ahstat.ahs_noxform++; + return; + } + + m->m_pkthdr.rcvif = tdbp->tdb_rcvif; + + m = (*(tdbp->tdb_xform->xf_input))(m, tdbp); + + if (m == NULL) + { + ahstat.ahs_badkcr++; + return; + } + + /* + * Interface pointer is already in first mbuf; chop off the + * `outer' header and reschedule. + */ + + ifq = &ipintrq; + + s = splimp(); /* isn't it already? */ + if (IF_QFULL(ifq)) + { + IF_DROP(ifq); + m_freem(m); + ahstat.ahs_qfull++; + splx(s); + return; + } + IF_ENQUEUE(ifq, m); + schednetisr(NETISR_IP); + splx(s); + return; +} diff --git a/sys/netinet/ip_ah.h b/sys/netinet/ip_ah.h new file mode 100644 index 00000000000..4ac4334dd36 --- /dev/null +++ b/sys/netinet/ip_ah.h @@ -0,0 +1,162 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Authentication Header Processing + * Per RFC1826 (Atkinson, 1995) + */ + +#include +#include + +struct ah +{ + u_int8_t ah_nh; /* Next header (protocol) */ + u_int8_t ah_hl; /* AH length, in 32-bit words */ + u_int16_t ah_rv; /* reserved, must be 0 */ + u_int32_t ah_spi; /* Security Parameters Index */ + u_int8_t ah_data[1]; /* More, really*/ +}; + +#define AH_FLENGTH 8 /* size of fixed part */ + +struct ahstat +{ + u_int32_t ahs_hdrops; /* packet shorter than header shows */ + u_int32_t ahs_notdb; + u_int32_t ahs_badkcr; + u_int32_t ahs_badauth; + u_int32_t ahs_noxform; + u_int32_t ahs_qfull; + u_int32_t ahs_wrap; + u_int32_t ahs_replay; + u_int32_t ahs_badauthl; /* bad authenticator length */ +}; + +#define AHHMACMD5_KMAX 64 /* max 512 bits key */ +#define AHHMACMD5_AMAX 64 /* up to 512 bits of authenticator */ +#define AHHMACMD5_RPLS 2 /* 64 bits of replay counter */ + +#define HMACMD5_HASHLEN 16 +#define HMACMD5_RPLENGTH 8 + +#define HMACMD5_IPAD_VAL 0x36 +#define HMACMD5_OPAD_VAL 0x5C + +#define AHHMACMD5_KMAX 64 /* max 512 bits key */ +#define AHHMACMD5_AMAX 64 /* up to 512 bits of authenticator */ +#define AHHMACMD5_RPLS 2 /* 64 bits of replay counter */ + +#define HMACMD5_HASHLEN 16 +#define HMACMD5_RPLENGTH 8 + +#define HMACMD5_IPAD_VAL 0x36 +#define HMACMD5_OPAD_VAL 0x5C + +struct ahhmacmd5 +{ + u_int8_t ah_nh; /* Next header (protocol) */ + u_int8_t ah_hl; /* AH length, in 32-bit words */ + u_int16_t ah_rv; /* reserved, must be 0 */ + u_int32_t ah_spi; /* Security Parameters Index */ + u_int64_t ah_rpl; /* Replay prevention */ + u_int8_t ah_data[AHHMACMD5_AMAX];/* Authenticator */ +}; + +struct ahhmacmd5_xencap +{ + u_int16_t amx_alen; + u_int16_t amx_rpl; + int32_t amx_wnd; + u_int8_t amx_key[AHHMACMD5_KMAX]; +}; + +struct ahhmacmd5_xdata +{ + u_int32_t amx_alen; /* authenticator length */ + int32_t amx_wnd; + u_int64_t amx_rpl; /* Replay counter */ + u_int64_t amx_bitmap; + MD5_CTX amx_ictx; /* Internal key+padding */ + MD5_CTX amx_octx; /* External key+padding */ +}; + +#define AHHMACSHA1_KMAX 64 /* max 512 bits key */ +#define AHHMACSHA1_AMAX 64 /* up to 512 bits of authenticator */ +#define AHHMACSHA1_RPLS 2 /* 64 bits of replay counter */ + +#define HMACSHA1_HASHLEN 20 +#define HMACSHA1_RPLENGTH 8 + +#define HMACSHA1_IPAD_VAL 0x36 +#define HMACSHA1_OPAD_VAL 0x5C + +struct ahhmacsha1 +{ + u_int8_t ah_nh; /* Next header (protocol) */ + u_int8_t ah_hl; /* AH length, in 32-bit words */ + u_int16_t ah_rv; /* reserved, must be 0 */ + u_int32_t ah_spi; /* Security Parameters Index */ + u_int64_t ah_rpl; /* Replay prevention */ + u_int8_t ah_data[AHHMACSHA1_AMAX];/* Authenticator */ +}; + +struct ahhmacsha1_xencap +{ + u_int32_t amx_alen; + int32_t amx_wnd; + u_int8_t amx_key[AHHMACSHA1_KMAX]; +}; + +struct ahhmacsha1_xdata +{ + u_int32_t amx_alen; /* authenticator length */ + int32_t amx_wnd; + u_int64_t amx_rpl; /* Replay counter */ + u_int64_t amx_bitmap; + SHA1_CTX amx_ictx; /* Internal key+padding */ + SHA1_CTX amx_octx; /* External key+padding */ +}; + +#define AHMD5_KMAX 32 /* max 256 bits key */ +#define AHMD5_AMAX 64 /* up to 512 bits of authenticator */ + +struct ahmd5 +{ + u_int8_t ah_nh; /* Next header (protocol) */ + u_int8_t ah_hl; /* AH length, in 32-bit words */ + u_int16_t ah_rv; /* reserved, must be 0 */ + u_int32_t ah_spi; /* Security Parameters Index */ + u_int8_t ah_data[AHMD5_AMAX]; /* */ +}; + +struct ahmd5_xdata +{ + u_int16_t amx_klen; /* Key material length */ + u_int16_t amx_alen; /* authenticator length */ + u_int8_t amx_key[AHMD5_KMAX]; /* Key material */ +}; + +#ifdef _KERNEL +struct ahstat ahstat; +#endif diff --git a/sys/netinet/ip_ahhmacmd5.c b/sys/netinet/ip_ahhmacmd5.c new file mode 100644 index 00000000000..008fef0e575 --- /dev/null +++ b/sys/netinet/ip_ahhmacmd5.c @@ -0,0 +1,459 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Based on draft-ietf-ipsec-ah-hmac-md5-04.txt. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +/* + * ahhmacmd5_attach() is called from the transformation initialization code. + * It just returns. + */ + +int +ahhmacmd5_attach() +{ + return 0; +} + +/* + * ahhmacmd5_init() is called when an SPI is being set up. It interprets the + * encap_msghdr present in m, and sets up the transformation data. + */ + +int +ahhmacmd5_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + struct ahhmacmd5_xdata *xd; + struct ahhmacmd5_xencap txd; + struct encap_msghdr *em; + int len; + + tdbp->tdb_xform = xsp; + + MALLOC(tdbp->tdb_xdata, caddr_t, sizeof (struct ahhmacmd5_xdata), + M_XDATA, M_WAITOK); + if (tdbp->tdb_xdata == NULL) + return ENOBUFS; + bzero(tdbp->tdb_xdata, sizeof (struct ahhmacmd5_xdata)); + bzero(&txd, sizeof(struct ahhmacmd5_xencap)); + xd = (struct ahhmacmd5_xdata *)tdbp->tdb_xdata; + + em = mtod(m, struct encap_msghdr *); + if (em->em_msglen - EMT_SETSPI_FLEN > sizeof (struct ahhmacmd5_xencap)) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + m_copydata(m, EMT_SETSPI_FLEN, em->em_msglen - EMT_SETSPI_FLEN, (caddr_t)&txd); + + xd->amx_rpl = 1; + xd->amx_alen = txd.amx_alen; + xd->amx_bitmap = 0; + xd->amx_wnd = txd.amx_wnd; + + realMD5Init(&(xd->amx_ictx)); + realMD5Init(&(xd->amx_octx)); + + for (len = 0; len < AHHMACMD5_KMAX; len++) + txd.amx_key[len] ^= HMACMD5_IPAD_VAL; + + MD5Update(&(xd->amx_ictx), txd.amx_key, AHHMACMD5_KMAX); + + for (len = 0; len < AHHMACMD5_KMAX; len++) + txd.amx_key[len] ^= (HMACMD5_IPAD_VAL ^ HMACMD5_OPAD_VAL); + + MD5Update(&(xd->amx_octx), txd.amx_key, AHHMACMD5_KMAX); + bzero(&txd, sizeof(struct ahhmacmd5_xencap)); + bzero(ipseczeroes, IPSEC_ZEROES_SIZE); /* paranoid */ + + return 0; +} + +/* + * Free memory + */ + +int +ahhmacmd5_zeroize(struct tdb *tdbp) +{ + FREE(tdbp->tdb_xdata, M_XDATA); + return 0; +} + +/* + * ahhmacmd5_input() gets called to verify that an input packet + * passes authentication. + */ + +extern struct ifnet loif; + +struct mbuf * +ahhmacmd5_input(struct mbuf *m, struct tdb *tdb) +{ + struct ahhmacmd5_xdata *xd; + struct ip *ip, ipo; + struct ah *ah; + struct ahhmacmd5 aho, *ahp; + struct ifnet *rcvif; + int ohlen, len, count, off, ado, errc; + u_int64_t btsx; + struct mbuf *m0; + MD5_CTX ctx; + + xd = (struct ahhmacmd5_xdata *)tdb->tdb_xdata; + ohlen = sizeof (struct ip) + AH_FLENGTH + xd->amx_alen; + if (xd->amx_wnd >= 0) + ohlen += HMACMD5_RPLENGTH; + + rcvif = m->m_pkthdr.rcvif; + if (rcvif == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahhmacmd5_input: receive interface is NULL!!!\n"); +#endif + rcvif = &loif; + } + + if (m->m_len < ohlen) + { + if ((m = m_pullup(m, ohlen)) == NULL) + { + ahstat.ahs_hdrops++; + return NULL; + } + } + + ip = mtod(m, struct ip *); + ah = (struct ah *)(ip + 1); + ahp = (struct ahhmacmd5 *)ah; + + if (xd->amx_wnd >= 0) + ado = HMACMD5_RPLENGTH; + else + ado = 0; + + if (ah->ah_hl != xd->amx_alen + ado) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahhmacmd5_input: bad authenticator length\n"); +#endif + ahstat.ahs_badauthl++; + m_freem(m); + return NULL; + } + + ipo = *ip; + ipo.ip_tos = 0; + ipo.ip_len += sizeof (struct ip); /* adjusted in ip_intr() */ + HTONS(ipo.ip_len); + HTONS(ipo.ip_id); + ipo.ip_off = htons(ipo.ip_off & IP_DF); /* XXX -- and the C bit? */ + ipo.ip_ttl = 0; + ipo.ip_sum = 0; + + ctx = xd->amx_ictx; + MD5Update(&ctx, (unsigned char *)&ipo, sizeof (struct ip)); + if (xd->amx_wnd >= 0) + MD5Update(&ctx, (unsigned char *)ahp, AH_FLENGTH + HMACMD5_RPLENGTH); + else + MD5Update(&ctx, (unsigned char *)ahp, AH_FLENGTH); + MD5Update(&ctx, ipseczeroes, xd->amx_alen); + + /* + * Code shamelessly stolen from m_copydata + */ + off = ohlen; + len = m->m_pkthdr.len - off; + m0 = m; + + while (off > 0) + { + if (m0 == 0) + panic("ahhmacmd5_input: m_copydata (off)"); + if (off < m0->m_len) + break; + off -= m0->m_len; + m0 = m0->m_next; + } + + while (len > 0) + { + if (m0 == 0) + panic("ahhmacmd5_input: m_copydata (copy)"); + count = min(m0->m_len - off, len); + MD5Update(&ctx, mtod(m0, unsigned char *) + off, count); + len -= count; + off = 0; + m0 = m0->m_next; + } + + MD5Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + ctx = xd->amx_octx; + MD5Update(&ctx, (unsigned char *)(&(aho.ah_data[0])), HMACMD5_HASHLEN); + MD5Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + + if (bcmp(aho.ah_data, ah->ah_data + ado, xd->amx_alen)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahhmacmd5_input: bad auth\n"); /* XXX */ +#endif + ahstat.ahs_badauth++; + m_freem(m); + return NULL; + } + + if (xd->amx_wnd >= 0) + { + btsx = ntohq(ahp->ah_rpl); + if ((errc = checkreplaywindow64(btsx, &(xd->amx_rpl), + xd->amx_wnd, &(xd->amx_bitmap))) + != 0) + { + switch(errc) + { + case 1: +#ifdef ENCDEBUG + printf("ahhmacmd5_input: replay counter wrapped\n"); +#endif + ahstat.ahs_wrap++; + break; + case 2: +#ifdef ENCDEBUG + printf("ahhmacmd5_input: received old packet\n"); +#endif + ahstat.ahs_replay++; + break; + case 3: +#ifdef ENCDEBUG + printf("ahhmacmd5_input: packet already received\n"); +#endif + ahstat.ahs_replay++; + break; + } + m_freem(m); + return NULL; + } + } + + ipo = *ip; + ipo.ip_p = ah->ah_nh; + + m->m_len -= (ohlen - sizeof(struct ip)); + m->m_data += (ohlen - sizeof(struct ip)); + m->m_pkthdr.len -= (ohlen - sizeof(struct ip)); + m->m_pkthdr.rcvif = rcvif; /* this should not be necessary */ + + ip = mtod(m, struct ip *); + *ip = ipo; + ip->ip_len = htons(ip->ip_len - ohlen + 2 * sizeof (struct ip)); + HTONS(ip->ip_id); + HTONS(ip->ip_off); + ip->ip_sum = 0; + ip->ip_sum = in_cksum(m, sizeof (struct ip)); + + return m; +} + + +#define AHXPORT + +int +ahhmacmd5_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct ahhmacmd5_xdata *xd; + struct ip *ip, ipo; + struct ah *ah; + struct ahhmacmd5 *ahp, aho; + register int len, off, count; + register struct mbuf *m0; + MD5_CTX ctx; + int ilen, ohlen; + + + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + + xd = (struct ahhmacmd5_xdata *)tdb->tdb_xdata; + + ilen = ntohs(ip->ip_len); + +#ifdef AHXPORT + ohlen = AH_FLENGTH + xd->amx_alen; +#else + ohlen = sizeof (struct ip) + AH_FLENGTH + xd->amx_alen; +#endif + if (xd->amx_wnd >= 0) + ohlen += HMACMD5_RPLENGTH; + + ipo.ip_v = IPVERSION; + ipo.ip_hl = 5; + ipo.ip_tos = 0; + ipo.ip_len = htons(ohlen + ilen); + ipo.ip_id = ip->ip_id; + ipo.ip_off = htons(ntohs(ip->ip_off) & IP_DF); + ipo.ip_ttl = 0; + ipo.ip_p = IPPROTO_AH; + ipo.ip_sum = 0; +#ifdef AHXPORT + ipo.ip_src = ip->ip_src; + ipo.ip_dst = ip->ip_dst; + aho.ah_nh = ip->ip_p; +#else + ipo.ip_src = gw->sen_ipsp_src; + ipo.ip_dst = gw->sen_ipsp_dst; + aho.ah_nh = IPPROTO_IP4; +#endif + aho.ah_hl = (xd->amx_alen >> 2); + if (xd->amx_wnd >= 0) + aho.ah_hl += (HMACMD5_RPLENGTH / sizeof(u_int32_t)); + aho.ah_rv = 0; + aho.ah_spi = tdb->tdb_spi; + + if (xd->amx_wnd >= 0) + { + if (xd->amx_rpl == 0) + { +#ifdef ENCDEBUG + printf("ahhmacmd5_output: key should have changed long ago\n"); +#endif + ahstat.ahs_wrap++; + return NULL; + } + } + + aho.ah_rpl = htonq(xd->amx_rpl++); + + ctx = xd->amx_ictx; + MD5Update(&ctx, (unsigned char *)&ipo, sizeof (struct ip)); + if (xd->amx_wnd >= 0) + MD5Update(&ctx, (unsigned char *)&aho, AH_FLENGTH + HMACMD5_RPLENGTH); + else + MD5Update(&ctx, (unsigned char *)&aho, AH_FLENGTH); + MD5Update(&ctx, ipseczeroes, xd->amx_alen); + +#ifdef AHXPORT + off = sizeof (struct ip); +#else + off = 0; +#endif + + /* + * Code shamelessly stolen from m_copydata + */ + len = m->m_pkthdr.len - off; + + m0 = m; + + while (len > 0) + { + if (m0 == 0) + panic("ahhmacmd5_output: m_copydata"); + count = min(m0->m_len - off, len); + MD5Update(&ctx, mtod(m0, unsigned char *) + off, count); + + len -= count; + off = 0; + m0 = m0->m_next; + } + + MD5Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + ctx = xd->amx_octx; + MD5Update(&ctx, (unsigned char *)(&(aho.ah_data[0])), HMACMD5_HASHLEN); + MD5Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + + ipo.ip_tos = ip->ip_tos; + ipo.ip_id = ip->ip_id; + ipo.ip_off = ip->ip_off; + ipo.ip_ttl = ip->ip_ttl; +/* ipo.ip_len = ntohs(ipo.ip_len); */ + + M_PREPEND(m, ohlen, M_DONTWAIT); + if (m == NULL) + return ENOBUFS; + + m = m_pullup(m, ohlen + sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + ah = (struct ah *)(ip + 1); + ahp = (struct ahhmacmd5 *)ah; + *ip = ipo; + ah->ah_nh = aho.ah_nh; + ah->ah_hl = aho.ah_hl; + ah->ah_rv = aho.ah_rv; + ah->ah_spi = aho.ah_spi; + if (xd->amx_wnd >= 0) + { + ahp->ah_rpl = aho.ah_rpl; + bcopy((unsigned char *)(&(aho.ah_data[0])), + ahp->ah_data, xd->amx_alen); + } + else + bcopy((unsigned char *)(&(aho.ah_data[0])), + ah->ah_data, xd->amx_alen); + + *mp = m; + + return 0; +} diff --git a/sys/netinet/ip_ahhmacsha1.c b/sys/netinet/ip_ahhmacsha1.c new file mode 100644 index 00000000000..af306827e7c --- /dev/null +++ b/sys/netinet/ip_ahhmacsha1.c @@ -0,0 +1,463 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Based on draft-ietf-ipsec-ah-hmac-sha-04.txt. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +/* + * ahhmacsha1_attach() is called from the transformation initialization code. + * It just returns. + */ + +int +ahhmacsha1_attach() +{ + return 0; +} + +/* + * ahhmacsha1_init() is called when an SPI is being set up. It interprets the + * encap_msghdr present in m, and sets up the transformation data. + */ + +int +ahhmacsha1_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + struct ahhmacsha1_xdata *xd; + struct ahhmacsha1_xencap txd; + struct encap_msghdr *em; + int len; + + tdbp->tdb_xform = xsp; + + MALLOC(tdbp->tdb_xdata, caddr_t, sizeof (struct ahhmacsha1_xdata), + M_XDATA, M_WAITOK); + if (tdbp->tdb_xdata == NULL) + return ENOBUFS; + bzero(tdbp->tdb_xdata, sizeof (struct ahhmacsha1_xdata)); + bzero(&txd, sizeof(struct ahhmacsha1_xencap)); + xd = (struct ahhmacsha1_xdata *)tdbp->tdb_xdata; + + em = mtod(m, struct encap_msghdr *); + if (em->em_msglen - EMT_SETSPI_FLEN > sizeof (struct ahhmacsha1_xencap)) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + m_copydata(m, EMT_SETSPI_FLEN, em->em_msglen - EMT_SETSPI_FLEN, (caddr_t)&txd); + + xd->amx_rpl = 1; + xd->amx_alen = txd.amx_alen; + xd->amx_bitmap = 0; + xd->amx_wnd = txd.amx_wnd; + + SHA1Init(&(xd->amx_ictx)); + SHA1Init(&(xd->amx_octx)); + + for (len = 0; len < AHHMACSHA1_KMAX; len++) + txd.amx_key[len] ^= HMACSHA1_IPAD_VAL; + + SHA1Update(&(xd->amx_ictx), txd.amx_key, AHHMACSHA1_KMAX); + + for (len = 0; len < AHHMACSHA1_KMAX; len++) + txd.amx_key[len] ^= (HMACSHA1_IPAD_VAL ^ HMACSHA1_OPAD_VAL); + + SHA1Update(&(xd->amx_octx), txd.amx_key, AHHMACSHA1_KMAX); + bzero(&txd, sizeof(struct ahhmacsha1_xencap)); + bzero(ipseczeroes, IPSEC_ZEROES_SIZE); /* paranoid */ + + return 0; +} + +/* + * Free memory + */ + +int +ahhmacsha1_zeroize(struct tdb *tdbp) +{ + FREE(tdbp->tdb_xdata, M_XDATA); + return 0; +} + +/* + * ahhmacsha1_input() gets called to verify that an input packet + * passes authentication. + */ + +extern struct ifnet loif; + +struct mbuf * +ahhmacsha1_input(struct mbuf *m, struct tdb *tdb) +{ + struct ahhmacsha1_xdata *xd; + struct ip *ip, ipo; + struct ah *ah; + struct ahhmacsha1 aho, *ahp; + struct ifnet *rcvif; + int ohlen, len, count, off, ado, errc; + u_int64_t btsx; + struct mbuf *m0; + SHA1_CTX ctx; + + xd = (struct ahhmacsha1_xdata *)tdb->tdb_xdata; + ohlen = sizeof (struct ip) + AH_FLENGTH + xd->amx_alen; + if (xd->amx_wnd >= 0) + ohlen += HMACSHA1_RPLENGTH; + + rcvif = m->m_pkthdr.rcvif; + if (rcvif == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahhmacsha1_input: receive interface is NULL!!!\n"); +#endif + rcvif = &loif; + } + + if (m->m_len < ohlen) + { + if ((m = m_pullup(m, ohlen)) == NULL) + { + ahstat.ahs_hdrops++; + return NULL; + } + } + + ip = mtod(m, struct ip *); + ah = (struct ah *)(ip + 1); + ahp = (struct ahhmacsha1 *)ah; + + if (xd->amx_wnd >= 0) + ado = HMACSHA1_RPLENGTH; + else + ado = 0; + + if (ah->ah_hl != xd->amx_alen + ado) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahhmacsha1_input: bad authenticator length\n"); +#endif + ahstat.ahs_badauthl++; + m_freem(m); + return NULL; + } + + ipo = *ip; + ipo.ip_tos = 0; + ipo.ip_len += sizeof (struct ip); /* adjusted in ip_intr() */ + HTONS(ipo.ip_len); + HTONS(ipo.ip_id); + ipo.ip_off = htons(ipo.ip_off & IP_DF); /* XXX -- and the C bit? */ + ipo.ip_ttl = 0; + ipo.ip_sum = 0; + + ctx = xd->amx_ictx; + SHA1Update(&ctx, (unsigned char *)&ipo, sizeof (struct ip)); + if (xd->amx_wnd >= 0) + SHA1Update(&ctx, (unsigned char *)ahp, + AH_FLENGTH + HMACSHA1_RPLENGTH); + else + SHA1Update(&ctx, (unsigned char *)ahp, AH_FLENGTH); + SHA1Update(&ctx, ipseczeroes, xd->amx_alen); + + /* + * Code shamelessly stolen from m_copydata + */ + off = ohlen; + len = m->m_pkthdr.len - off; + m0 = m; + + while (off > 0) + { + if (m0 == 0) + panic("ahhmacsha1_input: m_copydata (off)"); + if (off < m0->m_len) + break; + off -= m0->m_len; + m0 = m0->m_next; + } + + while (len > 0) + { + if (m0 == 0) + panic("ahhmacsha1_input: m_copydata (copy)"); + count = min(m0->m_len - off, len); + SHA1Update(&ctx, mtod(m0, unsigned char *) + off, count); + len -= count; + off = 0; + m0 = m0->m_next; + } + + SHA1Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + ctx = xd->amx_octx; + SHA1Update(&ctx, (unsigned char *)(&(aho.ah_data[0])), + HMACSHA1_HASHLEN); + SHA1Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + + if (bcmp(aho.ah_data, ah->ah_data + ado, xd->amx_alen)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahhmacsha1_input: bad auth\n"); /* XXX */ +#endif + ahstat.ahs_badauth++; + m_freem(m); + return NULL; + } + + if (xd->amx_wnd >= 0) + { + btsx = ntohq(ahp->ah_rpl); + if ((errc = checkreplaywindow64(btsx, &(xd->amx_rpl), + xd->amx_wnd, &(xd->amx_bitmap))) + != 0) + { + switch(errc) + { + case 1: +#ifdef ENCDEBUG + printf("ahhmacsha1_input: replay counter wrapped\n"); +#endif + ahstat.ahs_wrap++; + break; + case 2: +#ifdef ENCDEBUG + printf("ahhmacsha1_input: received old packet\n"); +#endif + ahstat.ahs_replay++; + break; + case 3: +#ifdef ENCDEBUG + printf("ahhmacsha1_input: packet already received\n"); +#endif + ahstat.ahs_replay++; + break; + } + m_freem(m); + return NULL; + } + } + + ipo = *ip; + ipo.ip_p = ah->ah_nh; + + m->m_len -= (ohlen - sizeof(struct ip)); + m->m_data += (ohlen - sizeof(struct ip)); + m->m_pkthdr.len -= (ohlen - sizeof(struct ip)); + m->m_pkthdr.rcvif = rcvif; /* this should not be necessary */ + + ip = mtod(m, struct ip *); + *ip = ipo; + ip->ip_len = htons(ip->ip_len - ohlen + 2 * sizeof (struct ip)); + HTONS(ip->ip_id); + HTONS(ip->ip_off); + ip->ip_sum = 0; + ip->ip_sum = in_cksum(m, sizeof (struct ip)); + + return m; +} + + +#define AHXPORT + +int +ahhmacsha1_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct ahhmacsha1_xdata *xd; + struct ip *ip, ipo; + struct ah *ah; + struct ahhmacsha1 *ahp, aho; + register int len, off, count; + register struct mbuf *m0; + SHA1_CTX ctx; + int ilen, ohlen; + + + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + + xd = (struct ahhmacsha1_xdata *)tdb->tdb_xdata; + + ilen = ntohs(ip->ip_len); + +#ifdef AHXPORT + ohlen = AH_FLENGTH + xd->amx_alen; +#else + ohlen = sizeof (struct ip) + AH_FLENGTH + xd->amx_alen; +#endif + if (xd->amx_wnd >= 0) + ohlen += HMACSHA1_RPLENGTH; + + ipo.ip_v = IPVERSION; + ipo.ip_hl = 5; + ipo.ip_tos = 0; + ipo.ip_len = htons(ohlen + ilen); + ipo.ip_id = ip->ip_id; + ipo.ip_off = htons(ntohs(ip->ip_off) & IP_DF); + ipo.ip_ttl = 0; + ipo.ip_p = IPPROTO_AH; + ipo.ip_sum = 0; +#ifdef AHXPORT + ipo.ip_src = ip->ip_src; + ipo.ip_dst = ip->ip_dst; + aho.ah_nh = ip->ip_p; +#else + ipo.ip_src = gw->sen_ipsp_src; + ipo.ip_dst = gw->sen_ipsp_dst; + aho.ah_nh = IPPROTO_IP4; +#endif + aho.ah_hl = (xd->amx_alen >> 2); + if (xd->amx_wnd >= 0) + aho.ah_hl += (HMACSHA1_RPLENGTH / sizeof(u_int32_t)); + aho.ah_rv = 0; + aho.ah_spi = tdb->tdb_spi; + + if (xd->amx_wnd >= 0) + { + if (xd->amx_rpl == 0) + { +#ifdef ENCDEBUG + printf("ahhmacsha1_output: key should have changed long ago\n"); +#endif + ahstat.ahs_wrap++; + return NULL; + } + } + + aho.ah_rpl = htonq(xd->amx_rpl++); + + ctx = xd->amx_ictx; + SHA1Update(&ctx, (unsigned char *)&ipo, sizeof (struct ip)); + if (xd->amx_wnd >= 0) + SHA1Update(&ctx, (unsigned char *)&aho, + AH_FLENGTH + HMACSHA1_RPLENGTH); + else + SHA1Update(&ctx, (unsigned char *)&aho, AH_FLENGTH); + SHA1Update(&ctx, ipseczeroes, xd->amx_alen); + +#ifdef AHXPORT + off = sizeof (struct ip); +#else + off = 0; +#endif + + /* + * Code shamelessly stolen from m_copydata + */ + len = m->m_pkthdr.len - off; + + m0 = m; + + while (len > 0) + { + if (m0 == 0) + panic("ahhmacsha1_output: m_copydata"); + count = min(m0->m_len - off, len); + SHA1Update(&ctx, mtod(m0, unsigned char *) + off, count); + + len -= count; + off = 0; + m0 = m0->m_next; + } + + SHA1Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + ctx = xd->amx_octx; + SHA1Update(&ctx, (unsigned char *)(&(aho.ah_data[0])), + HMACSHA1_HASHLEN); + SHA1Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + + ipo.ip_tos = ip->ip_tos; + ipo.ip_id = ip->ip_id; + ipo.ip_off = ip->ip_off; + ipo.ip_ttl = ip->ip_ttl; +/* ipo.ip_len = ntohs(ipo.ip_len); */ + + M_PREPEND(m, ohlen, M_DONTWAIT); + if (m == NULL) + return ENOBUFS; + + m = m_pullup(m, ohlen + sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + ah = (struct ah *)(ip + 1); + ahp = (struct ahhmacsha1 *)ah; + *ip = ipo; + ah->ah_nh = aho.ah_nh; + ah->ah_hl = aho.ah_hl; + ah->ah_rv = aho.ah_rv; + ah->ah_spi = aho.ah_spi; + if (xd->amx_wnd >= 0) + { + ahp->ah_rpl = aho.ah_rpl; + bcopy((unsigned char *)(&(aho.ah_data[0])), + ahp->ah_data, xd->amx_alen); + } + else + bcopy((unsigned char *)(&(aho.ah_data[0])), + ah->ah_data, xd->amx_alen); + + *mp = m; + + return 0; +} diff --git a/sys/netinet/ip_ahmd5.c b/sys/netinet/ip_ahmd5.c new file mode 100644 index 00000000000..27429cb5fa1 --- /dev/null +++ b/sys/netinet/ip_ahmd5.c @@ -0,0 +1,353 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Authentication Header Processing + * Per RFC1828 (Metzger & Simpson, 1995) + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include + +/* + * ahmd5_attach() is called from the transformation initialization code. + * It just returns. + */ + +int +ahmd5_attach() +{ + return 0; +} + +/* + * ahmd5_init() is called when an SPI is being set up. It interprets the + * encap_msghdr present in m, and sets up the transformation data. + */ + +int +ahmd5_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + struct ahmd5_xdata *xd; + struct encap_msghdr *em; + + tdbp->tdb_xform = xsp; + + MALLOC(tdbp->tdb_xdata, caddr_t, sizeof (struct ahmd5_xdata), + M_XDATA, M_WAITOK); + if (tdbp->tdb_xdata == NULL) + return ENOBUFS; + bzero(tdbp->tdb_xdata, sizeof (struct ahmd5_xdata)); + xd = (struct ahmd5_xdata *)tdbp->tdb_xdata; + + em = mtod(m, struct encap_msghdr *); + if (em->em_msglen - EMT_SETSPI_FLEN > sizeof (struct ahmd5_xdata)) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + m_copydata(m, EMT_SETSPI_FLEN, em->em_msglen - EMT_SETSPI_FLEN, (caddr_t)xd); + bzero(ipseczeroes, IPSEC_ZEROES_SIZE); /* paranoid */ + return 0; +} + +/* + * Free memory + */ + +int +ahmd5_zeroize(struct tdb *tdbp) +{ + FREE(tdbp->tdb_xdata, M_XDATA); + return 0; +} + +/* + * ahmd5_input() gets called to verify that an input packet + * passes authentication. + */ + +extern struct ifnet loif; + +struct mbuf * +ahmd5_input(struct mbuf *m, struct tdb *tdb) +{ + struct ahmd5_xdata *xd; + struct ip *ip, ipo; + struct ah *ah; + struct ahmd5 aho; + struct ifnet *rcvif; + int ohlen, len, count, off; + struct mbuf *m0; + MD5_CTX ctx; + + xd = (struct ahmd5_xdata *)tdb->tdb_xdata; + ohlen = sizeof (struct ip) + AH_FLENGTH + xd->amx_alen; + + rcvif = m->m_pkthdr.rcvif; + if (rcvif == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahmd5_input: receive interface is NULL!!!\n"); +#endif + rcvif = &loif; + } + + if (m->m_len < ohlen) + { + if ((m = m_pullup(m, ohlen)) == NULL) + { + ahstat.ahs_hdrops++; + return NULL; + } + } + + ip = mtod(m, struct ip *); + ah = (struct ah *)(ip + 1); + + ipo = *ip; + ipo.ip_tos = 0; + ipo.ip_len += sizeof (struct ip); /* adjusted in ip_intr() */ + HTONS(ipo.ip_len); + HTONS(ipo.ip_id); + ipo.ip_off = htons(ipo.ip_off & IP_DF); /* XXX -- and the C bit? */ + ipo.ip_ttl = 0; + ipo.ip_sum = 0; + + realMD5Init(&ctx); + MD5Update(&ctx, (unsigned char *)xd->amx_key, xd->amx_klen); + MD5Final(NULL, &ctx); /* non-std usage of MD5Final! */ + MD5Update(&ctx, (unsigned char *)&ipo, sizeof (struct ip)); + MD5Update(&ctx, (unsigned char *)ah, AH_FLENGTH); + MD5Update(&ctx, ipseczeroes, xd->amx_alen); + + /* + * Code shamelessly stolen from m_copydata + */ + off = ohlen; + len = m->m_pkthdr.len - off; + m0 = m; + + while (off > 0) + { + if (m0 == 0) + panic("ahmd5_input: m_copydata (off)"); + if (off < m0->m_len) + break; + off -= m0->m_len; + m0 = m0->m_next; + } + + while (len > 0) + { + if (m0 == 0) + panic("ahmd5_input: m_copydata (copy)"); + count = min(m0->m_len - off, len); + MD5Update(&ctx, mtod(m0, unsigned char *) + off, count); + len -= count; + off = 0; + m0 = m0->m_next; + } + + + MD5Update(&ctx, (unsigned char *)xd->amx_key, xd->amx_klen); + MD5Final((unsigned char *)(&(aho.ah_data[0])), &ctx); + + if (bcmp(aho.ah_data, ah->ah_data, xd->amx_alen)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("ahmd5_input: bad auth\n"); /* XXX */ +#endif + ahstat.ahs_badauth++; + m_freem(m); + return NULL; + } + + ipo = *ip; + ipo.ip_p = ah->ah_nh; + + m->m_len -= (ohlen - sizeof(struct ip)); + m->m_data += (ohlen - sizeof(struct ip)); + m->m_pkthdr.len -= (ohlen - sizeof(struct ip)); + m->m_pkthdr.rcvif = rcvif; /* this should not be necessary */ + + ip = mtod(m, struct ip *); + *ip = ipo; + ip->ip_len = htons(ip->ip_len - ohlen + 2 * sizeof (struct ip)); + HTONS(ip->ip_id); + HTONS(ip->ip_off); + ip->ip_sum = 0; + ip->ip_sum = in_cksum(m, sizeof (struct ip)); + + return m; +} + + +#define AHXPORT + +int +ahmd5_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct ahmd5_xdata *xd; + struct ip *ip, ipo; + struct ah *ah, aho; + register int len, off, count; + register struct mbuf *m0; + + MD5_CTX ctx; + + int ilen, ohlen; + + + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + + xd = (struct ahmd5_xdata *)tdb->tdb_xdata; + + ilen = ntohs(ip->ip_len); + +#ifdef AHXPORT + ohlen = AH_FLENGTH + xd->amx_alen; +#else + ohlen = sizeof (struct ip) + AH_FLENGTH + xd->amx_alen; +#endif + + ipo.ip_v = IPVERSION; + ipo.ip_hl = 5; + ipo.ip_tos = 0; + ipo.ip_len = htons(ohlen + ilen); + ipo.ip_id = ip->ip_id; + ipo.ip_off = htons(ntohs(ip->ip_off) & IP_DF); + ipo.ip_ttl = 0; + ipo.ip_p = IPPROTO_AH; + ipo.ip_sum = 0; +#ifdef AHXPORT + ipo.ip_src = ip->ip_src; + ipo.ip_dst = ip->ip_dst; + aho.ah_nh = ip->ip_p; +#else + ipo.ip_src = gw->sen_ipsp_src; + ipo.ip_dst = gw->sen_ipsp_dst; + aho.ah_nh = IPPROTO_IP4; +#endif + aho.ah_hl = xd->amx_alen >> 2; + aho.ah_rv = 0; + aho.ah_spi = tdb->tdb_spi; + + realMD5Init(&ctx); + + MD5Update(&ctx, (unsigned char *)xd->amx_key, xd->amx_klen); + MD5Final(NULL, &ctx); + MD5Update(&ctx, (unsigned char *)&ipo, sizeof (struct ip)); + MD5Update(&ctx, (unsigned char *)&aho, AH_FLENGTH); + MD5Update(&ctx, ipseczeroes, xd->amx_alen); + +#ifdef AHXPORT + off = sizeof (struct ip); +#else + off = 0; +#endif + + /* + * Code shamelessly stolen from m_copydata + */ + len = m->m_pkthdr.len - off; + + m0 = m; + + while (len > 0) + { + if (m0 == 0) + panic("ahmd5_output: m_copydata"); + count = min(m0->m_len - off, len); + MD5Update(&ctx, mtod(m0, unsigned char *) + off, count); + len -= count; + off = 0; + m0 = m0->m_next; + } + + MD5Update(&ctx, (unsigned char *)xd->amx_key, xd->amx_klen); + + ipo.ip_tos = ip->ip_tos; + ipo.ip_id = ip->ip_id; + ipo.ip_off = ip->ip_off; + ipo.ip_ttl = ip->ip_ttl; +/* ipo.ip_len = ntohs(ipo.ip_len); */ + + M_PREPEND(m, ohlen, M_DONTWAIT); + if (m == NULL) + return ENOBUFS; + + m = m_pullup(m, ohlen + sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + ah = (struct ah *)(ip + 1); + *ip = ipo; + ah->ah_nh = aho.ah_nh; + ah->ah_hl = aho.ah_hl; + ah->ah_rv = aho.ah_rv; + ah->ah_spi = aho.ah_spi; + + + MD5Final(&(ah->ah_data[0]), &ctx); + + *mp = m; + + return 0; +} diff --git a/sys/netinet/ip_esp.c b/sys/netinet/ip_esp.c new file mode 100644 index 00000000000..13541d3b59e --- /dev/null +++ b/sys/netinet/ip_esp.c @@ -0,0 +1,158 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Encapsulation Security Payload Processing + * Per RFC1827 (Atkinson, 1995) + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +/* + * esp_input gets called when we receive an packet with an ESP. + */ + +void +esp_input(register struct mbuf *m, int iphlen) +{ + struct ip *ipo; + struct ifqueue *ifq = NULL; + int s; + u_long spi; + struct tdb *tdbp; + + /* + * Strip IP options, if any. + */ + + if (iphlen > sizeof (struct ip)) + { + ip_stripoptions(m, (struct mbuf *)0); + iphlen = sizeof (struct ip); + } + + /* + * Make sure that at least the SPI is in the same mbuf + */ + + ipo = mtod(m, struct ip *); + if (m->m_len < iphlen + ESP_FLENGTH) + { + if ((m = m_pullup(m, iphlen + ESP_FLENGTH)) == 0) + { + espstat.esps_hdrops++; + return; + } + ipo = mtod(m, struct ip *); + } + spi = *((u_long *)((caddr_t)ipo + iphlen)); + + /* + * Find tunnel control block and (indirectly) call the appropriate + * kernel crypto routine. The resulting mbuf chain is a valid + * IP packet ready to go through input processing. + */ + + tdbp = gettdb(spi, ipo->ip_dst); + if (tdbp == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp_input: no tdb for spi=%x\n", spi); +#endif ENCDEBUG + m_freem(m); + espstat.esps_notdb++; + return; + } + + if (tdbp->tdb_xform == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp_input: no xform for spi=%x\n", spi); +#endif ENCDEBUG + m_freem(m); + espstat.esps_noxform++; + return; + } + + m->m_pkthdr.rcvif = tdbp->tdb_rcvif; + + m = (*(tdbp->tdb_xform->xf_input))(m, tdbp); + + if (m == NULL) + { + espstat.esps_badkcr++; + return; + } + + /* + * Interface pointer is already in first mbuf; chop off the + * `outer' header and reschedule. + */ + + ifq = &ipintrq; + + s = splimp(); /* isn't it already? */ + if (IF_QFULL(ifq)) + { + IF_DROP(ifq); + m_freem(m); + espstat.esps_qfull++; + splx(s); + return; + } + IF_ENQUEUE(ifq, m); + schednetisr(NETISR_IP); + splx(s); + return; +} diff --git a/sys/netinet/ip_esp.h b/sys/netinet/ip_esp.h new file mode 100644 index 00000000000..abd2abf1f62 --- /dev/null +++ b/sys/netinet/ip_esp.h @@ -0,0 +1,179 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Encapsulation Security Payload Processing + * Per RFC1827 (Atkinson, 1995) + */ + +#ifndef _MD5_H_ +#include +#endif + +#define ESPDESMD5_KEYSZ 64 +#define ESPDESMD5_IVS 8 +#define ESPDESMD5_ALEN 16 +#define ESPDESMD5_IPAD_VAL 0x36 +#define ESPDESMD5_OPAD_VAL 0x5C +#define ESPDESMD5_DESBLK 8 +#define ESPDESMD5_RPLENGTH 4 +#define ESPDESMD5_DPADI 0x5C +#define ESPDESMD5_DPADR 0x3A +#define ESPDESMD5_IPADI 0xAC +#define ESPDESMD5_IPADR 0x55 +#define ESPDESMD5_HPADI 0x53 +#define ESPDESMD5_HPADR 0x3C +#define ESPDESMD5_RPADI 0x35 +#define ESPDESMD5_RPADR 0xCC + +#define ESP3DESMD5_KEYSZ 64 +#define ESP3DESMD5_IVS 8 +#define ESP3DESMD5_ALEN 16 +#define ESP3DESMD5_IPAD_VAL 0x36 +#define ESP3DESMD5_OPAD_VAL 0x5C +#define ESP3DESMD5_DESBLK 8 +#define ESP3DESMD5_RPLENGTH 4 +#define ESP3DESMD5_DPADI 0x5C +#define ESP3DESMD5_DPADR 0x3A +#define ESP3DESMD5_IPADI 0xAC +#define ESP3DESMD5_IPADR 0x55 +#define ESP3DESMD5_HPADI 0x53 +#define ESP3DESMD5_HPADR 0x3C +#define ESP3DESMD5_RPADI 0x35 +#define ESP3DESMD5_RPADR 0xCC + +struct esp +{ + u_int32_t esp_spi; /* Security Parameters Index */ + u_int8_t esp_iv[8]; /* iv[4] may actually be data! */ +}; + +struct espstat +{ + u_long esps_hdrops; /* packet shorter than header shows */ + u_long esps_notdb; + u_long esps_badkcr; + u_long esps_qfull; + u_long esps_noxform; + u_long esps_badilen; + u_long esps_wrap; /* Replay counter wrapped around */ + u_long esps_badauth; /* Only valid for transforms with auth */ + u_long esps_replay; /* Possible packet replay detected */ +}; + +struct espdes_xdata +{ + int32_t edx_ivlen; /* 4 or 8 */ + union + { + u_int8_t Iv[8]; /* that's enough space */ + u_int32_t Ivl; /* XXX make sure this is 4 bytes */ + u_int64_t Ivq; /* XXX make sure this is 8 bytes! */ + }Iu; +#define edx_iv Iu.Iv +#define edx_ivl Iu.Ivl +#define edx_ivq Iu.Ivq + union + { + u_int8_t Rk[8]; + u_int32_t Eks[16][2]; + }Xu; +#define edx_rk Xu.Rk +#define edx_eks Xu.Eks +}; + +struct esp3desmd5_xencap +{ + int8_t edx_ivlen; /* 0 or 8 */ + int8_t edx_initiator; /* 1 if setting an I key */ + u_int16_t edx_keylen; + u_int32_t edx_wnd; + u_int8_t edx_ivv[ESP3DESMD5_IVS]; + u_int8_t edx_key[ESP3DESMD5_KEYSZ]; +}; + +struct espdesmd5_xencap +{ + int8_t edx_ivlen; /* 0 or 8 */ + int8_t edx_initiator; /* 1 if setting an I key */ + u_int16_t edx_keylen; + u_int32_t edx_wnd; + u_int8_t edx_ivv[ESPDESMD5_IVS]; + u_int8_t edx_key[ESPDESMD5_KEYSZ]; +}; + +#define ESPDESMD5_ULENGTH 8+ESPDESMD5_IVS+ESPDESMD5_KEYSZ +#define ESP3DESMD5_ULENGTH 8+ESP3DESMD5_IVS+ESP3DESMD5_KEYSZ + +struct espdesmd5_xdata +{ + int32_t edx_ivlen; /* 0 or 8 */ + u_int32_t edx_rpl; /* Replay counter */ + u_int32_t edx_wnd; /* Replay window */ + u_int32_t edx_bitmap; + u_int32_t edx_initial; /* initial replay value */ + union + { + u_int8_t Iv[8]; /* that's enough space */ + u_int32_t Ivl; /* XXX make sure this is 4 bytes */ + u_int64_t Ivq; /* XXX make sure this is 8 bytes! */ + }Iu; + union + { + u_int8_t Rk[8]; + u_int32_t Eks[16][2]; + }Xu; + MD5_CTX edx_ictx; + MD5_CTX edx_octx; +}; + +struct esp3desmd5_xdata +{ + int32_t edx_ivlen; /* 0 or 4 or 8 */ + u_int32_t edx_rpl; /* Replay counter */ + u_int32_t edx_wnd; /* Replay window */ + u_int32_t edx_bitmap; + u_int32_t edx_initial; + union + { + u_int8_t Iv[8]; /* that's enough space */ + u_int32_t Ivl; /* XXX make sure this is 4 bytes */ + u_int64_t Ivq; /* XXX make sure this is 8 bytes! */ + }Iu; + union + { + u_int8_t Rk[3][8]; + u_int32_t Eks[3][16][2]; + }Xu; + MD5_CTX edx_ictx; + MD5_CTX edx_octx; +}; + +#define ESP_FLENGTH 12 +#define ESP_ULENGTH 20 /* coming from user mode */ + +#ifdef _KERNEL + +struct espstat espstat; + +#endif diff --git a/sys/netinet/ip_esp3desmd5.c b/sys/netinet/ip_esp3desmd5.c new file mode 100644 index 00000000000..d0d5b204ac3 --- /dev/null +++ b/sys/netinet/ip_esp3desmd5.c @@ -0,0 +1,749 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Based on draft-ietf-ipsec-esp-3des-md5-00.txt. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +extern struct ifnet loif; + +extern void des_ecb_encrypt(caddr_t, caddr_t, caddr_t, int); +extern void des_set_key(caddr_t, caddr_t); + +int +esp3desmd5_attach() +{ + return 0; +} + +/* + * esp3desmd5_init() is called when an SPI is being set up. It interprets the + * encap_msghdr present in m, and sets up the transformation data, in + * this case, the encryption and decryption key schedules + */ + +int +esp3desmd5_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + struct esp3desmd5_xdata *xd; + struct encap_msghdr *em; + struct esp3desmd5_xencap txd; + u_char buf[ESP3DESMD5_KEYSZ]; + int len; + MD5_CTX ctx; + + tdbp->tdb_xform = xsp; + + m = m_pullup(m, ESP3DESMD5_ULENGTH); + if (m == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_init: can't pull up %d bytes\n", ESP_ULENGTH); +#endif ENCDEBUG + return ENOBUFS; + } + + MALLOC(tdbp->tdb_xdata, caddr_t, sizeof (struct esp3desmd5_xdata), + M_XDATA, M_WAITOK); + if (tdbp->tdb_xdata == NULL) + return ENOBUFS; + bzero(tdbp->tdb_xdata, sizeof (struct esp3desmd5_xdata)); + xd = (struct esp3desmd5_xdata *)tdbp->tdb_xdata; + + em = mtod(m, struct encap_msghdr *); + if (em->em_msglen - EMT_SETSPI_FLEN != ESP3DESMD5_ULENGTH) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + m_copydata(m, EMT_SETSPI_FLEN, em->em_msglen - EMT_SETSPI_FLEN, (caddr_t)&txd); + + if ((txd.edx_ivlen != 0) && (txd.edx_ivlen != 8)) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + bzero(ipseczeroes, IPSEC_ZEROES_SIZE); /* paranoid */ + + xd->edx_ivlen = txd.edx_ivlen; + xd->edx_bitmap = 0; + xd->edx_wnd = txd.edx_wnd; + + /* Fix the IV */ + +#ifdef ENCDEBUG + if (encdebug) + { + if (txd.edx_initiator) + printf("INITIATOR\n"); + printf("IV length: %d\n", txd.edx_ivlen); + } +#endif + if (txd.edx_ivlen) + bcopy(txd.edx_ivv, xd->edx_iv, ESP3DESMD5_IVS); + else + { + for (len = 0; len < ESP3DESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESP3DESMD5_IPADI : + ESP3DESMD5_IPADR; + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + bcopy(buf, xd->edx_iv, ESP3DESMD5_IVS); +#ifdef ENCDEBUG + printf("IV "); + if (encdebug) + for (len = 0; len < ESP3DESMD5_IVS; len++) + printf(" %02x", xd->edx_iv[len]); + printf("\n"); +#endif + } + + /* DES key */ + + for (len = 1; len < ESP3DESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESP3DESMD5_DPADI : ESP3DESMD5_DPADR; + + buf[0] = 0; + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + des_set_key((caddr_t)buf, (caddr_t)(xd->edx_eks[0])); + + buf[0] = 1; + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + des_set_key((caddr_t)buf, (caddr_t)(xd->edx_eks[1])); + + buf[0] = 2; + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + des_set_key((caddr_t)buf, (caddr_t)(xd->edx_eks[2])); + + /* HMAC contexts */ + + realMD5Init(&ctx); + for (len = 0; len < ESP3DESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESP3DESMD5_HPADI : ESP3DESMD5_HPADR; + + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + + bzero(buf + ESP3DESMD5_ALEN, ESP3DESMD5_KEYSZ - ESP3DESMD5_ALEN); + + for (len = 0; len < ESP3DESMD5_KEYSZ; len++) + buf[len] ^= ESP3DESMD5_IPAD_VAL; + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + xd->edx_ictx = ctx; + + for (len = 0; len < ESP3DESMD5_KEYSZ; len++) + buf[len] ^= (ESP3DESMD5_IPAD_VAL ^ ESP3DESMD5_OPAD_VAL); + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + xd->edx_octx = ctx; + + /* Replay counter */ + + for (len = 0; len < ESP3DESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESP3DESMD5_RPADI : + ESP3DESMD5_RPADR; + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESP3DESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + bcopy(buf, (unsigned char *)&(xd->edx_rpl), ESP3DESMD5_RPLENGTH); + xd->edx_initial = xd->edx_rpl - 1; + +#ifdef ENCDEBUG + if (encdebug) + printf("Initial replay counter: %x (%x)\n", xd->edx_rpl, + xd->edx_initial); +#endif + + bzero(&txd, sizeof(struct esp3desmd5_xencap)); + bzero(buf, ESP3DESMD5_KEYSZ); + bzero(&ctx, sizeof(MD5_CTX)); + + return 0; +} + +int +esp3desmd5_zeroize(struct tdb *tdbp) +{ + FREE(tdbp->tdb_xdata, M_XDATA); + return 0; +} + + +struct mbuf * +esp3desmd5_input(struct mbuf *m, struct tdb *tdb) +{ + struct esp3desmd5_xdata *xd; + struct ip *ip, ipo; + u_char iv[8], niv[8], blk[8], auth[ESP3DESMD5_ALEN]; + u_char iauth[ESP3DESMD5_ALEN]; + u_char *idat, *odat; + struct esp *esp; + struct ifnet *rcvif; + int plen, ilen, olen, i, authp, oplen, errc; + u_int32_t rplc, tbitmap, trpl; + u_char padsize, nextproto; + struct mbuf *mi, *mo; + MD5_CTX ctx; + + xd = (struct esp3desmd5_xdata *)tdb->tdb_xdata; + + rcvif = m->m_pkthdr.rcvif; + if (rcvif == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_input: receive interface is NULL!!!\n"); +#endif ENCDEBUG + rcvif = &loif; + } + + ip = mtod(m, struct ip *); + ipo = *ip; + esp = (struct esp *)(ip + 1); + + plen = m->m_pkthdr.len - sizeof (struct ip) - sizeof (u_long) - xd->edx_ivlen; + if (plen & 07) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_input: payload not a multiple of 8 octets\n"); +#endif ENCDEBUG + espstat.esps_badilen++; + m_freem(m); + return NULL; + } + + oplen = plen; + ilen = m->m_len - sizeof (struct ip) - ESP3DESMD5_IVS - sizeof(u_long); + idat = mtod(m, unsigned char *) + sizeof (struct ip) + sizeof(u_long) + + ESP3DESMD5_IVS; + + if (xd->edx_ivlen == 0) /* KeyIV in use */ + { + bcopy(xd->edx_iv, iv, ESP3DESMD5_IVS); + ilen += ESP3DESMD5_IVS; + idat -= ESP3DESMD5_IVS; + } + else + bcopy(idat - ESP3DESMD5_IVS, iv, ESP3DESMD5_IVS); + + olen = ilen; + odat = idat; + mi = mo = m; + i = 0; + authp = 0; + + ctx = xd->edx_ictx; + + MD5Update(&ctx, (unsigned char *)&(tdb->tdb_spi), sizeof(u_int32_t)); + MD5Update(&ctx, iv, ESP3DESMD5_IVS); + +#ifdef ENCDEBUG + printf("IV "); + for (i = 0; i < ESP3DESMD5_IVS; i++) + printf(" %02x", iv[i]); + printf("\n"); + i = 0; +#endif + + /* + * At this point: + * plen is # of encapsulated payload octets + * ilen is # of octets left in this mbuf + * idat is first encapsulated payload octed in this mbuf + * same for olen and odat + * iv contains the IV. + * mi and mo point to the first mbuf + * + * From now on until the end of the mbuf chain: + * . move the next eight octets of the chain into blk[] + * (ilen, idat, and mi are adjusted accordingly) + * and save it back into iv[] + * . decrypt blk[], xor with iv[], put back into chain + * (olen, odat, amd mo are adjusted accordingly) + * . repeat + */ + + while (plen > 0) /* while not done */ + { + while (ilen == 0) /* we exhausted previous mbuf */ + { + mi = mi->m_next; + if (mi == NULL) + panic("esp3desmd5_input: bad chain (i)\n"); + ilen = mi->m_len; + idat = (u_char *)mi->m_data; + } + + blk[i] = niv[i] = *idat++; + i++; + ilen--; + + if (i == 8) + { + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks[2]), + 0); + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks[1]), + 0); + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks[0]), + 0); + for (i=0; i<8; i++) + { + while (olen == 0) + { + mo = mo->m_next; + if (mo == NULL) + panic("esp3desmd5_input: bad chain (o)\n"); + olen = mo->m_len; + odat = (u_char *)mo->m_data; + } + *odat = blk[i] ^ iv[i]; + iv[i] = niv[i]; + blk[i] = *odat++; /* needed elsewhere */ + olen--; + } + i = 0; + + if (plen < ESP3DESMD5_ALEN) + { + bcopy(blk, auth + authp, ESP3DESMD5_DESBLK); + authp += ESP3DESMD5_DESBLK; +#ifdef ENCDEBUG + if (encdebug) + printf("Copying authenticator from %d\n", + plen); +#endif + } + else + { + if (plen == ESP3DESMD5_ALEN + 1) + { + nextproto = blk[7]; + padsize = blk[6]; +#ifdef ENCDEBUG + if (encdebug) + printf("Next protocol: %d\nPadsize: %d\n", nextproto, padsize); +#endif + } + else + if (plen + 7 == oplen) + { +#ifdef ENCDEBUG + if (encdebug) + printf("SEQ %02x %02x %02x %02x\n", + blk[0], blk[1], blk[2], + blk[3]); +#endif + tbitmap = xd->edx_bitmap; /* Save it */ + trpl = xd->edx_rpl; + rplc = ntohl(*((u_int32_t *)blk)); + if ((errc = checkreplaywindow32(rplc, xd->edx_initial, &(xd->edx_rpl), xd->edx_wnd, &(xd->edx_bitmap))) != 0) + { + switch (errc) + { + case 1: +#ifdef ENCDEBUG + printf("esp3desmd5_input: replay counter wrapped\n"); +#endif + espstat.esps_wrap++; + break; + case 2: +#ifdef ENCDEBUG + printf("esp3desmd5_input: received old packet, seq = %08x\n", rplc); +#endif + espstat.esps_replay++; + break; + case 3: +#ifdef ENCDEBUG + printf("esp3desmd5_input: packet already received\n"); +#endif + espstat.esps_replay++; + break; + } + m_freem(m); + return NULL; + } + } + + MD5Update(&ctx, blk, ESP3DESMD5_DESBLK); + } + } + + plen--; + } + + /* + * Now, the entire chain has been decrypted. + */ + + MD5Final(iauth, &ctx); + ctx = xd->edx_octx; + MD5Update(&ctx, iauth, ESP3DESMD5_ALEN); + MD5Final(iauth, &ctx); + +#ifdef ENCDEBUG + printf("RECEIVED "); + for (rplc = 0; rplc < ESP3DESMD5_ALEN; rplc++) + printf(" %02x", auth[rplc]); + printf("\nSHOULD HAVE "); + for (rplc = 0; rplc < ESP3DESMD5_ALEN; rplc++) + printf(" %02x", iauth[rplc]); + printf("\n"); +#endif + + if (bcmp(auth, iauth, ESP3DESMD5_ALEN)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_input: bad auth\n"); +#endif + xd->edx_rpl = trpl; + xd->edx_bitmap = tbitmap; /* Restore */ + espstat.esps_badauth++; + m_freem(m); + return NULL; + } + + m_adj(m, - padsize - 2 - ESP3DESMD5_ALEN); + m_adj(m, 4 + xd->edx_ivlen + ESP3DESMD5_RPLENGTH); + + if (m->m_len < sizeof (struct ip)) + { + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + { + xd->edx_rpl = trpl; + xd->edx_bitmap = tbitmap; + return NULL; + } + } + + ip = mtod(m, struct ip *); + ipo.ip_p = nextproto; + ipo.ip_id = htons(ipo.ip_id); + ipo.ip_off = 0; + ipo.ip_len += sizeof (struct ip) - ESP3DESMD5_RPLENGTH - 4 - xd->edx_ivlen - padsize - 2 - ESP3DESMD5_ALEN; +#ifdef ENCDEBUG + if (encdebug) + printf("IP packet size %d\n", ipo.ip_len); +#endif + ipo.ip_len = htons(ipo.ip_len); + ipo.ip_sum = 0; + *ip = ipo; + ip->ip_sum = in_cksum(m, sizeof (struct ip)); + + return m; +} + +int +esp3desmd5_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct esp3desmd5_xdata *xd; + struct ip *ip, ipo; + int i, ilen, olen, ohlen, nh, rlen, plen, padding; + u_int32_t rplc; + u_long spi; + struct mbuf *mi, *mo, *ms; + u_char *pad, *idat, *odat; + u_char iv[ESP3DESMD5_IVS], blk[8], auth[ESP3DESMD5_ALEN]; + MD5_CTX ctx; + + m = m_pullup(m, sizeof (struct ip)); /* Get IP header in one mbuf */ + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + spi = tdb->tdb_spi; + + xd = (struct esp3desmd5_xdata *)tdb->tdb_xdata; + ilen = ntohs(ip->ip_len); /* Size of the packet */ + ohlen = sizeof (u_int32_t) + xd->edx_ivlen; /* size of plaintext ESP */ + + if (xd->edx_rpl == xd->edx_initial) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: replay counter wrapped\n"); +#endif + espstat.esps_wrap++; + return EHOSTDOWN; /* XXX */ + } + + ipo = *ip; + nh = ipo.ip_p; + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: next protocol is %d\n", nh); +#endif + + /* Raw payload length */ + rlen = ESP3DESMD5_RPLENGTH + ilen - sizeof (struct ip); + + padding = ((8 - ((rlen + 2) % 8)) % 8) + 2; + + pad = (u_char *)m_pad(m, padding); + if (pad == NULL) + return ENOBUFS; + + pad[padding-2] = padding - 2; + pad[padding-1] = nh; + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: padding %d bytes\n", padding); +#endif + + plen = rlen + padding + ESP3DESMD5_ALEN; + + ctx = xd->edx_ictx; /* Get inner padding cached */ + + bcopy(xd->edx_iv, iv, ESP3DESMD5_IVS); + + MD5Update(&ctx, (u_char *)&spi, sizeof(u_long)); + MD5Update(&ctx, iv, ESP3DESMD5_IVS); + rplc = htonl(xd->edx_rpl); + MD5Update(&ctx, (unsigned char *)&rplc, ESP3DESMD5_RPLENGTH); + xd->edx_rpl++; + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: using replay counter %x\n", + xd->edx_rpl - 1); +#endif + mi = m; + + /* MD5 the data */ + while (mi != NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: MD5'ing %d bytes\n", mi->m_len); +#endif + if (mi == m) + MD5Update(&ctx, (u_char *)mi->m_data + sizeof(struct ip), + mi->m_len - sizeof(struct ip)); + else + MD5Update(&ctx, (u_char *)mi->m_data, mi->m_len); + mi = mi->m_next; + } + + MD5Final(auth, &ctx); + ctx = xd->edx_octx; + MD5Update(&ctx, auth, ESP3DESMD5_ALEN); + MD5Final(auth, &ctx); /* That's the authenticator */ + + /* + * This routine is different from espdes_output() in that + * here we construct the whole packet before starting encrypting. + */ + + m = m_pullup(m, sizeof(struct ip) + ESP3DESMD5_RPLENGTH + + sizeof(u_int32_t) + xd->edx_ivlen); + if (m == NULL) + return ENOBUFS; + + /* Copy data if necessary */ + if (m->m_len - sizeof(struct ip)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: pushing data\n"); +#endif + ms = m_copym(m, sizeof(struct ip), m->m_len - sizeof(struct ip), + M_DONTWAIT); + if (ms == NULL) + return ENOBUFS; + + ms->m_next = m->m_next; + m->m_next = ms; + m->m_len = sizeof(struct ip); + } + + /* Copy SPI, IV (or not) and replay counter */ + bcopy((caddr_t)&spi, mtod(m, caddr_t) + sizeof (struct ip), + sizeof (u_int32_t)); + bcopy((caddr_t)iv, mtod(m, caddr_t) + sizeof (struct ip) + + sizeof (u_int32_t), xd->edx_ivlen); + bcopy((caddr_t)&rplc, mtod(m, caddr_t) + sizeof(struct ip) + + sizeof(u_int32_t) + xd->edx_ivlen, ESP3DESMD5_RPLENGTH); + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: replay counter (wire value) %x\n", rplc); +#endif + + /* Adjust the length accordingly */ + m->m_len += sizeof(u_int32_t) + ESP3DESMD5_RPLENGTH + xd->edx_ivlen; + m->m_pkthdr.len += sizeof(u_int32_t) + ESP3DESMD5_RPLENGTH + + xd->edx_ivlen; + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: mbuf chain length %d\n", m->m_pkthdr.len); +#endif + + /* Let's append the authenticator too */ + MGET(ms, M_DONTWAIT, MT_DATA); + if (ms == NULL) + return ENOBUFS; + + bcopy(auth, mtod(ms, u_char *), ESP3DESMD5_ALEN); + ms->m_len = ESP3DESMD5_ALEN; + + m_cat(m, ms); + m->m_pkthdr.len += ESP3DESMD5_ALEN; /* Adjust length */ + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: final mbuf chain length %d\n", + m->m_pkthdr.len); +#endif + + ilen = olen = m->m_len - sizeof (struct ip) - sizeof(u_int32_t) - + xd->edx_ivlen; + idat = odat = mtod(m, u_char *) + sizeof (struct ip) + + sizeof(u_int32_t) + xd->edx_ivlen; + i = 0; + mi = mo = m; + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: starting encryption with ilen=%d, plen=%d\n", ilen, plen); +#endif + + while (plen > 0) /* while not done */ + { + while (ilen == 0) /* we exhausted previous mbuf */ + { + mi = mi->m_next; + if (mi == NULL) + panic("esp3desmd5_output: bad chain (i)\n"); + ilen = mi->m_len; + idat = (u_char *)mi->m_data; + } + + blk[i] = *idat++ ^ iv[i]; + + i++; + ilen--; + + if (i == 8) /* We have full block */ + { + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks[0]), + 1); + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks[1]), + 1); + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks[2]), + 1); + for (i=0; i<8; i++) + { + while (olen == 0) + { + mo = mo->m_next; + if (mo == NULL) + panic("esp3desmd5_output: bad chain (o)\n"); + olen = mo->m_len; + odat = (u_char *)mo->m_data; + } + *odat++ = blk[i]; + iv[i] = blk[i]; + olen--; + } + i = 0; + } + + plen--; + } + +#ifdef ENCDEBUG + if (encdebug) + printf("esp3desmd5_output: almost done now\n"); +#endif + + if (xd->edx_ivlen != 0) + bcopy(iv, xd->edx_iv, ESP3DESMD5_IVS); /* New IV */ + + /* Fix the length and the next protocol, copy back and off we go */ + ipo.ip_len = htons(sizeof (struct ip) + ohlen + rlen + padding + + ESP3DESMD5_ALEN); + ipo.ip_p = IPPROTO_ESP; + bcopy((caddr_t)&ipo, mtod(m, caddr_t), sizeof(struct ip)); + + *mp = m; + return 0; +} diff --git a/sys/netinet/ip_espdes.c b/sys/netinet/ip_espdes.c new file mode 100644 index 00000000000..b034a3e78db --- /dev/null +++ b/sys/netinet/ip_espdes.c @@ -0,0 +1,516 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * DES-CBC + * Per RFC1829 (Metzger & Simpson, 1995) + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include + +extern struct ifnet loif; + +extern void des_ecb_encrypt(caddr_t, caddr_t, caddr_t, int); +extern void des_set_key(caddr_t, caddr_t); + +extern MD5_CTX IP4_ctx; + +extern int ticks; +#ifdef EXT_CLOCK +extern int clock_count; +#endif + +int +espdes_attach() +{ + return 0; +} + +/* + * espdes_init() is called when an SPI is being set up. It interprets the + * encap_msghdr present in m, and sets up the transformation data, in + * this case, the encryption and decryption key schedules + */ + +int +espdes_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + struct espdes_xdata *xd; + struct encap_msghdr *em; + u_long rk[2]; + + tdbp->tdb_xform = xsp; + + m = m_pullup(m, ESP_ULENGTH); + if (m == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdes_init: can't pull up %d bytes\n", ESP_ULENGTH); +#endif ENCDEBUG + return ENOBUFS; + } + + MALLOC(tdbp->tdb_xdata, caddr_t, sizeof (struct espdes_xdata), + M_XDATA, M_WAITOK); + if (tdbp->tdb_xdata == NULL) + return ENOBUFS; + bzero(tdbp->tdb_xdata, sizeof (struct espdes_xdata)); + xd = (struct espdes_xdata *)tdbp->tdb_xdata; + + em = mtod(m, struct encap_msghdr *); + if (em->em_msglen - EMT_SETSPI_FLEN != ESP_ULENGTH) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + m_copydata(m, EMT_SETSPI_FLEN, ESP_ULENGTH, (caddr_t)xd); + + rk[0] = xd->edx_eks[0][0]; /* some overloading doesn't hurt */ + rk[1] = xd->edx_eks[0][1]; /* XXX -- raw-major order */ + + des_set_key((caddr_t)rk, (caddr_t)(xd->edx_eks)); + rk[0] = rk[1] = 0; /* zeroize! */ + + return 0; +} + +int +espdes_zeroize(struct tdb *tdbp) +{ + FREE(tdbp->tdb_xdata, M_XDATA); + return 0; +} + + +struct mbuf * +espdes_input(struct mbuf *m, struct tdb *tdb) +{ + struct espdes_xdata *xd; + struct ip *ip, ipo; + u_char iv[8], niv[8], blk[8]; + u_char *idat, *odat; + struct esp *esp; + struct ifnet *rcvif; + int ohlen, plen, ilen, olen, i; + struct mbuf *mi, *mo; + + xd = (struct espdes_xdata *)tdb->tdb_xdata; + ohlen = sizeof (struct ip) + ESP_FLENGTH; + + rcvif = m->m_pkthdr.rcvif; + if (rcvif == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdes_input: receive interface is NULL!!!\n"); +#endif ENCDEBUG + rcvif = &loif; + } + + ip = mtod(m, struct ip *); + ipo = *ip; + esp = (struct esp *)(ip + 1); + + plen = m->m_pkthdr.len - sizeof (struct ip) - sizeof (u_long) - xd->edx_ivlen; + if (plen & 07) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdes_input: payload not a multiple of 8 octets\n"); +#endif ENCDEBUG + espstat.esps_badilen++; + m_freem(m); + return NULL; + } + + ilen = m->m_len - sizeof (struct ip) - 8; + idat = mtod(m, unsigned char *) + sizeof (struct ip) + 8; + + iv[0] = esp->esp_iv[0]; + iv[1] = esp->esp_iv[1]; + iv[2] = esp->esp_iv[2]; + iv[3] = esp->esp_iv[3]; + if (xd->edx_ivlen == 4) + { + iv[4] = ~esp->esp_iv[0]; + iv[5] = ~esp->esp_iv[1]; + iv[6] = ~esp->esp_iv[2]; + iv[7] = ~esp->esp_iv[3]; + } + else + { + iv[4] = esp->esp_iv[4]; + iv[5] = esp->esp_iv[5]; + iv[6] = esp->esp_iv[6]; + iv[7] = esp->esp_iv[7]; + + ilen -= 4; + idat += 4; + } + + olen = ilen; + odat = idat; + mi = mo = m; + i = 0; + + /* + * At this point: + * plen is # of encapsulated payload octets + * ilen is # of octets left in this mbuf + * idat is first encapsulated payload octed in this mbuf + * same for olen and odat + * iv contains the IV. + * mi and mo point to the first mbuf + * + * From now on until the end of the mbuf chain: + * . move the next eight octets of the chain into blk[] + * (ilen, idat, and mi are adjusted accordingly) + * and save it back into iv[] + * . decrypt blk[], xor with iv[], put back into chain + * (olen, odat, amd mo are adjusted accordingly) + * . repeat + */ + + while (plen > 0) /* while not done */ + { + while (ilen == 0) /* we exhausted previous mbuf */ + { + mi = mi->m_next; + if (mi == NULL) + panic("espdes_input: bad chain (i)\n"); + ilen = mi->m_len; + idat = (u_char *)mi->m_data; + } + + blk[i] = niv[i] = *idat++; + i++; + ilen--; + + if (i == 8) + { + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks), 0); + for (i=0; i<8; i++) + { + while (olen == 0) + { + mo = mo->m_next; + if (mo == NULL) + panic("espdes_input: bad chain (o)\n"); + olen = mo->m_len; + odat = (u_char *)mo->m_data; + } + *odat = blk[i] ^ iv[i]; + iv[i] = niv[i]; + blk[i] = *odat++; /* needed elsewhere */ + olen--; + } + i = 0; + } + + plen--; + } + + /* + * Now, the entire chain has been decrypted. As a side effect, + * blk[7] contains the next protocol, and blk[6] contains the + * amount of padding the original chain had. Chop off the + * appropriate parts of the chain, and return. + */ + + m_adj(m, -blk[6] - 2); + m_adj(m, 4 + xd->edx_ivlen); + if (m->m_len < sizeof (struct ip)) + { + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + { + return NULL; + } + } + + ip = mtod(m, struct ip *); + ipo.ip_p = blk[7]; + ipo.ip_id = htons(ipo.ip_id); + ipo.ip_off = 0; + ipo.ip_len += sizeof (struct ip) - 4 - xd->edx_ivlen - blk[6] - 2; + ipo.ip_len = htons(ipo.ip_len); + ipo.ip_sum = 0; + *ip = ipo; + ip->ip_sum = in_cksum(m, sizeof (struct ip)); + + return m; +} + +int +espdes_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct espdes_xdata *xd; + struct ip *ip, ipo; + int i, ilen, olen, ohlen, nh, rlen, plen, padding; + u_long spi; + struct mbuf *mi, *mo; + u_char *pad, *idat, *odat; + u_char iv[8], blk[8]; + + + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + spi = tdb->tdb_spi; + + xd = (struct espdes_xdata *)tdb->tdb_xdata; + ilen = ntohs(ip->ip_len); + ohlen = sizeof (u_long) + xd->edx_ivlen; + + ipo = *ip; + nh = ipo.ip_p; + + rlen = ilen - sizeof (struct ip); /* raw payload length */ + padding = ((8 - ((rlen + 2) % 8)) % 8) + 2; + + pad = (u_char *)m_pad(m, padding); + if (pad == NULL) + return ENOBUFS; + + pad[padding-2] = padding - 2; + pad[padding-1] = nh; + + plen = rlen + padding; + mi = mo = m; + ilen = olen = m->m_len - sizeof (struct ip); + idat = odat = mtod(m, u_char *) + sizeof (struct ip); + i = 0; + + /* + * We are now ready to encrypt the payload. + */ + + xd->edx_ivl++; + + iv[0] = xd->edx_iv[0]; + iv[1] = xd->edx_iv[1]; + iv[2] = xd->edx_iv[2]; + iv[3] = xd->edx_iv[3]; + if (xd->edx_ivlen == 4) + { + iv[4] = ~xd->edx_iv[0]; + iv[5] = ~xd->edx_iv[1]; + iv[6] = ~xd->edx_iv[2]; + iv[7] = ~xd->edx_iv[3]; + } + else + { + iv[4] = xd->edx_iv[4]; + iv[5] = xd->edx_iv[5]; + iv[6] = xd->edx_iv[6]; + iv[7] = xd->edx_iv[7]; + } + + while (plen > 0) /* while not done */ + { + while (ilen == 0) /* we exhausted previous mbuf */ + { + mi = mi->m_next; + if (mi == NULL) + panic("espdes_output: bad chain (i)\n"); + ilen = mi->m_len; + idat = (u_char *)mi->m_data; + } + + blk[i] = *idat++ ^ iv[i]; + + i++; + ilen--; + + if (i == 8) + { + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks), 1); + for (i=0; i<8; i++) + { + while (olen == 0) + { + mo = mo->m_next; + if (mo == NULL) + panic("espdes_output: bad chain (o)\n"); + olen = mo->m_len; + odat = (u_char *)mo->m_data; + } + *odat++ = blk[i]; + iv[i] = blk[i]; + olen--; + } + i = 0; + } + + plen--; + } + + /* + * Done with encryption. Let's wedge in the ESP header + * and send it out. + */ + + M_PREPEND(m, ohlen, M_DONTWAIT); + if (m == NULL) + return ENOBUFS; + + m = m_pullup(m, sizeof(struct ip) + xd->edx_ivlen + sizeof(u_long)); + if (m == NULL) + return ENOBUFS; + + ipo.ip_len = htons(sizeof (struct ip) + ohlen + rlen + padding); + ipo.ip_p = IPPROTO_ESP; + + iv[0] = xd->edx_iv[0]; + iv[1] = xd->edx_iv[1]; + iv[2] = xd->edx_iv[2]; + iv[3] = xd->edx_iv[3]; + if (xd->edx_ivlen == 8) + { + iv[4] = xd->edx_iv[4]; + iv[5] = xd->edx_iv[5]; + iv[6] = xd->edx_iv[6]; + iv[7] = xd->edx_iv[7]; + } + + bcopy((caddr_t)&ipo, mtod(m, caddr_t), sizeof (struct ip)); + bcopy((caddr_t)&spi, mtod(m, caddr_t) + sizeof (struct ip), sizeof (u_long)); + bcopy((caddr_t)iv, mtod(m, caddr_t) + sizeof (struct ip) + sizeof (u_long), xd->edx_ivlen); + + *mp = m; + return 0; +} + + + +/* + * + * + * m_pad(m, n) pads with bytes at the end. The packet header + * length is updated, and a pointer to the first byte of the padding + * (which is guaranteed to be all in one mbuf) is returned. + * + */ + +caddr_t +m_pad(struct mbuf *m, int n) +{ + register int len, pad; + register struct mbuf *m0, *m1; + caddr_t retval; + u_char dat; + + if (n <= 0) /* no stupid arguments */ + return NULL; + + len = m->m_pkthdr.len; + pad = n; + + m0 = m; + + while (m0->m_len < len) + { + len -= m0->m_len; + m0 = m0->m_next; + } + + if (m0->m_len != len) + { +#ifdef ENCDEBUG + if (encdebug) + printf("m_pad: length mismatch (should be %d instead of %d\n", + m->m_pkthdr.len, m->m_pkthdr.len + m0->m_len - len); +#endif ENCDEBUG + m_freem(m); + return NULL; + } + + if ((m0->m_flags & M_EXT) || + (m0->m_data + m0->m_len + pad >= &(m0->m_dat[MLEN]))) + { + /* + * Add an mbuf to the chain + */ + + MGET(m1, M_DONTWAIT, MT_DATA); + if (m1 == 0) + { + m_freem(m0); +#ifdef ENCDEBUG + if (encdebug) + printf("m_pad: cannot append\n"); +#endif ENCDEBUG + return NULL; + } + m0->m_next = m1; + m0 = m1; + m0->m_len = 0; + } + + retval = m0->m_data + m0->m_len; + m0->m_len += pad; + m->m_pkthdr.len += pad; + + for (len = 0; len < n; len++) + { + get_random_bytes((void *)&dat, sizeof(dat)); + retval[len] = len + dat; + } + + return retval; +} diff --git a/sys/netinet/ip_espdesmd5.c b/sys/netinet/ip_espdesmd5.c new file mode 100644 index 00000000000..ed1b2c9845a --- /dev/null +++ b/sys/netinet/ip_espdesmd5.c @@ -0,0 +1,805 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * Based on draft-ietf-ipsec-esp-des-md5-03.txt. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + +extern struct ifnet loif; + +extern void des_ecb_encrypt(caddr_t, caddr_t, caddr_t, int); +extern void des_set_key(caddr_t, caddr_t); + +int +espdesmd5_attach() +{ + return 0; +} + +/* + * espdesmd5_init() is called when an SPI is being set up. It interprets the + * encap_msghdr present in m, and sets up the transformation data, in + * this case, the encryption and decryption key schedules + */ + +int +espdesmd5_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + struct espdesmd5_xdata *xd; + struct encap_msghdr *em; + struct espdesmd5_xencap txd; + u_char buf[ESPDESMD5_KEYSZ]; + int len; + MD5_CTX ctx; + + tdbp->tdb_xform = xsp; + + m = m_pullup(m, ESPDESMD5_ULENGTH); + if (m == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_init: can't pull up %d bytes\n", ESP_ULENGTH); +#endif ENCDEBUG + return ENOBUFS; + } + + MALLOC(tdbp->tdb_xdata, caddr_t, sizeof (struct espdesmd5_xdata), + M_XDATA, M_WAITOK); + if (tdbp->tdb_xdata == NULL) + return ENOBUFS; + bzero(tdbp->tdb_xdata, sizeof (struct espdesmd5_xdata)); + xd = (struct espdesmd5_xdata *)tdbp->tdb_xdata; + + em = mtod(m, struct encap_msghdr *); + if (em->em_msglen - EMT_SETSPI_FLEN != ESPDESMD5_ULENGTH) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + m_copydata(m, EMT_SETSPI_FLEN, em->em_msglen - EMT_SETSPI_FLEN, (caddr_t)&txd); + + if ((txd.edx_ivlen != 0) && (txd.edx_ivlen != 8)) + { + free((caddr_t)tdbp->tdb_xdata, M_XDATA); + tdbp->tdb_xdata = NULL; + return EINVAL; + } + + bzero(ipseczeroes, IPSEC_ZEROES_SIZE); /* paranoid */ + + xd->edx_ivlen = txd.edx_ivlen; + xd->edx_bitmap = 0; + xd->edx_wnd = txd.edx_wnd; + + /* Fix the IV */ + +#ifdef ENCDEBUG + if (encdebug) + { + if (txd.edx_initiator) + printf("INITIATOR\n"); + printf("IV length: %d\n", txd.edx_ivlen); + } +#endif + if (txd.edx_ivlen) + bcopy(txd.edx_ivv, xd->edx_iv, ESPDESMD5_IVS); + else + { + for (len = 0; len < ESPDESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESPDESMD5_IPADI : + ESPDESMD5_IPADR; + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESPDESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + bcopy(buf, xd->edx_iv, ESPDESMD5_IVS); +#ifdef ENCDEBUG + printf("IV "); + if (encdebug) + for (len = 0; len < ESPDESMD5_IVS; len++) + printf(" %02x", xd->edx_iv[len]); + printf("\n"); +#endif + } + + /* DES key */ + + realMD5Init(&ctx); + for (len = 0; len < ESPDESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESPDESMD5_DPADI : ESPDESMD5_DPADR; + + MD5Update(&ctx, buf, ESPDESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + des_set_key((caddr_t)buf, (caddr_t)(xd->edx_eks)); + + /* HMAC contexts */ + + realMD5Init(&ctx); + for (len = 0; len < ESPDESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESPDESMD5_HPADI : ESPDESMD5_HPADR; + + MD5Update(&ctx, buf, ESPDESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + + bzero(buf + ESPDESMD5_ALEN, ESPDESMD5_KEYSZ - ESPDESMD5_ALEN); + + for (len = 0; len < ESPDESMD5_KEYSZ; len++) + buf[len] ^= ESPDESMD5_IPAD_VAL; + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESPDESMD5_KEYSZ); + xd->edx_ictx = ctx; + + for (len = 0; len < ESPDESMD5_KEYSZ; len++) + buf[len] ^= (ESPDESMD5_IPAD_VAL ^ ESPDESMD5_OPAD_VAL); + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESPDESMD5_KEYSZ); + xd->edx_octx = ctx; + + /* Replay counter */ + + for (len = 0; len < ESPDESMD5_KEYSZ; len++) + buf[len] = txd.edx_initiator ? ESPDESMD5_RPADI : + ESPDESMD5_RPADR; + + realMD5Init(&ctx); + MD5Update(&ctx, buf, ESPDESMD5_KEYSZ); + MD5Update(&ctx, txd.edx_key, txd.edx_keylen); + MD5Final(buf, &ctx); + bcopy(buf, (unsigned char *)&(xd->edx_rpl), ESPDESMD5_RPLENGTH); + xd->edx_initial = xd->edx_rpl - 1; + +#ifdef ENCDEBUG + if (encdebug) + printf("Initial replay counter: %x (%x)\n", xd->edx_rpl, + xd->edx_initial); +#endif + + bzero(&txd, sizeof(struct espdesmd5_xencap)); + bzero(buf, ESPDESMD5_KEYSZ); + bzero(&ctx, sizeof(MD5_CTX)); + + return 0; +} + +int +espdesmd5_zeroize(struct tdb *tdbp) +{ + FREE(tdbp->tdb_xdata, M_XDATA); + return 0; +} + + +struct mbuf * +espdesmd5_input(struct mbuf *m, struct tdb *tdb) +{ + struct espdesmd5_xdata *xd; + struct ip *ip, ipo; + u_char iv[8], niv[8], blk[8], auth[ESPDESMD5_ALEN]; + u_char iauth[ESPDESMD5_ALEN]; + u_char *idat, *odat; + struct esp *esp; + struct ifnet *rcvif; + int plen, ilen, olen, i, authp, oplen, errc; + u_int32_t rplc, tbitmap, trpl; + u_char padsize, nextproto; + struct mbuf *mi, *mo; + MD5_CTX ctx; + + xd = (struct espdesmd5_xdata *)tdb->tdb_xdata; + + rcvif = m->m_pkthdr.rcvif; + if (rcvif == NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_input: receive interface is NULL!!!\n"); +#endif ENCDEBUG + rcvif = &loif; + } + + ip = mtod(m, struct ip *); + ipo = *ip; + esp = (struct esp *)(ip + 1); + + plen = m->m_pkthdr.len - sizeof (struct ip) - sizeof (u_long) - xd->edx_ivlen; + if (plen & 07) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_input: payload not a multiple of 8 octets\n"); +#endif ENCDEBUG + espstat.esps_badilen++; + m_freem(m); + return NULL; + } + + oplen = plen; + ilen = m->m_len - sizeof (struct ip) - ESPDESMD5_IVS - sizeof(u_long); + idat = mtod(m, unsigned char *) + sizeof (struct ip) + sizeof(u_long) + + ESPDESMD5_IVS; + + if (xd->edx_ivlen == 0) /* KeyIV in use */ + { + bcopy(xd->edx_iv, iv, ESPDESMD5_IVS); + ilen += ESPDESMD5_IVS; + idat -= ESPDESMD5_IVS; + } + else + bcopy(idat - ESPDESMD5_IVS, iv, ESPDESMD5_IVS); + + olen = ilen; + odat = idat; + mi = mo = m; + i = 0; + authp = 0; + + ctx = xd->edx_ictx; + + MD5Update(&ctx, (unsigned char *)&(tdb->tdb_spi), sizeof(u_int32_t)); + MD5Update(&ctx, iv, ESPDESMD5_IVS); + +#ifdef ENCDEBUG + printf("IV "); + for (i = 0; i < ESPDESMD5_IVS; i++) + printf(" %02x", iv[i]); + printf("\n"); + i = 0; +#endif + + /* + * At this point: + * plen is # of encapsulated payload octets + * ilen is # of octets left in this mbuf + * idat is first encapsulated payload octed in this mbuf + * same for olen and odat + * iv contains the IV. + * mi and mo point to the first mbuf + * + * From now on until the end of the mbuf chain: + * . move the next eight octets of the chain into blk[] + * (ilen, idat, and mi are adjusted accordingly) + * and save it back into iv[] + * . decrypt blk[], xor with iv[], put back into chain + * (olen, odat, amd mo are adjusted accordingly) + * . repeat + */ + + while (plen > 0) /* while not done */ + { + while (ilen == 0) /* we exhausted previous mbuf */ + { + mi = mi->m_next; + if (mi == NULL) + panic("espdesmd5_input: bad chain (i)\n"); + ilen = mi->m_len; + idat = (u_char *)mi->m_data; + } + + blk[i] = niv[i] = *idat++; + i++; + ilen--; + + if (i == 8) + { + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks), 0); + for (i=0; i<8; i++) + { + while (olen == 0) + { + mo = mo->m_next; + if (mo == NULL) + panic("espdesmd5_input: bad chain (o)\n"); + olen = mo->m_len; + odat = (u_char *)mo->m_data; + } + *odat = blk[i] ^ iv[i]; + iv[i] = niv[i]; + blk[i] = *odat++; /* needed elsewhere */ + olen--; + } + i = 0; + + if (plen < ESPDESMD5_ALEN) + { + bcopy(blk, auth + authp, ESPDESMD5_DESBLK); + authp += ESPDESMD5_DESBLK; +#ifdef ENCDEBUG + if (encdebug) + printf("Copying authenticator from %d\n", + plen); +#endif + } + else + { + if (plen == ESPDESMD5_ALEN + 1) + { + nextproto = blk[7]; + padsize = blk[6]; +#ifdef ENCDEBUG + if (encdebug) + printf("Next protocol: %d\nPadsize: %d\n", nextproto, padsize); +#endif + } + else + if (plen + 7 == oplen) + { +#ifdef ENCDEBUG + if (encdebug) + printf("SEQ %02x %02x %02x %02x\n", + blk[0], blk[1], blk[2], + blk[3]); +#endif + tbitmap = xd->edx_bitmap; /* Save it */ + trpl = xd->edx_rpl; + rplc = ntohl(*((u_int32_t *)blk)); + if ((errc = checkreplaywindow32(rplc, xd->edx_initial, &(xd->edx_rpl), xd->edx_wnd, &(xd->edx_bitmap))) != 0) + { + switch (errc) + { + case 1: +#ifdef ENCDEBUG + printf("espdesmd5_input: replay counter wrapped\n"); +#endif + espstat.esps_wrap++; + break; + case 2: +#ifdef ENCDEBUG + printf("espdesmd5_input: received old packet, seq = %08x\n", rplc); +#endif + espstat.esps_replay++; + break; + case 3: +#ifdef ENCDEBUG + printf("espdesmd5_input: packet already received\n"); +#endif + espstat.esps_replay++; + break; + } + m_freem(m); + return NULL; + } + } + + MD5Update(&ctx, blk, ESPDESMD5_DESBLK); + } + } + + plen--; + } + + /* + * Now, the entire chain has been decrypted. + */ + + MD5Final(iauth, &ctx); + ctx = xd->edx_octx; + MD5Update(&ctx, iauth, ESPDESMD5_ALEN); + MD5Final(iauth, &ctx); + +#ifdef ENCDEBUG + printf("RECEIVED "); + for (rplc = 0; rplc < ESPDESMD5_ALEN; rplc++) + printf(" %02x", auth[rplc]); + printf("\nSHOULD HAVE "); + for (rplc = 0; rplc < ESPDESMD5_ALEN; rplc++) + printf(" %02x", iauth[rplc]); + printf("\n"); +#endif + + if (bcmp(auth, iauth, ESPDESMD5_ALEN)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_input: bad auth\n"); +#endif + xd->edx_rpl = trpl; + xd->edx_bitmap = tbitmap; /* Restore */ + espstat.esps_badauth++; + m_freem(m); + return NULL; + } + + m_adj(m, - padsize - 2 - ESPDESMD5_ALEN); + m_adj(m, 4 + xd->edx_ivlen + ESPDESMD5_RPLENGTH); + + if (m->m_len < sizeof (struct ip)) + { + m = m_pullup(m, sizeof (struct ip)); + if (m == NULL) + { + xd->edx_rpl = trpl; + xd->edx_bitmap = tbitmap; + return NULL; + } + } + + ip = mtod(m, struct ip *); + ipo.ip_p = nextproto; + ipo.ip_id = htons(ipo.ip_id); + ipo.ip_off = 0; + ipo.ip_len += sizeof (struct ip) - ESPDESMD5_RPLENGTH - 4 - xd->edx_ivlen - padsize - 2 - ESPDESMD5_ALEN; +#ifdef ENCDEBUG + if (encdebug) + printf("IP packet size %d\n", ipo.ip_len); +#endif + ipo.ip_len = htons(ipo.ip_len); + ipo.ip_sum = 0; + *ip = ipo; + ip->ip_sum = in_cksum(m, sizeof (struct ip)); + + return m; +} + +int +espdesmd5_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct espdesmd5_xdata *xd; + struct ip *ip, ipo; + int i, ilen, olen, ohlen, nh, rlen, plen, padding; + u_int32_t rplc; + u_long spi; + struct mbuf *mi, *mo, *ms; + u_char *pad, *idat, *odat; + u_char iv[ESPDESMD5_IVS], blk[8], auth[ESPDESMD5_ALEN]; + MD5_CTX ctx; + + m = m_pullup(m, sizeof (struct ip)); /* Get IP header in one mbuf */ + if (m == NULL) + return ENOBUFS; + + ip = mtod(m, struct ip *); + spi = tdb->tdb_spi; + + xd = (struct espdesmd5_xdata *)tdb->tdb_xdata; + ilen = ntohs(ip->ip_len); /* Size of the packet */ + ohlen = sizeof (u_int32_t) + xd->edx_ivlen; /* size of plaintext ESP */ + + if (xd->edx_rpl == xd->edx_initial) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: replay counter wrapped\n"); +#endif + espstat.esps_wrap++; + return EHOSTDOWN; /* XXX */ + } + + ipo = *ip; + nh = ipo.ip_p; + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: next protocol is %d\n", nh); +#endif + + /* Raw payload length */ + rlen = ESPDESMD5_RPLENGTH + ilen - sizeof (struct ip); + + padding = ((8 - ((rlen + 2) % 8)) % 8) + 2; + + pad = (u_char *)m_pad(m, padding); + if (pad == NULL) + return ENOBUFS; + + pad[padding-2] = padding - 2; + pad[padding-1] = nh; + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: padding %d bytes\n", padding); +#endif + + plen = rlen + padding + ESPDESMD5_ALEN; + + ctx = xd->edx_ictx; /* Get inner padding cached */ + + bcopy(xd->edx_iv, iv, ESPDESMD5_IVS); + + MD5Update(&ctx, (u_char *)&spi, sizeof(u_long)); + MD5Update(&ctx, iv, ESPDESMD5_IVS); + rplc = htonl(xd->edx_rpl); + MD5Update(&ctx, (unsigned char *)&rplc, ESPDESMD5_RPLENGTH); + xd->edx_rpl++; + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: using replay counter %x\n", + xd->edx_rpl - 1); +#endif + mi = m; + + /* MD5 the data */ + while (mi != NULL) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: MD5'ing %d bytes\n", mi->m_len); +#endif + if (mi == m) + MD5Update(&ctx, (u_char *)mi->m_data + sizeof(struct ip), + mi->m_len - sizeof(struct ip)); + else + MD5Update(&ctx, (u_char *)mi->m_data, mi->m_len); + mi = mi->m_next; + } + + MD5Final(auth, &ctx); + ctx = xd->edx_octx; + MD5Update(&ctx, auth, ESPDESMD5_ALEN); + MD5Final(auth, &ctx); /* That's the authenticator */ + + /* + * This routine is different from espdes_output() in that + * here we construct the whole packet before starting encrypting. + */ + + m = m_pullup(m, sizeof(struct ip) + ESPDESMD5_RPLENGTH + + sizeof(u_int32_t) + xd->edx_ivlen); + if (m == NULL) + return ENOBUFS; + + /* Copy data if necessary */ + if (m->m_len - sizeof(struct ip)) + { +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: pushing data\n"); +#endif + ms = m_copym(m, sizeof(struct ip), m->m_len - sizeof(struct ip), + M_DONTWAIT); + if (ms == NULL) + return ENOBUFS; + + ms->m_next = m->m_next; + m->m_next = ms; + m->m_len = sizeof(struct ip); + } + + /* Copy SPI, IV (or not) and replay counter */ + bcopy((caddr_t)&spi, mtod(m, caddr_t) + sizeof (struct ip), + sizeof (u_int32_t)); + bcopy((caddr_t)iv, mtod(m, caddr_t) + sizeof (struct ip) + + sizeof (u_int32_t), xd->edx_ivlen); + bcopy((caddr_t)&rplc, mtod(m, caddr_t) + sizeof(struct ip) + + sizeof(u_int32_t) + xd->edx_ivlen, ESPDESMD5_RPLENGTH); + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: replay counter (wire value) %x\n", rplc); +#endif + + /* Adjust the length accordingly */ + m->m_len += sizeof(u_int32_t) + ESPDESMD5_RPLENGTH + xd->edx_ivlen; + m->m_pkthdr.len += sizeof(u_int32_t) + ESPDESMD5_RPLENGTH + + xd->edx_ivlen; + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: mbuf chain length %d\n", m->m_pkthdr.len); +#endif + + /* Let's append the authenticator too */ + MGET(ms, M_DONTWAIT, MT_DATA); + if (ms == NULL) + return ENOBUFS; + + bcopy(auth, mtod(ms, u_char *), ESPDESMD5_ALEN); + ms->m_len = ESPDESMD5_ALEN; + + m_cat(m, ms); + m->m_pkthdr.len += ESPDESMD5_ALEN; /* Adjust length */ + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: final mbuf chain length %d\n", + m->m_pkthdr.len); +#endif + + ilen = olen = m->m_len - sizeof (struct ip) - sizeof(u_int32_t) - + xd->edx_ivlen; + idat = odat = mtod(m, u_char *) + sizeof (struct ip) + + sizeof(u_int32_t) + xd->edx_ivlen; + i = 0; + mi = mo = m; + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: starting encryption with ilen=%d, plen=%d\n", ilen, plen); +#endif + + while (plen > 0) /* while not done */ + { + while (ilen == 0) /* we exhausted previous mbuf */ + { + mi = mi->m_next; + if (mi == NULL) + panic("espdesmd5_output: bad chain (i)\n"); + ilen = mi->m_len; + idat = (u_char *)mi->m_data; + } + + blk[i] = *idat++ ^ iv[i]; + + i++; + ilen--; + + if (i == 8) /* We have full block */ + { + des_ecb_encrypt(blk, blk, (caddr_t)(xd->edx_eks), 1); + for (i=0; i<8; i++) + { + while (olen == 0) + { + mo = mo->m_next; + if (mo == NULL) + panic("espdesmd5_output: bad chain (o)\n"); + olen = mo->m_len; + odat = (u_char *)mo->m_data; + } + *odat++ = blk[i]; + iv[i] = blk[i]; + olen--; + } + i = 0; + } + + plen--; + } + +#ifdef ENCDEBUG + if (encdebug) + printf("espdesmd5_output: almost done now\n"); +#endif + + bcopy(iv, xd->edx_iv, ESPDESMD5_IVS); /* New IV */ + + /* Fix the length and the next protocol, copy back and off we go */ + ipo.ip_len = htons(sizeof (struct ip) + ohlen + rlen + padding + + ESPDESMD5_ALEN); + ipo.ip_p = IPPROTO_ESP; + bcopy((caddr_t)&ipo, mtod(m, caddr_t), sizeof(struct ip)); + + *mp = m; + return 0; +} + + +/* + * both versions of the checkreplaywindow for 32 and 64 bit counters + * return 0 on success + * return 1 for counter == 0 + * return 2 for very old packet + * return 3 for packet within current window but already received + */ + +int +checkreplaywindow64(u_int64_t seq, u_int64_t *lastseq, u_int64_t window, u_int64_t *bitmap) +{ + u_int64_t diff; + + if (seq == 0) + return 1; + + if (seq > *lastseq) + { + diff = seq - *lastseq; + if (diff < window) + *bitmap = ((*bitmap) << diff) | 1; + else + *bitmap = 1; + *lastseq = seq; + return 0; + } + diff = *lastseq - seq; + if (diff >= window) + { + espstat.esps_wrap++; + return 2; + } + if ((*bitmap) & (((u_int64_t) 1) << diff)) + { + espstat.esps_replay++; + return 3; + } + *bitmap |= (((u_int64_t) 1) << diff); + return 0; +} + +int +checkreplaywindow32(u_int32_t seq, u_int32_t initial, u_int32_t *lastseq, u_int32_t window, u_int32_t *bitmap) +{ + u_int32_t diff; + +#ifdef ENCDEBUG + if (encdebug) + printf("checkreplaywindow32: seq=%x lastseq=%x\n", seq, *lastseq); +#endif + + seq -= initial; + + if (seq == 0) + return 1; + + if (seq > *lastseq - initial) + { + diff = seq - (*lastseq - initial); + if (diff < window) + *bitmap = ((*bitmap) << diff) | 1; + else + *bitmap = 1; + *lastseq = seq + initial; + return 0; + } + diff = *lastseq - initial - seq; + if (diff >= window) + { + espstat.esps_wrap++; + return 2; + } + if ((*bitmap) & (((u_int32_t) 1) << diff)) + { + espstat.esps_replay++; + return 3; + } + *bitmap |= (((u_int32_t) 1) << diff); + return 0; +} diff --git a/sys/netinet/ip_ip4.c b/sys/netinet/ip_ip4.c new file mode 100644 index 00000000000..b16b0786d8e --- /dev/null +++ b/sys/netinet/ip_ip4.c @@ -0,0 +1,222 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * IP-inside-IP processing + */ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +#include +#include +#include + + + +/* + * ip4_input gets called when we receive an encapsulated packet, + * either because we got it at a real interface, or because AH or ESP + * were being used in tunnel mode (in which case the rcvif element will + * contain the address of the encapX interface associated with the tunnel. + */ + +void +ip4_input(register struct mbuf *m, int iphlen) +{ + struct ip *ipo, *ipi; + struct ifqueue *ifq = NULL; + int s; + /* + * Strip IP options, if any. + */ + + if (iphlen > sizeof (struct ip)) + { + ip_stripoptions(m, (struct mbuf *)0); + iphlen = sizeof (struct ip); + } + + /* + * Make sure next IP header is in the first mbuf. + * + * Careful here! we are receiving the packet from ipintr; + * this means that the ip_len field has been adjusted to + * not count the ip header, and is also in host order. + */ + + ipo = mtod(m, struct ip *); + + if (m->m_len < iphlen + sizeof (struct ip)) + { + if ((m = m_pullup(m, iphlen + sizeof (struct ip))) == 0) + { + ip4stat.ip4s_hdrops++; + return; + } + ipo = mtod(m, struct ip *); + } + ipi = (struct ip *)((caddr_t)ipo + iphlen); + + /* + * XXX - Should we do anything to the inner packet? + * Does arriving at the far end of the tunnel count as one hop + * (thus requiring ipi->ip_ttl to be decremented)? + */ + + if (ipi->ip_v != IPVERSION) + { + ip4stat.ip4s_notip4++; + return; + } + + /* + * Interface pointer is already in first mbuf; chop off the + * `outer' header and reschedule. + */ + + m->m_len -= iphlen; + m->m_pkthdr.len -= iphlen; + m->m_data += iphlen; + + /* XXX -- interface pointer stays the same (which is probably + * the way it should be. + */ + + ifq = &ipintrq; + + s = splimp(); /* isn't it already? */ + if (IF_QFULL(ifq)) + { + IF_DROP(ifq); + m_freem(m); + ip4stat.ip4s_qfull++; + splx(s); + return; + } + IF_ENQUEUE(ifq, m); + schednetisr(NETISR_IP); + splx(s); + + return; +} + +int +ipe4_output(struct mbuf *m, struct sockaddr_encap *gw, struct tdb *tdb, struct mbuf **mp) +{ + struct ip *ipo, *ipi; + ushort ilen; + + ipi = mtod(m, struct ip *); + ilen = ntohs(ipi->ip_len); + + M_PREPEND(m, sizeof (struct ip), M_DONTWAIT); + if (m == 0) + return ENOBUFS; + + ipo = mtod(m, struct ip *); + + ipo->ip_v = IPVERSION; + ipo->ip_hl = 5; + ipo->ip_tos = ipi->ip_tos; + ipo->ip_len = htons(ilen + sizeof (struct ip)); + /* ipo->ip_id = htons(ip_id++); */ + get_random_bytes((void *)&(ipo->ip_id), sizeof(ipo->ip_id)); + ipo->ip_off = ipi->ip_off & ~(IP_MF | IP_OFFMASK); /* keep C and DF */ + ipo->ip_ttl = ipi->ip_ttl; /* already decremented if fwding */ + ipo->ip_p = IPPROTO_IPIP; + ipo->ip_sum = 0; + ipo->ip_src = gw->sen_ipsp_src; + ipo->ip_dst = gw->sen_ipsp_dst; + +/* printf("ip4_output: [%x->%x](l=%d, p=%d)", + ntohl(ipi->ip_src.s_addr), ntohl(ipi->ip_dst.s_addr), + ilen, ipi->ip_p); + printf(" through [%x->%x](l=%d, p=%d)\n", + ntohl(ipo->ip_src.s_addr), ntohl(ipo->ip_dst.s_addr), + ipo->ip_len, ipo->ip_p);*/ + + *mp = m; + return 0; + +/* return ip_output(m, NULL, NULL, IP_ENCAPSULATED, NULL);*/ +} + +int +ipe4_attach() +{ + return 0; +} + +int +ipe4_init(struct tdb *tdbp, struct xformsw *xsp, struct mbuf *m) +{ + printf("ipe4_init: setting up\n"); + tdbp->tdb_xform = xsp; + if (m) + m_freem(m); + return 0; +} + +int +ipe4_zeroize(struct tdb *tdbp) +{ + /* Nothing much really - we don't need any state */ + return 0; +} + + + +void +ipe4_input(struct mbuf *m, ...) +{ + printf("ipe4_input: should never be called\n"); + if (m) + m_freem(m); +} diff --git a/sys/netinet/ip_ip4.h b/sys/netinet/ip_ip4.h new file mode 100644 index 00000000000..4e580fe7524 --- /dev/null +++ b/sys/netinet/ip_ip4.h @@ -0,0 +1,40 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * IP-inside-IP processing. + * Not quite all the functionality of RFC-1853, but the main idea is there. + */ + +struct ip4stat +{ + u_long ip4s_ipackets; /* total input packets */ + u_long ip4s_hdrops; /* packet shorter than header shows */ + u_long ip4s_badlen; + u_long ip4s_notip4; + u_long ip4s_qfull; +}; + +#ifdef _KERNEL +struct ip4stat ip4stat; +#endif diff --git a/sys/netinet/ip_ipsp.c b/sys/netinet/ip_ipsp.c new file mode 100644 index 00000000000..390745def98 --- /dev/null +++ b/sys/netinet/ip_ipsp.c @@ -0,0 +1,259 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * IPSP Processing + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#define IPSEC_IPSP_C +#include +#undef IPSEC_IPSP_C +#include +#include + +#ifdef ENCDEBUG +int encdebug = 1; +#endif + +/* + * This is the proper place to define the various encapsulation transforms. + * CAUTION: the human-readable string should be LESS than 200 bytes if the + * kernfs is to work properly. + */ + +struct xformsw xformsw[] = { +{ XF_IP4, 0, "IPv4 Simple Encapsulation", + ipe4_attach, ipe4_init, ipe4_zeroize, + (struct mbuf * (*)(struct mbuf *, struct tdb *))ipe4_input, ipe4_output, }, +{ XF_AHMD5, XFT_AUTH, "Keyed MD5 Authentication", + ahmd5_attach, ahmd5_init, ahmd5_zeroize, + ahmd5_input, ahmd5_output, }, +{ XF_ESPDES, XFT_CONF, "DES-CBC Encryption", + espdes_attach, espdes_init, espdes_zeroize, + espdes_input, espdes_output, }, +{ XF_AHHMACMD5, XFT_AUTH, "HMAC MD5 Authentication", + ahhmacmd5_attach, ahhmacmd5_init, ahhmacmd5_zeroize, + ahhmacmd5_input, ahhmacmd5_output, }, +{ XF_AHHMACSHA1, XFT_AUTH, "HMAC SHA1 Authentication", + ahhmacsha1_attach, ahhmacsha1_init, ahhmacsha1_zeroize, + ahhmacsha1_input, ahhmacsha1_output, }, +{ XF_ESPDESMD5, XFT_CONF, "DES-CBC Encryption + MD5 Authentication", + espdesmd5_attach, espdesmd5_init, espdesmd5_zeroize, + espdesmd5_input, espdesmd5_output, }, +{ XF_ESP3DESMD5, XFT_CONF, "3DES-CBC Encryption + MD5 Authentication", + esp3desmd5_attach, esp3desmd5_init, esp3desmd5_zeroize, + esp3desmd5_input, esp3desmd5_output, }, +}; + +struct xformsw *xformswNXFORMSW = &xformsw[sizeof(xformsw)/sizeof(xformsw[0])]; + +unsigned char ipseczeroes[IPSEC_ZEROES_SIZE]; /* zeroes! */ + +static char *ipspkernfs = NULL; +static int ipspkernfs_len = 0; +int ipspkernfs_dirty = 1; + +/* + * An IPSP SAID is really the concatenation of the SPI found in the + * packet and the destination address of the packet. When we receive + * an IPSP packet, we need to look up its tunnel descriptor block, + * based on the SPI in the packet and the destination address (which is + * really one of our addresses if we received the packet! + */ + +struct tdb * +gettdb(u_long spi, struct in_addr dst) +{ + int hashval; + struct tdb *tdbp; + + hashval = (spi+dst.s_addr) % TDB_HASHMOD; + + for (tdbp = tdbh[hashval]; tdbp; tdbp = tdbp->tdb_hnext) + if ((tdbp->tdb_spi == spi) && (tdbp->tdb_dst.s_addr == dst.s_addr)) + break; + + return tdbp; +} + +void +puttdb(struct tdb *tdbp) +{ + int hashval; + hashval = ((tdbp->tdb_spi + tdbp->tdb_dst.s_addr) % TDB_HASHMOD); + tdbp->tdb_hnext = tdbh[hashval]; + tdbh[hashval] = tdbp; + ipspkernfs_dirty = 1; +} + +int +tdb_delete(struct tdb *tdbp, int delchain) +{ + struct tdb *tdbpp; + int hashval; + + hashval = ((tdbp->tdb_spi + tdbp->tdb_dst.s_addr) % TDB_HASHMOD); + + if (tdbh[hashval] == tdbp) + { + tdbpp = tdbp; + tdbh[hashval] = tdbp->tdb_hnext; + } + else + for (tdbpp = tdbh[hashval]; tdbpp != NULL; tdbpp = tdbpp->tdb_hnext) + if (tdbpp->tdb_hnext == tdbp) + { + tdbpp->tdb_hnext = tdbp->tdb_hnext; + tdbpp = tdbp; + } + + if (tdbp != tdbpp) + return EINVAL; /* Should never happen */ + + ipspkernfs_dirty = 1; + tdbpp = tdbp->tdb_onext; + (*(tdbp->tdb_xform->xf_zeroize))(tdbp); + FREE(tdbp, M_TDB); + if (delchain && tdbpp) + return tdb_delete(tdbpp, delchain); + else + return 0; +} + +int +tdb_init(struct tdb *tdbp, struct mbuf *m) +{ + int alg; + struct encap_msghdr *em; + struct xformsw *xsp; + + em = mtod(m, struct encap_msghdr *); + alg = em->em_alg; + + for (xsp = xformsw; xsp < xformswNXFORMSW; xsp++) + if (xsp->xf_type == alg) + return (*(xsp->xf_init))(tdbp, xsp, m); + + printf("tdbinit: no alg %d for spi %x, addr %x\n", alg, tdbp->tdb_spi, ntohl(tdbp->tdb_dst.s_addr)); + + m_freem(m); + return EINVAL; +} + + +int +ipsp_kern(int off, char **bufp, int len) +{ + struct tdb *tdbp; + int i, k; + char *b, buf[512]; + + if (off != 0) + return 0; + + if ((!ipspkernfs_dirty) && (ipspkernfs)) + { + *bufp = ipspkernfs; + return ipspkernfs_len; + } + else + ipspkernfs_dirty = 0; + + if (ipspkernfs) + { + FREE(ipspkernfs, M_XDATA); + ipspkernfs = NULL; + } + + for (i = 0, k = 0; i < TDB_HASHMOD; i++) + for (tdbp = tdbh[i]; tdbp != (struct tdb *) NULL; tdbp = tdbp->tdb_hnext) + { + /* Being paranoid to avoid buffer overflows */ + + if (strlen(tdbp->tdb_xform->xf_name) >= 200) + return 0; + + b = (char *)&(tdbp->tdb_dst.s_addr); + k += sprintf(buf, + "SPI=%x, destination=%d.%d.%d.%d, interface=%s\n algorithm=%d (%s)\n next SPI=%x, previous SPI=%x\n", + ntohl(tdbp->tdb_spi), ((int)b[0] & 0xff), ((int)b[1] & 0xff), + ((int)b[2] & 0xff), ((int)b[3] & 0xff), + (tdbp->tdb_rcvif ? tdbp->tdb_rcvif->if_xname : "none"), + tdbp->tdb_xform->xf_type, tdbp->tdb_xform->xf_name, + (tdbp->tdb_onext ? ntohl(tdbp->tdb_onext->tdb_spi) : 0), + (tdbp->tdb_inext ? ntohl(tdbp->tdb_inext->tdb_spi) : 0)); + } + + if (k == 0) + return 0; + + MALLOC(ipspkernfs, char *, k + 1, M_XDATA, M_DONTWAIT); + if (!ipspkernfs) + return 0; + + ipspkernfs_len = k + 1; + + for (i = 0, k = 0; i < TDB_HASHMOD; i++) + for (tdbp = tdbh[i]; tdbp != (struct tdb *) NULL; tdbp = tdbp->tdb_hnext) + { + b = (char *)&(tdbp->tdb_dst.s_addr); + k += sprintf(ipspkernfs + k, + "SPI=%x, destination=%d.%d.%d.%d, interface=%s\n algorithm=%d (%s)\n next SPI=%x, previous SPI=%x\n", + ntohl(tdbp->tdb_spi), ((int)b[0] & 0xff), ((int)b[1] & 0xff), + ((int)b[2] & 0xff), ((int)b[3] & 0xff), + (tdbp->tdb_rcvif ? tdbp->tdb_rcvif->if_xname : "none"), + tdbp->tdb_xform->xf_type, tdbp->tdb_xform->xf_name, + (tdbp->tdb_onext ? ntohl(tdbp->tdb_onext->tdb_spi) : 0), + (tdbp->tdb_inext ? ntohl(tdbp->tdb_inext->tdb_spi) : 0)); + } + + ipspkernfs[k] = '\0'; + *bufp = ipspkernfs; + return ipspkernfs_len; +} diff --git a/sys/netinet/ip_ipsp.h b/sys/netinet/ip_ipsp.h new file mode 100644 index 00000000000..85e122a752e --- /dev/null +++ b/sys/netinet/ip_ipsp.h @@ -0,0 +1,139 @@ +/* + * The author of this code is John Ioannidis, ji@tla.org, + * (except when noted otherwise). + * + * This code was written for BSD/OS in Athens, Greece, in November 1995. + * + * Ported to OpenBSD and NetBSD, with additional transforms, in December 1996, + * by Angelos D. Keromytis, kermit@forthnet.gr. + * + * Copyright (C) 1995, 1996, 1997 by John Ioannidis and Angelos D. Keromytis. + * + * Permission to use, copy, and modify this software without fee + * is hereby granted, provided that this entire notice is included in + * all copies of any software which is or includes a copy or + * modification of this software. + * + * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR + * IMPLIED WARRANTY. IN PARTICULAR, NEITHER AUTHOR MAKES ANY + * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE + * MERCHANTABILITY OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR + * PURPOSE. + */ + +/* + * IPSP global definitions. + */ + +struct tdb /* tunnel descriptor block */ +{ + struct tdb *tdb_hnext; /* next in hash chain */ + struct tdb *tdb_onext; /* next in output */ + struct tdb *tdb_inext; /* next in input (prev!) */ + u_long tdb_spi; /* SPI to use */ + struct in_addr tdb_dst; /* dest address for this SPI */ + struct ifnet *tdb_rcvif; /* related rcv encap interface */ + struct xformsw *tdb_xform; /* transformation to use */ + caddr_t tdb_xdata; /* transformation data (opaque) */ +}; + +#define TDB_HASHMOD 257 + +struct xformsw +{ + u_short xf_type; /* Unique ID of xform */ + u_short xf_flags; /* flags (see below) */ + char *xf_name; /* human-readable name */ + int (*xf_attach)(void); /* called at config time */ + int (*xf_init)(struct tdb *, struct xformsw *, struct mbuf *); /* xform initialization */ + int (*xf_zeroize)(struct tdb *); /* termination */ + struct mbuf *(*xf_input)(struct mbuf *, struct tdb *); /* called when packet received */ + int (*xf_output)(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); /* called when packet sent */ +}; + +#define XF_IP4 1 /* IP inside IP */ +#define XF_AHMD5 2 /* AH MD5 */ +#define XF_AHSHA1 3 /* AH SHA */ +#define XF_ESPDES 4 /* ESP DES-CBC */ +#define XF_ESP3DES 5 /* ESP DES3-CBC */ +#define XF_AHHMACMD5 6 /* AH-HMAC-MD5 with opt replay prot */ +#define XF_AHHMACSHA1 7 /* AH-HMAC-SHA1 with opt replay prot */ +#define XF_ESPDESMD5 8 /* ESP DES-CBC + MD5 */ +#define XF_ESP3DESMD5 9 /* ESP 3DES-CBC + MD5 */ + +#define XFT_AUTH 0x0001 +#define XFT_CONF 0x0100 + +#define IPSEC_ZEROES_SIZE 64 + +#ifdef IPSEC_IPSP_C +#if BYTE_ORDER == LITTLE_ENDIAN +inline u_int64_t +htonq(u_int64_t q) +{ + register u_int32_t u, l; + u = q >> 32; + l = (u_int32_t) q; + + return htonl(u) | ((u_int64_t)htonl(l) << 32); +} + +#define ntohq(_x) htonq(_x) + +#elif BYTE_ORDER == BIG_ENDIAN + +#define htonq(_x) (_x) +#define ntohq(_x) htonq(_x) + +#else +#error "Please fix " +#endif +#else +u_int64_t htonq(u_int64_t); +#define ntohq(_x) htonq(_x) +extern unsigned char ipseczeroes[IPSEC_ZEROES_SIZE]; +#endif + +#ifdef _KERNEL +#undef ENCDEBUG +extern int encdebug; + +struct tdb *tdbh[TDB_HASHMOD]; +extern struct xformsw xformsw[], *xformswNXFORMSW; + +extern struct tdb *gettdb(u_long, struct in_addr); +extern void puttdb(struct tdb *); +extern int tdb_delete(struct tdb *, int); + +extern int ipe4_attach(void), ipe4_init(struct tdb *, struct xformsw *, struct mbuf *), ipe4_zeroize(struct tdb *); +extern int ipe4_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern void ipe4_input __P((struct mbuf *, ...)); + +extern int ahmd5_attach(void), ahmd5_init(struct tdb *, struct xformsw *, struct mbuf *), ahmd5_zeroize(struct tdb *); +extern int ahmd5_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern struct mbuf *ahmd5_input(struct mbuf *, struct tdb *); + +extern int ahhmacmd5_attach(void), ahhmacmd5_init(struct tdb *, struct xformsw *, struct mbuf *), ahhmacmd5_zeroize(struct tdb *); +extern int ahhmacmd5_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern struct mbuf *ahhmacmd5_input(struct mbuf *, struct tdb *); + +extern int ahhmacsha1_attach(void), ahhmacsha1_init(struct tdb *, struct xformsw *, struct mbuf *), ahhmacsha1_zeroize(struct tdb *); +extern int ahhmacsha1_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern struct mbuf *ahhmacsha1_input(struct mbuf *, struct tdb *); + +extern int espdes_attach(void), espdes_init(struct tdb *, struct xformsw *, struct mbuf *), espdes_zeroize(struct tdb *); +extern int espdes_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern struct mbuf *espdes_input(struct mbuf *, struct tdb *); + +extern int espdesmd5_attach(void), espdesmd5_init(struct tdb *, struct xformsw *, struct mbuf *), espdesmd5_zeroize(struct tdb *); +extern int espdesmd5_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern struct mbuf *espdesmd5_input(struct mbuf *, struct tdb *); + +extern int esp3desmd5_attach(void), esp3desmd5_init(struct tdb *, struct xformsw *, struct mbuf *), esp3desmd5_zeroize(struct tdb *); +extern int esp3desmd5_output(struct mbuf *, struct sockaddr_encap *, struct tdb *, struct mbuf **); +extern struct mbuf *esp3desmd5_input(struct mbuf *, struct tdb *); + +extern caddr_t m_pad(struct mbuf *, int); +extern int checkreplaywindow32(u_int32_t, u_int32_t, u_int32_t *, u_int32_t, u_int32_t *); +extern int checkreplaywindow64(u_int64_t, u_int64_t *, u_int64_t, u_int64_t *); +#endif diff --git a/sys/netinet/ip_md5.h b/sys/netinet/ip_md5.h new file mode 100644 index 00000000000..2e102c8fcdc --- /dev/null +++ b/sys/netinet/ip_md5.h @@ -0,0 +1,71 @@ +/* GLOBAL.H - RSAREF types and constants + */ + +/* PROTOTYPES should be set to one if and only if the compiler supports + function argument prototyping. + The following makes PROTOTYPES default to 0 if it has not already + been defined with C compiler flags. + */ +#ifndef PROTOTYPES +#define PROTOTYPES 1 +#endif + +/* POINTER defines a generic pointer type */ +typedef unsigned char *POINTER; + +/* UINT2 defines a two byte word */ +typedef unsigned short int UINT2; + +/* UINT4 defines a four byte word */ +typedef unsigned long int UINT4; + +/* PROTO_LIST is defined depending on how PROTOTYPES is defined above. + If using PROTOTYPES, then PROTO_LIST returns the list, otherwise it + returns an empty list. + */ + +#if PROTOTYPES +#define PROTO_LIST(list) list +#else +#define PROTO_LIST(list) () +#endif + + +/* MD5.H - header file for MD5C.C + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + */ + +/* MD5 context. */ +typedef struct { + UINT4 state[4]; /* state (ABCD) */ + UINT4 count[2]; /* number of bits, modulo 2^64 (lsb first) */ + unsigned char buffer[64]; /* input buffer */ +} MD5_CTX; + +void realMD5Init PROTO_LIST ((MD5_CTX *)); +void MD5Update PROTO_LIST + ((MD5_CTX *, unsigned char *, unsigned int)); +void MD5Final PROTO_LIST ((unsigned char [16], MD5_CTX *)); + +#define _MD5_H_ diff --git a/sys/netinet/ip_md5c.c b/sys/netinet/ip_md5c.c new file mode 100644 index 00000000000..80eae87b3c7 --- /dev/null +++ b/sys/netinet/ip_md5c.c @@ -0,0 +1,383 @@ +/* + * The rest of the code is derived from MD5C.C by RSADSI. Minor cosmetic + * changes to accomodate it in the kernel by ji. + */ + +/* MD5C.C - RSA Data Security, Inc., MD5 message-digest algorithm + */ + +/* Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All +rights reserved. + +License to copy and use this software is granted provided that it +is identified as the "RSA Data Security, Inc. MD5 Message-Digest +Algorithm" in all material mentioning or referencing this software +or this function. + +License is also granted to make and use derivative works provided +that such works are identified as "derived from the RSA Data +Security, Inc. MD5 Message-Digest Algorithm" in all material +mentioning or referencing the derived work. + +RSA Data Security, Inc. makes no representations concerning either +the merchantability of this software or the suitability of this +software for any particular purpose. It is provided "as is" +without express or implied warranty of any kind. + +These notices must be retained in any copies of any part of this +documentation and/or software. + */ + +/* + * Additions by JI + * + * HAVEMEMCOPY is defined if mem* routines are available + * + * HAVEHTON is defined if htons() and htonl() can be used + * for big/little endian conversions + * + */ + +#include +#include +#include + +#define HAVEBCOPY + +/* Constants for MD5Transform routine. + */ + +#define S11 7 +#define S12 12 +#define S13 17 +#define S14 22 +#define S21 5 +#define S22 9 +#define S23 14 +#define S24 20 +#define S31 4 +#define S32 11 +#define S33 16 +#define S34 23 +#define S41 6 +#define S42 10 +#define S43 15 +#define S44 21 + +static void MD5Transform PROTO_LIST ((UINT4 [4], unsigned char [64])); + +#if BYTE_ORDER == LITTLE_ENDIAN +#define Encode MD5_memcpy +#define Decode MD5_memcpy +#else +static void Encode PROTO_LIST + ((unsigned char *, UINT4 *, unsigned int)); +static void Decode PROTO_LIST + ((UINT4 *, unsigned char *, unsigned int)); +#endif + +#ifdef HAVEMEMCOPY +#include +#define MD5_memcpy memcpy +#define MD5_memset memset +#else +#ifdef HAVEBCOPY +#define MD5_memcpy(_a,_b,_c) bcopy((_b),(_a),(_c)) +#define MD5_memset(_a,_b,_c) bzero((_a),(_c)) +#else +static void MD5_memcpy PROTO_LIST ((POINTER, POINTER, unsigned int)); +static void MD5_memset PROTO_LIST ((POINTER, int, unsigned int)); +#endif +#endif +static unsigned char PADDING[64] = { + 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 +}; + +/* F, G, H and I are basic MD5 functions. + */ +#define F(x, y, z) (((x) & (y)) | ((~x) & (z))) +#define G(x, y, z) (((x) & (z)) | ((y) & (~z))) +#define H(x, y, z) ((x) ^ (y) ^ (z)) +#define I(x, y, z) ((y) ^ ((x) | (~z))) + +/* ROTATE_LEFT rotates x left n bits. + */ +#define ROTATE_LEFT(x, n) (((x) << (n)) | ((x) >> (32-(n)))) + +/* FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. +Rotation is separate from addition to prevent recomputation. + */ +#define FF(a, b, c, d, x, s, ac) { \ + (a) += F ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define GG(a, b, c, d, x, s, ac) { \ + (a) += G ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define HH(a, b, c, d, x, s, ac) { \ + (a) += H ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } +#define II(a, b, c, d, x, s, ac) { \ + (a) += I ((b), (c), (d)) + (x) + (UINT4)(ac); \ + (a) = ROTATE_LEFT ((a), (s)); \ + (a) += (b); \ + } + +/* MD5 initialization. Begins an MD5 operation, writing a new context. + */ +void realMD5Init (context) +MD5_CTX *context; /* context */ +{ + context->count[0] = context->count[1] = 0; + /* Load magic initialization constants. +*/ + context->state[0] = 0x67452301; + context->state[1] = 0xefcdab89; + context->state[2] = 0x98badcfe; + context->state[3] = 0x10325476; +} + +/* MD5 block update operation. Continues an MD5 message-digest + operation, processing another message block, and updating the + context. + */ +void MD5Update (context, input, inputLen) +MD5_CTX *context; /* context */ +unsigned char *input; /* input block */ +unsigned int inputLen; /* length of input block */ +{ + unsigned int i, index, partLen; + + /* Compute number of bytes mod 64 */ + index = (unsigned int)((context->count[0] >> 3) & 0x3F); + + /* Update number of bits */ + if ((context->count[0] += ((UINT4)inputLen << 3)) + < ((UINT4)inputLen << 3)) + context->count[1]++; + context->count[1] += ((UINT4)inputLen >> 29); + + partLen = 64 - index; + + /* Transform as many times as possible. +*/ + if (inputLen >= partLen) { + MD5_memcpy + ((POINTER)&context->buffer[index], (POINTER)input, partLen); + MD5Transform (context->state, context->buffer); + + for (i = partLen; i + 63 < inputLen; i += 64) + MD5Transform (context->state, &input[i]); + + index = 0; + } + else + i = 0; + + /* Buffer remaining input */ + MD5_memcpy + ((POINTER)&context->buffer[index], (POINTER)&input[i], + inputLen-i); +} + +/* MD5 finalization. Ends an MD5 message-digest operation, writing the + the message digest and zeroizing the context. + */ +void MD5Final (digest, context) +unsigned char digest[16]; /* message digest */ +MD5_CTX *context; /* context */ +{ + unsigned char bits[8]; + unsigned int index, padLen; + + /* Save number of bits */ + Encode (bits, context->count, 8); + + /* Pad out to 56 mod 64. +*/ + index = (unsigned int)((context->count[0] >> 3) & 0x3f); + padLen = (index < 56) ? (56 - index) : (120 - index); + MD5Update (context, PADDING, padLen); + + /* Append length (before padding) */ + MD5Update (context, bits, 8); + + if (digest != NULL) /* Bill Simpson's padding */ + { + /* store state in digest */ + Encode (digest, context->state, 16); + + /* Zeroize sensitive information. + */ + MD5_memset ((POINTER)context, 0, sizeof (*context)); + } +} + +/* MD5 basic transformation. Transforms state based on block. + */ +static void MD5Transform (state, block) +UINT4 state[4]; +unsigned char block[64]; +{ + UINT4 a = state[0], b = state[1], c = state[2], d = state[3], x[16]; + + Decode (x, block, 64); + + /* Round 1 */ + FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */ + FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */ + FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */ + FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */ + FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */ + FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */ + FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */ + FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */ + FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */ + FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */ + FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */ + FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */ + FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */ + FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */ + FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */ + FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */ + + /* Round 2 */ + GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */ + GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */ + GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */ + GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */ + GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */ + GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */ + GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */ + GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */ + GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */ + GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */ + GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */ + GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */ + GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */ + GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */ + GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */ + GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */ + + /* Round 3 */ + HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */ + HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */ + HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */ + HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */ + HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */ + HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */ + HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */ + HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */ + HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */ + HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */ + HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */ + HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */ + HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */ + HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */ + HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */ + HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */ + + /* Round 4 */ + II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */ + II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */ + II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */ + II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */ + II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */ + II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */ + II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */ + II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */ + II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */ + II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */ + II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */ + II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */ + II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */ + II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */ + II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */ + II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */ + + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + + /* Zeroize sensitive information. +*/ + MD5_memset ((POINTER)x, 0, sizeof (x)); +} + +#if BYTE_ORDER != LITTLE_ENDIAN + +/* Encodes input (UINT4) into output (unsigned char). Assumes len is + a multiple of 4. + */ +static void Encode (output, input, len) +unsigned char *output; +UINT4 *input; +unsigned int len; +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) { + output[j] = (unsigned char)(input[i] & 0xff); + output[j+1] = (unsigned char)((input[i] >> 8) & 0xff); + output[j+2] = (unsigned char)((input[i] >> 16) & 0xff); + output[j+3] = (unsigned char)((input[i] >> 24) & 0xff); + } +} + +/* Decodes input (unsigned char) into output (UINT4). Assumes len is + a multiple of 4. + */ +static void Decode (output, input, len) +UINT4 *output; +unsigned char *input; +unsigned int len; +{ + unsigned int i, j; + + for (i = 0, j = 0; j < len; i++, j += 4) + output[i] = ((UINT4)input[j]) | (((UINT4)input[j+1]) << 8) | + (((UINT4)input[j+2]) << 16) | (((UINT4)input[j+3]) << 24); +} + +#endif + +#ifndef HAVEMEMCOPY +#ifndef HAVEBCOPY +/* Note: Replace "for loop" with standard memcpy if possible. + */ + +static void MD5_memcpy (output, input, len) +POINTER output; +POINTER input; +unsigned int len; +{ + unsigned int i; + + for (i = 0; i < len; i++) + + output[i] = input[i]; +} + +/* Note: Replace "for loop" with standard memset if possible. + */ +static void MD5_memset (output, value, len) +POINTER output; +int value; +unsigned int len; +{ + unsigned int i; + + for (i = 0; i < len; i++) + ((char *)output)[i] = (char)value; +} +#endif +#endif + diff --git a/sys/netinet/ip_mroute.c b/sys/netinet/ip_mroute.c index 7eeb38ee6ad..ddfe57f6d3a 100644 --- a/sys/netinet/ip_mroute.c +++ b/sys/netinet/ip_mroute.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ip_mroute.c,v 1.4 1996/05/10 12:31:19 deraadt Exp $ */ +/* $OpenBSD: ip_mroute.c,v 1.5 1997/02/20 01:08:04 deraadt Exp $ */ /* $NetBSD: ip_mroute.c,v 1.27 1996/05/07 02:40:50 thorpej Exp $ */ /* @@ -42,6 +42,10 @@ #include +#ifdef IPSEC +#include +#endif + #define IP_MULTICASTOPTS 0 #define M_PULLUP(m, len) \ do { \ @@ -1393,7 +1397,11 @@ encap_send(ip, vifp, m) */ ip_copy = mtod(mb_copy, struct ip *); *ip_copy = multicast_encap_iphdr; +#ifdef IPSEC + get_random_bytes((void *)&(ip_copy->ip_id), sizeof(ip_copy->ip_id)); +#else ip_copy->ip_id = htons(ip_id++); +#endif ip_copy->ip_len = len; ip_copy->ip_src = vifp->v_lcl_addr; ip_copy->ip_dst = vifp->v_rmt_addr; @@ -1439,16 +1447,19 @@ ipip_input(m, va_alist) register int s; register struct ifqueue *ifq; register struct vif *vifp; + int isencaped = 0; va_list ap; va_start(ap, m); hlen = va_arg(ap, int); va_end(ap); +#ifndef IPSEC if (!have_encap_tunnel) { rip_input(m); return; } +#endif /* * dump the packet if it's not to a multicast destination or if @@ -1458,6 +1469,10 @@ ipip_input(m, va_alist) * at most one tunnel with the remote site). */ if (!IN_MULTICAST(((struct ip *)((char *)ip + hlen))->ip_dst.s_addr)) { +#ifdef IPSEC + isencaped = 1; + goto acceptedhere; +#endif ++mrtstat.mrts_bad_tunnel; m_freem(m); return; @@ -1485,10 +1500,16 @@ ipip_input(m, va_alist) } else vifp = last_encap_vif; +acceptedhere: m->m_data += hlen; m->m_len -= hlen; m->m_pkthdr.len -= hlen; +#ifdef IPSEC + if (isencaped == 0) + m->m_pkthdr.rcvif = vifp->v_ifp; +#else m->m_pkthdr.rcvif = vifp->v_ifp; +#endif ifq = &ipintrq; s = splimp(); if (IF_QFULL(ifq)) { diff --git a/sys/netinet/ip_output.c b/sys/netinet/ip_output.c index 2b31d8dd9f2..0bfe9cce3f7 100644 --- a/sys/netinet/ip_output.c +++ b/sys/netinet/ip_output.c @@ -1,4 +1,4 @@ -/* $OpenBSD: ip_output.c,v 1.6 1996/07/29 02:34:31 downsj Exp $ */ +/* $OpenBSD: ip_output.c,v 1.7 1997/02/20 01:08:06 deraadt Exp $ */ /* $NetBSD: ip_output.c,v 1.28 1996/02/13 23:43:07 christos Exp $ */ /* @@ -61,6 +61,13 @@ #include +#ifdef IPSEC +#include +#include +#include +#include +#endif + static struct mbuf *ip_insertoptions __P((struct mbuf *, struct mbuf *, int *)); static void ip_mloopback __P((struct ifnet *, struct mbuf *, struct sockaddr_in *)); @@ -96,6 +103,11 @@ ip_output(m0, va_alist) int flags; struct ip_moptions *imo; va_list ap; +#ifdef IPSEC + struct mbuf *mp; + struct udphdr *udp; + struct tcphdr *tcp; +#endif va_start(ap, m0); opt = va_arg(ap, struct mbuf *); @@ -127,6 +139,174 @@ ip_output(m0, va_alist) } else { hlen = ip->ip_hl << 2; } + +#ifdef IPSEC + /* + * Check if the packet needs encapsulation + */ + if (!(flags & IP_ENCAPSULATED)) { + struct route_enc { + struct rtentry *re_rt; + struct sockaddr_encap re_dst; + } re0, *re = &re0; + struct sockaddr_encap *dst, *gw; + struct tdb *tdb; + + bzero((caddr_t)re, sizeof (*re)); + dst = (struct sockaddr_encap *)&re->re_dst; + dst->sen_family = AF_ENCAP; + dst->sen_len = SENT_IP4_LEN; + dst->sen_type = SENT_IP4; + dst->sen_ip_src = ip->ip_src; + dst->sen_ip_dst = ip->ip_dst; + dst->sen_proto = ip->ip_p; + + if ((m->m_len < hlen + 2*sizeof(u_int16_t)) && + ((m = m_pullup(m, hlen + 2*sizeof(u_int16_t))) == 0)) + goto bad; + + switch (ip->ip_p) { + case IPPROTO_TCP: + udp = (struct udphdr *) (mtod(m, u_char *) + hlen); + dst->sen_sport = ntohs(udp->uh_sport); + dst->sen_dport = ntohs(udp->uh_dport); + break; + case IPPROTO_UDP: + tcp = (struct tcphdr *) (mtod(m, u_char *) + hlen); + dst->sen_sport = ntohs(tcp->th_sport); + dst->sen_dport = ntohs(tcp->th_dport); + break; + default: + dst->sen_sport = 0; + dst->sen_dport = 0; + } + rtalloc((struct route *)re); + if (re->re_rt == NULL) + goto no_encap; + + gw = (struct sockaddr_encap *)(re->re_rt->rt_gateway); + if (gw == NULL || gw->sen_type != SENT_IPSP) { +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: no gw or gw data not IPSP\n"); +#endif ENCDEBUG + m_freem(m); + RTFREE(re->re_rt); + return EHOSTUNREACH; + } + + ifp = re->re_rt->rt_ifp; + + if (ip->ip_src.s_addr == INADDR_ANY) { + struct sockaddr_encap *sen; + struct sockaddr_in *sinp; + + if (ifp->if_addrlist.tqh_first) + sen = (struct sockaddr_encap *) + ifp->if_addrlist.tqh_first->ifa_addr; + else { +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: interface %s has no default address\n", + ifp->if_xname); +#endif ENCDEBUG + return ENXIO; + } + + if (sen->sen_family != AF_ENCAP) { +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: %s does not have AF_ENCAP address\n", + ifp->if_xname); +#endif ENCDEBUG + m_freem(m); + RTFREE(re->re_rt); + return EHOSTDOWN; + } + + if (sen->sen_type != SENT_DEFIF) { +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: %s does not have SENT_DEFIF address\n", + ifp->if_xname); +#endif ENCDEBUG + m_freem(m); + RTFREE(re->re_rt); + return EHOSTDOWN; + } + sinp = (struct sockaddr_in *)&(sen->sen_dfl); + ip->ip_src = sinp->sin_addr; + } + + if (hlen > sizeof (struct ip)) { /* XXX IPOPT */ + ip_stripoptions(m, (struct mbuf *)0); + hlen = sizeof (struct ip); + } + +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: encapsulating %x->%x through %x->%x\n", + ip->ip_src.s_addr, ip->ip_dst.s_addr, + gw->sen_ipsp_src, gw->sen_ipsp_dst); +#endif + ip->ip_len = htons((u_short)ip->ip_len); + ip->ip_off = htons((u_short)ip->ip_off); + ip->ip_sum = 0; + ip->ip_sum = in_cksum(m, hlen); + + /* + * At this point we have an IPSP "gateway" (tunnel) spec. + * Use the destination of the tunnel and the SPI to + * look up the necessary Tunnel Control Block. Look it up, + * and then pass it, along with the packet and the gw, + * to the appropriate transformation. + */ + + tdb = (struct tdb *) gettdb(gw->sen_ipsp_spi, gw->sen_ipsp_dst); + +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: tdb=0x%x, tdb->tdb_xform=0x%x, tdb->tdb_xform->xf_output=%x\n", tdb, tdb->tdb_xform, tdb->tdb_xform->xf_output); +#endif ENCDEBUG + + while (tdb && tdb->tdb_xform) { + m0 = NULL; +#ifdef ENCDEBUG + if (encdebug) + printf("ip_output: calling %s\n", + tdb->tdb_xform->xf_name); +#endif ENCDEBUG + error = (*(tdb->tdb_xform->xf_output))(m, gw, tdb, &mp); + if (mp == NULL) + error = EFAULT; + if (error) { + RTFREE(re->re_rt); + return error; + } + tdb = tdb->tdb_onext; + m = mp; + } + + /* + * At this point, mp is pointing to an mbuf chain with the + * processed packet. Call ourselves recursively, but + * bypass the encap code. + */ + + RTFREE(re->re_rt); + + ip = mtod(m, struct ip *); + NTOHS(ip->ip_len); + NTOHS(ip->ip_off); + + return ip_output(m, NULL, NULL, IP_ENCAPSULATED | IP_RAWOUTPUT, NULL); + +no_encap: + if (re->re_rt) + RTFREE(re->re_rt); + } +#endif IPSEC + /* * Route packet. */ diff --git a/sys/netinet/ip_sha1.c b/sys/netinet/ip_sha1.c new file mode 100644 index 00000000000..c90a61d0033 --- /dev/null +++ b/sys/netinet/ip_sha1.c @@ -0,0 +1,166 @@ +/* +SHA-1 in C +By Steve Reid +100% Public Domain + +Test Vectors (from FIPS PUB 180-1) +"abc" + A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D +"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq" + 84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1 +A million repetitions of "a" + 34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F +*/ + +/* #define LITTLE_ENDIAN * This should be #define'd already, if true. */ +/* #define SHA1HANDSOFF * Copies data before messing with it. */ + +#define SHA1HANDSOFF + +#include +#include +#include + +#define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) + +/* blk0() and blk() perform the initial expand. */ +/* I got the idea of expanding during the round function from SSLeay */ +#if BYTE_ORDER == LITTLE_ENDIAN +#define blk0(i) (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \ + |(rol(block->l[i],8)&0x00FF00FF)) +#else +#define blk0(i) block->l[i] +#endif +#define blk(i) (block->l[i&15] = rol(block->l[(i+13)&15]^block->l[(i+8)&15] \ + ^block->l[(i+2)&15]^block->l[i&15],1)) + +/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */ +#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)+blk(i)+0x5A827999+rol(v,5);w=rol(w,30); +#define R2(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30); +#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30); +#define R4(v,w,x,y,z,i) z+=(w^x^y)+blk(i)+0xCA62C1D6+rol(v,5);w=rol(w,30); + + +/* Hash a single 512-bit block. This is the core of the algorithm. */ + +void SHA1Transform(unsigned long state[5], unsigned char buffer[64]) +{ +unsigned long a, b, c, d, e; +typedef union { + unsigned char c[64]; + unsigned long l[16]; +} CHAR64LONG16; +CHAR64LONG16* block; +#ifdef SHA1HANDSOFF +static unsigned char workspace[64]; + block = (CHAR64LONG16*)workspace; + bcopy(buffer, block, 64); +#else + block = (CHAR64LONG16*)buffer; +#endif + /* Copy context->state[] to working vars */ + a = state[0]; + b = state[1]; + c = state[2]; + d = state[3]; + e = state[4]; + /* 4 rounds of 20 operations each. Loop unrolled. */ + R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3); + R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7); + R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11); + R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15); + R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19); + R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23); + R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27); + R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31); + R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35); + R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39); + R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43); + R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47); + R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51); + R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55); + R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59); + R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63); + R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67); + R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71); + R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75); + R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79); + /* Add the working vars back into context.state[] */ + state[0] += a; + state[1] += b; + state[2] += c; + state[3] += d; + state[4] += e; + /* Wipe variables */ + a = b = c = d = e = 0; +} + + +/* SHA1Init - Initialize new context */ + +void SHA1Init(SHA1_CTX* context) +{ + /* SHA1 initialization constants */ + context->state[0] = 0x67452301; + context->state[1] = 0xEFCDAB89; + context->state[2] = 0x98BADCFE; + context->state[3] = 0x10325476; + context->state[4] = 0xC3D2E1F0; + context->count[0] = context->count[1] = 0; +} + + +/* Run your data through this. */ + +void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len) +{ +unsigned int i; +unsigned long j; + + j = context->count[0]; + if ((context->count[0] += len << 3) < j) context->count[1] += (len>>29)+1; + j = (j >> 3) & 63; + if ((j + len) > 63) { + bcopy(data, &context->buffer[j], (i = 64-j)); + SHA1Transform(context->state, context->buffer); + for ( ; i + 63 < len; i += 64) { + SHA1Transform(context->state, &data[i]); + } + j = 0; + } + else i = 0; + bcopy(&data[i], &context->buffer[j], len - i); +} + + +/* Add padding and return the message digest. */ + +void SHA1Final(unsigned char digest[20], SHA1_CTX* context) +{ +unsigned long i, j; +unsigned char finalcount[8]; + + for (i = 0; i < 8; i++) { + finalcount[i] = (unsigned char)((context->count[(i >= 4 ? 0 : 1)] + >> ((3-(i & 3)) * 8) ) & 255); /* Endian independent */ + } + SHA1Update(context, (unsigned char *)"\200", 1); + while ((context->count[0] & 504) != 448) { + SHA1Update(context, (unsigned char *)"\0", 1); + } + SHA1Update(context, finalcount, 8); /* Should cause a SHA1Transform() */ + for (i = 0; i < 20; i++) { + digest[i] = (unsigned char) + ((context->state[i>>2] >> ((3-(i & 3)) * 8) ) & 255); + } + /* Wipe variables */ + i = j = 0; + bzero(context->buffer, 64); + bzero(context->state, 20); + bzero(context->count, 8); + bzero(&finalcount, 8); +#ifdef SHA1HANDSOFF /* make SHA1Transform overwrite it's own static vars */ + SHA1Transform(context->state, context->buffer); +#endif +} diff --git a/sys/netinet/ip_sha1.h b/sys/netinet/ip_sha1.h new file mode 100644 index 00000000000..e4fd065782c --- /dev/null +++ b/sys/netinet/ip_sha1.h @@ -0,0 +1,16 @@ +/* +SHA-1 in C +By Steve Reid +100% Public Domain +*/ + +typedef struct { + unsigned long state[5]; + unsigned long count[2]; + unsigned char buffer[64]; +} SHA1_CTX; + +void SHA1Transform(unsigned long state[5], unsigned char buffer[64]); +void SHA1Init(SHA1_CTX* context); +void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len); +void SHA1Final(unsigned char digest[20], SHA1_CTX* context); diff --git a/sys/netinet/ip_var.h b/sys/netinet/ip_var.h index c79623bd0a8..743172b3cf9 100644 --- a/sys/netinet/ip_var.h +++ b/sys/netinet/ip_var.h @@ -1,4 +1,4 @@ -/* $OpenBSD: ip_var.h,v 1.4 1997/01/26 01:23:44 tholo Exp $ */ +/* $OpenBSD: ip_var.h,v 1.5 1997/02/20 01:08:09 deraadt Exp $ */ /* $NetBSD: ip_var.h,v 1.16 1996/02/13 23:43:20 christos Exp $ */ /* @@ -154,6 +154,10 @@ struct ipstat { #define IP_ROUTETOIF SO_DONTROUTE /* bypass routing tables */ #define IP_ALLOWBROADCAST SO_BROADCAST /* can send broadcast packets */ +#ifdef IPSEC +#define IP_ENCAPSULATED 0x0800 /* encapsulated already */ +#endif + struct ipstat ipstat; LIST_HEAD(ipqhead, ipq) ipq; /* ip reass. queue */ u_int16_t ip_id; /* ip packet ctr, for ids */ diff --git a/sys/sys/malloc.h b/sys/sys/malloc.h index 02e4a1dc8e0..63743b5102d 100644 --- a/sys/sys/malloc.h +++ b/sys/sys/malloc.h @@ -1,4 +1,4 @@ -/* $OpenBSD: malloc.h,v 1.8 1997/02/13 18:11:04 kstailey Exp $ */ +/* $OpenBSD: malloc.h,v 1.9 1997/02/20 01:07:34 deraadt Exp $ */ /* $NetBSD: malloc.h,v 1.23 1996/04/05 04:52:52 mhitch Exp $ */ /* @@ -123,7 +123,9 @@ #define M_AFS 70 /* Andrew File System */ #define M_ADOSFSBITMAP 71 /* adosfs bitmap */ #define M_EXT2FSNODE 72 /* EXT2FS vnode private part */ -#define M_PFIL 73 /* packer filter */ +#define M_PFIL 73 /* packer filter */ +#define M_TDB 75 /* Transforms database */ +#define M_XDATA 76 /* IPsec data */ #define M_TEMP 84 /* misc temporary data buffers */ #define M_LAST 85 /* Must be last type + 1 */ @@ -202,7 +204,10 @@ "adosfs bitmap", /* 71 M_ADOSFSBITMAP */ \ "EXT2FS node", /* 72 M_EXT2FSNODE */ \ "pfil", /* 73 M_PFIL */ \ - NULL, NULL, NULL, NULL, NULL, \ + NULL, \ + "tdb", /* 75 M_TDB */ \ + "xform_data", /* 76 M_XDATA */ \ + NULL, NULL, \ NULL, NULL, NULL, NULL, NULL, \ "temp", /* 84 M_TEMP */ \ } diff --git a/sys/sys/socket.h b/sys/sys/socket.h index 2069279f6c5..d9e2c6f390d 100644 --- a/sys/sys/socket.h +++ b/sys/sys/socket.h @@ -1,4 +1,4 @@ -/* $OpenBSD: socket.h,v 1.8 1996/12/12 13:50:53 mickey Exp $ */ +/* $OpenBSD: socket.h,v 1.9 1997/02/20 01:07:35 deraadt Exp $ */ /* $NetBSD: socket.h,v 1.14 1996/02/09 18:25:36 christos Exp $ */ /* @@ -125,8 +125,8 @@ struct linger { #define AF_ISDN 26 /* Integrated Services Digital Network*/ #define AF_E164 AF_ISDN /* CCITT E.164 recommendation */ #define AF_NATM 27 /* native ATM access */ - -#define AF_MAX 28 +#define AF_ENCAP 28 +#define AF_MAX 29 /* * Structure used by kernel to store most @@ -180,7 +180,7 @@ struct sockproto { #define PF_PIP pseudo_AF_PIP #define PF_ISDN AF_ISDN #define PF_NATM AF_NATM - +#define PF_ENCAP AF_ENCAP #define PF_MAX AF_MAX /* @@ -221,6 +221,7 @@ struct sockproto { { "sip", CTLTYPE_NODE }, \ { "pip", CTLTYPE_NODE }, \ { "natm", CTLTYPE_NODE }, \ + { "ipsec", CTLTYPE_NODE }, \ } /* -- 2.20.1