fiked-0.0.5+git20120331.1.e6a5109/COPYING0000644000000000000000000004311011735550573013314 0ustar00 GNU GENERAL PUBLIC LICENSE Version 2, June 1991 Copyright (C) 1989, 1991 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. Preamble The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to guarantee your freedom to share and change free software--to make sure the software is free for all its users. This General Public License applies to most of the Free Software Foundation's software and to any other program whose authors commit to using it. (Some other Free Software Foundation software is covered by the GNU Library General Public License instead.) You can apply it to your programs, too. When we speak of free software, we are referring to freedom, not price. Our General Public Licenses are designed to make sure that you have the freedom to distribute copies of free software (and charge for this service if you wish), that you receive source code or can get it if you want it, that you can change the software or use pieces of it in new free programs; and that you know you can do these things. To protect your rights, we need to make restrictions that forbid anyone to deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the software, or if you modify it. For example, if you distribute copies of such a program, whether gratis or for a fee, you must give the recipients all the rights that you have. You must make sure that they, too, receive or can get the source code. And you must show them these terms so they know their rights. We protect your rights with two steps: (1) copyright the software, and (2) offer you this license which gives you legal permission to copy, distribute and/or modify the software. Also, for each author's protection and ours, we want to make certain that everyone understands that there is no warranty for this free software. If the software is modified by someone else and passed on, we want its recipients to know that what they have is not the original, so that any problems introduced by others will not reflect on the original authors' reputations. Finally, any free program is threatened constantly by software patents. We wish to avoid the danger that redistributors of a free program will individually obtain patent licenses, in effect making the program proprietary. To prevent this, we have made it clear that any patent must be licensed for everyone's free use or not licensed at all. The precise terms and conditions for copying, distribution and modification follow. GNU GENERAL PUBLIC LICENSE TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION 0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under the terms of this General Public License. The "Program", below, refers to any such program or work, and a "work based on the Program" means either the Program or any derivative work under copyright law: that is to say, a work containing the Program or a portion of it, either verbatim or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term "modification".) Each licensee is addressed as "you". Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the Program is not restricted, and the output from the Program is covered only if its contents constitute a work based on the Program (independent of having been made by running the Program). Whether that is true depends on what the Program does. 1. You may copy and distribute verbatim copies of the Program's source code as you receive it, in any medium, provided that you conspicuously and appropriately publish on each copy an appropriate copyright notice and disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients of the Program a copy of this License along with the Program. You may charge a fee for the physical act of transferring a copy, and you may at your option offer warranty protection in exchange for a fee. 2. You may modify your copy or copies of the Program or any portion of it, thus forming a work based on the Program, and copy and distribute such modifications or work under the terms of Section 1 above, provided that you also meet all of these conditions: a) You must cause the modified files to carry prominent notices stating that you changed the files and the date of any change. b) You must cause any work that you distribute or publish, that in whole or in part contains or is derived from the Program or any part thereof, to be licensed as a whole at no charge to all third parties under the terms of this License. c) If the modified program normally reads commands interactively when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these conditions, and telling the user how to view a copy of this License. (Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is not required to print an announcement.) These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be reasonably considered independent and separate works in themselves, then this License, and its terms, do not apply to those sections when you distribute them as separate works. But when you distribute the same sections as part of a whole which is a work based on the Program, the distribution of the whole must be on the terms of this License, whose permissions for other licensees extend to the entire whole, and thus to each and every part regardless of who wrote it. Thus, it is not the intent of this section to claim rights or contest your rights to work written entirely by you; rather, the intent is to exercise the right to control the distribution of derivative or collective works based on the Program. In addition, mere aggregation of another work not based on the Program with the Program (or with a work based on the Program) on a volume of a storage or distribution medium does not bring the other work under the scope of this License. 3. You may copy and distribute the Program (or a work based on it, under Section 2) in object code or executable form under the terms of Sections 1 and 2 above provided that you also do one of the following: a) Accompany it with the complete corresponding machine-readable source code, which must be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, b) Accompany it with a written offer, valid for at least three years, to give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable copy of the corresponding source code, to be distributed under the terms of Sections 1 and 2 above on a medium customarily used for software interchange; or, c) Accompany it with the information you received as to the offer to distribute corresponding source code. (This alternative is allowed only for noncommercial distribution and only if you received the program in object code or executable form with such an offer, in accord with Subsection b above.) The source code for a work means the preferred form of the work for making modifications to it. For an executable work, complete source code means all the source code for all modules it contains, plus any associated interface definition files, plus the scripts used to control compilation and installation of the executable. However, as a special exception, the source code distributed need not include anything that is normally distributed (in either source or binary form) with the major components (compiler, kernel, and so on) of the operating system on which the executable runs, unless that component itself accompanies the executable. If distribution of executable or object code is made by offering access to copy from a designated place, then offering equivalent access to copy the source code from the same place counts as distribution of the source code, even though third parties are not compelled to copy the source along with the object code. 4. You may not copy, modify, sublicense, or distribute the Program except as expressly provided under this License. Any attempt otherwise to copy, modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance. 5. You are not required to accept this License, since you have not signed it. However, nothing else grants you permission to modify or distribute the Program or its derivative works. These actions are prohibited by law if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your acceptance of this License to do so, and all its terms and conditions for copying, distributing or modifying the Program or works based on it. 6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original licensor to copy, distribute or modify the Program subject to these terms and conditions. You may not impose any further restrictions on the recipients' exercise of the rights granted herein. You are not responsible for enforcing compliance by third parties to this License. 7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are imposed on you (whether by court order, agreement or otherwise) that contradict the conditions of this License, they do not excuse you from the conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent obligations, then as a consequence you may not distribute the Program at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or indirectly through you, then the only way you could satisfy both it and this License would be to refrain entirely from distribution of the Program. If any portion of this section is held invalid or unenforceable under any particular circumstance, the balance of the section is intended to apply and the section as a whole is intended to apply in other circumstances. It is not the purpose of this section to induce you to infringe any patents or other property right claims or to contest validity of any such claims; this section has the sole purpose of protecting the integrity of the free software distribution system, which is implemented by public license practices. Many people have made generous contributions to the wide range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if he or she is willing to distribute software through any other system and a licensee cannot impose that choice. This section is intended to make thoroughly clear what is believed to be a consequence of the rest of this License. 8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written in the body of this License. 9. The Free Software Foundation may publish revised and/or new versions of the General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Program specifies a version number of this License which applies to it and "any later version", you have the option of following the terms and conditions either of that version or of any later version published by the Free Software Foundation. If the Program does not specify a version number of this License, you may choose any version ever published by the Free Software Foundation. 10. If you wish to incorporate parts of the Program into other free programs whose distribution conditions are different, write to the author to ask for permission. For software which is copyrighted by the Free Software Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of preserving the free status of all derivatives of our free software and of promoting the sharing and reuse of software generally. NO WARRANTY 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. END OF TERMS AND CONDITIONS How to Apply These Terms to Your New Programs If you develop a new program, and you want it to be of the greatest possible use to the public, the best way to achieve this is to make it free software which everyone can redistribute and change under these terms. To do so, attach the following notices to the program. It is safest to attach them to the start of each source file to most effectively convey the exclusion of warranty; and each file should have at least the "copyright" line and a pointer to where the full notice is found. Copyright (C) This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA Also add information on how to contact you by electronic and paper mail. If the program is interactive, make it output a short notice like this when it starts in an interactive mode: Gnomovision version 69, Copyright (C) year name of author Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. This is free software, and you are welcome to redistribute it under certain conditions; type `show c' for details. The hypothetical commands `show w' and `show c' should show the appropriate parts of the General Public License. Of course, the commands you use may be called something other than `show w' and `show c'; they could even be mouse-clicks or menu items--whatever suits your program. You should also get your employer (if you work as a programmer) or your school, if any, to sign a "copyright disclaimer" for the program, if necessary. Here is a sample; alter the names: Yoyodyne, Inc., hereby disclaims all copyright interest in the program `Gnomovision' (which makes passes at compilers) written by James Hacker. , 1 April 1989 Ty Coon, President of Vice This General Public License does not permit incorporating your program into proprietary programs. If your program is a subroutine library, you may consider it more useful to permit linking proprietary applications with the library. If this is what you want to do, use the GNU Library General Public License instead of this License. fiked-0.0.5+git20120331.1.e6a5109/GNUmakefile0000644000000000000000000000511111735550573014332 0ustar00# fiked - a fake IKE PSK+XAUTH daemon based on vpnc # Copyright (C) 2005,2009 Daniel Roethlisberger # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see http://www.gnu.org/copyleft/ PREFIX?=/usr/local LOCALBASE?=/usr/local CC?=gcc CFLAGS?=-g -Wall -pedantic LDFLAGS?=-g -Wall -pedantic CSTD=-std=c99 COPTS=-I$(LOCALBASE)/include LDOPTS=-L$(LOCALBASE)/lib LIBS=-lgcrypt ifndef WITHOUT_LIBNET LIBNET_CFLAGS?=$(shell libnet11-config --cflags || libnet-config --cflags) LIBNET_LIBS?=$(shell libnet11-config --libs || libnet-config --libs) CFLAGS+=$(LIBNET_CFLAGS) LIBS+=$(LIBNET_LIBS) COPTS+=-DWITH_LIBNET endif ifeq ($(shell uname),Linux) COPTS+=-D_BSD_SOURCE -D_GNU_SOURCE endif PGM=fiked OBJS=mem.o config.o datagram.o send_dgm.o peer_ctx.o results.o log.o ike.o main.o SUBDIR=vpnc SUBLIB=lib$(SUBDIR).a URL=http://www.roe.ch/FakeIKEd VERSION=$(shell cat VERSION) all: $(PGM) $(PGM): $(OBJS) $(SUBLIB) $(CC) $(LDFLAGS) $(LDOPTS) -o $@ $^ $(LIBS) subdir: @CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS)" \ CSTD="$(CSTD)" COPTS="$(COPTS)" LDOPTS="$(LDOPTS)" \ $(MAKE) -C $(SUBDIR) all $(SUBLIB): subdir @ln -sf $(SUBDIR)/$@ $@ main.o: main.c $(SUBDIR)/*.h *.h $(CC) $(CFLAGS) $(CSTD) -DVERSION=\"$(VERSION)\" -DURL=\"$(URL)\" \ $(COPTS) -c -o $@ $< %.o: %.c %.h $(CC) $(CFLAGS) $(CSTD) $(COPTS) -c -o $@ $< strip: $(PGM) strip -g $^ install: strip install -o root -g 0 -m 0444 $(PGM).1 $(PREFIX)/man/man1/ install -o root -g 0 -m 0511 $(PGM) $(PREFIX)/bin/ uninstall: rm -f $(PREFIX)/man/man1/$(PGM).1 rm -f $(PREFIX)/bin/$(PGM) package: clean mkdir $(PGM)-$(VERSION) && \ tar -c -f - `find . -type f | grep -v svn` \ | tar -x -C $(PGM)-$(VERSION)/ -f - && \ tar cvfy $(PGM)-$(VERSION).tar.bz2 $(PGM)-$(VERSION) && \ rm -r $(PGM)-$(VERSION) clean: rm -rf *.o *.a *.core *.log ChangeLog $(PGM)-$(VERSION).tar.bz2 $(PGM) @CC="$(CC)" CFLAGS="$(CFLAGS)" LDFLAGS="$(LDFLAGS)" CSTD="$(CSTD)" \ COPTS="$(COPTS)" LDOPTS="$(LDOPTS)" LIBS="$(LIBS)" \ $(MAKE) -C $(SUBDIR) clean .PHONY: all install uninstall package clean subdir fiked-0.0.5+git20120331.1.e6a5109/NEWS0000644000000000000000000000123411735550573012761 0ustar000.0.6 ????-??-?? * TBD 0.0.5 2009-08-04 * Also load the group IDs when dropping privileges to an unprivileged account. * Errno handling fixed. 0.0.4 2005-12-21 * Memory handling refactored for improved portability older / non-FreeBSD systems. * Fixed the deep copying of the SA payload, which led to the SPI buffer being doubly free()'d. * Drop privileges if euid != uid or a user is specified with -u, and -r is not given. 0.0.3 2005-12-17 * Support for building on Linux. * Added WITHOUT_LIBNET tunable. * GNUmakefile honours CC now. 0.0.2 2005-12-06 * Support for multiple shared secrets. 0.0.1 2005-11-03 * Initial release. fiked-0.0.5+git20120331.1.e6a5109/README0000644000000000000000000000617511735550573013153 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005,2009 Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ // Overview This is a fake IKE daemon supporting just enough of the standards and Cisco extensions to attack commonly found insecure Cisco PSK+XAUTH VPN setups. Basically, if you know the pre-shared key, also known as shared secret or group password, you can impersonate the VPN gateway in IKE phase 1, and learn XAUTH user credentials in phase 2. This attack [2,3] is not new. It has been known for a long time that IKE using PSK with XAUTH is insecure, and this is not the first actual implementation of the attack. The configuration supported by fiked is IKE aggressive mode using pre-shared keys and XAUTH. Supported algorithms are DES, 3DES, AES128, AES192, AES256; MD5, SHA1; and DH groups 1, 2 and 5. Main mode is not supported. Based on this work, a full MITM attack could be implemented. // Attack Setup To successfully demostrate an attack on a VPN site, you need to know the shared secret, and you must be able to intercept the IKE traffic between the clients and the VPN gateway. There are several ways to find out the shared secret [4], and several ways to redirect the IKE traffic to your running fiked instance. With the -r option, you can control whether fiked should forge the source address on packets or not, depending on whether your particular attack setup needs it or not. // Installation You need these libraries to build and run fiked: * libgcrypt >= 1.1.90 http://directory.fsf.org/security/libgcrypt.html * libnet >= 1.1.0 (optional) http://www.packetfactory.net/projects/libnet/ You should be able to build and install fiked by just running GNU make install (gmake on BSD) on systems with a C99 capable GCC. Fiked has been developed on FreeBSD, but should build and run fine on other BSD and Linux boxes. Please do send me patches. Reported to work fine are OpenBSD and Debian. By defining WITHOUT_LIBNET, you can omit libnet support, which will remove the dependency on libnet, and will give you a fiked which does not support sending replies with forged source address (-r option). // Credits Fiked is loosely based on vpnc [5]. The code borrowed from vpnc is found in the vpnc subdirectory, see vpnc/NOTICE. // References [1] http://www.roe.ch/FakeIKEd [2] http://www.cisco.com/warp/public/707/cisco-sn-20040415-grppass.shtml [3] http://www.ima.umn.edu/~pliam/xauth/ [4] http://ikecrack.sourceforge.net/ [5] http://www.unix-ag.uni-kl.de/~massar/vpnc/ fiked-0.0.5+git20120331.1.e6a5109/TODO0000644000000000000000000000100711735550573012750 0ustar00 * write a pid file when running as a daemon * rewrite main() to not open any files before daemon() * implement --script functionality for launching vpnc * implement token support * implement main mode * -s sniffing option using libpcap * check on the nonce in phase2_hash * code cleanup: replace all those ugly linked lists with real, generic data structure implementations, and use hash maps instead of linked lists where appropriate (config->keys, peer_ctx->msg_iv) * implement full MitM (well, maybe) fiked-0.0.5+git20120331.1.e6a5109/VERSION0000644000000000000000000000001211735550573013323 0ustar000.0.6-dev fiked-0.0.5+git20120331.1.e6a5109/bsd.h0000644000000000000000000000173111735550573013205 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef BSD_H #define BSD_H #ifndef __BSD__ #if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__DragonFly__) || defined(__APPLE__) #define __BSD__ #endif #endif #endif /* BSD_H */ fiked-0.0.5+git20120331.1.e6a5109/config.c0000644000000000000000000000347011735550573013677 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "config.h" #include "mem.h" #include #include /* psk */ char * psk_get_key(char *id, psk *head) { char *key = NULL; for (psk *p = head; p && !key; p = p->next) { if (!strcmp(p->id, id) || !p->next) key = p->key; } return key; } void psk_set_key(char *id, char *key, psk **head) { psk *found = NULL; for (psk *p = *head; p && !found; p = p->next) { if (p->id == id) found = p; } if (!found) { mem_allocate(&found, sizeof(psk)); memset(found, 0, sizeof(psk)); found->id = strdup(id); found->next = *head; *head = found; } found->key = strdup(key); } void psk_free(psk *keys) { mem_free(&keys->next); mem_free(&keys->id); mem_free(&keys->key); free(keys); } /* config */ config * config_new() { config *cfg = NULL; mem_allocate(&cfg, sizeof(config)); memset(cfg, 0, sizeof(config)); return cfg; } void config_free(config *cfg) { if (cfg->us) { udp_socket_free(cfg->us); cfg->us = NULL; } mem_free(&cfg->gateway); if (cfg->keys) { psk_free(cfg->keys); cfg->keys = NULL; } free(cfg); } fiked-0.0.5+git20120331.1.e6a5109/config.h0000644000000000000000000000255211735550573013704 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef CONFIG_H #define CONFIG_H #include "datagram.h" typedef struct _psk { struct _psk *next; char *id; /* primary key */ char *key; } psk; typedef struct _config { udp_socket *us; /* UDP socket we listen on */ char *gateway; /* IP address of VPN gateway to impersonate */ psk *keys; /* list of pre-shared keys */ #ifdef WITH_LIBNET int opt_raw; /* use raw sockets to send packets */ #endif } config; char * psk_get_key(char *id, psk *head); void psk_set_key(char *id, char *key, psk **head); void psk_free(psk *keys); config * config_new(); void config_free(config *cfg); #endif /* CONFIG_H */ fiked-0.0.5+git20120331.1.e6a5109/datagram.c0000644000000000000000000000653511735550573014217 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "datagram.h" #include "log.h" #include "mem.h" #include #include #include #include #include #include #include #include #include /* * Create a new datagram instance of given size. * If size is 0, make it as large as supported by UDP. */ datagram * datagram_new(size_t size) { if (size == 0) size = UDP_DGM_MAXSIZE; datagram *dgm = NULL; mem_allocate(&dgm, sizeof(datagram)); memset(dgm, 0, sizeof(datagram)); dgm->len = size; mem_allocate(&dgm->data, dgm->len); memset(dgm->data, 0, sizeof(dgm->len)); return dgm; } /* * Free a datagram instance. */ void datagram_free(datagram *dgm) { if (dgm) { mem_free(&dgm->data); free(dgm); } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Open a UDP socket on the given port. * Will quit on errors. */ udp_socket * udp_socket_new(uint16_t port) { udp_socket *s = NULL; mem_allocate(&s, sizeof(udp_socket)); s->port = port; s->fd = socket(PF_INET, SOCK_DGRAM, 0); if (s->fd < 0) { fprintf(stderr, "FATAL: socket(udp) returned %d: %s (%d)\n", s->fd, strerror(errno), errno); exit(EXIT_FAILURE); } struct sockaddr_in sa; sa.sin_family = AF_INET; sa.sin_port = htons(s->port); sa.sin_addr.s_addr = htonl(INADDR_ANY); int ret = bind(s->fd, (struct sockaddr *)&sa, sizeof(sa)); if (ret < 0) { fprintf(stderr, "FATAL: bind(%d/udp) returned %d: %s (%d)\n", s->port, ret, strerror(errno), errno); exit(EXIT_FAILURE); } return s; } /* * Close UDP socket. */ void udp_socket_free(udp_socket *s) { if (s) { close(s->fd); free(s); } } /* * Receive next incoming UDP datagram on socket s. * Blocks until a datagram is received. */ datagram * udp_socket_recv(udp_socket *s) { char buf[UDP_DGM_MAXSIZE]; struct sockaddr_in sa; socklen_t sa_len = sizeof(sa); int ret = recvfrom(s->fd, buf, sizeof(buf), 0, (struct sockaddr *)&sa, &sa_len); if (ret < 0) { log_printf(NULL, "ERROR: recvfrom(%d) returned %d: %s (%d)\n", s->fd, ret, strerror(errno), errno); } datagram *dgm = datagram_new(ret); memcpy(dgm->data, buf, dgm->len); dgm->peer_addr = sa; return dgm; } /* * Send a UDP datagram onto socket s. */ void udp_socket_send(udp_socket *s, datagram *dgm) { int ret = sendto(s->fd, dgm->data, dgm->len, 0, (struct sockaddr*)&dgm->peer_addr, sizeof(dgm->peer_addr)); if (ret < 0) { log_printf(NULL, "ERROR: sendto(%d to %s:%d) returned %d: %s (%d)\n", s->fd, inet_ntoa(dgm->peer_addr.sin_addr), ntohs(dgm->peer_addr.sin_port), ret, strerror(errno), errno); } } fiked-0.0.5+git20120331.1.e6a5109/datagram.h0000644000000000000000000000247711735550573014225 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef DATAGRAM_H #define DATAGRAM_H #include #include #include #define UDP_DGM_MAXSIZE 65507 typedef struct _datagram { size_t len; uint8_t *data; struct sockaddr_in peer_addr; } datagram; typedef struct _udp_socket { int fd; uint16_t port; } udp_socket; datagram * datagram_new(size_t size); void datagram_free(datagram *dgm); udp_socket * udp_socket_new(uint16_t port); void udp_socket_free(); datagram * udp_socket_recv(udp_socket *s); void udp_socket_send(udp_socket *s, datagram *dgm); #endif /* DATAGRAM_H */ fiked-0.0.5+git20120331.1.e6a5109/doc/0000755000000000000000000000000011735550573013027 5ustar00fiked-0.0.5+git20120331.1.e6a5109/fiked.10000644000000000000000000001211711735550573013430 0ustar00.\" fiked - a fake IKE PSK+XAUTH daemon based on vpnc .\" Copyright (C) 2005,2009 Daniel Roethlisberger .\" .\" This program is free software; you can redistribute it and/or modify .\" it under the terms of the GNU General Public License as published by .\" the Free Software Foundation; either version 2 of the License, or .\" (at your option) any later version. .\" .\" This program is distributed in the hope that it will be useful, .\" but WITHOUT ANY WARRANTY; without even the implied warranty of .\" MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the .\" GNU General Public License for more details. .\" .\" You should have received a copy of the GNU General Public License .\" along with this program; if not, see http://www.gnu.org/copyleft/ .\" .TH FIKED 1 "4 August 2009" .SH NAME fiked \- a fake IKE PSK+XAUTH daemon based on vpnc .SH SYNOPSIS .na .B fiked [\fB-rdqhV\fP] \fB-g\fP \fIgateway\fP \fB-k\fP \fIid\fP\fB:\fP\fIsecret\fP [\fB-u\fP \fIuser\fP] [\fB-l\fP \fIfile\fP] [\fB-L\fP \fIfile\fP] .br .ad .SH DESCRIPTION .LP \fIFiked\fP impersonates a VPN \fIgateway\fP's IKE responder in order to capture XAUTH login credentials in insecure PSK+XAUTH setups, such as commonly found in Cisco based VPN sites. .LP \fIFiked\fP supports IKEv1 in aggressive mode, using pre-shared keys and XAUTH. Supported algorithms are DES, 3DES, AES-128, AES-192, AES-256; MD5, SHA1; and DH groups 1, 2 and 5. IKE main mode is not supported. .LP To actually implement an attack against a VPN site, you have to intercept the IKE traffic to the VPN \fIgateway\fP and redirect it to \fIfiked\fP. Your options include hostap or ARP poisoning, and usually will require some (eg.) .BR pf (4) redirection magic, depending on the situation. .LP Opening a socket on 500/udp requires root privileges on most systems. .SH OPTIONS .TP .B \-d Detach from TTY and run as a daemon. .TP .B \-g Impersonate \fIgateway\fP. This IP address is used in the responder ID payload, and as a source address if \fB-r\fP is used. .TP .B \-h Display help and exit. .TP .B \-k Use \fIsecret\fP with key/group id \fIid\fP as pre-shared key in phase 1 authentication. This option may be used multiple times, each time specifying a different \fIid\fP, \fIsecret\fP pair. \fIFiked\fP will use the key id specified by a client to choose a matching \fIsecret\fP, or the first one if none matches. .br Note that specifying \fIsecret\fP's on the command line exposes them to other users on the system. .TP .B \-u Drop privileges after opening sockets and files by setting the real, effective and stored user IDs to \fIuser\fP and loading the appropriate primary and ancillary groups. This potentially reduces the impact of security vulnerabilities in \fIfiked\fP, because the ISAKMP / IKE handling code, which is most likely to be vulnerable, will not be running with super user privileges. .br If \fB-u\fP is not given, \fIfiked\fP will drop privileges only if the real user ID is different from the effective user ID (i.e. when installed set-user-ID root and run as a non-root user), in which case the real user ID will be the new effective and stored user ID, and the group list will be left untouched. .TP .B \-l Append captured XAUTH user credentials to \fIfile\fP using a grep friendly format, including the \fIsecret\fP, group id, and \fIgateway\fP address. .TP .B \-L Append verbose logging to \fIfile\fP instead of just standard output. If \fB-q\fP is also given, log to \fIfile\fP only. .TP .B \-q Be quiet and do not log to standard output. .TP .B \-r Forge the source address on sent packets to match \fIgateway\fP. This uses a raw socket to send the packets. Use this option if your particular attack setup does not rewrite the packets travelling from \fIfiked\fP back to clients. .br Note that using \fI-r\fP prevents dropping privileges if \fIfiked\fP is installed set-user-ID root, since libnet requires root privileges to send packets through a raw socket. .br This option is not available if \fIfiked\fP was built without libnet support. .TP .B \-V Display version information and exit. .SH EXAMPLES .LP To impersonate \fIgateway\fP 10.0.0.1 using \fIsecret\fPs for group \fIid\fPs group1 and group2, writing results to \fIfile\fP account.log: .RS .nf \fBfiked -g 10.0.0.1 -k group1:g3h31m -k group2:s3kr3t -l account.log\fP .fi .RE .LP The same with only one key, and running as a daemon logging to \fIfile\fP fiked.log: .RS .nf \fBfiked -g 10.0.0.1 -k group1:g3h31m -l account.log -d -L fiked.log\fP .fi .RE .SH "SEE ALSO" arpspoof(8), ath(4), wi(4), pf(4), iptables(8), vpnc(8) .SH AUTHORS \fIFiked\fP was written by Daniel Roethlisberger , based in part on \fIvpnc\fP by Maurice Massar, Geoffrey Keating and contributors. .SH BUGS IKE protocol compliance is just good enough to attack Cisco VPN clients and clones like vpnc, but nowhere near complete, secure, or error free. .LP Main mode is not supported. .LP Only a single \fIgateway\fP address can be specified. .LP \fISecret\fPs can only be specified as command line arguments, which potentially exposes them to other users on the system, especially on systems which do not have setproctitle(3), such as Linux. fiked-0.0.5+git20120331.1.e6a5109/ike.c0000644000000000000000000010016411735550573013200 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "ike.h" #include "datagram.h" #include "send_dgm.h" #include "log.h" #include "peer_ctx.h" #include "config.h" #include "mem.h" #include "vpnc/math_group.h" #include "vpnc/dh.h" #include #include #include #include #include #include #include #include /* * W A R N I N G / D I S C L A I M E R * * This code is unsuitable for building a genuine IKE responder! * It's very likely to be any or all of: insecure, incompatible, * inefficient, unstable, unportable, or outright broken. * There's hardly enough sanity checking and failure resistance. * If you want genuine IKE source code, look for a proper * implementation instead. This is a quick hack to snarf XAUTH * credentials from clients, not a full implementation of IKE. * You've been warned. */ /* forward declarations */ void ike_process_new(peer_ctx *ctx, struct isakmp_packet *ikp); /* minimum */ static inline int min(int a, int b) { return (a < b) ? a : b; } /* vendor ids */ static const uint8_t xauth_vid[] = XAUTH_VENDOR_ID; static const uint8_t unity_vid[] = UNITY_VENDOR_ID; /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * IKE encryption and decryption routines * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Encrypts or decrypts the buffer buf. * Buf must already be padded to blocksize of the encryption algorithm in use. */ void ike_crypt_crypt(int algo, int enc, uint8_t *buf, size_t buflen, uint8_t *key, size_t keylen, uint8_t *iv, size_t ivlen) { gcry_cipher_hd_t crypt_ctx; gcry_cipher_open(&crypt_ctx, algo, GCRY_CIPHER_MODE_CBC, 0); gcry_cipher_setkey(crypt_ctx, key, keylen); gcry_cipher_setiv(crypt_ctx, iv, ivlen); if (!enc) gcry_cipher_decrypt(crypt_ctx, buf, buflen, NULL, 0); else gcry_cipher_encrypt(crypt_ctx, buf, buflen, NULL, 0); gcry_cipher_close(crypt_ctx); } /* * Generic encryption/decryption routine. * If payload of ikp is encrypted, decrypt it, if not, encrypt it. * Handles phase 1 and phase 2 enc/dec, and IV generation. */ int ike_crypt(peer_ctx *ctx, struct isakmp_packet *ikp) { /* * phase 1, first: iv = hash(i_dh_public r_dh_public) * phase 1, rest: iv = last_block_phase1 * phase 2, first: iv = hash(last_block_phase1 message_id) * phase 2, rest: iv = last_block_phase2 */ uint8_t *iv = NULL; int update_iv = 1; uint8_t *fp = NULL; size_t fp_len; uint8_t fp_type; gcry_md_hd_t md_ctx; int reject = 0; message_iv *msg_iv = NULL; int enc = !(ikp->flags & ISAKMP_FLAG_E); switch (ctx->state) { case STATE_PHASE1: /* iv0 not set means no phase 1 encrypted packets yet */ if (!ctx->iv0) { /* generate initial phase 1 iv */ gcry_md_open(&md_ctx, ctx->md_algo, 0); gcry_md_write(md_ctx, ctx->dh_i_public, dh_getlen(ctx->dh_group)); gcry_md_write(md_ctx, ctx->dh_r_public, dh_getlen(ctx->dh_group)); gcry_md_final(md_ctx); mem_allocate(&ctx->iv0, ctx->blk_len); memcpy(ctx->iv0, gcry_md_read(md_ctx, 0), ctx->blk_len); gcry_md_close(md_ctx); } iv = ctx->iv0; break; case STATE_PHASE2: /* fetch message_iv for this exchange */ msg_iv = message_iv_get(ikp->message_id, &ctx->msg_iv); if (!msg_iv->iv) { /* generate initial phase 2 iv */ gcry_md_open(&md_ctx, ctx->md_algo, 0); gcry_md_write(md_ctx, ctx->iv0, ctx->blk_len); gcry_md_putc(md_ctx, (ikp->message_id >> 24) & 0xFF); gcry_md_putc(md_ctx, (ikp->message_id >> 16) & 0xFF); gcry_md_putc(md_ctx, (ikp->message_id >> 8) & 0xFF); gcry_md_putc(md_ctx, (ikp->message_id) & 0xFF); gcry_md_final(md_ctx); mem_allocate(&msg_iv->iv, ctx->md_len); memcpy(msg_iv->iv, gcry_md_read(md_ctx, 0), ctx->blk_len); gcry_md_close(md_ctx); } iv = msg_iv->iv; break; default: log_printf(ctx, "ike_crypt in illegal state %d, packet ignored", ctx->state); return -1; break; } if (enc) { /* flatten and encrypt payload */ fp_type = ikp->u.payload->type; flatten_isakmp_payload(ikp->u.payload, &fp, &fp_len, ctx->blk_len); ike_crypt_crypt(ctx->algo, enc, fp, fp_len, ctx->key, ctx->key_len, iv, ctx->blk_len); /* swap payload for encrypted buffer */ free_isakmp_payload(ikp->u.payload); ikp->u.enc.length = fp_len; ikp->u.enc.data = NULL; /* don't free */ mem_allocate(&ikp->u.enc.data, ikp->u.enc.length); memcpy(ikp->u.enc.data, fp, ikp->u.enc.length); ikp->u.enc.type = fp_type; /* update IV with last cipher block */ if (update_iv) { memcpy(iv, fp + fp_len - ctx->blk_len, ctx->blk_len); } } else { /* dec */ uint8_t *newiv = NULL; /* copy encrypted buffer */ fp_len = ikp->u.enc.length; mem_allocate(&fp, fp_len); memcpy(fp, ikp->u.enc.data, fp_len); /* store last cipher block */ if (update_iv) { mem_allocate(&newiv, ctx->blk_len); memcpy(newiv, fp + fp_len - ctx->blk_len, ctx->blk_len); } /* decrypt encrypted buffer */ ike_crypt_crypt(ctx->algo, enc, fp, fp_len, ctx->key, ctx->key_len, iv, ctx->blk_len); /* copy stored last cipher block to iv */ if (update_iv) { memcpy(iv, newiv, ctx->blk_len); mem_free(&newiv); } /* swap encrypted buffer for decoded payload */ const uint8_t *cfp = fp; struct isakmp_payload *pl = parse_isakmp_payload( ikp->u.enc.type, &cfp, &fp_len, &reject); if (reject) { log_printf(ctx, "illegal decrypted payload (%d), packet ignored", reject); mem_free(&fp); return reject; } free(ikp->u.enc.data); ikp->u.payload = pl; } mem_free(&fp); /* flip the "encrypted" flag */ ikp->flags ^= ISAKMP_FLAG_E; return 0; } /* * Return phase 2 authentication hash for payload pl. * Returned hash must be freed. */ uint8_t * phase2_hash(peer_ctx *ctx, uint32_t message_id, struct isakmp_payload *pl) { gcry_md_hd_t md_ctx; uint8_t *pl_flat; size_t pl_size; uint8_t *hash = NULL; mem_allocate(&hash, ctx->md_len); gcry_md_open(&md_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md_ctx, ctx->skeyid_a, ctx->md_len); gcry_md_putc(md_ctx, (message_id >> 24) & 0xFF); gcry_md_putc(md_ctx, (message_id >> 16) & 0xFF); gcry_md_putc(md_ctx, (message_id >> 8) & 0xFF); gcry_md_putc(md_ctx, (message_id) & 0xFF); /* XXX: nonce? */ if (pl) { flatten_isakmp_payload(pl, &pl_flat, &pl_size, 1); gcry_md_write(md_ctx, pl_flat, pl_size); free(pl_flat); } else { gcry_md_putc(md_ctx, 0); } gcry_md_final(md_ctx); memcpy(hash, gcry_md_read(md_ctx, 0), ctx->md_len); gcry_md_close(md_ctx); return hash; } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Security Association payload helpers * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Is this a supported SA transform? Return 1 if yes, 0 if not. * We do not prioritize, instead we just select the very first supported * transform. */ int sa_transform_matches(peer_ctx* ctx, struct isakmp_payload *t) { struct isakmp_attribute *enc = NULL; struct isakmp_attribute *keylen = NULL; struct isakmp_attribute *hash = NULL; struct isakmp_attribute *auth_method = NULL; struct isakmp_attribute *group_desc = NULL; for (struct isakmp_attribute *a = t->u.t.attributes; a; a = a->next) { switch (a->type) { case IKE_ATTRIB_ENC: enc = a; break; case IKE_ATTRIB_KEY_LENGTH: keylen = a; break; case IKE_ATTRIB_HASH: hash = a; break; case IKE_ATTRIB_AUTH_METHOD: auth_method = a; break; case IKE_ATTRIB_GROUP_DESC: group_desc = a; break; default: /* silently ignore */ break; } } /* do we have all required attributes? */ if (!(enc && hash && auth_method && group_desc)) { log_printf(ctx, "missing attribute(s): enc=%p hash=%p am=%p gd=%p", (void*)enc, (void*)hash, (void*)auth_method, (void*)group_desc); return 0; } /* we don't support anything other than PSK+XAUTH */ if (auth_method->u.attr_16 != IKE_AUTH_XAUTHInitPreShared) return 0; /* choose algorithms we support */ char *enc_txt = NULL; char *md_txt = NULL; char *dh_txt = NULL; switch (enc->u.attr_16) { case IKE_ENC_DES_CBC: ctx->algo = GCRY_CIPHER_DES; enc_txt = "DES"; break; case IKE_ENC_3DES_CBC: ctx->algo = GCRY_CIPHER_3DES; enc_txt = "3DES"; break; case IKE_ENC_AES_CBC: if(!keylen) return 0; switch(keylen->u.attr_16) { case 128: ctx->algo = GCRY_CIPHER_AES128; enc_txt = "AES128"; break; case 192: ctx->algo = GCRY_CIPHER_AES192; enc_txt = "AES192"; break; case 256: ctx->algo = GCRY_CIPHER_AES256; enc_txt = "AES256"; break; default: return 0; } break; default: return 0; } switch (hash->u.attr_16) { case IKE_HASH_MD5: ctx->md_algo = GCRY_MD_MD5; md_txt = "MD5"; break; case IKE_HASH_SHA: ctx->md_algo = GCRY_MD_SHA1; md_txt = "SHA1"; break; default: return 0; } switch (group_desc->u.attr_16) { case IKE_GROUP_MODP_768: if (ctx->dh_group) group_free(ctx->dh_group); ctx->dh_group = group_get(OAKLEY_GRP_1); dh_txt = "DH1"; break; case IKE_GROUP_MODP_1024: if (ctx->dh_group) group_free(ctx->dh_group); ctx->dh_group = group_get(OAKLEY_GRP_2); dh_txt = "DH2"; break; case IKE_GROUP_MODP_1536: if (ctx->dh_group) group_free(ctx->dh_group); ctx->dh_group = group_get(OAKLEY_GRP_5); dh_txt = "DH5"; break; default: return 0; } log_printf(ctx, "using %s %s %s", enc_txt, md_txt, dh_txt); /* set up lengths according to chosen algorithms */ ctx->md_len = gcry_md_get_algo_dlen(ctx->md_algo); gcry_cipher_algo_info(ctx->algo, GCRYCTL_GET_BLKLEN, NULL, &(ctx->blk_len)); gcry_cipher_algo_info(ctx->algo, GCRYCTL_GET_KEYLEN, NULL, &(ctx->key_len)); return 1; } /* * Walk proposal SA, choose a transform, copy relevant stuff to response SA. */ void sa_transform_choose(peer_ctx* ctx, struct isakmp_payload *response, struct isakmp_payload *proposal) { /* copy SA payload */ *response = *proposal; response->u.sa.proposals = new_isakmp_payload(ISAKMP_PAYLOAD_P); /* copy proposals payload */ *response->u.sa.proposals = *proposal->u.sa.proposals; response->u.sa.proposals->u.p.spi = NULL; mem_allocate(&response->u.sa.proposals->u.p.spi, response->u.sa.proposals->u.p.spi_size); memcpy(response->u.sa.proposals->u.p.spi, proposal->u.sa.proposals->u.p.spi, response->u.sa.proposals->u.p.spi_size); response->u.sa.proposals->u.p.transforms = new_isakmp_payload(ISAKMP_PAYLOAD_T); /* find matching transform */ struct isakmp_payload *p; for (p = proposal->u.sa.proposals->u.p.transforms; p; p = p->next) { if (sa_transform_matches(ctx, p)) break; } if (!p) { log_printf(ctx, "no matching algo proposal, ignoring request"); return; } /* copy chosen transform payload */ *response->u.sa.proposals->u.p.transforms = *p; response->u.sa.proposals->u.p.transforms->next = NULL; struct isakmp_attribute *ra = NULL; for (struct isakmp_attribute *pa = p->u.t.attributes; pa; pa = pa->next) { if (!ra) { /* first attribute */ ra = response->u.sa.proposals->u.p.transforms->u.t.attributes = new_isakmp_attribute(pa->type, NULL); } else { /* subsequent attributes */ ra->next = new_isakmp_attribute(pa->type, NULL); ra = ra->next; } *ra = *pa; ra->next = NULL; switch (ra->af) { case isakmp_attr_lots: ra->u.lots.data = NULL; /* don't free */ mem_allocate(&ra->u.lots.data, ra->u.lots.length); memcpy(ra->u.lots.data, pa->u.lots.data, ra->u.lots.length); break; case isakmp_attr_acl: ra->u.acl.acl_ent = NULL; /* don't free */ mem_allocate(&ra->u.acl.acl_ent, ra->u.acl.count * sizeof(*ra->u.acl.acl_ent)); memcpy(ra->u.acl.acl_ent, pa->u.acl.acl_ent, ra->u.acl.count * sizeof(*ra->u.acl.acl_ent)); break; default: /* ignore */ break; } } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Informational packet handler * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Process an IKE Informational packet. * Packet must already be decrypted. */ void ike_process_informational(peer_ctx *ctx, struct isakmp_packet *ikp) { if (ikp->flags & ISAKMP_FLAG_E) { log_printf(ctx, "encrypted informational packet, reset state"); peer_ctx_reset(ctx); return; } for (struct isakmp_payload *p = ikp->u.payload; p; p = p->next) { switch (p->type) { case ISAKMP_PAYLOAD_N: switch (p->u.n.type) { case ISAKMP_N_INVALID_PAYLOAD_TYPE: log_printf(ctx, "error from peer: invalid payload type, reset state"); peer_ctx_reset(ctx); break; case ISAKMP_N_CISCO_HEARTBEAT: /* ignore */ break; default: log_printf(ctx, "unhandled informational notification type 0x%02x, ignored", p->u.n.type); break; } break; case ISAKMP_PAYLOAD_D: case ISAKMP_PAYLOAD_HASH: /* a real IKE responder would check the hash and drop * the packet if invalid -- we just ignore it */ break; default: log_printf(ctx, "unhandled informational payload type 0x%02x, ignored", p->type); break; }} } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Phase 2 handlers * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* IKE Initiator IKE Responder -------------- ----------------- <-- REQUEST(NAME="" PASSWORD="") REPLY(NAME="joe" PASSWORD="foobar") --> <-- SET(STATUS=OK) ACK(STATUS) --> */ /* * Begin XAUTH login. * REQUEST(NAME="" PASSWORD="") */ void ike_do_phase2_xauth_begin(peer_ctx *ctx) { struct isakmp_packet *r = new_isakmp_packet(); memcpy(r->i_cookie, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); memcpy(r->r_cookie, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); r->isakmp_version = ctx->isakmp_version; r->exchange_type = ISAKMP_EXCHANGE_MODECFG_TRANSACTION; r->flags = 0; gcry_create_nonce((uint8_t*)&r->message_id, sizeof(r->message_id)); r->u.payload = new_isakmp_payload(ISAKMP_PAYLOAD_HASH); r->u.payload->next = new_isakmp_payload(ISAKMP_PAYLOAD_MODECFG_ATTR); r->u.payload->next->u.modecfg.type = ISAKMP_MODECFG_CFG_REQUEST; r->u.payload->next->u.modecfg.attributes = new_isakmp_attribute(ISAKMP_XAUTH_ATTRIB_USER_NAME, new_isakmp_attribute(ISAKMP_XAUTH_ATTRIB_USER_PASSWORD, 0) ); struct isakmp_attribute *a = r->u.payload->next->u.modecfg.attributes; a->af = isakmp_attr_lots; a->u.lots.length = 0; a->u.lots.data = NULL; a = a->next; a->af = isakmp_attr_lots; a->u.lots.length = 0; a->u.lots.data = NULL; /* send response */ datagram *dgm = datagram_new(0); r->u.payload->u.hash.length = ctx->md_len; r->u.payload->u.hash.data = phase2_hash(ctx, r->message_id, r->u.payload->next); ike_crypt(ctx, r); mem_free(&dgm->data); flatten_isakmp_packet(r, &dgm->data, &dgm->len, ctx->blk_len); dgm->peer_addr = ctx->peer_addr; send_datagram(ctx, dgm); free_isakmp_packet(r); datagram_free(dgm); } /* * Handle XAUTH replies. * REPLY(NAME="joe" PASSWORD="foobar") */ void ike_do_phase2_xauth(peer_ctx *ctx, struct isakmp_packet *ikp) { for (struct isakmp_attribute *a = ikp->u.payload->next->u.modecfg.attributes; a; a = a->next) { switch (a->type) { case ISAKMP_XAUTH_ATTRIB_USER_NAME: mem_allocate(&ctx->xauth_username, a->u.lots.length + 1); memcpy(ctx->xauth_username, a->u.lots.data, a->u.lots.length); ctx->xauth_username[a->u.lots.length] = '\0'; log_printf(ctx, "Xauth username: %s", ctx->xauth_username); break; case ISAKMP_XAUTH_ATTRIB_USER_PASSWORD: mem_allocate(&ctx->xauth_password, a->u.lots.length + 1); memcpy(ctx->xauth_password, a->u.lots.data, a->u.lots.length); ctx->xauth_password[a->u.lots.length] = '\0'; log_printf(ctx, "Xauth password: %s", ctx->xauth_password); break; case ISAKMP_XAUTH_ATTRIB_STATUS: if (a->u.attr_16 == 0) { log_printf(ctx, "IKE session aborted by peer"); peer_ctx_reset(ctx); return; } break; default: log_printf(ctx, "unhandled modecfg attr type 0x%02x, ignored", a->type); break; } } /* log credentials */ ctx->done = 1; /* give client feedback in form of an auth failed message */ struct isakmp_packet *r = new_isakmp_packet(); memcpy(r->i_cookie, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); memcpy(r->r_cookie, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); r->isakmp_version = ctx->isakmp_version; r->exchange_type = ISAKMP_EXCHANGE_MODECFG_TRANSACTION; r->flags = 0; gcry_create_nonce((uint8_t*)&r->message_id, sizeof(r->message_id)); r->u.payload = new_isakmp_payload(ISAKMP_PAYLOAD_HASH); r->u.payload->next = new_isakmp_payload(ISAKMP_PAYLOAD_MODECFG_ATTR); r->u.payload->next->u.modecfg.type = ISAKMP_MODECFG_CFG_SET; r->u.payload->next->u.modecfg.attributes = new_isakmp_attribute(ISAKMP_XAUTH_ATTRIB_STATUS, 0); struct isakmp_attribute *a = r->u.payload->next->u.modecfg.attributes; a->af = isakmp_attr_16; a->u.attr_16 = 0; /* send response */ datagram *dgm = datagram_new(0); r->u.payload->u.hash.length = ctx->md_len; r->u.payload->u.hash.data = phase2_hash(ctx, r->message_id, r->u.payload->next); ike_crypt(ctx, r); mem_free(&dgm->data); flatten_isakmp_packet(r, &dgm->data, &dgm->len, ctx->blk_len); dgm->peer_addr = ctx->peer_addr; send_datagram(ctx, dgm); free_isakmp_packet(r); datagram_free(dgm); } /* * Process MODECFG packets. */ void ike_process_phase2_modecfg(peer_ctx *ctx, struct isakmp_packet *ikp) { switch (ikp->u.payload->next->u.modecfg.type) { case ISAKMP_MODECFG_CFG_REPLY: ike_do_phase2_xauth(ctx, ikp); break; case ISAKMP_MODECFG_CFG_ACK: /* final ACK(STATUS) for our SET(STATUS=FAIL) */ log_printf(ctx, "IKE session closed"); peer_ctx_reset(ctx); break; default: log_printf(ctx, "unhandled modecfg type 0x%02x, ignored", ikp->u.payload->next->u.modecfg.type); break; } } /* * Process an IKE packet in STATE_PHASE2. * Handles decryption. */ void ike_process_phase2(peer_ctx *ctx, struct isakmp_packet *ikp) { if (!(ikp->flags & ISAKMP_FLAG_E)) { log_printf(ctx, "unencrypted packet in STATE_PHASE2, reset state"); peer_ctx_reset(ctx); ike_process_new(ctx, ikp); return; } switch (ikp->exchange_type) { case ISAKMP_EXCHANGE_MODECFG_TRANSACTION: if (!ike_crypt(ctx, ikp)) ike_process_phase2_modecfg(ctx, ikp); break; case ISAKMP_EXCHANGE_INFORMATIONAL: if (!ike_crypt(ctx, ikp)) ike_process_informational(ctx, ikp); break; default: log_printf(ctx, "unhandled exchange type 0x%02x in STATE_PHASE1, ignored", ikp->exchange_type); break; } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Phase 1 handlers * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Process an IKE Aggressive Mode packet in STATE_NEW. */ void ike_do_phase1(peer_ctx *ctx, struct isakmp_packet *ikp) { /* get the payloads */ struct isakmp_payload *sa = NULL; struct isakmp_payload *ke = NULL; struct isakmp_payload *nonce = NULL; struct isakmp_payload *id = NULL; for (struct isakmp_payload *p = ikp->u.payload; p; p = p->next) { switch (p->type) { case ISAKMP_PAYLOAD_SA: sa = p; break; case ISAKMP_PAYLOAD_KE: ke = p; break; case ISAKMP_PAYLOAD_NONCE: nonce = p; break; case ISAKMP_PAYLOAD_ID: id = p; break; case ISAKMP_PAYLOAD_VID: /* silently ignore for now */ break; default: log_printf(ctx, "unhandled payload type 0x%02x, ignored", p->type); break; }} /* do we have all payloads? */ if (!(sa && ke && nonce && id)) { log_printf(ctx, "missing payload(s): sa=%p ke=%p nonce=%p id=%p, ignored", (void*)sa, (void*)ke, (void*)nonce, (void*)id); return; } /* heads up: the ipsec id */ switch (id->u.id.type) { case ISAKMP_IPSEC_ID_FQDN: case ISAKMP_IPSEC_ID_USER_FQDN: case ISAKMP_IPSEC_ID_KEY_ID: mem_allocate(&ctx->ipsec_id, id->u.id.length + 1); memcpy(ctx->ipsec_id, id->u.id.data, id->u.id.length); ctx->ipsec_id[id->u.id.length] = '\0'; ctx->ipsec_secret = (uint8_t*) strdup(psk_get_key( (char*)ctx->ipsec_id, ctx->cfg->keys)); log_printf(ctx, "IPSec ID: %s", ctx->ipsec_id); log_printf(ctx, "IPSec Secret: %s", ctx->ipsec_secret); break; default: log_printf(ctx, "IPSec ID type %d is binary, processing packet anyway", id->u.id.type); break; } /* grab proto version */ ctx->isakmp_version = ikp->isakmp_version; /* grab i_cookie */ memcpy(ctx->i_cookie, ikp->i_cookie, ISAKMP_COOKIE_LENGTH); /* grab i_sa */ struct isakmp_payload *tmp = sa->next; sa->next = NULL; mem_free(&ctx->i_sa); flatten_isakmp_payload(sa, &ctx->i_sa, &ctx->i_sa_len, 1); sa->next = tmp; /* grab dh_i_public */ mem_allocate(&ctx->dh_i_public, ke->u.ke.length); memcpy(ctx->dh_i_public, ke->u.ke.data, ke->u.ke.length); /* grab i_nonce */ mem_allocate(&ctx->i_nonce, nonce->u.nonce.length); ctx->i_nonce_len = nonce->u.nonce.length; memcpy(ctx->i_nonce, nonce->u.nonce.data, nonce->u.nonce.length); /* grab i_id */ tmp = id->next; id->next = NULL; mem_free(&ctx->i_id); flatten_isakmp_payload(id, &ctx->i_id, &ctx->i_id_len, 1); id->next = tmp; /* generate r_cookie */ gcry_create_nonce(ctx->r_cookie, ISAKMP_COOKIE_LENGTH); /* generate r_nonce */ ctx->r_nonce_len = ctx->i_nonce_len; mem_allocate(&ctx->r_nonce, ctx->r_nonce_len); gcry_create_nonce(ctx->r_nonce, ctx->r_nonce_len); /* header */ struct isakmp_packet *r = new_isakmp_packet(); memcpy(r->i_cookie, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); memcpy(r->r_cookie, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); r->isakmp_version = ikp->isakmp_version; r->exchange_type = ikp->exchange_type; r->flags = 0; r->message_id = ikp->message_id; /* payload: sa */ r->u.payload = new_isakmp_payload(ISAKMP_PAYLOAD_SA); sa_transform_choose(ctx, r->u.payload, sa); struct isakmp_payload *p = r->u.payload; /* complete dh key exchange */ mem_allocate(&ctx->dh_r_public, dh_getlen(ctx->dh_group)); dh_create_exchange(ctx->dh_group, ctx->dh_r_public); mem_allocate(&ctx->dh_secret, dh_getlen(ctx->dh_group)); dh_create_shared(ctx->dh_group, ctx->dh_secret, ctx->dh_i_public); /* payload: ke */ p = p->next = new_isakmp_data_payload(ISAKMP_PAYLOAD_KE, ctx->dh_r_public, dh_getlen(ctx->dh_group)); /* payload: nonce_r */ p = p->next = new_isakmp_data_payload(ISAKMP_PAYLOAD_NONCE, ctx->r_nonce, ctx->r_nonce_len); /* payload: id_r */ p = p->next = new_isakmp_payload(ISAKMP_PAYLOAD_ID); p->u.id.type = ISAKMP_IPSEC_ID_IPV4_ADDR; p->u.id.protocol = IPPROTO_UDP; p->u.id.port = IKE_PORT; p->u.id.length = sizeof(in_addr_t); mem_allocate(&p->u.id.data, p->u.id.length); *((in_addr_t*)p->u.id.data) = inet_addr(ctx->cfg->gateway); /* grab id_r */ mem_free(&ctx->r_id); flatten_isakmp_payload(p, &ctx->r_id, &ctx->r_id_len, 1); /* * SKEYID = hmac(pre-shared-key, Nonce_I | Nonce_R) * SKEYID_e = hmac(SKEYID, SKEYID_a | g^xy | Cookie_I | Cookie_R | 2) * SKEYID_a = hmac(SKEYID, SKEYID_d | g^xy | Cookie_I | Cookie_R | 1) * SKEYID_d = hmac(SKEYID, g^xy | Cookie_I | Cookie_R | 0) */ gcry_md_hd_t md_ctx; /* generate skeyid */ gcry_md_open(&md_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md_ctx, ctx->ipsec_secret, strlen((char*)ctx->ipsec_secret)); gcry_md_write(md_ctx, ctx->i_nonce, ctx->i_nonce_len); gcry_md_write(md_ctx, ctx->r_nonce, ctx->r_nonce_len); gcry_md_final(md_ctx); mem_allocate(&ctx->skeyid, ctx->md_len); memcpy(ctx->skeyid, gcry_md_read(md_ctx, 0), ctx->md_len); gcry_md_close(md_ctx); /* generate skeyid_e */ gcry_md_open(&md_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md_ctx, ctx->skeyid, ctx->md_len); gcry_md_write(md_ctx, ctx->dh_secret, dh_getlen(ctx->dh_group)); gcry_md_write(md_ctx, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(md_ctx, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_putc(md_ctx, 0); gcry_md_final(md_ctx); mem_allocate(&ctx->skeyid_d, ctx->md_len); memcpy(ctx->skeyid_d, gcry_md_read(md_ctx, 0), ctx->md_len); gcry_md_close(md_ctx); /* generate skeyid_a */ gcry_md_open(&md_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md_ctx, ctx->skeyid, ctx->md_len); gcry_md_write(md_ctx, ctx->skeyid_d, ctx->md_len); gcry_md_write(md_ctx, ctx->dh_secret, dh_getlen(ctx->dh_group)); gcry_md_write(md_ctx, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(md_ctx, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_putc(md_ctx, 1); gcry_md_final(md_ctx); mem_allocate(&ctx->skeyid_a, ctx->md_len); memcpy(ctx->skeyid_a, gcry_md_read(md_ctx, 0), ctx->md_len); gcry_md_close(md_ctx); /* generate skeyid_d */ gcry_md_open(&md_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md_ctx, ctx->skeyid, ctx->md_len); gcry_md_write(md_ctx, ctx->skeyid_a, ctx->md_len); gcry_md_write(md_ctx, ctx->dh_secret, dh_getlen(ctx->dh_group)); gcry_md_write(md_ctx, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(md_ctx, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_putc(md_ctx, 2); gcry_md_final(md_ctx); mem_allocate(&ctx->skeyid_e, ctx->md_len); memcpy(ctx->skeyid_e, gcry_md_read(md_ctx, 0), ctx->md_len); gcry_md_close(md_ctx); /* encryption key */ mem_allocate(&ctx->key, ctx->key_len); if (ctx->key_len > ctx->md_len) { for (int i = 0; i * ctx->md_len < ctx->key_len; i++) { gcry_md_open(&md_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(md_ctx, ctx->skeyid_e, ctx->md_len); if (i == 0) gcry_md_putc(md_ctx, 0); else gcry_md_write(md_ctx, ctx->key + (i - 1) * ctx->md_len, ctx->md_len); gcry_md_final(md_ctx); memcpy(ctx->key + i * ctx->md_len, gcry_md_read(md_ctx, 0), min(ctx->md_len, ctx->key_len - i * ctx->md_len)); gcry_md_close(md_ctx); } } else { memcpy(ctx->key, ctx->skeyid_e, ctx->key_len); } /* * HASH_I = prf(SKEYID, g^x | g^y | Cookie_I | Cookie_R | SA_I | ID_I ) * HASH_R = prf(SKEYID, g^y | g^x | Cookie_R | Cookie_I | SA_I | ID_R ) */ /* generate i_hash */ gcry_md_hd_t i_hash_ctx; gcry_md_open(&i_hash_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(i_hash_ctx, ctx->skeyid, ctx->md_len); gcry_md_write(i_hash_ctx, ctx->dh_i_public, dh_getlen(ctx->dh_group)); gcry_md_write(i_hash_ctx, ctx->dh_r_public, dh_getlen(ctx->dh_group)); gcry_md_write(i_hash_ctx, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(i_hash_ctx, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(i_hash_ctx, ctx->i_sa + 4, ctx->i_sa_len - 4); gcry_md_write(i_hash_ctx, ctx->i_id + 4, ctx->i_id_len - 4); gcry_md_final(i_hash_ctx); mem_allocate(&ctx->i_hash, ctx->md_len); memcpy(ctx->i_hash, gcry_md_read(i_hash_ctx, 0), ctx->md_len); gcry_md_close(i_hash_ctx); /* generate r_hash */ gcry_md_hd_t r_hash_ctx; gcry_md_open(&r_hash_ctx, ctx->md_algo, GCRY_MD_FLAG_HMAC); gcry_md_setkey(r_hash_ctx, ctx->skeyid, ctx->md_len); gcry_md_write(r_hash_ctx, ctx->dh_r_public, dh_getlen(ctx->dh_group)); gcry_md_write(r_hash_ctx, ctx->dh_i_public, dh_getlen(ctx->dh_group)); gcry_md_write(r_hash_ctx, ctx->r_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(r_hash_ctx, ctx->i_cookie, ISAKMP_COOKIE_LENGTH); gcry_md_write(r_hash_ctx, ctx->i_sa + 4, ctx->i_sa_len - 4); gcry_md_write(r_hash_ctx, ctx->r_id + 4, ctx->r_id_len - 4); gcry_md_final(r_hash_ctx); mem_allocate(&ctx->r_hash, ctx->md_len); memcpy(ctx->r_hash, gcry_md_read(r_hash_ctx, 0), ctx->md_len); gcry_md_close(r_hash_ctx); /* payload: hash_r */ p = p->next = new_isakmp_data_payload(ISAKMP_PAYLOAD_HASH, ctx->r_hash, ctx->md_len); /* payload: Cisco Unity vendor id */ p = p->next = new_isakmp_data_payload(ISAKMP_PAYLOAD_VID, unity_vid, sizeof(unity_vid)); /* payload: XAUTH vendor id */ p = p->next = new_isakmp_data_payload(ISAKMP_PAYLOAD_VID, xauth_vid, sizeof(xauth_vid)); /* send response */ datagram *dgm = datagram_new(0); mem_free(&dgm->data); flatten_isakmp_packet(r, &dgm->data, &dgm->len, ctx->blk_len); dgm->peer_addr = ctx->peer_addr; send_datagram(ctx, dgm); free_isakmp_packet(r); datagram_free(dgm); ctx->state = STATE_PHASE1; } /* * Process the last IKE Aggressive Mode packet in phase 1, containing i_hash. * Brings us to phase 2 (hopefully). */ void ike_do_phase1_end(peer_ctx *ctx, struct isakmp_packet *ikp) { /* get the payloads */ struct isakmp_payload *h = NULL; for (struct isakmp_payload *p = ikp->u.payload; p; p = p->next) { switch (p->type) { case ISAKMP_PAYLOAD_HASH: h = p; break; case ISAKMP_PAYLOAD_N: case ISAKMP_PAYLOAD_VID: /* silently ignore for now */ break; default: log_printf(ctx, "unhandled payload type 0x%02x, ignored", p->type); break; }} /* do we have all payloads? */ if (!h) { log_printf(ctx, "missing payload: h=%p, ignored", (void*)h); return; } /* verify hash */ if (h->u.hash.length != ctx->md_len || memcmp(h->u.hash.data, ctx->i_hash, ctx->md_len)) { log_printf(ctx, "IKE phase 1 auth failed (i_hash mismatch)"); return; } log_printf(ctx, "IKE phase 1 complete, entering phase 2"); ctx->state = STATE_PHASE2; ike_do_phase2_xauth_begin(ctx); } /* * Process an IKE packet in STATE_PHASE1. */ void ike_process_phase1(peer_ctx *ctx, struct isakmp_packet *ikp) { if (!(ikp->flags & ISAKMP_FLAG_E)) { log_printf(ctx, "unencrypted packet in STATE_PHASE1, reset state"); peer_ctx_reset(ctx); ike_process_new(ctx, ikp); return; } switch (ikp->exchange_type) { case ISAKMP_EXCHANGE_AGGRESSIVE: if (!ike_crypt(ctx, ikp)) ike_do_phase1_end(ctx, ikp); break; case ISAKMP_EXCHANGE_INFORMATIONAL: ike_process_informational(ctx, ikp); break; default: log_printf(ctx, "unhandled exchange type 0x%02x in STATE_PHASE1, ignored", ikp->exchange_type); break; } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Phase 0 handler * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* phase 0 is actually phase 1 before the key exchange is complete */ /* * Process an IKE packet in STATE_NEW. */ void ike_process_new(peer_ctx *ctx, struct isakmp_packet *ikp) { if (ikp->flags & ISAKMP_FLAG_E) { log_printf(ctx, "encrypted packet in STATE_NEW, ignored"); return; } switch (ikp->exchange_type) { case ISAKMP_EXCHANGE_AGGRESSIVE: log_printf(ctx, "IKE session initiated"); ike_do_phase1(ctx, ikp); break; /* case ISAKMP_EXCHANGE_MAIN: log_printf(ctx, "IKE session initiated (main mode)"); ike_do_phase1_main1(ctx, ikp); break; */ case ISAKMP_EXCHANGE_INFORMATIONAL: ike_process_informational(ctx, ikp); break; default: log_printf(ctx, "unhandled exchange type 0x%02x in STATE_NEW, ignored", ikp->exchange_type); break; } } /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * Main packet handler * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */ /* * Process an incoming IKE/ISAKMP packet. */ void ike_process_isakmp(peer_ctx *ctx, struct isakmp_packet *ikp) { /* * need some (simple) mechanism to clean out old states after * some time, maybe: if r_cookie == 0, reset to STATE_NEW */ switch (ctx->state) { case STATE_NEW: ike_process_new(ctx, ikp); break; case STATE_PHASE1: ike_process_phase1(ctx, ikp); break; case STATE_PHASE2: ike_process_phase2(ctx, ikp); break; default: log_printf(ctx, "unhandled state, reset state"); peer_ctx_reset(ctx); ike_process_new(ctx, ikp); break; } } fiked-0.0.5+git20120331.1.e6a5109/ike.h0000644000000000000000000000170011735550573013201 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef IKE_H #define IKE_H #include "peer_ctx.h" #include "vpnc/isakmp-pkt.h" #define IKE_PORT 500 void ike_process_isakmp(peer_ctx *ctx, struct isakmp_packet *ikp); #endif /* IKE_H */ fiked-0.0.5+git20120331.1.e6a5109/log.c0000644000000000000000000000431011735550573013205 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "log.h" #include #include #include #include #include #include #include #include #include #include #include static FILE* file = NULL; static int quiet = 0; void log_init(char *filename, int q) { log_cleanup(); if (filename) { file = fopen(filename, "a"); if (!file) { fprintf(stderr, "FATAL: cannot open file %s: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } } quiet = q; } void log_do_printf(const char *fmt, ...) { va_list ap; char *buf; va_start(ap, fmt); vasprintf(&buf, fmt, ap); va_end(ap); if (file) { fprintf(file, "%s", buf); } if (!quiet) { fprintf(stdout, "%s", buf); } free(buf); } void log_do_flush() { if (file) { fflush(file); } if (!quiet) { fflush(stdout); } } void log_printf(peer_ctx *ctx, const char *fmt, ...) { va_list ap; char timestamp[1024]; time_t epoch = time(0); strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S %z", localtime(&epoch)); char *buf; va_start(ap, fmt); vasprintf(&buf, fmt, ap); va_end(ap); log_do_printf("[%s] [%d] ", timestamp, getpid()); if (ctx) { log_do_printf("[%s:%d] ", inet_ntoa(ctx->peer_addr.sin_addr), ntohs(ctx->peer_addr.sin_port)); } log_do_printf("%s\n", buf); log_do_flush(); free(buf); } void log_cleanup() { if (file) { if (file != stdout) fclose(file); file = NULL; } } fiked-0.0.5+git20120331.1.e6a5109/log.h0000644000000000000000000000167611735550573013226 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef LOG_H #define LOG_H #include "peer_ctx.h" void log_init(char *filename, int quiet); void log_printf(peer_ctx *ctx, const char *fmt, ...); void log_cleanup(); #endif /* LOG_H */ fiked-0.0.5+git20120331.1.e6a5109/main.c0000644000000000000000000001642511735550573013362 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005,2009 Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "bsd.h" #include "results.h" #include "log.h" #include "datagram.h" #include "peer_ctx.h" #include "ike.h" #include "mem.h" #include "vpnc/isakmp-pkt.h" #include "vpnc/isakmp.h" #include "vpnc/math_group.h" #include #include #include #include #include #include #include #include #include #include #include #ifndef __BSD__ #include #endif char *self; void usage() { #ifdef WITH_LIBNET #define OPTIONS "g:k:u:l:L:rdqhV" fprintf(stderr, "Usage: %s [-rdqhV] -g gw -k id:psk [-k ..] [-u user] [-l file] [-L file]\n", self); fprintf(stderr, "\t-r\tuse raw socket: forge ip src addr to match (disables -u)\n"); #else #define OPTIONS "g:k:u:l:L:dqhV" fprintf(stderr, "Usage: %s [-dqhV] -g gw -k id:psk [-k ..] [-u user] [-l file] [-L file]\n", self); #endif fprintf(stderr, "\t-d\tdetach from tty and run as a daemon (implies -q)\n"); fprintf(stderr, "\t-q\tbe quiet, don't write anything to stdout\n"); fprintf(stderr, "\t-h\tprint help and exit\n"); fprintf(stderr, "\t-V\tprint version and exit\n"); fprintf(stderr, "\t-g gw\tVPN gateway address to impersonate\n"); fprintf(stderr, "\t-k i:k\tpre-shared key aka. group password, shared secret, prefixed\n\t\twith its group/key id (first -k sets default)\n"); fprintf(stderr, "\t-u user\tdrop privileges to unprivileged user account\n"); fprintf(stderr, "\t-l file\tappend results to credential log file\n"); fprintf(stderr, "\t-L file\tverbous logging to file instead of stdout\n"); exit(EXIT_FAILURE); } /* * Check for duplicate datagrams. * This is not too beautiful, but works. */ #define DUP_HASH_ALGO GCRY_MD_SHA1 int duplicate(peer_ctx *ctx, datagram *dgm) { int dup = 0; size_t hash_len = gcry_md_get_algo_dlen(DUP_HASH_ALGO); uint8_t *dgm_hash = NULL; mem_allocate(&dgm_hash, hash_len); gcry_md_hash_buffer(DUP_HASH_ALGO, dgm_hash, dgm->data, dgm->len); if (ctx->last_dgm_hash) { dup = !memcmp(ctx->last_dgm_hash, dgm_hash, hash_len); free(ctx->last_dgm_hash); } ctx->last_dgm_hash = dgm_hash; return dup; } #ifndef __BSD__ void setproctitle(const char *fmt, ...) { /* FIXME: add setproctitle replacement code for Linux here ... */ } #endif /* * Signal status to outside by setting the process title. * If ctx is set, logs credentials to results file. */ void status(config *cfg, peer_ctx *ctx) { static uint32_t count = 0; #ifdef WITH_LIBNET char *raw_txt = cfg->opt_raw ? "+raw" : ""; #else char *raw_txt = ""; #endif if (!ctx) { log_printf(NULL, "fiked-%s started (%d/udp%s)", VERSION, cfg->us->port, raw_txt); setproctitle("[%d/udp%s] %d logins", cfg->us->port, raw_txt, count); } else { setproctitle("[%d/udp%s] %d logins, last: %s@%s", cfg->us->port, raw_txt, ++count, ctx->xauth_username, ctx->ipsec_id); } } /* * Permanently drop from root privileges to an unprivileged user account. * Sets the real, effective and stored user and group ID and the list of * ancillary groups. This is only safe if the effective user ID is 0. * Returns 0 on success, -1 on failure. */ int drop_to_user(const char *user) { struct passwd *pw; int ret; ret = -1; if (!user) user = "nobody"; if (!(pw = getpwnam(user))) goto error; if (initgroups(user, pw->pw_gid) == -1) goto error; if (setgid(pw->pw_gid) == -1) goto error; if (setuid(pw->pw_uid) == -1) goto error; ret = 0; error: endpwent(); return ret; } /* * Initialize libgrypt. * INIT_SECMEM drops privileges, so we disable secure memory if we * need root privileges later on (eg. for libnet to open raw sockets). * Since we don't put our own secrets in secure memory, we don't have * to worry about libgcrypt using secure memory or not. */ void init_gcrypt(int need_root) { gcry_control(GCRYCTL_SUSPEND_SECMEM_WARN); if (!gcry_check_version(GCRYPT_VERSION)) { fprintf(stderr, "libgcrypt version mismatch! (expected: " GCRYPT_VERSION ")"); exit(EXIT_FAILURE); } if (!need_root) { gcry_control(GCRYCTL_INIT_SECMEM, 16384, 0); } else { gcry_control(GCRYCTL_DISABLE_SECMEM, 0); } gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0); } /* * Option processing and main loop. */ int main(int argc, char *argv[]) { setproctitle("initializing"); self = argv[0]; umask(0077); config *cfg = config_new(); char *logfile = NULL; int ch = 0; int opt_quiet = 0; int opt_daemon = 0; int need_root = 0; char *p = NULL; int k_valid = 0; char *username = NULL; while ((ch = getopt(argc, argv, OPTIONS)) != -1) { switch (ch) { case 'g': cfg->gateway = strdup(optarg); break; case 'k': k_valid = 0; for (p = optarg; *p; p++) { if (*p == ':') { *p++ = '\0'; k_valid = 1; break; } } if (!k_valid) usage(); psk_set_key(optarg, p, &cfg->keys); break; case 'u': username = strdup(optarg); break; case 'l': results_init(optarg); break; case 'L': logfile = strdup(optarg); break; case 'd': opt_quiet = 1; opt_daemon = 1; break; #ifdef WITH_LIBNET case 'r': cfg->opt_raw = 1; need_root = 1; break; #endif case 'q': opt_quiet = 1; break; case 'V': printf("fiked-%s - fake IKE PSK+XAUTH daemon based on vpnc\n", VERSION); printf("Copyright (C) 2005,2009 Daniel Roethlisberger \n"); printf("Licensed under the GNU General Public License, version 2 or later\n"); printf("%s\n", URL); exit(EXIT_SUCCESS); case 'h': case '?': default: usage(); } } argc -= optind; argv += optind; if (!(cfg->gateway && cfg->keys)) usage(); group_init(); test_pack_unpack(); log_init(logfile, opt_quiet); cfg->us = udp_socket_new(IKE_PORT); init_gcrypt(need_root); if (opt_daemon) daemon(0, 0); if (!need_root) { if (getuid() != geteuid() && !username) { setuid(getuid()); } else { drop_to_user(username); } } status(cfg, NULL); peer_ctx *peers = NULL; peer_ctx *ctx = NULL; datagram *dgm = NULL; int reject = 0; struct isakmp_packet *ikp; while (1) { dgm = udp_socket_recv(cfg->us); ctx = peer_ctx_get(dgm, cfg, &peers); if (!duplicate(ctx, dgm)) { ikp = parse_isakmp_packet(dgm->data, dgm->len, &reject); if (reject) { log_printf(ctx, "illegal ISAKMP packet (%d)", reject); } else { ike_process_isakmp(ctx, ikp); if (ctx->done) { results_add(ctx); status(ctx->cfg, ctx); ctx->done = 0; } } free_isakmp_packet(ikp); } datagram_free(dgm); } log_printf(NULL, "Bye."); results_cleanup(); log_cleanup(); peer_ctx_free(peers); config_free(cfg); exit(EXIT_SUCCESS); } fiked-0.0.5+git20120331.1.e6a5109/mem.c0000644000000000000000000000205511735550573013206 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "mem.h" #include inline void mem_free(void *memptr) { if (*(void**)memptr) { free(*(void**)memptr); *(void**)memptr = NULL; } } inline void mem_allocate(void *memptr, size_t size) { mem_free(memptr); *(void**)memptr = malloc(size); if (!*(void**)memptr) abort(); } fiked-0.0.5+git20120331.1.e6a5109/mem.h0000644000000000000000000000160611735550573013214 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef MEM_H #define MEM_H #include void mem_free(void *); void mem_allocate(void *, size_t); #endif /* MEM_H */ fiked-0.0.5+git20120331.1.e6a5109/peer_ctx.c0000644000000000000000000000617011735550573014243 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "peer_ctx.h" #include "mem.h" #include "vpnc/math_group.h" #include #include #include #include #include #include /* message_iv */ message_iv * message_iv_get(uint32_t id, message_iv **head) { message_iv *found = NULL; for (message_iv *p = *head; p && !found; p = p->next) { if (p->id == id) found = p; } if (!found) { mem_allocate(&found, sizeof(message_iv)); memset(found, 0, sizeof(message_iv)); found->id = id; found->next = *head; *head = found; } return found; } void message_iv_free(message_iv *msg_iv) { if (msg_iv->next) { message_iv_free(msg_iv->next); msg_iv->next = NULL; } mem_free(&msg_iv->iv); free(msg_iv); } /* peer_ctx */ peer_ctx * peer_ctx_get(datagram *dgm, config *cfg, peer_ctx **head) { peer_ctx *found = NULL; for (peer_ctx *p = *head; p && !found; p = p->next) { if (p->peer_addr.sin_addr.s_addr == dgm->peer_addr.sin_addr.s_addr && p->peer_addr.sin_port == dgm->peer_addr.sin_port) found = p; } if (!found) { mem_allocate(&found, sizeof(peer_ctx)); memset(found, 0, sizeof(peer_ctx)); found->peer_addr = dgm->peer_addr; found->next = *head; found->state = STATE_NEW; found->cfg = cfg; *head = found; } return found; } void peer_ctx_clear(peer_ctx *ctx) { mem_free(&ctx->ipsec_id); mem_free(&ctx->ipsec_secret); mem_free(&ctx->xauth_username); mem_free(&ctx->xauth_password); mem_free(&ctx->key); mem_free(&ctx->iv0); if (ctx->msg_iv) { message_iv_free(ctx->msg_iv); ctx->msg_iv = NULL; } if (ctx->dh_group) { group_free(ctx->dh_group); ctx->dh_group = NULL; } mem_free(&ctx->dh_i_public); mem_free(&ctx->dh_r_public); mem_free(&ctx->dh_secret); mem_free(&ctx->skeyid); mem_free(&ctx->skeyid_e); mem_free(&ctx->skeyid_a); mem_free(&ctx->skeyid_d); mem_free(&ctx->i_sa); mem_free(&ctx->i_id); mem_free(&ctx->r_id); mem_free(&ctx->i_nonce); mem_free(&ctx->r_nonce); mem_free(&ctx->i_hash); mem_free(&ctx->r_hash); } void peer_ctx_reset(peer_ctx *ctx) { peer_ctx_clear(ctx); memset((uint8_t *)&ctx->state, 0, (uint8_t *)ctx - (uint8_t *)&ctx->state + sizeof(peer_ctx)); ctx->state = STATE_NEW; } void peer_ctx_free(peer_ctx *ctx) { if (ctx->next) { peer_ctx_free(ctx->next); ctx->next = NULL; } mem_free(&ctx->last_dgm_hash); /* only free on free_peer_ctx */ peer_ctx_clear(ctx); free(ctx); } fiked-0.0.5+git20120331.1.e6a5109/peer_ctx.h0000644000000000000000000000523311735550573014247 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef PEER_CTX_H #define PEER_CTX_H #include "datagram.h" #include "config.h" #include "vpnc/isakmp.h" #include "vpnc/isakmp-pkt.h" #include #include #include typedef struct _message_iv { struct _message_iv *next; uint32_t id; /* primary key */ uint8_t *iv; } message_iv; typedef struct _peer_ctx { /* bookkeeping */ struct _peer_ctx *next; struct sockaddr_in peer_addr; /* primary key */ /* pointer to global configuration */ config *cfg; /* hash of last received datagram */ uint8_t *last_dgm_hash; /* internal FSM states */ enum { STATE_NEW, STATE_PHASE1, STATE_PHASE2 } state; /* from here, clear will zero everything */ /* done flag: signal that credentials are complete */ int done; /* the interesting stuff */ uint8_t *ipsec_id; uint8_t *ipsec_secret; uint8_t *xauth_username; uint8_t *xauth_password; /* IKE: symmetrical crypto */ int algo; size_t key_len; size_t blk_len; uint8_t *key; uint8_t *iv0; message_iv *msg_iv; /* IKE: message digest */ int md_algo; size_t md_len; /* IKE: Diffie-Hellman */ struct group *dh_group; uint8_t *dh_i_public; uint8_t *dh_r_public; uint8_t *dh_secret; /* IKE: intermediate key material */ uint8_t *skeyid; uint8_t *skeyid_d; uint8_t *skeyid_a; uint8_t *skeyid_e; /* IKE: header fields */ uint8_t i_cookie[ISAKMP_COOKIE_LENGTH]; uint8_t r_cookie[ISAKMP_COOKIE_LENGTH]; uint8_t isakmp_version; /* IKE: phase 1 payloads */ uint8_t *i_sa, *i_id, *r_id; size_t i_sa_len, i_id_len, r_id_len; uint8_t *i_nonce; uint8_t *r_nonce; size_t i_nonce_len, r_nonce_len; uint8_t *i_hash; uint8_t *r_hash; } peer_ctx; peer_ctx * peer_ctx_get(datagram *dgm, config *cfg, peer_ctx **head); void peer_ctx_reset(peer_ctx *ctx); void peer_ctx_free(peer_ctx *ctx); message_iv * message_iv_get(uint32_t id, message_iv **head); void message_iv_free(message_iv *msg_iv); #endif /* PEER_CTX_H */ fiked-0.0.5+git20120331.1.e6a5109/results.c0000644000000000000000000000324211735550573014130 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "results.h" #include #include #include #include #include #include #include #include #include static FILE* file = NULL; void results_init(char *filename) { results_cleanup(); file = fopen(filename, "a"); if (!file) { fprintf(stderr, "FATAL: cannot open file %s: %s\n", filename, strerror(errno)); exit(EXIT_FAILURE); } } void results_add(peer_ctx *ctx) { if (file) { char timestamp[1024]; time_t epoch = time(0); strftime(timestamp, sizeof(timestamp), "%Y-%m-%d %H:%M:%S %z", localtime(&epoch)); fprintf(file, "%s %s %s %s %s %s %s\n", timestamp, ctx->cfg->gateway, ctx->ipsec_id, ctx->ipsec_secret, inet_ntoa(ctx->peer_addr.sin_addr), ctx->xauth_username, ctx->xauth_password); fflush(file); } } void results_cleanup() { if (file) { fclose(file); file = NULL; } } fiked-0.0.5+git20120331.1.e6a5109/results.h0000644000000000000000000000166211735550573014141 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef RESULTS_H #define RESULTS_H #include "peer_ctx.h" void results_init(char *filename); void results_add(peer_ctx *ctx); void results_cleanup(); #endif /* RESULTS_H */ fiked-0.0.5+git20120331.1.e6a5109/send_dgm.c0000644000000000000000000000415111735550573014207 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #include "send_dgm.h" #include "log.h" #include "ike.h" #ifdef WITH_LIBNET #include /* * Send a UDP datagram on a raw socket. */ void raw_send(datagram *dgm, char *shost, uint16_t sport) { static char errbuf[LIBNET_ERRBUF_SIZE]; libnet_t *lnet = libnet_init(LIBNET_RAW4, NULL, errbuf); libnet_ptag_t udp = libnet_build_udp( sport, ntohs(dgm->peer_addr.sin_port), LIBNET_UDP_H + dgm->len, 0, dgm->data, dgm->len, lnet, 0); if (udp <= 0) { log_printf(NULL, "ERROR: cannot build UDP header: %s\n", libnet_geterror(lnet)); return; } libnet_ptag_t ip = libnet_build_ipv4( LIBNET_IPV4_H + LIBNET_UDP_H + dgm->len, 0, 0, 0, 64, IPPROTO_UDP, 0, inet_addr(shost), dgm->peer_addr.sin_addr.s_addr, NULL, 0, lnet, 0); if (ip <= 0) { log_printf(NULL, "FATAL: cannot build IP header: %s\n", libnet_geterror(lnet)); return; } int ret = libnet_write(lnet); if (ret <= 0) { log_printf(NULL, "ERROR: write error: %s\n", libnet_geterror(lnet)); return; } libnet_destroy(lnet); } #endif /* WITH_LIBNET */ /* * Send a datagram, using either raw sockets or UDP socket, depending on opt_raw. */ void send_datagram(peer_ctx *ctx, datagram *dgm) { #ifdef WITH_LIBNET if (ctx->cfg->opt_raw) { raw_send(dgm, ctx->cfg->gateway, IKE_PORT); } else { udp_socket_send(ctx->cfg->us, dgm); } #else udp_socket_send(ctx->cfg->us, dgm); #endif } fiked-0.0.5+git20120331.1.e6a5109/send_dgm.h0000644000000000000000000000164111735550573014215 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ */ #ifndef SEND_DGM_H #define SEND_DGM_H #include "peer_ctx.h" #include "datagram.h" void send_datagram(peer_ctx *ctx, datagram *dgm); #endif /* SEND_DGM_H */ fiked-0.0.5+git20120331.1.e6a5109/vpnc/0000755000000000000000000000000011735550573013230 5ustar00fiked-0.0.5+git20120331.1.e6a5109/doc/draft-beaulieu-ike-xauth-02.txt0000644000000000000000000013670311735550573020607 0ustar00 S. Beaulieu Internet Draft R. Pereira Document: Cisco Systems Expires April 2002 October 2001 Extended Authentication within IKE (XAUTH) Status of this Memo This document is an Internet-Draft and is in full conformance with all provisions of Section 10 of RFC2026 [1]. Internet-Drafts are working documents of the Internet Engineering Task Force (IETF), its areas, and its working groups. Note that other groups may also distribute working documents as Internet- Drafts. Internet-Drafts are draft documents valid for a maximum of six months and may be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to use Internet- Drafts as reference material or to cite them other than as "work in progress." The list of current Internet-Drafts can be accessed at http://www.ietf.org/ietf/1id-abstracts.txt The list of Internet-Draft Shadow Directories can be accessed at http://www.ietf.org/shadow.html. 1. Abstract [IKE] allows a device to set up a secure session by using a bidirectional authentication method using either pre-shared keys or digital certificates. However [IKE] does not provide a method to leverage legacy authentication methods which are widely deployed today. This document describes a method for using existing unidirectional authentication mechanisms such as RADIUS, SecurID, and OTP within IPsec's ISAKMP protocol. The purpose of this draft is not to replace or enhance the existing authentication mechanisms described in [IKE], but rather to allow them to be extended using legacy authentication mechanisms. This protocol is designed in such a way that extended authentication may be accomplished using any mode of operation for phase 1 (i.e. Main Mode or Aggressive Mode) as well as any authentication method supported by [IKE]. This protocol may also be easily extended to support new modes or authentication methods. This protocol does however require that the phase 1 authentication method be fully secure. Beaulieu, Pereira 1 Extended Authentication with ISAKMP/Oakley October 2001 The authors currently intend this document to be published as an Informational RFC, not a standards-track document, so that the many IPsec implementations that have implemented to earlier drafts of this protocol can have a single stable reference. Comments regarding this draft should be sent to ietf-xauth@vpnc.org or to the authors. 2. Conventions used in this document The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as described in RFC-2119 [2]. 3. Introduction The following technique allows IPsec's ISAKMP/Oakley [IKE] protocol to support extended authentication mechanisms like two-factor authentication, challenge/response and other remote access unidirectional authentication methods. These authentication mechanisms have a large deployment in remote access applications and many IT departments have requirements for these unidirectional authentication mechanisms. This draft defines packet formats for a protocol which allows you to carry legacy authentication information from one peer to another. It does so by extending the [IKECFG] protocol. This protocol requires a sufficient level of security from the phase 1 SA authentication. This protocol may be used in conjunction with a multitude of combinations of modes (i.e. Main Mode, Aggressive Mode, etc) and authentication methods (i.e. Pre-Shared keys, RSA Signatures, DSS Signatures, etc). This protocol has also been designed to work with any new modes and authentication methods. This draft also specifies how to accomplish legacy authentication when used with the existing modes and authentication methods defined in IKE (the assumption here being that they offer "sufficient" level of security to protect the XAUTH exchange). This is accomplished by extending the [IKE] protocol. The document has been published as informational as the IPSRA working group will not accept any protocol which extends ISAKMP or IKE. Furthermore, the IPsec working group refuses to accept any protocols that deal with remote access. At the time of the writing of this draft, the IPSRA working group has still not defined a protocol to solve the issue of legacy Beaulieu, Pereira 2 Extended Authentication with ISAKMP/Oakley October 2001 authentication. XAUTH has been in existance for several years, and has successfully proven interoperability. Several vendors have implemented and deployed the protocol. Several vendors wish to implement the protocol but have had problems finding the protocol specification. For this reason, the draft is being republished as informational to give new vendors an opportunity to interoperate with the many existing vendors who implement this protocol today. 3.1. Changes since last revision. The last revision of this document was published as "draft-beaulieu- ike-xauth-01.txt" o clarified text regarding CHALLENGE attribute o clarified text regarding NEXT-PIN attribute 3.2. Extended Authentication Two-factor authentication and challenge/response schemes like SDI's SecurID and RADIUS are forms of authentication that allow a gateway, firewall, or network access server to offload the user administration and authentication to a central management server. IPsec's ISAKMP/Oakley protocol supports certificates (RSA & DSS), shared-secret, and Kerberos as authentication methods, but since the authentication methods described within this document are only unidirectional authentication methods (client to a gateway/firewall), they cannot be used by themselves, but must be used in conjunction with the other standard ISAKMP authentication methods. The technique described within this document utilizes ISAKMP to transfer the user's authentication information (name, password) to the gateway/firewall (edge device) in a secured ISAKMP message. The edge device would then use the appropriate protocol (RADIUS, SecurID, OTP) to authenticate the user. This allows the authentication server to be within the private network that the edge device is protecting. 3.3. Reader Prerequisites It is assumed that the reader is familiar with the terms and concepts described in the "Security Architecture for the Internet Protocol" [ArchSec] and "IP Security Document Roadmap" [Thayer97] documents. Readers are advised to be familiar with both [IKE] and [ISAKMP] as well as [IKECFG] since this document is an extension to that document. Beaulieu, Pereira 3 Extended Authentication with ISAKMP/Oakley October 2001 4. Vendor ID XAUTH currently uses attribute numbers from the private ranges of both [IKE] and [IKECFG]. In order to ensure interoperability with future and past implementations of XAUTH a Vendor ID has been added. The Vendor ID payload is sent during the phase 1 exchange as per [ISAKMP]. The vendor id payload SHOULD be authenticated whenever possible. Two IKE implementations which support the [KIV] document will be capable of doing this. The Vendor ID for this revision of XAUTH is the following 8 bytes. Vendor ID = 0x09002689DFD6B712 If an implementation receives the aforementioned Vendor ID, it can assume that the peer also has implemented this protocol and therefore is a "mutually consenting party". If this document ever advances to the standard-track, then new numbers will be assigned by IANA from the appropriate number spaces of [IKE] and [IKECFG], thus eliminating the need for a Vendor ID payload. 5. Extended Authentication Method This specification allows for extended authentication by allowing an edge device to request extended authentication from an IPsec host (end-node), thus forcing the host to respond with its extended authentication credentials. The edge device will then respond with a failed or passed message. When the edge device requests extended authentication, it will specify the type of extra authentication and any parameters required for it. These parameters MAY be the attributes that it requires for authentication and they MAY be information required for the IPsec host's reply (e.g. challenge string). The Extended Authentication transaction is terminated either when the edge device starts a SET/ACK exchange which includes an XAUTH_STATUS attribute or when the remote device sends a XAUTH_STATUS attribute in a REPLY message. Please note that a remote device can not set XAUTH_STATUS to anything but FAIL. The edge device MAY request multiple different authentication transactions within one Extended Authentication transaction. This is done by having multiple REQUEST/REPLY pairs, initiated by the edge device, before the transaction is terminated as described above. Each REQUEST/REPLY pair MAY have a different value for XAUTH_TYPE. Beaulieu, Pereira 4 Extended Authentication with ISAKMP/Oakley October 2001 As with CHAP [CHAP], this protocol can also be used to periodically authenticate the user during the lifetime of a security association. If the IPsec host does not have support for the authentication method requested by the edge device, then it would send back a REPLY with the XAUTH_STATUS attribute set to FAIL, thus failing the authentication but completing the transaction. The Extended Authentication mechanism does not effect the nature of the phase 1 authentication mechanism in any way. Both peers MUST authenticate each other via the authentication methods described in [IKE] or some other authentication method in the ISAKMP framework. There are Security Considerations involved in at least one of the authentication methods in [IKE] and this is described in "Security Considerations" below. This method provides unidirectional authentication only, meaning that only one device is authenticated using both IKE authentication methods and Extended Authentication. Here are some types of extended authentication that this specification supports: 5.1 Simple Authentication Where a user name and password are required for authentication. IPsec Host Edge Device -------------- ----------------- <-- REQUEST(NAME="" PASSWORD="") REPLY(NAME="joe" PASSWORD="foobar") --> <-- SET(STATUS=OK) ACK(STATUS) --> Some authentication mechanisms hide the user password by some type of encryption mechanism. IPsec Host Edge Device -------------- ----------------- <-- REQUEST(TYPE=RADIUS-CHAP CHALLENGE="123456" NAME="" PASSWORD="") REPLY(TYPE=RADIUS-CHAP NAME="joe" PASSWORD="E4901AB7") --> <-- SET(STATUS=OK) ACK(STATUS) --> NOTE: This is a conceptual example of RADIUS-CHAP, for a more detailed example, see Appendix A. 5.2 Challenge/Response Beaulieu, Pereira 5 Extended Authentication with ISAKMP/Oakley October 2001 Where a challenge from the edge device must be incorporated with the reply. This makes each reply different. IPsec Host Edge Device -------------- ----------------- <-- REQUEST(NAME="" PASSWORD="") REPLY(NAME="joe" PASSWORD="foobar") --> <-- REQUEST(MESSAGE="Enter your password followed by your pin number" NAME="" PASSWORD="") REPLY(NAME="joe" PASSWORD="foobar0985124") --> <-- SET(STATUS=OK) ACK(STATUS) --> If, however, the edge device knows that a challenge will be required it may skip the first exchange as follows: IPsec Host Edge Device -------------- ----------------- <-- REQUEST(MESSAGE="Enter your password followed by your pin number" NAME="" PASSWORD="") REPLY(NAME="joe" PASSWORD="foobar0985124") --> <-- SET(STATUS=OK) ACK(STATUS) --> 5.3 Two-Factor Authentication This authentication method combines something the user knows (their password) and something that the user has (a token card). IPsec Host Edge Device -------------- ----------------- <-- REQUEST(NAME="" PASSWORD="" PASSCODE="") REPLY(NAME="joe" PASSWORD="foobar" PASSCODE="3412") --> <-- SET(STATUS=OK) ACK(STATUS) --> Some mechanisms allow for another optional request of the passcode. IPsec Host Edge Device -------------- ----------------- <-- REQUEST(NAME="" PASSWORD="" PASSCODE="") REPLY(NAME="joe" PASSWORD="foobar" PASSCODE="323415") --> <-- REQUEST(NAME="" PASSWORD="" PASSCODE="") REPLY(NAME="joe" PASSWORD="foobar" PASSCODE="513212") --> <-- SET(STATUS=OK) ACK(STATUS) --> 5.4 One-Time-Password Similar to the Challenge/Response method, this method allows authentication that is secure against passive attacks based on replaying captured passwords. Beaulieu, Pereira 6 Extended Authentication with ISAKMP/Oakley October 2001 IPsec Host Edge Device -------------- ----------------- <-- REQUEST(TYPE=OTP CHALLENGE, NAME="") REPLY(TYPE=OTP_CHALLENGE, NAME="joe")--> <-- REQUEST(TYPE=OTP CHALLENGE="otp-md5 499 ke1234" NAME="" PASSWORD="") REPLY(TYPE=OTP NAME="joe" PASSWORD="5bf0 75d9 959d 036f") --> <-- SET(STATUS=OK) ACK(STATUS) --> 5.5 User Previously Authenticated Some situations may occur where the edge device has already authenticated the host and no new authentication is required. This may happen when either the host or the edge device must rekey an existing phase 1 SA. It is important that this method not be used, unless the implementation can be sure that the current phase 1 SA was created with the same peer as the initial phase 1 SA, which was previously authenticated using XAUTH. There is currently no way defined to ensure that two separate phase 1 SAs actually belong to the same peer. One method suggested is to use the ID from the phase 1 negotiation (available in Main Mode and Aggressive Mode) but only if the ID is unique to the user and cannot not be forged. This concept is herein referred to as "ID-Checking". Implementation hint: o In order to accomplish ID-Checking for Phase 1 Authenticated With a Pre-Shared Key (as defined in [IKE]), the pre-shared key lookup must be based on the phase 1 ID. Please note that this method only currently works for Aggressive Mode, and may work with modes defined in the future. A static IP address could also be used for shared secret lookup, however, the binding of the user to XAUTH session would have to use the IP address instead of the ID. o In order to accomplish ID-Checking for IKE Phase 1 Authenticated With Signatures (as defined in [IKE]), the implementation must ensure that the ID provided in the phase 1 exchange matches the ID in the peer's certificate which must be signed by a trusted third party. In the situation where the peer does not require additional authentication, the following method is used. IPsec Host Edge Device ------------- ---------------- <-- SET(STATUS=OK) ACK(STATUS) --> Beaulieu, Pereira 7 Extended Authentication with ISAKMP/Oakley October 2001 5.6 Other Useful Examples More useful examples are found in Appendix A. 6 Extensions to ISAKMP-Config This protocol uses the mechanisms described in ISAKMP-Config [IKECFG] to accomplish its authentication transaction. This protocol uses Configuration Attributes from the private range of Isakmp-Config [IKECFG]. To ensure interoperability with past and future versions of Extended Authentication, a Vendor ID is provided in section 2. All ISAKMP-Config messages in an extended authentication transaction MUST contain the same ISAKMP-Config transaction identifier. The Message ID in the ISAKMP header follows the rules defined by the ISAKMP-Config protocol. This protocol can therefore be used in conjunction with any existing basic ISAKMP authentication method as defined in [IKE]. This authentication MUST be used after a phase 1 exchange has completed and before any other exchange with the exception of Info mode exchanges. If the extended authentication fails, then the phase 1 SA MUST be immediately deleted. The edge device MAY choose to retry an extended authentication request if the user failed to be authenticated, but must do so in the same ISAKMP-Config transaction, and MUST NOT send the SET message until the user is authenticated, or until the edge device wishes to stop retrying and fail the user. Extended Authentication MAY be initiated by the edge device at any time after the initial authentication exchange. For example, RADIUS servers may specify that a user only be authenticated for a certain time period. Once that time period has elapsed (minus a possible jitter), the edge device may request a new Extended Authentication exchange. If the Extended Authentication exchange fails, the edge device MUST tear down all phase 1 and phase 2 SAs associated with the user. The following are extensions to the ISAKMP-Config [IKECFG] specification to support Extended Authentication. 6.1 Message Types Type Value -------------------------- ----------------------------- ISAKMP-CFG-REQUEST ( as defined in [IKECFG] ) ISAKMP-CFG-REPLY ( as defined in [IKECFG] ) ISAKMP-CFG-SET ( as defined in [IKECFG] ) ISAKMP-CFG-ACK ( as defined in [IKECFG] ) Beaulieu, Pereira 8 Extended Authentication with ISAKMP/Oakley October 2001 ISAKMP-CFG-REQUEST - This message is sent from an edge device to an IPsec host trying to request extended authentication. Attributes that it requires sent back in the reply MUST be included with a length of zero (0). Attributes required for the authentication reply, such as a challenge string MUST be included with the proper values filled in. ISAKMP-CFG-REPLY - This message MUST contain the filled in authentication attributes that were requested by the edge device or if the proper authentication attributes can not be retrieved, then this message MUST contain the XAUTH-STATUS attribute with a value of FAIL. ISAKMP-CFG-SET - This message is sent from an edge device and is only used, within the scope of this document, to state the success of the authentication. This message MUST only include the success of failure of the authentication and MAY contain some clarification text. ISAKMP-CFG-ACK - This message is sent from the IPsec host acknowledging receipt of the authentication result. Its attributes are not relevant and MAY be skipped entirely, thus no attributes SHOULD be included. This last message in the authentication transaction is used solely as an acknowledgement of the previous message and to eliminate problems with unacknowledged messages over UDP. 6.2 Attributes Attribute Value Type --------------------- ------ --------------------- XAUTH-TYPE 16520 Basic XAUTH-USER-NAME 16521 Variable ASCII string XAUTH-USER-PASSWORD 16522 Variable ASCII string XAUTH-PASSCODE 16523 Variable ASCII string XAUTH-MESSAGE 16524 Variable ASCII string XAUTH-CHALLENGE 16525 Variable ASCII string XAUTH-DOMAIN 16526 Variable ASCII string XAUTH-STATUS 16527 Basic XAUTH-NEXT-PIN 16528 Variable ASCII string XAUTH-ANSWER 16529 Variable ASCII string NOTE: Variable ASCII strings need not be NULL-terminated, as the length field in the attribute header is sufficient to properly format the strings. XAUTH-TYPE - The type of extended authentication requested whose values are described in the next section. This is an optional attribute for the ISAKMP_CFG_REQUEST and ISAKMP_CFG_REPLY messages. If the XAUTH-TYPE is not present, then it is assumed to be Generic. The XAUTH-TYPE in a REPLY MUST be identical to the XAUTH-TYPE in the REQUEST. If the XAUTH-TYPE was not present in the REQUEST, then it MUST NOT be present in the REPLY. However, an XAUTH transaction MAY Beaulieu, Pereira 9 Extended Authentication with ISAKMP/Oakley October 2001 have multiple REQUEST/REPLY pairs with different XAUTH-TYPE values in each pair. XAUTH-USER-NAME - The user name MAY be any unique identifier of the user such as a login name, an email address, or a X.500 Distinguished Name. XAUTH-USER-PASSWORD - The user's password. XAUTH-PASSCODE - A token card's passcode. XAUTH-MESSAGE - A textual message from an edge device to an IPsec host. The message may contain a textual challenge or instruction. An example of this would be "Enter your password followed by your pin number". The message may also contain a reason why authentication failed or succeeded. This message SHOULD be displayed to the user. XAUTH-CHALLENGE - A challenge string sent from the edge device to the IPsec host for it to include in its calculation of a password. This attribute SHOULD only be sent in an ISAKMP-CFG-REQUEST message. Typically, the XAUTH-TYPE attribute dictates how the receiving device should handle the challenge. For example, RADIUS-CHAP uses the challenge to hide the password. The XAUTH-CHALLENGE attribute MUST NOT be used when XAUTH-TYPE is set to generic. XAUTH-DOMAIN - The domain to be authenticated in. This value will have different meaning depending on the authentication type. XAUTH-STATUS - A variable that is used to denote authentication success (OK=1) or failure (FAIL=0). This attribute MUST be sent in the ISAKMP-CFG-SET message, in which case it may be set to either OK or FAIL, and MAY be sent in a REPLY message by a remote peer, in which case it MUST be set to FAIL. XAUTH-NEXT-PIN - A variable which is used when the edge device is requesting that the user choose a new pin number. This attribute MUST NOT be used in conjunction with any attributes other than XAUTH-MESSAGE and / or XAUTH-TYPE. XAUTH-ANSWER - A variable length ASCII string used to send input to the edge device. An edge device MAY include this attribute in a REQUEST message in order to prompt an answer from the user, though it MUST be accompanied by an XAUTH-MESSAGE attribute. This attribute MUST NOT be used in conjunction with any attributes other than XAUTH-TYPE or XAUTH-MESSAGE. 6.3 Authentication Types Value Authentication Required ----- --------------------------------- Beaulieu, Pereira 10 Extended Authentication with ISAKMP/Oakley October 2001 0 Generic 1 RADIUS-CHAP 2 OTP 3 S/KEY 4-32767 Reserved for future use 32768-65535 Reserved for private use Generic - A catch-all type that allows for future extensibility and a generic mechanism to request authentication information. This method allows for any type of extended authentication which does not require specific processing, and should be used whenever possible. This is the default setting if no XAUTH_TYPE is present. RADIUS-CHAP - RADIUS-CHAP is one method of authentication defined in [RADIUS] which uses a challenge to hide the password. In order to use the CHAP functionality defined in [RADIUS], the XAUTH_TYPE MUST be set to RADIUS-CHAP. For all other methods defined in [RADIUS] (i.e. PAP), the XAUTH_TYPE MUST be set to Generic. OTP - One-Time-Passwords as defined in [OTP] uses a challenge string to request a certain generated password. The request SHOULD contain a user name, password and a challenge string while the reply MUST contain the user name and the generated password. The challenge string is formatted as defined in [OTPEXT]. S/KEY - This one-time-password scheme defined in [SKEY] was the precursor to OTP, thus the same rules applies. 7. XAUTH Notification It is important the edge device be able to notify the remote device of its intent to prompt for extended authentication. If such a mechanism were not present, the remote device would send a Quick Mode message, or a Mode-Cfg message before authentication was complete, and the state machines would get pretty complicated. We present here two methods of accomplishing this. The first is the simplest, and most intuitive. However it is not possible to achieve this within the [IKE] protocol as it stands today, and is therefore not recommended. It has been added to this document for completeness, and may be used in future versions of this document. 7.1 Notification payloads within a phase 1 exchange The following method is used to notify the remote device that an XAUTH exchange will follow the phase 1 exchange. Once the edge device does a policy lookup for the peer, the edge device appends a notify payload to any phase 1 exchange packet, indicating that an XAUTH exchange will follow. Note, that this notify payload is unauthenticated unless both devices support the mechanisms described in [KIV]. Therefore, implementations MUST NOT use this method unless they are also using the mechanisms described in [KIV]. Beaulieu, Pereira 11 Extended Authentication with ISAKMP/Oakley October 2001 Once again, this method is not part of the XAUTH protocol in its present form. It has only been added here for completeness, and may be used in future versions of this document. No payload definitions, assigned numbers, or vendor ID payloads will be provided for this method, as it is currently not part of the XAUTH protocol. These may be defined in the future if enough interest is shown, and if [KIV] becomes a standardized within the IPsec working group. 7.2 Notification via Authentication Method Types The following method is used to negotiate the use of XAUTH via the SA payload. New authentication methods are defined which allow the edge device to choose an authentication method which mandates XAUTH. This allows the edge device to notify the remote device that an XAUTH exchange will follow the phase 1 exchange. Edge devices which conform to this document MUST support this method. The following values relate to the ISAKMP authentication method attribute used in proposals. They optionally allow an XAUTH implementation to propose use of extended authentication after the initial phase 1 authentication. Values are taken from the private use range defined in [IKE] and should be used among mutually consenting parties. To ensure interoperability and avoid collisions, a Vendor ID is provided in the "Vendor ID" section of this document. Method Value ------------------------------ ----- XAUTHInitPreShared 65001 XAUTHRespPreShared 65002 XAUTHInitDSS 65003 XAUTHRespDSS 65004 XAUTHInitRSA 65005 XAUTHRespRSA 65006 XAUTHInitRSAEncryption 65007 XAUTHRespRSAEncryption 65008 XAUTHInitRSARevisedEncryption 65009 XAUTHRespRSARevisedEncryption 65010 An Extended Authentication proposal has two characteristics. The first is the direction of the authentication. Each type identifies whether the Initiator or the Responder is the device which should be authenticated using XAUTH. For example XAUTHInitPreShared is a type which demands that the Initiator be authenticated. Note that an edge device would typically initiate with one of the following: Beaulieu, Pereira 12 Extended Authentication with ISAKMP/Oakley October 2001 o XAUTHRespPreShared o XAUTHRespDSS o XAUTHRespRSA o XAUTHRespRSAEncryption o XAUTHRespRSARevisedEncryption and would typically only accept proposals with the following authentication methods: o XAUTHInitPreShared o XAUTHInitDSS o XAUTHInitRSA o XAUTHInitRSAEncryption o XAUTHInitRSARevisedEncryption The second characteristic is the IKE Authentication method to be used. The following table illustrates which keywords in the methods described above relate to which Authentication Methods described in [IKE] Appendix A. "PreShared" -> pre-shared key "DSS" -> DSS signatures "RSA" -> RSA signatures "RSAEncryption" -> Encryption with RSA "RSARevisedEncryption" -> Revised encryption with RSA 8. Other Scenarios for Extended Authentication Although this document described a scenario where an IPsec host (eg. mobile user) was being authenticated by an edge device (eg. firewall/gateway), the methods described can also be used for edge device to edge device authentication as well as IPsec host to IPsec host authentication. 9. Extensibility Although this protocol was initially developed for the corporate "Road Warrior" with a dynamic IP address to connect to a corporate Net, there may be certain applications where static IP addresses are used by the "Road Warrior" or where this protocol is used in a non remote-user environment where the IP address is static. There are Security Considerations for certain applications of this protocol in certain deployment scenarios. Please consult the "Security Considerations" section below for more detail. [IKE] defines many different ways to authenticate a user and generate keying material. There are two basic phase 1 modes defined: Main Mode and Aggressive Mode. There are also at least 5 different authentication schemes which can be used with each mode. Beaulieu, Pereira 13 Extended Authentication with ISAKMP/Oakley October 2001 New authentication schemes are being developed and surely more will be standardized in the future. Similarly new phase 1 modes are being proposed to address weaknesses or missing functionality in Main Mode and/or Aggressive mode. It is for this reason that XAUTH was designed to be fully extensible. Since XAUTH extends the phase 1 authentication provided by [IKE], it is an important design goal that a legacy user authentication scheme in IPsec be able to use the strengths of current and future authentication and key generation schemes. XAUTH accomplishes this by working with all modes which allow the negotiation of a phase 1 authentication method in ISAKMP. Any new authentication methods defined in the future which are not addressed by this document need simply to take values from the "consenting parties" ranges of [IKE]. Such an example would be the introduction of Encryption with El-Gamal and Revised Encryption with El-Gamal, and [HYBRID]. Furthermore, any new modes defined such as Base Mode, will automatically be able to use the functionality of XAUTH as no new numbers are needed. Finally, any new or forgotten Legacy User Authentication Schemes which are not part of XAUTH can be easily incorporated by taking numbers from the "consenting parties" ranges of XAUTH, or by requesting reserved numbers from IANA. 10. Security Considerations Care should be taken when sending sensitive information over public networks such as the Internet. A user's password should never be sent in the clear and when sent encrypted, the destination MUST have been previously authenticated. The use of ISAKMP-Config [IKECFG] addresses these issues. The protocol described in this memo strictly extends the authentication methods described in [IKE]. It does not in any way affect the authenticated nature of the phase 1 security association. In fact, this protocol heavily relies on the authenticated nature of the phase 1 SA. Without complete phase 1 authentication, this protocol does not provide protection against man-in-the-middle attacks. Therefore it MUST NOT be used without normal phase 1 authentication. This protocol was designed to be extensible, and can be used in many possible combinations of phase 1 Modes and authentication methods. However, certain combinations of scenarios could lead to weaker than desired security, and are therefore discouraged. When using XAUTH with Pre-Shared keys, where the peer's IP address is dynamic, Main Mode SHOULD NOT be used, and is STRONGLY DISCOURAGED. In this particular scenario, the phase 1 authentication becomes suspect as the administrator has little choice but to use Beaulieu, Pereira 14 Extended Authentication with ISAKMP/Oakley October 2001 one single Shared-Key for all users, and group-shared keys are susceptible to "social engineering attacks". However, the choice of implementation of this functionality is left up to the implementers of this protocol. There may be some applications where this functionality is desired. Some examples are: proof of concept deployments and small deployments where the proper management of a group shared-key is less difficult. If at some point restrictions are introduced in one of the IPsec Standard RFC documents which prohibit the use of group pre-shared keys, then this protocol will, by default, conform, and these Security Considerations will no longer be of concern. 11. References [1] Bradner, S., "The Internet Standards Process -- Revision 3", BCP 9, RFC 2026, October 1996. [2] Bradner, S., "Key words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997 [CHAP] W. Simpson, "PPP Challenge Handshake Authentication Protocol (CHAP)", RFC1994 [DIAMETER] P. Calhoun, A. Rubens, "DIAMETER - Base Protocol", draft-calhoun-diameter-02.txt [HYBRID] M. Litvin, R. Shamir, T. Zegman, "A Hybrid Authentication Mode for IKE", draft-ietf-ipsec-isakmp-hybrid-auth-05 [IKE] D. Harkins, D. Carrel, "The Internet Key Exchange (IKE)", RFC2409 [IKECFG] D. Dukes, R. Pereira, "The ISAKMP Configuration Method", draft-dukes-ike-mode-cfg-01.txt [KIV] Kivinen, T., "Fixing IKE Phase 1 & 2 Authentication HASHs", "draft-ietf-ipsec-ike-hash-revised-01.txt", work in progress. [OTP] N. Haller, C. Metz, P. Nesser, M. Straw, "A One-Time Password System", RFC2289 [OTPEXT] C. Metz, "OTP Extended Responses", RFC 2243 [RADIUS] C. Rigney, A. Rubens, W. Simpson, S. Willens, "Remote Authentication Dial In User Service (RADIUS)", RFC2138 Beaulieu, Pereira 15 Extended Authentication with ISAKMP/Oakley October 2001 [SKEY] N. Haller, "The S/KEY One-Time Password System", RFC1760 [TACACS] C. Finseth, "An Access Control Protocol, Sometimes Called TACACS", RFC1492 [TACACS+] D. Carrel, L. Grant, "The TACACS+ Protocol Version 1.77", draft-grant-tacacs-01.txt 12. Acknowledgments The authors would like to thank Tamir Zegmen, Moshe Litvin, Dan Harkins and all those from the IPsec community who have helped improve the XAUTH protocol. We would also like to thank Tim Jenkins, Ajai Puri, Laurie Shields, Andrew Krywaniuk, Gabriela Dinescu, Paul Kierstead and Scott Fanning for their continued support, and many sanity checks along the way. 13. Author's Addresses Stephane Beaulieu Cisco Systems Co. +1 (613) 721-3678 Roy Pereira Cisco Systems +1 (408) 526-6793 14. Expiration This draft expires April, 2002 Full Copyright Statement "Copyright (C) The Internet Society (date). All Rights Reserved. This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implmentation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into Beaulieu, Pereira 16 Extended Authentication with ISAKMP/Oakley October 2001 Beaulieu, Pereira 17 Extended Authentication with ISAKMP/Oakley October 2001 Appendix A This appendix gives more useful examples of Extended Authentication. SDI through RADIUS ================== The following 3 examples show examples of SDI running through RADIUS. Since the edge device does not necessarily know that we are indeed doing SDI, the edge device will typically send everything in terms of Username and Password. This of course results in the user being prompted with a password dialog when it isn't really a password which is required. This tends to be a little confusing, but it is really a limitation of RADIUS. NOTE: The edge device may choose to try and detect these situations and send better suited XAUTH attributes (such as XAUTH ANSWER or XAUTH NEXT PIN). The Client is typically protocol agnostic and will prompt the user for whatever attributes the edge device requests. Example A-1: ============ Secure ID Next PIN mode via RADIUS (Scenario 1 - SDI generated next pin) IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(Username = '', Password = '') REPLY(Username = 'joe', Password = '1637364856') --> <-- REQUEST(Username = '', Password = '', XAUTH_MESSAGE = 'The system has assigned you a new PIN of '1234', please re-enter your username and password') REPLY(Username = 'joe', Password = '1234764456') --> <-- SET(XAUTH_STATUS = OK) ACK(XAUTH_STATUS) --> Example A-2: ============ Secure ID Next PIN mode via RADIUS (Scenario 2 - User generated next pin) IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(Username = '', Password = '') REPLY(Username = 'joe', Password = '1637364856') --> <-- REQUEST(Username = '', Password = '', XAUTH_MESSAGE = 'Enter your new PIN containing 4-6 digits') REPLY(Username = 'joe', Password = '1234') --> Beaulieu, Pereira 18 Extended Authentication with ISAKMP/Oakley October 2001 <-- REQUEST(Username = '', Password = '') REPLY(Username = 'joe', Password = '1234764456') --> <-- SET(XAUTH_STATUS = OK) ACK(XAUTH_STATUS) --> Example A-3: ============ Secure ID Next PIN mode via RADIUS (Scenario 3 - RADIUS server offers choice of generating new PIN) IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(Username = '', Password = '') REPLY(Username = 'joe', Password = '1637364856') --> <-- REQUEST(Username = '', Password = '', XAUTH_MESSAGE = 'You must start using a new PIN. Would you like to generate your own PIN (y/n)?) REPLY(Username = 'joe', Password = 'y') --> <-- REQUEST(Username = '', Password = '', XAUTH MESSAGE = 'Enter your new PIN containing 4-6 digits') REPLY(Username = 'joe', Password = '1234') --> <-- REQUEST(Username = '', Password = '') REPLY(Username = 'joe', Password = '1234764456' <-- SET(XAUTH_STATUS = OK) ACK(XAUTH_STATUS) --> Native SDI ========== When doing native SDI between the edge device and the SDI server, the edge device has more information about what type of information is required from the user. The edge device can therefore use more intuitive attributes in certain situations as compared with the RADIUS examples above. Example A-4: ============ Secure ID Next PIN mode(Scenario 1 - SDI generated next pin) IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(Username = '', Passcode = '') REPLY(Username = 'joe', Passcode = '1637364856') --> <-- REQUEST(Username = '', Passcode = '', XAUTH_MESSAGE = 'The system has assigned you a Beaulieu, Pereira 19 Extended Authentication with ISAKMP/Oakley October 2001 new PIN of '1234', please re-enter your username and passcode') REPLY(Username = 'joe', Passcode = '1234764456') --> <-- SET(STATUS = OK) ACK(STATUS) --> Example A-5: ============ Secure ID Next PIN mode(Scenario 2 - User generated next pin) IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(Username = '', Passcode = '') REPLY(Username = 'joe', Passcode = '1637364856') --> <-- REQUEST(NEXT PIN = '', XAUTH_MESSAGE = 'Enter your new PIN containing 4-6 digits') REPLY(NEXT_PIN = '1234') --> <-- REQUEST(Username = '', Passcode = '') REPLY(Username = 'joe', Passcode = '1234764456') --> <-- SET(STATUS = OK) ACK(STATUS) --> Example A-6: ============ Secure ID Next PIN mode(Scenario 3 - SDI server offers choice of generating new PIN) IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(Username = '', Passcode = '') REPLY(Username = 'joe', Passcode = '1637364856') --> <-- REQUEST(ANSWER = '', XAUTH_MESSAGE = 'You must start using a new PIN. Would you like to generate your own PIN (y/n)?) REPLY(ANSWER = 'y') --> <-- REQUEST(NEXT_PIN = '', XAUTH MESSAGE = 'Enter your new PIN containing 4-6 digits') REPLY(NEXT PIN = '1234') --> <-- REQUEST(Username = '', Passcode = '') REPLY(Username = 'joe', Passcode = '1234764456' <-- SET(STATUS = OK) ACK(STATUS) --> Example A-7: ============ SDI next cardcode IPsec Client IPsec Gateway Beaulieu, Pereira 20 Extended Authentication with ISAKMP/Oakley October 2001 ------------ ------------- <-- REQUEST(Username = '', Passcode = '') REPLY(Username = 'joe', Passcode = '1637364856') --> <-- REQUEST(Username = '', Passcode = '', XAUTH_MESSAGE = 'Your token is out of sync with the server, please enter a new passcode.') REPLY(Username = 'joe', Passcode = '1637904324') --> <-- SET(STATUS = OK) ACK(STATUS) --> RADIUS Chap Challenge ===================== Example A-8: ============ IPsec Client IPsec Gateway ------------ ------------- <-- REQUEST(TYPE = RADIUS-CHAP, Username = '', Password = '', Challenge = 0x01020304050607080910111213141516) REPLY(TYPE = RADIUS-CHAP, Username = 'joe', Password = '0xaa11121314151617181920212223242526') --> <-- SET(STATUS = OK) ACK(STATUS) --> where the Challenge in the REQUEST is the random number generated by the edge device, and the Password in the reply contains the ID used to calculate the hash 'aa' concatenated with the hash of the (ID+secret+challenge). Beaulieu, Pereira 21 fiked-0.0.5+git20120331.1.e6a5109/doc/rfc2407.txt0000644000000000000000000020444611735550573014671 0ustar00 Network Working Group D. Piper Request for Comments: 2407 Network Alchemy Category: Standards Track November 1998 The Internet IP Security Domain of Interpretation for ISAKMP Status of this Memo This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited. Copyright Notice Copyright (C) The Internet Society (1998). All Rights Reserved. IESG Note Section 4.4.4.2 states, "All implememtations within the IPSEC DOI MUST support ESP_DES...". Recent work in the area of cryptanalysis suggests that DES may not be sufficiently strong for many applications. Therefore, it is very likely that the IETF will deprecate the use of ESP_DES as a mandatory cipher suite in the near future. It will remain as an optional use protocol. Although the IPsec working group and the IETF in general have not settled on an alternative algorithm (taking into account concerns of security and performance), implementers may want to heed the recommendations of section 4.4.4.3 on the use of ESP_3DES. 1. Abstract The Internet Security Association and Key Management Protocol (ISAKMP) defines a framework for security association management and cryptographic key establishment for the Internet. This framework consists of defined exchanges, payloads, and processing guidelines that occur within a given Domain of Interpretation (DOI). This document defines the Internet IP Security DOI (IPSEC DOI), which instantiates ISAKMP for use with IP when IP uses ISAKMP to negotiate security associations. For a list of changes since the previous version of the IPSEC DOI, please see Section 7. Piper Standards Track [Page 1] RFC 2407 IP Security Domain of Interpretation November 1998 2. Introduction Within ISAKMP, a Domain of Interpretation is used to group related protocols using ISAKMP to negotiate security associations. Security protocols sharing a DOI choose security protocol and cryptographic transforms from a common namespace and share key exchange protocol identifiers. They also share a common interpretation of DOI-specific payload data content, including the Security Association and Identification payloads. Overall, ISAKMP places the following requirements on a DOI definition: o define the naming scheme for DOI-specific protocol identifiers o define the interpretation for the Situation field o define the set of applicable security policies o define the syntax for DOI-specific SA Attributes (Phase II) o define the syntax for DOI-specific payload contents o define additional Key Exchange types, if needed o define additional Notification Message types, if needed The remainder of this document details the instantiation of these requirements for using the IP Security (IPSEC) protocols to provide authentication, integrity, and/or confidentiality for IP packets sent between cooperating host systems and/or firewalls. For a description of the overall IPSEC architecture, see [ARCH], [AH], and [ESP]. 3. Terms and Definitions The keywords MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL, when they appear in this document, are to be interpreted as described in [RFC 2119]. 4.1 IPSEC Naming Scheme Within ISAKMP, all DOI's must be registered with the IANA in the "Assigned Numbers" RFC [STD-2]. The IANA Assigned Number for the Internet IP Security DOI (IPSEC DOI) is one (1). Within the IPSEC DOI, all well-known identifiers MUST be registered with the IANA under the IPSEC DOI. Unless otherwise noted, all tables within this document refer to IANA Assigned Numbers for the IPSEC DOI. See Section 6 for further information relating to the IANA registry for the IPSEC DOI. All multi-octet binary values are stored in network byte order. Piper Standards Track [Page 2] RFC 2407 IP Security Domain of Interpretation November 1998 4.2 IPSEC Situation Definition Within ISAKMP, the Situation provides information that can be used by the responder to make a policy determination about how to process the incoming Security Association request. For the IPSEC DOI, the Situation field is a four (4) octet bitmask with the following values. Situation Value --------- ----- SIT_IDENTITY_ONLY 0x01 SIT_SECRECY 0x02 SIT_INTEGRITY 0x04 4.2.1 SIT_IDENTITY_ONLY The SIT_IDENTITY_ONLY type specifies that the security association will be identified by source identity information present in an associated Identification Payload. See Section 4.6.2 for a complete description of the various Identification types. All IPSEC DOI implementations MUST support SIT_IDENTITY_ONLY by including an Identification Payload in at least one of the Phase I Oakley exchanges ([IKE], Section 5) and MUST abort any association setup that does not include an Identification Payload. If an initiator supports neither SIT_SECRECY nor SIT_INTEGRITY, the situation consists only of the 4 octet situation bitmap and does not include the Labeled Domain Identifier field (Figure 1, Section 4.6.1) or any subsequent label information. Conversely, if the initiator supports either SIT_SECRECY or SIT_INTEGRITY, the Labeled Domain Identifier MUST be included in the situation payload. 4.2.2 SIT_SECRECY The SIT_SECRECY type specifies that the security association is being negotiated in an environment that requires labeled secrecy. If SIT_SECRECY is present in the Situation bitmap, the Situation field will be followed by variable-length data that includes a sensitivity level and compartment bitmask. See Section 4.6.1 for a complete description of the Security Association Payload format. If an initiator does not support SIT_SECRECY, SIT_SECRECY MUST NOT be set in the Situation bitmap and no secrecy level or category bitmaps shall be included. If a responder does not support SIT_SECRECY, a SITUATION-NOT- SUPPORTED Notification Payload SHOULD be returned and the security association setup MUST be aborted. Piper Standards Track [Page 3] RFC 2407 IP Security Domain of Interpretation November 1998 4.2.3 SIT_INTEGRITY The SIT_INTEGRITY type specifies that the security association is being negotiated in an environment that requires labeled integrity. If SIT_INTEGRITY is present in the Situation bitmap, the Situation field will be followed by variable-length data that includes an integrity level and compartment bitmask. If SIT_SECRECY is also in use for the association, the integrity information immediately follows the variable-length secrecy level and categories. See section 4.6.1 for a complete description of the Security Association Payload format. If an initiator does not support SIT_INTEGRITY, SIT_INTEGRITY MUST NOT be set in the Situation bitmap and no integrity level or category bitmaps shall be included. If a responder does not support SIT_INTEGRITY, a SITUATION-NOT- SUPPORTED Notification Payload SHOULD be returned and the security association setup MUST be aborted. 4.3 IPSEC Security Policy Requirements The IPSEC DOI does not impose specific security policy requirements on any implementation. Host system policy issues are outside of the scope of this document. However, the following sections touch on some of the issues that must be considered when designing an IPSEC DOI host implementation. This section should be considered only informational in nature. 4.3.1 Key Management Issues It is expected that many systems choosing to implement ISAKMP will strive to provide a protected domain of execution for a combined IKE key management daemon. On protected-mode multiuser operating systems, this key management daemon will likely exist as a separate privileged process. In such an environment, a formalized API to introduce keying material into the TCP/IP kernel may be desirable. The IP Security architecture does not place any requirements for structure or flow between a host TCP/IP kernel and its key management provider. Piper Standards Track [Page 4] RFC 2407 IP Security Domain of Interpretation November 1998 4.3.2 Static Keying Issues Host systems that implement static keys, either for use directly by IPSEC, or for authentication purposes (see [IKE] Section 5.4), should take steps to protect the static keying material when it is not residing in a protected memory domain or actively in use by the TCP/IP kernel. For example, on a laptop, one might choose to store the static keys in a configuration store that is, itself, encrypted under a private password. Depending on the operating system and utility software installed, it may not be possible to protect the static keys once they've been loaded into the TCP/IP kernel, however they should not be trivially recoverable on initial system startup without having to satisfy some additional form of authentication. 4.3.3 Host Policy Issues It is not realistic to assume that the transition to IPSEC will occur overnight. Host systems must be prepared to implement flexible policy lists that describe which systems they desire to speak securely with and which systems they require speak securely to them. Some notion of proxy firewall addresses may also be required. A minimal approach is probably a static list of IP addresses, network masks, and a security required flag or flags. A more flexible implementation might consist of a list of wildcard DNS names (e.g. '*.foo.bar'), an in/out bitmask, and an optional firewall address. The wildcard DNS name would be used to match incoming or outgoing IP addresses, the in/out bitmask would be used to determine whether or not security was to be applied and in which direction, and the optional firewall address would be used to indicate whether or not tunnel mode would be needed to talk to the target system though an intermediate firewall. 4.3.4 Certificate Management Host systems implementing a certificate-based authentication scheme will need a mechanism for obtaining and managing a database of certificates. Secure DNS is to be one certificate distribution mechanism, however the pervasive availability of secure DNS zones, in the short term, is doubtful for many reasons. What's far more likely is that hosts will Piper Standards Track [Page 5] RFC 2407 IP Security Domain of Interpretation November 1998 need an ability to import certificates that they acquire through secure, out-of-band mechanisms, as well as an ability to export their own certificates for use by other systems. However, manual certificate management should not be done so as to preclude the ability to introduce dynamic certificate discovery mechanisms and/or protocols as they become available. 4.4 IPSEC Assigned Numbers The following sections list the Assigned Numbers for the IPSEC DOI: Situation Identifiers, Protocol Identifiers, Transform Identifiers, AH, ESP, and IPCOMP Transform Identifiers, Security Association Attribute Type Values, Labeled Domain Identifiers, ID Payload Type Values, and Notify Message Type Values. 4.4.1 IPSEC Security Protocol Identifier The ISAKMP proposal syntax was specifically designed to allow for the simultaneous negotiation of multiple Phase II security protocol suites within a single negotiation. As a result, the protocol suites listed below form the set of protocols that can be negotiated at the same time. It is a host policy decision as to what protocol suites might be negotiated together. The following table lists the values for the Security Protocol Identifiers referenced in an ISAKMP Proposal Payload for the IPSEC DOI. Protocol ID Value ----------- ----- RESERVED 0 PROTO_ISAKMP 1 PROTO_IPSEC_AH 2 PROTO_IPSEC_ESP 3 PROTO_IPCOMP 4 4.4.1.1 PROTO_ISAKMP The PROTO_ISAKMP type specifies message protection required during Phase I of the ISAKMP protocol. The specific protection mechanism used for the IPSEC DOI is described in [IKE]. All implementations within the IPSEC DOI MUST support PROTO_ISAKMP. NB: ISAKMP reserves the value one (1) across all DOI definitions. Piper Standards Track [Page 6] RFC 2407 IP Security Domain of Interpretation November 1998 4.4.1.2 PROTO_IPSEC_AH The PROTO_IPSEC_AH type specifies IP packet authentication. The default AH transform provides data origin authentication, integrity protection, and replay detection. For export control considerations, confidentiality MUST NOT be provided by any PROTO_IPSEC_AH transform. 4.4.1.3 PROTO_IPSEC_ESP The PROTO_IPSEC_ESP type specifies IP packet confidentiality. Authentication, if required, must be provided as part of the ESP transform. The default ESP transform includes data origin authentication, integrity protection, replay detection, and confidentiality. 4.4.1.4 PROTO_IPCOMP The PROTO_IPCOMP type specifies IP payload compression as defined in [IPCOMP]. 4.4.2 IPSEC ISAKMP Transform Identifiers As part of an ISAKMP Phase I negotiation, the initiator's choice of Key Exchange offerings is made using some host system policy description. The actual selection of Key Exchange mechanism is made using the standard ISAKMP Proposal Payload. The following table lists the defined ISAKMP Phase I Transform Identifiers for the Proposal Payload for the IPSEC DOI. Transform Value --------- ----- RESERVED 0 KEY_IKE 1 Within the ISAKMP and IPSEC DOI framework it is possible to define key establishment protocols other than IKE (Oakley). Previous versions of this document defined types both for manual keying and for schemes based on use of a generic Key Distribution Center (KDC). These identifiers have been removed from the current document. The IPSEC DOI can still be extended later to include values for additional non-Oakley key establishment protocols for ISAKMP and IPSEC, such as Kerberos [RFC-1510] or the Group Key Management Protocol (GKMP) [RFC-2093]. Piper Standards Track [Page 7] RFC 2407 IP Security Domain of Interpretation November 1998 4.4.2.1 KEY_IKE The KEY_IKE type specifies the hybrid ISAKMP/Oakley Diffie-Hellman key exchange (IKE) as defined in the [IKE] document. All implementations within the IPSEC DOI MUST support KEY_IKE. 4.4.3 IPSEC AH Transform Identifiers The Authentication Header Protocol (AH) defines one mandatory and several optional transforms used to provide authentication, integrity, and replay detection. The following table lists the defined AH Transform Identifiers for the ISAKMP Proposal Payload for the IPSEC DOI. Note: the Authentication Algorithm attribute MUST be specified to identify the appropriate AH protection suite. For example, AH_MD5 can best be thought of as a generic AH transform using MD5. To request the HMAC construction with AH, one specifies the AH_MD5 transform ID along with the Authentication Algorithm attribute set to HMAC-MD5. This is shown using the "Auth(HMAC-MD5)" notation in the following sections. Transform ID Value ------------ ----- RESERVED 0-1 AH_MD5 2 AH_SHA 3 AH_DES 4 Note: all mandatory-to-implement algorithms are listed as "MUST" implement (e.g. AH_MD5) in the following sections. All other algorithms are optional and MAY be implemented in any particular implementation. 4.4.3.1 AH_MD5 The AH_MD5 type specifies a generic AH transform using MD5. The actual protection suite is determined in concert with an associated SA attribute list. A generic MD5 transform is currently undefined. All implementations within the IPSEC DOI MUST support AH_MD5 along with the Auth(HMAC-MD5) attribute. This suite is defined as the HMAC-MD5-96 transform described in [HMACMD5]. The AH_MD5 type along with the Auth(KPDK) attribute specifies the AH transform (Key/Pad/Data/Key) described in RFC-1826. Piper Standards Track [Page 8] RFC 2407 IP Security Domain of Interpretation November 1998 Use of AH_MD5 with any other Authentication Algorithm attribute value is currently undefined. 4.4.3.2 AH_SHA The AH_SHA type specifies a generic AH transform using SHA-1. The actual protection suite is determined in concert with an associated SA attribute list. A generic SHA transform is currently undefined. All implementations within the IPSEC DOI MUST support AH_SHA along with the Auth(HMAC-SHA) attribute. This suite is defined as the HMAC-SHA-1-96 transform described in [HMACSHA]. Use of AH_SHA with any other Authentication Algorithm attribute value is currently undefined. 4.4.3.3 AH_DES The AH_DES type specifies a generic AH transform using DES. The actual protection suite is determined in concert with an associated SA attribute list. A generic DES transform is currently undefined. The IPSEC DOI defines AH_DES along with the Auth(DES-MAC) attribute to be a DES-MAC transform. Implementations are not required to support this mode. Use of AH_DES with any other Authentication Algorithm attribute value is currently undefined. 4.4.4 IPSEC ESP Transform Identifiers The Encapsulating Security Payload (ESP) defines one mandatory and many optional transforms used to provide data confidentiality. The following table lists the defined ESP Transform Identifiers for the ISAKMP Proposal Payload for the IPSEC DOI. Note: when authentication, integrity protection, and replay detection are required, the Authentication Algorithm attribute MUST be specified to identify the appropriate ESP protection suite. For example, to request HMAC-MD5 authentication with 3DES, one specifies the ESP_3DES transform ID with the Authentication Algorithm attribute set to HMAC-MD5. For additional processing requirements, see Section 4.5 (Authentication Algorithm). Piper Standards Track [Page 9] RFC 2407 IP Security Domain of Interpretation November 1998 Transform ID Value ------------ ----- RESERVED 0 ESP_DES_IV64 1 ESP_DES 2 ESP_3DES 3 ESP_RC5 4 ESP_IDEA 5 ESP_CAST 6 ESP_BLOWFISH 7 ESP_3IDEA 8 ESP_DES_IV32 9 ESP_RC4 10 ESP_NULL 11 Note: all mandatory-to-implement algorithms are listed as "MUST" implement (e.g. ESP_DES) in the following sections. All other algorithms are optional and MAY be implemented in any particular implementation. 4.4.4.1 ESP_DES_IV64 The ESP_DES_IV64 type specifies the DES-CBC transform defined in RFC-1827 and RFC-1829 using a 64-bit IV. 4.4.4.2 ESP_DES The ESP_DES type specifies a generic DES transform using DES-CBC. The actual protection suite is determined in concert with an associated SA attribute list. A generic transform is currently undefined. All implementations within the IPSEC DOI MUST support ESP_DES along with the Auth(HMAC-MD5) attribute. This suite is defined as the [DES] transform, with authentication and integrity provided by HMAC MD5 [HMACMD5]. 4.4.4.3 ESP_3DES The ESP_3DES type specifies a generic triple-DES transform. The actual protection suite is determined in concert with an associated SA attribute list. The generic transform is currently undefined. All implementations within the IPSEC DOI are strongly encouraged to support ESP_3DES along with the Auth(HMAC-MD5) attribute. This suite is defined as the [ESPCBC] transform, with authentication and integrity provided by HMAC MD5 [HMACMD5]. Piper Standards Track [Page 10] RFC 2407 IP Security Domain of Interpretation November 1998 4.4.4.4 ESP_RC5 The ESP_RC5 type specifies the RC5 transform defined in [ESPCBC]. 4.4.4.5 ESP_IDEA The ESP_IDEA type specifies the IDEA transform defined in [ESPCBC]. 4.4.4.6 ESP_CAST The ESP_CAST type specifies the CAST transform defined in [ESPCBC]. 4.4.4.7 ESP_BLOWFISH The ESP_BLOWFISH type specifies the BLOWFISH transform defined in [ESPCBC]. 4.4.4.8 ESP_3IDEA The ESP_3IDEA type is reserved for triple-IDEA. 4.4.4.9 ESP_DES_IV32 The ESP_DES_IV32 type specifies the DES-CBC transform defined in RFC-1827 and RFC-1829 using a 32-bit IV. 4.4.4.10 ESP_RC4 The ESP_RC4 type is reserved for RC4. 4.4.4.11 ESP_NULL The ESP_NULL type specifies no confidentiality is to be provided by ESP. ESP_NULL is used when ESP is being used to tunnel packets which require only authentication, integrity protection, and replay detection. All implementations within the IPSEC DOI MUST support ESP_NULL. The ESP NULL transform is defined in [ESPNULL]. See the Authentication Algorithm attribute description in Section 4.5 for additional requirements relating to the use of ESP_NULL. 4.4.5 IPSEC IPCOMP Transform Identifiers The IP Compression (IPCOMP) transforms define optional compression algorithms that can be negotiated to provide for IP payload compression ([IPCOMP]). The following table lists the defined IPCOMP Transform Identifiers for the ISAKMP Proposal Payload within the Piper Standards Track [Page 11] RFC 2407 IP Security Domain of Interpretation November 1998 IPSEC DOI. Transform ID Value ------------ ----- RESERVED 0 IPCOMP_OUI 1 IPCOMP_DEFLATE 2 IPCOMP_LZS 3 4.4.5.1 IPCOMP_OUI The IPCOMP_OUI type specifies a proprietary compression transform. The IPCOMP_OUI type must be accompanied by an attribute which further identifies the specific vendor algorithm. 4.4.5.2 IPCOMP_DEFLATE The IPCOMP_DEFLATE type specifies the use of the "zlib" deflate algorithm as specified in [DEFLATE]. 4.4.5.3 IPCOMP_LZS The IPCOMP_LZS type specifies the use of the Stac Electronics LZS algorithm as specified in [LZS]. 4.5 IPSEC Security Association Attributes The following SA attribute definitions are used in Phase II of an IKE negotiation. Attribute types can be either Basic (B) or Variable- Length (V). Encoding of these attributes is defined in the base ISAKMP specification. Attributes described as basic MUST NOT be encoded as variable. Variable length attributes MAY be encoded as basic attributes if their value can fit into two octets. See [IKE] for further information on attribute encoding in the IPSEC DOI. All restrictions listed in [IKE] also apply to the IPSEC DOI. Piper Standards Track [Page 12] RFC 2407 IP Security Domain of Interpretation November 1998 Attribute Types class value type ------------------------------------------------- SA Life Type 1 B SA Life Duration 2 V Group Description 3 B Encapsulation Mode 4 B Authentication Algorithm 5 B Key Length 6 B Key Rounds 7 B Compress Dictionary Size 8 B Compress Private Algorithm 9 V Class Values SA Life Type SA Duration Specifies the time-to-live for the overall security association. When the SA expires, all keys negotiated under the association (AH or ESP) must be renegotiated. The life type values are: RESERVED 0 seconds 1 kilobytes 2 Values 3-61439 are reserved to IANA. Values 61440-65535 are for private use. For a given Life Type, the value of the Life Duration attribute defines the actual length of the component lifetime -- either a number of seconds, or a number of Kbytes that can be protected. If unspecified, the default value shall be assumed to be 28800 seconds (8 hours). An SA Life Duration attribute MUST always follow an SA Life Type which describes the units of duration. See Section 4.5.4 for additional information relating to lifetime notification. Group Description Specifies the Oakley Group to be used in a PFS QM negotiation. For a list of supported values, see Appendix A of [IKE]. Piper Standards Track [Page 13] RFC 2407 IP Security Domain of Interpretation November 1998 Encapsulation Mode RESERVED 0 Tunnel 1 Transport 2 Values 3-61439 are reserved to IANA. Values 61440-65535 are for private use. If unspecified, the default value shall be assumed to be unspecified (host-dependent). Authentication Algorithm RESERVED 0 HMAC-MD5 1 HMAC-SHA 2 DES-MAC 3 KPDK 4 Values 5-61439 are reserved to IANA. Values 61440-65535 are for private use. There is no default value for Auth Algorithm, as it must be specified to correctly identify the applicable AH or ESP transform, except in the following case. When negotiating ESP without authentication, the Auth Algorithm attribute MUST NOT be included in the proposal. When negotiating ESP without confidentiality, the Auth Algorithm attribute MUST be included in the proposal and the ESP transform ID must be ESP_NULL. Key Length RESERVED 0 There is no default value for Key Length, as it must be specified for transforms using ciphers with variable key lengths. For fixed length ciphers, the Key Length attribute MUST NOT be sent. Key Rounds RESERVED 0 There is no default value for Key Rounds, as it must be specified for transforms using ciphers with varying numbers of rounds. Piper Standards Track [Page 14] RFC 2407 IP Security Domain of Interpretation November 1998 Compression Dictionary Size RESERVED 0 Specifies the log2 maximum size of the dictionary. There is no default value for dictionary size. Compression Private Algorithm Specifies a private vendor compression algorithm. The first three (3) octets must be an IEEE assigned company_id (OUI). The next octet may be a vendor specific compression subtype, followed by zero or more octets of vendor data. 4.5.1 Required Attribute Support To ensure basic interoperability, all implementations MUST be prepared to negotiate all of the following attributes. SA Life Type SA Duration Auth Algorithm 4.5.2 Attribute Parsing Requirement (Lifetime) To allow for flexible semantics, the IPSEC DOI requires that a conforming ISAKMP implementation MUST correctly parse an attribute list that contains multiple instances of the same attribute class, so long as the different attribute entries do not conflict with one another. Currently, the only attributes which requires this treatment are Life Type and Duration. To see why this is important, the following example shows the binary encoding of a four entry attribute list that specifies an SA Lifetime of either 100MB or 24 hours. (See Section 3.3 of [ISAKMP] for a complete description of the attribute encoding format.) Attribute #1: 0x80010001 (AF = 1, type = SA Life Type, value = seconds) Attribute #2: 0x00020004 (AF = 0, type = SA Duration, length = 4 bytes) 0x00015180 (value = 0x15180 = 86400 seconds = 24 hours) Attribute #3: 0x80010002 (AF = 1, type = SA Life Type, value = KB) Piper Standards Track [Page 15] RFC 2407 IP Security Domain of Interpretation November 1998 Attribute #4: 0x00020004 (AF = 0, type = SA Duration, length = 4 bytes) 0x000186A0 (value = 0x186A0 = 100000KB = 100MB) If conflicting attributes are detected, an ATTRIBUTES-NOT-SUPPORTED Notification Payload SHOULD be returned and the security association setup MUST be aborted. 4.5.3 Attribute Negotiation If an implementation receives a defined IPSEC DOI attribute (or attribute value) which it does not support, an ATTRIBUTES-NOT-SUPPORT SHOULD be sent and the security association setup MUST be aborted, unless the attribute value is in the reserved range. If an implementation receives an attribute value in the reserved range, an implementation MAY chose to continue based on local policy. 4.5.4 Lifetime Notification When an initiator offers an SA lifetime greater than what the responder desires based on their local policy, the responder has three choices: 1) fail the negotiation entirely; 2) complete the negotiation but use a shorter lifetime than what was offered; 3) complete the negotiation and send an advisory notification to the initiator indicating the responder's true lifetime. The choice of what the responder actually does is implementation specific and/or based on local policy. To ensure interoperability in the latter case, the IPSEC DOI requires the following only when the responder wishes to notify the initiator: if the initiator offers an SA lifetime longer than the responder is willing to accept, the responder SHOULD include an ISAKMP Notification Payload in the exchange that includes the responder's IPSEC SA payload. Section 4.6.3.1 defines the payload layout for the RESPONDER-LIFETIME Notification Message type which MUST be used for this purpose. 4.6 IPSEC Payload Content The following sections describe those ISAKMP payloads whose data representations are dependent on the applicable DOI. 4.6.1 Security Association Payload The following diagram illustrates the content of the Security Association Payload for the IPSEC DOI. See Section 4.2 for a description of the Situation bitmap. Piper Standards Track [Page 16] RFC 2407 IP Security Domain of Interpretation November 1998 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Domain of Interpretation (IPSEC) | +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Situation (bitmap) ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Labeled Domain Identifier ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Secrecy Length (in octets) ! RESERVED ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Secrecy Level ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Secrecy Cat. Length (in bits) ! RESERVED ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Secrecy Category Bitmap ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Integrity Length (in octets) ! RESERVED ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Integrity Level ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Integ. Cat. Length (in bits) ! RESERVED ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Integrity Category Bitmap ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 1: Security Association Payload Format The Security Association Payload is defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, this field will be zero (0). o RESERVED (1 octet) - Unused, must be zero (0). o Payload Length (2 octets) - Length, in octets, of the current payload, including the generic header. o Domain of Interpretation (4 octets) - Specifies the IPSEC DOI, which has been assigned the value one (1). o Situation (4 octets) - Bitmask used to interpret the remainder of the Security Association Payload. See Section 4.2 for a complete list of values. Piper Standards Track [Page 17] RFC 2407 IP Security Domain of Interpretation November 1998 o Labeled Domain Identifier (4 octets) - IANA Assigned Number used to interpret the Secrecy and Integrity information. o Secrecy Length (2 octets) - Specifies the length, in octets, of the secrecy level identifier, excluding pad bits. o RESERVED (2 octets) - Unused, must be zero (0). o Secrecy Level (variable length) - Specifies the mandatory secrecy level required. The secrecy level MUST be padded with zero (0) to align on the next 32-bit boundary. o Secrecy Category Length (2 octets) - Specifies the length, in bits, of the secrecy category (compartment) bitmap, excluding pad bits. o RESERVED (2 octets) - Unused, must be zero (0). o Secrecy Category Bitmap (variable length) - A bitmap used to designate secrecy categories (compartments) that are required. The bitmap MUST be padded with zero (0) to align on the next 32-bit boundary. o Integrity Length (2 octets) - Specifies the length, in octets, of the integrity level identifier, excluding pad bits. o RESERVED (2 octets) - Unused, must be zero (0). o Integrity Level (variable length) - Specifies the mandatory integrity level required. The integrity level MUST be padded with zero (0) to align on the next 32-bit boundary. o Integrity Category Length (2 octets) - Specifies the length, in bits, of the integrity category (compartment) bitmap, excluding pad bits. o RESERVED (2 octets) - Unused, must be zero (0). o Integrity Category Bitmap (variable length) - A bitmap used to designate integrity categories (compartments) that are required. The bitmap MUST be padded with zero (0) to align on the next 32-bit boundary. 4.6.1.1 IPSEC Labeled Domain Identifiers The following table lists the assigned values for the Labeled Domain Identifier field contained in the Situation field of the Security Association Payload. Piper Standards Track [Page 18] RFC 2407 IP Security Domain of Interpretation November 1998 Domain Value ------- ----- RESERVED 0 4.6.2 Identification Payload Content The Identification Payload is used to identify the initiator of the Security Association. The identity of the initiator SHOULD be used by the responder to determine the correct host system security policy requirement for the association. For example, a host might choose to require authentication and integrity without confidentiality (AH) from a certain set of IP addresses and full authentication with confidentiality (ESP) from another range of IP addresses. The Identification Payload provides information that can be used by the responder to make this decision. During Phase I negotiations, the ID port and protocol fields MUST be set to zero or to UDP port 500. If an implementation receives any other values, this MUST be treated as an error and the security association setup MUST be aborted. This event SHOULD be auditable. The following diagram illustrates the content of the Identification Payload. 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ID Type ! Protocol ID ! Port ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Identification Data ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 2: Identification Payload Format The Identification Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, this field will be zero (0). o RESERVED (1 octet) - Unused, must be zero (0). o Payload Length (2 octets) - Length, in octets, of the identification data, including the generic header. o Identification Type (1 octet) - Value describing the identity information found in the Identification Data field. Piper Standards Track [Page 19] RFC 2407 IP Security Domain of Interpretation November 1998 o Protocol ID (1 octet) - Value specifying an associated IP protocol ID (e.g. UDP/TCP). A value of zero means that the Protocol ID field should be ignored. o Port (2 octets) - Value specifying an associated port. A value of zero means that the Port field should be ignored. o Identification Data (variable length) - Value, as indicated by the Identification Type. 4.6.2.1 Identification Type Values The following table lists the assigned values for the Identification Type field found in the Identification Payload. ID Type Value ------- ----- RESERVED 0 ID_IPV4_ADDR 1 ID_FQDN 2 ID_USER_FQDN 3 ID_IPV4_ADDR_SUBNET 4 ID_IPV6_ADDR 5 ID_IPV6_ADDR_SUBNET 6 ID_IPV4_ADDR_RANGE 7 ID_IPV6_ADDR_RANGE 8 ID_DER_ASN1_DN 9 ID_DER_ASN1_GN 10 ID_KEY_ID 11 For types where the ID entity is variable length, the size of the ID entity is computed from size in the ID payload header. When an IKE exchange is authenticated using certificates (of any format), any ID's used for input to local policy decisions SHOULD be contained in the certificate used in the authentication of the exchange. 4.6.2.2 ID_IPV4_ADDR The ID_IPV4_ADDR type specifies a single four (4) octet IPv4 address. 4.6.2.3 ID_FQDN The ID_FQDN type specifies a fully-qualified domain name string. An example of a ID_FQDN is, "foo.bar.com". The string should not contain any terminators. Piper Standards Track [Page 20] RFC 2407 IP Security Domain of Interpretation November 1998 4.6.2.4 ID_USER_FQDN The ID_USER_FQDN type specifies a fully-qualified username string, An example of a ID_USER_FQDN is, "piper@foo.bar.com". The string should not contain any terminators. 4.6.2.5 ID_IPV4_ADDR_SUBNET The ID_IPV4_ADDR_SUBNET type specifies a range of IPv4 addresses, represented by two four (4) octet values. The first value is an IPv4 address. The second is an IPv4 network mask. Note that ones (1s) in the network mask indicate that the corresponding bit in the address is fixed, while zeros (0s) indicate a "wildcard" bit. 4.6.2.6 ID_IPV6_ADDR The ID_IPV6_ADDR type specifies a single sixteen (16) octet IPv6 address. 4.6.2.7 ID_IPV6_ADDR_SUBNET The ID_IPV6_ADDR_SUBNET type specifies a range of IPv6 addresses, represented by two sixteen (16) octet values. The first value is an IPv6 address. The second is an IPv6 network mask. Note that ones (1s) in the network mask indicate that the corresponding bit in the address is fixed, while zeros (0s) indicate a "wildcard" bit. 4.6.2.8 ID_IPV4_ADDR_RANGE The ID_IPV4_ADDR_RANGE type specifies a range of IPv4 addresses, represented by two four (4) octet values. The first value is the beginning IPv4 address (inclusive) and the second value is the ending IPv4 address (inclusive). All addresses falling between the two specified addresses are considered to be within the list. 4.6.2.9 ID_IPV6_ADDR_RANGE The ID_IPV6_ADDR_RANGE type specifies a range of IPv6 addresses, represented by two sixteen (16) octet values. The first value is the beginning IPv6 address (inclusive) and the second value is the ending IPv6 address (inclusive). All addresses falling between the two specified addresses are considered to be within the list. 4.6.2.10 ID_DER_ASN1_DN The ID_DER_ASN1_DN type specifies the binary DER encoding of an ASN.1 X.500 Distinguished Name [X.501] of the principal whose certificates are being exchanged to establish the SA. Piper Standards Track [Page 21] RFC 2407 IP Security Domain of Interpretation November 1998 4.6.2.11 ID_DER_ASN1_GN The ID_DER_ASN1_GN type specifies the binary DER encoding of an ASN.1 X.500 GeneralName [X.509] of the principal whose certificates are being exchanged to establish the SA. 4.6.2.12 ID_KEY_ID The ID_KEY_ID type specifies an opaque byte stream which may be used to pass vendor-specific information necessary to identify which pre- shared key should be used to authenticate Aggressive mode negotiations. 4.6.3 IPSEC Notify Message Types ISAKMP defines two blocks of Notify Message codes, one for errors and one for status messages. ISAKMP also allocates a portion of each block for private use within a DOI. The IPSEC DOI defines the following private message types for its own use. Notify Messages - Error Types Value ----------------------------- ----- RESERVED 8192 Notify Messages - Status Types Value ------------------------------ ----- RESPONDER-LIFETIME 24576 REPLAY-STATUS 24577 INITIAL-CONTACT 24578 Notification Status Messages MUST be sent under the protection of an ISAKMP SA: either as a payload in the last Main Mode exchange; in a separate Informational Exchange after Main Mode or Aggressive Mode processing is complete; or as a payload in any Quick Mode exchange. These messages MUST NOT be sent in Aggressive Mode exchange, since Aggressive Mode does not provide the necessary protection to bind the Notify Status Message to the exchange. Nota Bene: a Notify payload is fully protected only in Quick Mode, where the entire payload is included in the HASH(n) digest. In Main Mode, while the notify payload is encrypted, it is not currently included in the HASH(n) digests. As a result, an active substitution attack on the Main Mode ciphertext could cause the notify status message type to be corrupted. (This is true, in general, for the last message of any Main Mode exchange.) While the risk is small, a corrupt notify message might cause the receiver to abort the entire negotiation thinking that the sender encountered a fatal error. Piper Standards Track [Page 22] RFC 2407 IP Security Domain of Interpretation November 1998 Implementation Note: the ISAKMP protocol does not guarantee delivery of Notification Status messages when sent in an ISAKMP Informational Exchange. To ensure receipt of any particular message, the sender SHOULD include a Notification Payload in a defined Main Mode or Quick Mode exchange which is protected by a retransmission timer. 4.6.3.1 RESPONDER-LIFETIME The RESPONDER-LIFETIME status message may be used to communicate the IPSEC SA lifetime chosen by the responder. When present, the Notification Payload MUST have the following format: o Payload Length - set to length of payload + size of data (var) o DOI - set to IPSEC DOI (1) o Protocol ID - set to selected Protocol ID from chosen SA o SPI Size - set to either sixteen (16) (two eight-octet ISAKMP cookies) or four (4) (one IPSEC SPI) o Notify Message Type - set to RESPONDER-LIFETIME (Section 4.6.3) o SPI - set to the two ISAKMP cookies or to the sender's inbound IPSEC SPI o Notification Data - contains an ISAKMP attribute list with the responder's actual SA lifetime(s) Implementation Note: saying that the Notification Data field contains an attribute list is equivalent to saying that the Notification Data field has zero length and the Notification Payload has an associated attribute list. 4.6.3.2 REPLAY-STATUS The REPLAY-STATUS status message may be used for positive confirmation of the responder's election on whether or not he is to perform anti-replay detection. When present, the Notification Payload MUST have the following format: o Payload Length - set to length of payload + size of data (4) o DOI - set to IPSEC DOI (1) o Protocol ID - set to selected Protocol ID from chosen SA o SPI Size - set to either sixteen (16) (two eight-octet ISAKMP cookies) or four (4) (one IPSEC SPI) o Notify Message Type - set to REPLAY-STATUS o SPI - set to the two ISAKMP cookies or to the sender's inbound IPSEC SPI o Notification Data - a 4 octet value: Piper Standards Track [Page 23] RFC 2407 IP Security Domain of Interpretation November 1998 0 = replay detection disabled 1 = replay detection enabled 4.6.3.3 INITIAL-CONTACT The INITIAL-CONTACT status message may be used when one side wishes to inform the other that this is the first SA being established with the remote system. The receiver of this Notification Message might then elect to delete any existing SA's it has for the sending system under the assumption that the sending system has rebooted and no longer has access to the original SA's and their associated keying material. When used, the content of the Notification Data field SHOULD be null (i.e. the Payload Length should be set to the fixed length of Notification Payload). When present, the Notification Payload MUST have the following format: o Payload Length - set to length of payload + size of data (0) o DOI - set to IPSEC DOI (1) o Protocol ID - set to selected Protocol ID from chosen SA o SPI Size - set to sixteen (16) (two eight-octet ISAKMP cookies) o Notify Message Type - set to INITIAL-CONTACT o SPI - set to the two ISAKMP cookies o Notification Data - 4.7 IPSEC Key Exchange Requirements The IPSEC DOI introduces no additional Key Exchange types. 5. Security Considerations This entire memo pertains to the Internet Key Exchange protocol ([IKE]), which combines ISAKMP ([ISAKMP]) and Oakley ([OAKLEY]) to provide for the derivation of cryptographic keying material in a secure and authenticated manner. Specific discussion of the various security protocols and transforms identified in this document can be found in the associated base documents and in the cipher references. 6. IANA Considerations This document contains many "magic" numbers to be maintained by the IANA. This section explains the criteria to be used by the IANA to assign additional numbers in each of these lists. All values not explicitly defined in previous sections are reserved to IANA. Piper Standards Track [Page 24] RFC 2407 IP Security Domain of Interpretation November 1998 6.1 IPSEC Situation Definition The Situation Definition is a 32-bit bitmask which represents the environment under which the IPSEC SA proposal and negotiation is carried out. Requests for assignments of new situations must be accompanied by an RFC which describes the interpretation for the associated bit. If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. The upper two bits are reserved for private use amongst cooperating systems. 6.2 IPSEC Security Protocol Identifiers The Security Protocol Identifier is an 8-bit value which identifies a security protocol suite being negotiated. Requests for assignments of new security protocol identifiers must be accompanied by an RFC which describes the requested security protocol. [AH] and [ESP] are examples of security protocol documents. If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. The values 249-255 are reserved for private use amongst cooperating systems. 6.3 IPSEC ISAKMP Transform Identifiers The IPSEC ISAKMP Transform Identifier is an 8-bit value which identifies a key exchange protocol to be used for the negotiation. Requests for assignments of new ISAKMP transform identifiers must be accompanied by an RFC which describes the requested key exchange protocol. [IKE] is an example of one such document. If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. The values 249-255 are reserved for private use amongst cooperating systems. Piper Standards Track [Page 25] RFC 2407 IP Security Domain of Interpretation November 1998 6.4 IPSEC AH Transform Identifiers The IPSEC AH Transform Identifier is an 8-bit value which identifies a particular algorithm to be used to provide integrity protection for AH. Requests for assignments of new AH transform identifiers must be accompanied by an RFC which describes how to use the algorithm within the AH framework ([AH]). If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. The values 249-255 are reserved for private use amongst cooperating systems. 6.5 IPSEC ESP Transform Identifiers The IPSEC ESP Transform Identifier is an 8-bit value which identifies a particular algorithm to be used to provide secrecy protection for ESP. Requests for assignments of new ESP transform identifiers must be accompanied by an RFC which describes how to use the algorithm within the ESP framework ([ESP]). If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. The values 249-255 are reserved for private use amongst cooperating systems. 6.6 IPSEC IPCOMP Transform Identifiers The IPSEC IPCOMP Transform Identifier is an 8-bit value which identifier a particular algorithm to be used to provide IP-level compression before ESP. Requests for assignments of new IPCOMP transform identifiers must be accompanied by an RFC which describes how to use the algorithm within the IPCOMP framework ([IPCOMP]). In addition, the requested algorithm must be published and in the public domain. If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. Piper Standards Track [Page 26] RFC 2407 IP Security Domain of Interpretation November 1998 The values 1-47 are reserved for algorithms for which an RFC has been approved for publication. The values 48-63 are reserved for private use amongst cooperating systems. The values 64-255 are reserved for future expansion. 6.7 IPSEC Security Association Attributes The IPSEC Security Association Attribute consists of a 16-bit type and its associated value. IPSEC SA attributes are used to pass miscellaneous values between ISAKMP peers. Requests for assignments of new IPSEC SA attributes must be accompanied by an Internet Draft which describes the attribute encoding (Basic/Variable-Length) and its legal values. Section 4.5 of this document provides an example of such a description. The values 32001-32767 are reserved for private use amongst cooperating systems. 6.8 IPSEC Labeled Domain Identifiers The IPSEC Labeled Domain Identifier is a 32-bit value which identifies a namespace in which the Secrecy and Integrity levels and categories values are said to exist. Requests for assignments of new IPSEC Labeled Domain Identifiers should be granted on demand. No accompanying documentation is required, though Internet Drafts are encouraged when appropriate. The values 0x80000000-0xffffffff are reserved for private use amongst cooperating systems. 6.9 IPSEC Identification Type The IPSEC Identification Type is an 8-bit value which is used as a discriminant for interpretation of the variable-length Identification Payload. Requests for assignments of new IPSEC Identification Types must be accompanied by an RFC which describes how to use the identification type within IPSEC. If the RFC is not on the standards-track (i.e., it is an informational or experimental RFC), it must be explicitly reviewed and approved by the IESG before the RFC is published and the transform identifier is assigned. The values 249-255 are reserved for private use amongst cooperating systems. Piper Standards Track [Page 27] RFC 2407 IP Security Domain of Interpretation November 1998 6.10 IPSEC Notify Message Types The IPSEC Notify Message Type is a 16-bit value taken from the range of values reserved by ISAKMP for each DOI. There is one range for error messages (8192-16383) and a different range for status messages (24576-32767). Requests for assignments of new Notify Message Types must be accompanied by an Internet Draft which describes how to use the identification type within IPSEC. The values 16001-16383 and the values 32001-32767 are reserved for private use amongst cooperating systems. 7. Change Log 7.1 Changes from V9 o add explicit reference to [IPCOMP], [DEFLATE], and [LZS] o allow RESPONDER-LIFETIME and REPLAY-STATUS to be directed at an IPSEC SPI in addition to the ISAKMP "SPI" o added padding exclusion to Secrecy and Integrity Length text o added forward reference to Section 4.5 in Section 4.4.4 o update document references 7.2 Changes from V8 o update IPCOMP identifier range to better reflect IPCOMP draft o update IANA considerations per Jeff/Ted's suggested text o eliminate references to DES-MAC ID ([DESMAC]) o correct bug in Notify section; ISAKMP Notify values are 16-bits 7.3 Changes from V7 o corrected name of IPCOMP (IP Payload Compression) o corrected references to [ESPCBC] o added missing Secrecy Level and Integrity Level to Figure 1 o removed ID references to PF_KEY and ARCFOUR o updated Basic/Variable text to align with [IKE] o updated document references and add intro pointer to [ARCH] o updated Notification requirements; remove aggressive reference o added clarification about protection for Notify payloads o restored RESERVED to ESP transform ID namespace; moved ESP_NULL o added requirement for ESP_NULL support and [ESPNULL] reference o added clarification on Auth Alg use with AH/ESP o added restriction against using conflicting AH/Auth combinations 7.4 Changes from V6 The following changes were made relative to the IPSEC DOI V6: Piper Standards Track [Page 28] RFC 2407 IP Security Domain of Interpretation November 1998 o added IANA Considerations section o moved most IANA numbers to IANA Considerations section o added prohibition on sending (V) encoding for (B) attributes o added prohibition on sending Key Length attribute for fixed length ciphers (e.g. DES) o replaced references to ISAKMP/Oakley with IKE o renamed ESP_ARCFOUR to ESP_RC4 o updated Security Considerations section o updated document references 7.5 Changes from V5 The following changes were made relative to the IPSEC DOI V5: o changed SPI size in Lifetime Notification text o changed REPLAY-ENABLED to REPLAY-STATUS o moved RESPONDER-LIFETIME payload definition from Section 4.5.4 to Section 4.6.3.1 o added explicit payload layout for 4.6.3.3 o added Implementation Note to Section 4.6.3 introduction o changed AH_SHA text to require SHA-1 in addition to MD5 o updated document references 7.6 Changes from V4 The following changes were made relative to the IPSEC DOI V4: o moved compatibility AH KPDK authentication method from AH transform ID to Authentication Algorithm identifier o added REPLAY-ENABLED notification message type per Architecture o added INITIAL-CONTACT notification message type per list o added text to ensure protection for Notify Status messages o added Lifetime qualification to attribute parsing section o added clarification that Lifetime notification is optional o removed private Group Description list (now points at [IKE]) o replaced Terminology with pointer to RFC-2119 o updated HMAC MD5 and SHA-1 ID references o updated Section 1 (Abstract) o updated Section 4.4 (IPSEC Assigned Numbers) o added restriction for ID port/protocol values for Phase I 7.7 Changes from V3 to V4 The following changes were made relative to the IPSEC DOI V3, that was posted to the IPSEC mailing list prior to the Munich IETF: o added ESP transform identifiers for NULL and ARCFOUR Piper Standards Track [Page 29] RFC 2407 IP Security Domain of Interpretation November 1998 o renamed HMAC Algorithm to Auth Algorithm to accommodate DES-MAC and optional authentication/integrity for ESP o added AH and ESP DES-MAC algorithm identifiers o removed KEY_MANUAL and KEY_KDC identifier definitions o added lifetime duration MUST follow lifetype attribute to SA Life Type and SA Life Duration attribute definition o added lifetime notification and IPSEC DOI message type table o added optional authentication and confidentiality restrictions to MAC Algorithm attribute definition o corrected attribute parsing example (used obsolete attribute) o corrected several Internet Draft document references o added ID_KEY_ID per ipsec list discussion (18-Mar-97) o removed Group Description default for PFS QM ([IKE] MUST) Acknowledgments This document is derived, in part, from previous works by Douglas Maughan, Mark Schertler, Mark Schneider, Jeff Turner, Dan Harkins, and Dave Carrel. Matt Thomas, Roy Pereira, Greg Carter, and Ran Atkinson also contributed suggestions and, in many cases, text. References [AH] Kent, S., and R. Atkinson, "IP Authentication Header", RFC 2402, November 1998. [ARCH] Kent, S., and R. Atkinson, "Security Architecture for the Internet Protocol", RFC 2401, November 1998. [DEFLATE] Pereira, R., "IP Payload Compression Using DEFLATE", RFC 2394, August 1998. [ESP] Kent, S., and R. Atkinson, "IP Encapsulating Security Payload (ESP)", RFC 2406, November 1998. [ESPCBC] Pereira, R., and R. Adams, "The ESP CBC-Mode Cipher Algorithms", RFC 2451, November 1998. [ESPNULL] Glenn, R., and S. Kent, "The NULL Encryption Algorithm and Its Use With IPsec", RFC 2410, November 1998. [DES] Madson, C., and N. Doraswamy, "The ESP DES-CBC Cipher Algorithm With Explicit IV", RFC 2405, November 1998. [HMACMD5] Madson, C., and R. Glenn, "The Use of HMAC-MD5 within ESP and AH", RFC 2403, November 1998. Piper Standards Track [Page 30] RFC 2407 IP Security Domain of Interpretation November 1998 [HMACSHA] Madson, C., and R. Glenn, "The Use of HMAC-SHA-1-96 within ESP and AH", RFC 2404, November 1998. [IKE] Harkins, D., and D. Carrel, D., "The Internet Key Exchange (IKE)", RFC 2409, November 1998. [IPCOMP] Shacham, A., Monsour, R., Pereira, R., and M. Thomas, "IP Payload Compression Protocol (IPComp)", RFC 2393, August 1998. [ISAKMP] Maughan, D., Schertler, M., Schneider, M., and J. Turner, "Internet Security Association and Key Management Protocol (ISAKMP)", RFC 2408, November 1998. [LZS] Friend, R., and R. Monsour, "IP Payload Compression Using LZS", RFC 2395, August 1998. [OAKLEY] Orman, H., "The OAKLEY Key Determination Protocol", RFC 2412, November 1998. [X.501] ISO/IEC 9594-2, "Information Technology - Open Systems Interconnection - The Directory: Models", CCITT/ITU Recommendation X.501, 1993. [X.509] ISO/IEC 9594-8, "Information Technology - Open Systems Interconnection - The Directory: Authentication Framework", CCITT/ITU Recommendation X.509, 1993. Author's Address Derrell Piper Network Alchemy 1521.5 Pacific Ave Santa Cruz, California, 95060 United States of America Phone: +1 408 460-3822 EMail: ddp@network-alchemy.com Piper Standards Track [Page 31] RFC 2407 IP Security Domain of Interpretation November 1998 Full Copyright Statement Copyright (C) The Internet Society (1998). All Rights Reserved. This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English. The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns. This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Piper Standards Track [Page 32] fiked-0.0.5+git20120331.1.e6a5109/doc/rfc2408.txt0000644000000000000000000063045211735550573014672 0ustar00 Network Working Group D. Maughan Request for Comments: 2408 National Security Agency Category: Standards Track M. Schertler Securify, Inc. M. Schneider National Security Agency J. Turner RABA Technologies, Inc. November 1998 Internet Security Association and Key Management Protocol (ISAKMP) Status of this Memo This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited. Copyright Notice Copyright (C) The Internet Society (1998). All Rights Reserved. Abstract This memo describes a protocol utilizing security concepts necessary for establishing Security Associations (SA) and cryptographic keys in an Internet environment. A Security Association protocol that negotiates, establishes, modifies and deletes Security Associations and their attributes is required for an evolving Internet, where there will be numerous security mechanisms and several options for each security mechanism. The key management protocol must be robust in order to handle public key generation for the Internet community at large and private key requirements for those private networks with that requirement. The Internet Security Association and Key Management Protocol (ISAKMP) defines the procedures for authenticating a communicating peer, creation and management of Security Associations, key generation techniques, and threat mitigation (e.g. denial of service and replay attacks). All of these are necessary to establish and maintain secure communications (via IP Security Service or any other security protocol) in an Internet environment. Maughan, et. al. Standards Track [Page 1] RFC 2408 ISAKMP November 1998 Table of Contents 1 Introduction 4 1.1 Requirements Terminology . . . . . . . . . . . . . . . . . 5 1.2 The Need for Negotiation . . . . . . . . . . . . . . . . . 5 1.3 What can be Negotiated? . . . . . . . . . . . . . . . . . 6 1.4 Security Associations and Management . . . . . . . . . . . 7 1.4.1 Security Associations and Registration . . . . . . . . 7 1.4.2 ISAKMP Requirements . . . . . . . . . . . . . . . . . 8 1.5 Authentication . . . . . . . . . . . . . . . . . . . . . . 8 1.5.1 Certificate Authorities . . . . . . . . . . . . . . . 9 1.5.2 Entity Naming . . . . . . . . . . . . . . . . . . . . 9 1.5.3 ISAKMP Requirements . . . . . . . . . . . . . . . . . 10 1.6 Public Key Cryptography . . . . . . . . . . . . . . . . . . 10 1.6.1 Key Exchange Properties . . . . . . . . . . . . . . . 11 1.6.2 ISAKMP Requirements . . . . . . . . . . . . . . . . . 12 1.7 ISAKMP Protection . . . . . . . . . . . . . . . . . . . . . 12 1.7.1 Anti-Clogging (Denial of Service) . . . . . . . . . . 12 1.7.2 Connection Hijacking . . . . . . . . . . . . . . . . . 13 1.7.3 Man-in-the-Middle Attacks . . . . . . . . . . . . . . 13 1.8 Multicast Communications . . . . . . . . . . . . . . . . . 13 2 Terminology and Concepts 14 2.1 ISAKMP Terminology . . . . . . . . . . . . . . . . . . . . 14 2.2 ISAKMP Placement . . . . . . . . . . . . . . . . . . . . . 16 2.3 Negotiation Phases . . . . . . . . . . . . . . . . . . . . 16 2.4 Identifying Security Associations . . . . . . . . . . . . . 17 2.5 Miscellaneous . . . . . . . . . . . . . . . . . . . . . . . 20 2.5.1 Transport Protocol . . . . . . . . . . . . . . . . . . 20 2.5.2 RESERVED Fields . . . . . . . . . . . . . . . . . . . 20 2.5.3 Anti-Clogging Token ("Cookie") Creation . . . . . . . 20 3 ISAKMP Payloads 21 3.1 ISAKMP Header Format . . . . . . . . . . . . . . . . . . . 21 3.2 Generic Payload Header . . . . . . . . . . . . . . . . . . 25 3.3 Data Attributes . . . . . . . . . . . . . . . . . . . . . . 25 3.4 Security Association Payload . . . . . . . . . . . . . . . 27 3.5 Proposal Payload . . . . . . . . . . . . . . . . . . . . . 28 3.6 Transform Payload . . . . . . . . . . . . . . . . . . . . . 29 3.7 Key Exchange Payload . . . . . . . . . . . . . . . . . . . 31 3.8 Identification Payload . . . . . . . . . . . . . . . . . . 32 3.9 Certificate Payload . . . . . . . . . . . . . . . . . . . . 33 3.10 Certificate Request Payload . . . . . . . . . . . . . . . 34 3.11 Hash Payload . . . . . . . . . . . . . . . . . . . . . . 36 3.12 Signature Payload . . . . . . . . . . . . . . . . . . . . 37 3.13 Nonce Payload . . . . . . . . . . . . . . . . . . . . . . 37 3.14 Notification Payload . . . . . . . . . . . . . . . . . . 38 3.14.1 Notify Message Types . . . . . . . . . . . . . . . . 40 3.15 Delete Payload . . . . . . . . . . . . . . . . . . . . . 41 3.16 Vendor ID Payload . . . . . . . . . . . . . . . . . . . . 43 Maughan, et. al. Standards Track [Page 2] RFC 2408 ISAKMP November 1998 4 ISAKMP Exchanges 44 4.1 ISAKMP Exchange Types . . . . . . . . . . . . . . . . . . . 45 4.1.1 Notation . . . . . . . . . . . . . . . . . . . . . . . 46 4.2 Security Association Establishment . . . . . . . . . . . . 46 4.2.1 Security Association Establishment Examples . . . . . 48 4.3 Security Association Modification . . . . . . . . . . . . . 50 4.4 Base Exchange . . . . . . . . . . . . . . . . . . . . . . . 51 4.5 Identity Protection Exchange . . . . . . . . . . . . . . . 52 4.6 Authentication Only Exchange . . . . . . . . . . . . . . . 54 4.7 Aggressive Exchange . . . . . . . . . . . . . . . . . . . . 55 4.8 Informational Exchange . . . . . . . . . . . . . . . . . . 57 5 ISAKMP Payload Processing 58 5.1 General Message Processing . . . . . . . . . . . . . . . . 58 5.2 ISAKMP Header Processing . . . . . . . . . . . . . . . . . 59 5.3 Generic Payload Header Processing . . . . . . . . . . . . . 61 5.4 Security Association Payload Processing . . . . . . . . . . 62 5.5 Proposal Payload Processing . . . . . . . . . . . . . . . . 63 5.6 Transform Payload Processing . . . . . . . . . . . . . . . 64 5.7 Key Exchange Payload Processing . . . . . . . . . . . . . . 65 5.8 Identification Payload Processing . . . . . . . . . . . . . 66 5.9 Certificate Payload Processing . . . . . . . . . . . . . . 66 5.10 Certificate Request Payload Processing . . . . . . . . . 67 5.11 Hash Payload Processing . . . . . . . . . . . . . . . . . 69 5.12 Signature Payload Processing . . . . . . . . . . . . . . 69 5.13 Nonce Payload Processing . . . . . . . . . . . . . . . . 70 5.14 Notification Payload Processing . . . . . . . . . . . . . 71 5.15 Delete Payload Processing . . . . . . . . . . . . . . . . 73 6 Conclusions 75 A ISAKMP Security Association Attributes 77 A.1 Background/Rationale . . . . . . . . . . . . . . . . . . . 77 A.2 Internet IP Security DOI Assigned Value . . . . . . . . . . 77 A.3 Supported Security Protocols . . . . . . . . . . . . . . . 77 A.4 ISAKMP Identification Type Values . . . . . . . . . . . . . 78 A.4.1 ID_IPV4_ADDR . . . . . . . . . . . . . . . . . . . . . 78 A.4.2 ID_IPV4_ADDR_SUBNET . . . . . . . . . . . . . . . . . . 78 A.4.3 ID_IPV6_ADDR . . . . . . . . . . . . . . . . . . . . . 78 A.4.4 ID_IPV6_ADDR_SUBNET . . . . . . . . . . . . . . . . . 78 B Defining a new Domain of Interpretation 79 B.1 Situation . . . . . . . . . . . . . . . . . . . . . . . . . 79 B.2 Security Policies . . . . . . . . . . . . . . . . . . . . . 80 B.3 Naming Schemes . . . . . . . . . . . . . . . . . . . . . . 80 B.4 Syntax for Specifying Security Services . . . . . . . . . . 80 B.5 Payload Specification . . . . . . . . . . . . . . . . . . . 80 B.6 Defining new Exchange Types . . . . . . . . . . . . . . . . 80 Security Considerations 81 IANA Considerations 81 Domain of Interpretation 81 Supported Security Protocols 82 Maughan, et. al. Standards Track [Page 3] RFC 2408 ISAKMP November 1998 Acknowledgements 82 References 82 Authors' Addresses 85 Full Copyright Statement 86 List of Figures 1 ISAKMP Relationships . . . . . . . . . . . . . . . . . . . 16 2 ISAKMP Header Format . . . . . . . . . . . . . . . . . . . 22 3 Generic Payload Header . . . . . . . . . . . . . . . . . . 25 4 Data Attributes . . . . . . . . . . . . . . . . . . . . . . 26 5 Security Association Payload . . . . . . . . . . . . . . . 27 6 Proposal Payload Format . . . . . . . . . . . . . . . . . . 28 7 Transform Payload Format . . . . . . . . . . . . . . . . . 30 8 Key Exchange Payload Format . . . . . . . . . . . . . . . . 31 9 Identification Payload Format . . . . . . . . . . . . . . . 32 10 Certificate Payload Format . . . . . . . . . . . . . . . . 33 11 Certificate Request Payload Format . . . . . . . . . . . . 34 12 Hash Payload Format . . . . . . . . . . . . . . . . . . . . 36 13 Signature Payload Format . . . . . . . . . . . . . . . . . 37 14 Nonce Payload Format . . . . . . . . . . . . . . . . . . . 38 15 Notification Payload Format . . . . . . . . . . . . . . . . 39 16 Delete Payload Format . . . . . . . . . . . . . . . . . . . 42 17 Vendor ID Payload Format . . . . . . . . . . . . . . . . . 44 1 Introduction This document describes an Internet Security Association and Key Management Protocol (ISAKMP). ISAKMP combines the security concepts of authentication, key management, and security associations to establish the required security for government, commercial, and private communications on the Internet. The Internet Security Association and Key Management Protocol (ISAKMP) defines procedures and packet formats to establish, negotiate, modify and delete Security Associations (SA). SAs contain all the information required for execution of various network security services, such as the IP layer services (such as header authentication and payload encapsulation), transport or application layer services, or self-protection of negotiation traffic. ISAKMP defines payloads for exchanging key generation and authentication data. These formats provide a consistent framework for transferring key and authentication data which is independent of the key generation technique, encryption algorithm and authentication mechanism. Maughan, et. al. Standards Track [Page 4] RFC 2408 ISAKMP November 1998 ISAKMP is distinct from key exchange protocols in order to cleanly separate the details of security association management (and key management) from the details of key exchange. There may be many different key exchange protocols, each with different security properties. However, a common framework is required for agreeing to the format of SA attributes, and for negotiating, modifying, and deleting SAs. ISAKMP serves as this common framework. Separating the functionality into three parts adds complexity to the security analysis of a complete ISAKMP implementation. However, the separation is critical for interoperability between systems with differing security requirements, and should also simplify the analysis of further evolution of a ISAKMP server. ISAKMP is intended to support the negotiation of SAs for security protocols at all layers of the network stack (e.g., IPSEC, TLS, TLSP, OSPF, etc.). By centralizing the management of the security associations, ISAKMP reduces the amount of duplicated functionality within each security protocol. ISAKMP can also reduce connection setup time, by negotiating a whole stack of services at once. The remainder of section 1 establishes the motivation for security negotiation and outlines the major components of ISAKMP, i.e. Security Associations and Management, Authentication, Public Key Cryptography, and Miscellaneous items. Section 2 presents the terminology and concepts associated with ISAKMP. Section 3 describes the different ISAKMP payload formats. Section 4 describes how the payloads of ISAKMP are composed together as exchange types to establish security associations and perform key exchanges in an authenticated manner. Additionally, security association modification, deletion, and error notification are discussed. Section 5 describes the processing of each payload within the context of ISAKMP exchanges, including error handling and associated actions. The appendices provide the attribute values necessary for ISAKMP and requirement for defining a new Domain of Interpretation (DOI) within ISAKMP. 1.1 Requirements Terminology The keywords MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL, when they appear in this document, are to be interpreted as described in [RFC-2119]. 1.2 The Need for Negotiation ISAKMP extends the assertion in [DOW92] that authentication and key exchanges must be combined for better security to include security association exchanges. The security services required for Maughan, et. al. Standards Track [Page 5] RFC 2408 ISAKMP November 1998 communications depends on the individual network configurations and environments. Organizations are setting up Virtual Private Networks (VPN), also known as Intranets, that will require one set of security functions for communications within the VPN and possibly many different security functions for communications outside the VPN to support geographically separate organizational components, customers, suppliers, sub-contractors (with their own VPNs), government, and others. Departments within large organizations may require a number of security associations to separate and protect data (e.g. personnel data, company proprietary data, medical) on internal networks and other security associations to communicate within the same department. Nomadic users wanting to "phone home" represent another set of security requirements. These requirements must be tempered with bandwidth challenges. Smaller groups of people may meet their security requirements by setting up "Webs of Trust". ISAKMP exchanges provide these assorted networking communities the ability to present peers with the security functionality that the user supports in an authenticated and protected manner for agreement upon a common set of security attributes, i.e. an interoperable security association. 1.3 What can be Negotiated? Security associations must support different encryption algorithms, authentication mechanisms, and key establishment algorithms for other security protocols, as well as IP Security. Security associations must also support host-oriented certificates for lower layer protocols and user- oriented certificates for higher level protocols. Algorithm and mechanism independence is required in applications such as e-mail, remote login, and file transfer, as well as in session oriented protocols, routing protocols, and link layer protocols. ISAKMP provides a common security association and key establishment protocol for this wide range of security protocols, applications, security requirements, and network environments. ISAKMP is not bound to any specific cryptographic algorithm, key generation technique, or security mechanism. This flexibility is beneficial for a number of reasons. First, it supports the dynamic communications environment described above. Second, the independence from specific security mechanisms and algorithms provides a forward migration path to better mechanisms and algorithms. When improved security mechanisms are developed or new attacks against current encryption algorithms, authentication mechanisms and key exchanges are discovered, ISAKMP will allow the updating of the algorithms and mechanisms without having to develop a completely new KMP or patch the current one. Maughan, et. al. Standards Track [Page 6] RFC 2408 ISAKMP November 1998 ISAKMP has basic requirements for its authentication and key exchange components. These requirements guard against denial of service, replay / reflection, man-in-the-middle, and connection hijacking attacks. This is important because these are the types of attacks that are targeted against protocols. Complete Security Association (SA) support, which provides mechanism and algorithm independence, and protection from protocol threats are the strengths of ISAKMP. 1.4 Security Associations and Management A Security Association (SA) is a relationship between two or more entities that describes how the entities will utilize security services to communicate securely. This relationship is represented by a set of information that can be considered a contract between the entities. The information must be agreed upon and shared between all the entities. Sometimes the information alone is referred to as an SA, but this is just a physical instantiation of the existing relationship. The existence of this relationship, represented by the information, is what provides the agreed upon security information needed by entities to securely interoperate. All entities must adhere to the SA for secure communications to be possible. When accessing SA attributes, entities use a pointer or identifier refered to as the Security Parameter Index (SPI). [SEC-ARCH] provides details on IP Security Associations (SA) and Security Parameter Index (SPI) definitions. 1.4.1 Security Associations and Registration The SA attributes required and recommended for the IP Security (AH, ESP) are defined in [SEC-ARCH]. The attributes specified for an IP Security SA include, but are not limited to, authentication mechanism, cryptographic algorithm, algorithm mode, key length, and Initialization Vector (IV). Other protocols that provide algorithm and mechanism independent security MUST define their requirements for SA attributes. The separation of ISAKMP from a specific SA definition is important to ensure ISAKMP can es tablish SAs for all possible security protocols and applications. NOTE: See [IPDOI] for a discussion of SA attributes that should be considered when defining a security protocol or application. In order to facilitate easy identification of specific attributes (e.g. a specific encryption algorithm) among different network entites the attributes must be assigned identifiers and these identifiers must be registered by a central authority. The Internet Assigned Numbers Authority (IANA) provides this function for the Internet. Maughan, et. al. Standards Track [Page 7] RFC 2408 ISAKMP November 1998 1.4.2 ISAKMP Requirements Security Association (SA) establishment MUST be part of the key management protocol defined for IP based networks. The SA concept is required to support security protocols in a diverse and dynamic networking environment. Just as authentication and key exchange must be linked to provide assurance that the key is established with the authenticated party [DOW92], SA establishment must be linked with the authentication and the key exchange protocol. ISAKMP provides the protocol exchanges to establish a security association between negotiating entities followed by the establishment of a security association by these negotiating entities in behalf of some protocol (e.g. ESP/AH). First, an initial protocol exchange allows a basic set of security attributes to be agreed upon. This basic set provides protection for subsequent ISAKMP exchanges. It also indicates the authentication method and key exchange that will be performed as part of the ISAKMP protocol. If a basic set of security attributes is already in place between the negotiating server entities, the initial ISAKMP exchange may be skipped and the establishment of a security association can be done directly. After the basic set of security attributes has been agreed upon, initial identity authenticated, and required keys generated, the established SA can be used for subsequent communications by the entity that invoked ISAKMP. The basic set of SA attributes that MUST be implemented to provide ISAKMP interoperability are defined in Appendix A. 1.5 Authentication A very important step in establishing secure network communications is authentication of the entity at the other end of the communication. Many authentication mechanisms are available. Authentication mechanisms fall into two catagories of strength - weak and strong. Sending cleartext keys or other unprotected authenticating information over a network is weak, due to the threat of reading them with a network sniffer. Additionally, sending one- way hashed poorly-chosen keys with low entropy is also weak, due to the threat of brute-force guessing attacks on the sniffed messages. While passwords can be used for establishing identity, they are not considered in this context because of recent statements from the Internet Architecture Board [IAB]. Digital signatures, such as the Digital Signature Standard (DSS) and the Rivest-Shamir-Adleman (RSA) signature, are public key based strong authentication mechanisms. When using public key digital signatures each entity requires a public key and a private key. Certificates are an essential part of a digital signature authentication mechanism. Certificates bind a specific entity's identity (be it host, network, user, or Maughan, et. al. Standards Track [Page 8] RFC 2408 ISAKMP November 1998 application) to its public keys and possibly other security-related information such as privileges, clearances, and compartments. Authentication based on digital signatures requires a trusted third party or certificate authority to create, sign and properly distribute certificates. For more detailed information on digital signatures, such as DSS and RSA, and certificates see [Schneier]. 1.5.1 Certificate Authorities Certificates require an infrastructure for generation, verification, revocation, management and distribution. The Internet Policy Registration Authority (IPRA) [RFC-1422] has been established to direct this infrastructure for the IETF. The IPRA certifies Policy Certification Authorities (PCA). PCAs control Certificate Authorities (CA) which certify users and subordinate entities. Current certificate related work includes the Domain Name System (DNS) Security Extensions [DNSSEC] which will provide signed entity keys in the DNS. The Public Key Infrastucture (PKIX) working group is specifying an Internet profile for X.509 certificates. There is also work going on in industry to develop X.500 Directory Services which would provide X.509 certificates to users. The U.S. Post Office is developing a (CA) hierarchy. The NIST Public Key Infrastructure Working Group has also been doing work in this area. The DOD Multi Level Information System Security Initiative (MISSI) program has begun deploying a certificate infrastructure for the U.S. Government. Alternatively, if no infrastructure exists, the PGP Web of Trust certificates can be used to provide user authentication and privacy in a community of users who know and trust each other. 1.5.2 Entity Naming An entity's name is its identity and is bound to its public keys in certificates. The CA MUST define the naming semantics for the certificates it issues. See the UNINETT PCA Policy Statements [Berge] for an example of how a CA defines its naming policy. When the certificate is verified, the name is verified and that name will have meaning within the realm of that CA. An example is the DNS security extensions which make DNS servers CAs for the zones and nodes they serve. Resource records are provided for public keys and signatures on those keys. The names associated with the keys are IP addresses and domain names which have meaning to entities accessing the DNS for this information. A Web of Trust is another example. When webs of trust are set up, names are bound with the public keys. In PGP the name is usually the entity's e-mail address which has meaning to those, and only those, who understand e-mail. Another web of trust could use an entirely different naming scheme. Maughan, et. al. Standards Track [Page 9] RFC 2408 ISAKMP November 1998 1.5.3 ISAKMP Requirements Strong authentication MUST be provided on ISAKMP exchanges. Without being able to authenticate the entity at the other end, the Security Association (SA) and session key established are suspect. Without authentication you are unable to trust an entity's identification, which makes access control questionable. While encryption (e.g. ESP) and integrity (e.g. AH) will protect subsequent communications from passive eavesdroppers, without authentication it is possible that the SA and key may have been established with an adversary who performed an active man-in-the-middle attack and is now stealing all your personal data. A digital signature algorithm MUST be used within ISAKMP's authentication component. However, ISAKMP does not mandate a specific signature algorithm or certificate authority (CA). ISAKMP allows an entity initiating communications to indicate which CAs it supports. After selection of a CA, the protocol provides the messages required to support the actual authentication exchange. The protocol provides a facility for identification of different certificate authorities, certificate types (e.g. X.509, PKCS #7, PGP, DNS SIG and KEY records), and the exchange of the certificates identified. ISAKMP utilizes digital signatures, based on public key cryptography, for authentication. There are other strong authentication systems available, which could be specified as additional optional authentication mechanisms for ISAKMP. Some of these authentication systems rely on a trusted third party called a key distribution center (KDC) to distribute secret session keys. An example is Kerberos, where the trusted third party is the Kerberos server, which holds secret keys for all clients and servers within its network domain. A client's proof that it holds its secret key provides authenticaton to a server. The ISAKMP specification does not specify the protocol for communicating with the trusted third parties (TTP) or certificate directory services. These protocols are defined by the TTP and directory service themselves and are outside the scope of this specification. The use of these additional services and protocols will be described in a Key Exchange specific document. 1.6 Public Key Cryptography Public key cryptography is the most flexible, scalable, and efficient way for users to obtain the shared secrets and session keys needed to support the large number of ways Internet users will interoperate. Many key generation algorithms, that have different properties, are Maughan, et. al. Standards Track [Page 10] RFC 2408 ISAKMP November 1998 available to users (see [DOW92], [ANSI], and [Oakley]). Properties of key exchange protocols include the key establishment method, authentication, symmetry, perfect forward secrecy, and back traffic protection. NOTE: Cryptographic keys can protect information for a considerable length of time. However, this is based on the assumption that keys used for protection of communications are destroyed after use and not kept for any reason. 1.6.1 Key Exchange Properties Key Establishment (Key Generation / Key Transport): The two common methods of using public key cryptography for key establishment are key transport and key generation. An example of key transport is the use of the RSA algorithm to encrypt a randomly generated session key (for encrypting subsequent communications) with the recipient's public key. The encrypted random key is then sent to the recipient, who decrypts it using his private key. At this point both sides have the same session key, however it was created based on input from only one side of the communications. The benefit of the key transport method is that it has less computational overhead than the following method. The Diffie-Hellman (D-H) algorithm illustrates key generation using public key cryptography. The D-H algorithm is begun by two users exchanging public information. Each user then mathematically combines the other's public information along with their own secret information to compute a shared secret value. This secret value can be used as a session key or as a key encryption key for encrypting a randomly generated session key. This method generates a session key based on public and secret information held by both users. The benefit of the D-H algorithm is that the key used for encrypting messages is based on information held by both users and the independence of keys from one key exchange to another provides perfect forward secrecy. Detailed descriptions of these algorithms can be found in [Schneier]. There are a number of variations on these two key generation schemes and these variations do not necessarily interoperate. Key Exchange Authentication: Key exchanges may be authenticated during the protocol or after protocol completion. Authentication of the key exchange during the protocol is provided when each party provides proof it has the secret session key before the end of the protocol. Proof can be provided by encrypting known data in the secret session key during the protocol echange. Authentication after the protocol must occur in subsequent commu nications. Authentication during the protocol is preferred so subsequent communications are not initiated if the secret session key is not established with the desired party. Maughan, et. al. Standards Track [Page 11] RFC 2408 ISAKMP November 1998 Key Exchange Symmetry: A key exchange provides symmetry if either party can initiate the exchange and exchanged messages can cross in transit without affecting the key that is generated. This is desirable so that computation of the keys does not require either party to know who initated the exchange. While key exchange symmetry is desirable, symmetry in the entire key management protocol may provide a vulnerablity to reflection attacks. Perfect Forward Secrecy: As described in [DOW92], an authenticated key exchange protocol provides perfect forward secrecy if disclosure of longterm secret keying material does not compromise the secrecy of the exchanged keys from previous communications. The property of perfect forward secrecy does not apply to key exchange without authentication. 1.6.2 ISAKMP Requirements An authenticated key exchange MUST be supported by ISAKMP. Users SHOULD choose additional key establishment algorithms based on their requirements. ISAKMP does not specify a specific key exchange. However, [IKE] describes a proposal for using the Oakley key exchange [Oakley] in conjunction with ISAKMP. Requirements that should be evaluated when choosing a key establishment algorithm include establishment method (generation vs. transport), perfect forward secrecy, computational overhead, key escrow, and key strength. Based on user requirements, ISAKMP allows an entity initiating communications to indicate which key exchanges it supports. After selection of a key exchange, the protocol provides the messages required to support the actual key establishment. 1.7 ISAKMP Protection 1.7.1 Anti-Clogging (Denial of Service) Of the numerous security services available, protection against denial of service always seems to be one of the most difficult to address. A "cookie" or anti-clogging token (ACT) is aimed at protecting the computing resources from attack without spending excessive CPU resources to determine its authenticity. An exchange prior to CPU-intensive public key operations can thwart some denial of service attempts (e.g. simple flooding with bogus IP source addresses). Absolute protection against denial of service is impossible, but this anti-clogging token provides a technique for making it easier to handle. The use of an anti-clogging token was introduced by Karn and Simpson in [Karn]. Maughan, et. al. Standards Track [Page 12] RFC 2408 ISAKMP November 1998 It should be noted that in the exchanges shown in section 4, the anticlogging mechanism should be used in conjuction with a garbage- state collection mechanism; an attacker can still flood a server using packets with bogus IP addresses and cause state to be created. Such aggressive memory management techniques SHOULD be employed by protocols using ISAKMP that do not go through an initial, anti- clogging only phase, as was done in [Karn]. 1.7.2 Connection Hijacking ISAKMP prevents connection hijacking by linking the authentication, key exchange and security association exchanges. This linking prevents an attacker from allowing the authentication to complete and then jumping in and impersonating one entity to the other during the key and security association exchanges. 1.7.3 Man-in-the-Middle Attacks Man-in-the-Middle attacks include interception, insertion, deletion, and modification of messages, reflecting messages back at the sender, replaying old messages and redirecting messages. ISAKMP features prevent these types of attacks from being successful. The linking of the ISAKMP exchanges prevents the insertion of messages in the protocol exchange. The ISAKMP protocol state machine is defined so deleted messages will not cause a partial SA to be created, the state machine will clear all state and return to idle. The state machine also prevents reflection of a message from causing harm. The requirement for a new cookie with time variant material for each new SA establishment prevents attacks that involve replaying old messages. The ISAKMP strong authentication requirement prevents an SA from being established with anyone other than the intended party. Messages may be redirected to a different destination or modified but this will be detected and an SA will not be established. The ISAKMP specification defines where abnormal processing has occurred and recommends notifying the appropriate party of this abnormality. 1.8 Multicast Communications It is expected that multicast communications will require the same security services as unicast communications and may introduce the need for additional security services. The issues of distributing SPIs for multicast traffic are presented in [SEC-ARCH]. Multicast security issues are also discussed in [RFC-1949] and [BC]. A future extension to ISAKMP will support multicast key distribution. For an introduction to the issues related to multicast security, consult the Internet Drafts, [RFC-2094] and [RFC-2093], describing Sparta's research in this area. Maughan, et. al. Standards Track [Page 13] RFC 2408 ISAKMP November 1998 2 Terminology and Concepts 2.1 ISAKMP Terminology Security Protocol: A Security Protocol consists of an entity at a single point in the network stack, performing a security service for network communication. For example, IPSEC ESP and IPSEC AH are two different security protocols. TLS is another example. Security Protocols may perform more than one service, for example providing integrity and confidentiality in one module. Protection Suite: A protection suite is a list of the security services that must be applied by various security protocols. For example, a protection suite may consist of DES encryption in IP ESP, and keyed MD5 in IP AH. All of the protections in a suite must be treated as a single unit. This is necessary because security services in different security protocols can have subtle interactions, and the effects of a suite must be analyzed and verified as a whole. Security Association (SA): A Security Association is a security- protocol- specific set of parameters that completely defines the services and mechanisms necessary to protect traffic at that security protocol location. These parameters can include algorithm identifiers, modes, cryptographic keys, etc. The SA is referred to by its associated security protocol (for example, "ISAKMP SA", "ESP SA", "TLS SA"). ISAKMP SA: An SA used by the ISAKMP servers to protect their own traffic. Sections 2.3 and 2.4 provide more details about ISAKMP SAs. Security Parameter Index (SPI): An identifier for a Security Assocation, relative to some security protocol. Each security protocol has its own "SPI-space". A (security protocol, SPI) pair may uniquely identify an SA. The uniqueness of the SPI is implementation dependent, but could be based per system, per protocol, or other options. Depending on the DOI, additional information (e.g. host address) may be necessary to identify an SA. The DOI will also determine which SPIs (i.e. initiator's or responder's) are sent during communication. Domain of Interpretation: A Domain of Interpretation (DOI) defines payload formats, exchange types, and conventions for naming security-relevant information such as security policies or cryptographic algorithms and modes. A Domain of Interpretation (DOI) identifier is used to interpret the payloads of ISAKMP payloads. A system SHOULD support multiple Domains of Interpretation simultaneously. The concept of a DOI is based on previous work by Maughan, et. al. Standards Track [Page 14] RFC 2408 ISAKMP November 1998 the TSIG CIPSO Working Group, but extends beyond security label interpretation to include naming and interpretation of security services. A DOI defines: o A "situation": the set of information that will be used to determine the required security services. o The set of security policies that must, and may, be supported. o A syntax for the specification of proposed security services. o A scheme for naming security-relevant information, including encryption algorithms, key exchange algorithms, security policy attributes, and certificate authorities. o The specific formats of the various payload contents. o Additional exchange types, if required. The rules for the IETF IP Security DOI are presented in [IPDOI]. Specifications of the rules for customized DOIs will be presented in separate documents. Situation: A situation contains all of the security-relevant information that a system considers necessary to decide the security services required to protect the session being negotiated. The situation may include addresses, security classifications, modes of operation (normal vs. emergency), etc. Proposal: A proposal is a list, in decreasing order of preference, of the protection suites that a system considers acceptable to protect traffic under a given situation. Payload: ISAKMP defines several types of payloads, which are used to transfer information such as security association data, or key exchange data, in DOI-defined formats. A payload consists of a generic payload header and a string of octects that is opaque to ISAKMP. ISAKMP uses DOI- specific functionality to synthesize and interpret these payloads. Multiple payloads can be sent in a single ISAKMP message. See section 3 for more details on the payload types, and [IPDOI] for the formats of the IETF IP Security DOI payloads. Exchange Type: An exchange type is a specification of the number of messages in an ISAKMP exchange, and the payload types that are contained in each of those messages. Each exchange type is designed to provide a particular set of security services, such as anonymity of the participants, perfect forward secrecy of the keying material, authentication of the participants, etc. Section 4.1 defines the Maughan, et. al. Standards Track [Page 15] RFC 2408 ISAKMP November 1998 default set of ISAKMP exchange types. Other exchange types can be added to support additional key exchanges, if required. 2.2 ISAKMP Placement Figure 1 is a high level view of the placement of ISAKMP within a system context in a network architecture. An important part of negotiating security services is to consider the entire "stack" of individual SAs as a unit. This is referred to as a "protection suite". +------------+ +--------+ +--------------+ ! DOI ! ! ! ! Application ! ! Definition ! <----> ! ISAKMP ! ! Process ! +------------+ --> ! ! !--------------! +--------------+ ! +--------+ ! Appl Protocol! ! Key Exchange ! ! ^ ^ +--------------+ ! Definition !<-- ! ! ^ +--------------+ ! ! ! ! ! ! !----------------! ! ! v ! ! +-------+ v v ! API ! +---------------------------------------------+ +-------+ ! Socket Layer ! ! !---------------------------------------------! v ! Transport Protocol (TCP / UDP) ! +----------+ !---------------------------------------------! ! Security ! <----> ! IP ! ! Protocol ! !---------------------------------------------! +----------+ ! Link Layer Protocol ! +---------------------------------------------+ Figure 1: ISAKMP Relationships 2.3 Negotiation Phases ISAKMP offers two "phases" of negotiation. In the first phase, two entities (e.g. ISAKMP servers) agree on how to protect further negotiation traffic between themselves, establishing an ISAKMP SA. This ISAKMP SA is then used to protect the negotiations for the Protocol SA being requested. Two entities (e.g. ISAKMP servers) can negotiate (and have active) multiple ISAKMP SAs. Maughan, et. al. Standards Track [Page 16] RFC 2408 ISAKMP November 1998 The second phase of negotiation is used to establish security associations for other security protocols. This second phase can be used to establish many security associations. The security associations established by ISAKMP during this phase can be used by a security protocol to protect many message/data exchanges. While the two-phased approach has a higher start-up cost for most simple scenarios, there are several reasons that it is beneficial for most cases. First, entities (e.g. ISAKMP servers) can amortize the cost of the first phase across several second phase negotiations. This allows multiple SAs to be established between peers over time without having to start over for each communication. Second, security services negotiated during the first phase provide security properties for the second phase. For example, after the first phase of negotiation, the encryption provided by the ISAKMP SA can provide identity protection, potentially allowing the use of simpler second-phase exchanges. On the other hand, if the channel established during the first phase is not adequate to protect identities, then the second phase must negotiate adequate security mechanisms. Third, having an ISAKMP SA in place considerably reduces the cost of ISAKMP management activity - without the "trusted path" that an ISAKMP SA gives you, the entities (e.g. ISAKMP servers) would have to go through a complete re-authentication for each error notification or deletion of an SA. Negotiation during each phase is accomplished using ISAKMP-defined exchanges (see section 4) or exchanges defined for a key exchange within a DOI. Note that security services may be applied differently in each negotiation phase. For example, different parties are being authenticated during each of the phases of negotiation. During the first phase, the parties being authenticated may be the ISAKMP servers/hosts, while during the second phase, users or application level programs are being authenticated. 2.4 Identifying Security Associations While bootstrapping secure channels between systems, ISAKMP cannot assume the existence of security services, and must provide some protections for itself. Therefore, ISAKMP considers an ISAKMP Security Association to be different than other types, and manages ISAKMP SAs itself, in their own name space. ISAKMP uses the two Maughan, et. al. Standards Track [Page 17] RFC 2408 ISAKMP November 1998 cookie fields in the ISAKMP header to identify ISAKMP SAs. The Message ID in the ISAKMP Header and the SPI field in the Proposal payload are used during SA establishment to identify the SA for other security protocols. The interpretation of these four fields is dependent on the operation taking place. The following table shows the presence or absence of several fields during SA establishment. The following fields are necessary for various operations associated with SA establishment: cookies in the ISAKMP header, the ISAKMP Header Message ID field, and the SPI field in the Proposal payload. An 'X' in the column means the value MUST be present. An 'NA' in the column means a value in the column is Not Applicable to the operation. # Operation I-Cookie R-Cookie Message ID SPI (1) Start ISAKMP SA negotiation X 0 0 0 (2) Respond ISAKMP SA negotiation X X 0 0 (3) Init other SA negotiation X X X X (4) Respond other SA negotiation X X X X (5) Other (KE, ID, etc.) X X X/0 NA (6) Security Protocol (ESP, AH) NA NA NA X In the first line (1) of the table, the initiator includes the Initiator Cookie field in the ISAKMP Header, using the procedures outlined in sections 2.5.3 and 3.1. In the second line (2) of the table, the responder includes the Initiator and Responder Cookie fields in the ISAKMP Header, using the procedures outlined in sections 2.5.3 and 3.1. Additional messages may be exchanged between ISAKMP peers, depending on the ISAKMP exchange type used during the phase 1 negotiation. Once the phase 1 exchange is completed, the Initiator and Responder cookies are included in the ISAKMP Header of all subsequent communications between the ISAKMP peers. During phase 1 negotiations, the initiator and responder cookies determine the ISAKMP SA. Therefore, the SPI field in the Proposal payload is redundant and MAY be set to 0 or it MAY contain the transmitting entity's cookie. In the third line (3) of the table, the initiator associates a Message ID with the Protocols contained in the SA Proposal. This Message ID and the initiator's SPI(s) to be associated with each protocol in the Proposal are sent to the responder. The SPI(s) will be used by the security protocols once the phase 2 negotiation is completed. Maughan, et. al. Standards Track [Page 18] RFC 2408 ISAKMP November 1998 In the fourth line (4) of the table, the responder includes the same Message ID and the responder's SPI(s) to be associated with each protocol in the accepted Proposal. This information is returned to the initiator. In the fifth line (5) of the table, the initiator and responder use the Message ID field in the ISAKMP Header to keep track of the in- progress protocol negotiation. This is only applicable for a phase 2 exchange and the value MUST be 0 for a phase 1 exchange because the combined cookies identify the ISAKMP SA. The SPI field in the Proposal payload is not applicable because the Proposal payload is only used during the SA negotiation message exchange (steps 3 and 4). In the sixth line (6) of the table, the phase 2 negotiation is complete. The security protocols use the SPI(s) to determine which security services and mechanisms to apply to the communication between them. The SPI value shown in the sixth line (6) is not the SPI field in the Proposal payload, but the SPI field contained within the security protocol header. During the SA establishment, a SPI MUST be generated. ISAKMP is designed to handle variable sized SPIs. This is accomplished by using the SPI Size field within the Proposal payload during SA establishment. Handling of SPIs will be outlined by the DOI specification (e.g. [IPDOI]). When a security association (SA) is initially established, one side assumes the role of initiator and the other the role of responder. Once the SA is established, both the original initiator and responder can initiate a phase 2 negotiation with the peer entity. Thus, ISAKMP SAs are bidirectional in nature. Additionally, ISAKMP allows both initiator and responder to have some control during the negotiation process. While ISAKMP is designed to allow an SA negotiation that includes multiple proposals, the initiator can maintain some control by only making one proposal in accordance with the initiator's local security policy. Once the initiator sends a proposal containing more than one proposal (which are sent in decreasing preference order), the initiator relinquishes control to the responder. Once the responder is controlling the SA establishment, the responder can make its policy take precedence over the initiator within the context of the multiple options offered by the initiator. This is accomplished by selecting the proposal best suited for the responder's local security policy and returning this selection to the initiator. Maughan, et. al. Standards Track [Page 19] RFC 2408 ISAKMP November 1998 2.5 Miscellaneous 2.5.1 Transport Protocol ISAKMP can be implemented over any transport protocol or over IP itself. Implementations MUST include send and receive capability for ISAKMP using the User Datagram Protocol (UDP) on port 500. UDP Port 500 has been assigned to ISAKMP by the Internet Assigned Numbers Authority (IANA). Implementations MAY additionally support ISAKMP over other transport protocols or over IP itself. 2.5.2 RESERVED Fields The existence of RESERVED fields within ISAKMP payloads are used strictly to preserve byte alignment. All RESERVED fields in the ISAKMP protocol MUST be set to zero (0) when a packet is issued. The receiver SHOULD check the RESERVED fields for a zero (0) value and discard the packet if other values are found. 2.5.3 Anti-Clogging Token ("Cookie") Creation The details of cookie generation are implementation dependent, but MUST satisfy these basic requirements (originally stated by Phil Karn in [Karn]): 1. The cookie must depend on the specific parties. This prevents an attacker from obtaining a cookie using a real IP address and UDP port, and then using it to swamp the victim with Diffie-Hellman requests from randomly chosen IP addresses or ports. 2. It must not be possible for anyone other than the issuing entity to generate cookies that will be accepted by that entity. This implies that the issuing entity must use local secret information in the generation and subsequent verification of a cookie. It must not be possible to deduce this secret information from any particular cookie. 3. The cookie generation function must be fast to thwart attacks intended to sabotage CPU resources. Karn's suggested method for creating the cookie is to perform a fast hash (e.g. MD5) over the IP Source and Destination Address, the UDP Source and Destination Ports and a locally generated secret random value. ISAKMP requires that the cookie be unique for each SA establishment to help prevent replay attacks, therefore, the date and time MUST be added to the information hashed. The generated cookies are placed in the ISAKMP Header (described in section 3.1) Initiator Maughan, et. al. Standards Track [Page 20] RFC 2408 ISAKMP November 1998 and Responder cookie fields. These fields are 8 octets in length, thus, requiring a generated cookie to be 8 octets. Notify and Delete messages (see sections 3.14, 3.15, and 4.8) are uni-directional transmissions and are done under the protection of an existing ISAKMP SA, thus, not requiring the generation of a new cookie. One exception to this is the transmission of a Notify message during a Phase 1 exchange, prior to completing the establishment of an SA. Sections 3.14 and 4.8 provide additional details. 3 ISAKMP Payloads ISAKMP payloads provide modular building blocks for constructing ISAKMP messages. The presence and ordering of payloads in ISAKMP is defined by and dependent upon the Exchange Type Field located in the ISAKMP Header (see Figure 2). The ISAKMP payload types are discussed in sections 3.4 through 3.15. The descriptions of the ISAKMP payloads, messages, and exchanges (see Section 4) are shown using network octet ordering. 3.1 ISAKMP Header Format An ISAKMP message has a fixed header format, shown in Figure 2, followed by a variable number of payloads. A fixed header simplifies parsing, providing the benefit of protocol parsing software that is less complex and easier to implement. The fixed header contains the information required by the protocol to maintain state, process payloads and possibly prevent denial of service or replay attacks. The ISAKMP Header fields are defined as follows: o Initiator Cookie (8 octets) - Cookie of entity that initiated SA establishment, SA notification, or SA deletion. o Responder Cookie (8 octets) - Cookie of entity that is responding to an SA establishment request, SA notification, or SA deletion. Maughan, et. al. Standards Track [Page 21] RFC 2408 ISAKMP November 1998 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Initiator ! ! Cookie ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Responder ! ! Cookie ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! MjVer ! MnVer ! Exchange Type ! Flags ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Message ID ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 2: ISAKMP Header Format o Next Payload (1 octet) - Indicates the type of the first payload in the message. The format for each payload is defined in sections 3.4 through 3.16. The processing for the payloads is defined in section 5. Next Payload Type Value NONE 0 Security Association (SA) 1 Proposal (P) 2 Transform (T) 3 Key Exchange (KE) 4 Identification (ID) 5 Certificate (CERT) 6 Certificate Request (CR) 7 Hash (HASH) 8 Signature (SIG) 9 Nonce (NONCE) 10 Notification (N) 11 Delete (D) 12 Vendor ID (VID) 13 RESERVED 14 - 127 Private USE 128 - 255 o Major Version (4 bits) - indicates the major version of the ISAKMP protocol in use. Implementations based on this version of the ISAKMP Internet-Draft MUST set the Major Version to 1. Implementations based on previous versions of ISAKMP Internet- Drafts MUST set the Major Version to 0. Implementations SHOULD Maughan, et. al. Standards Track [Page 22] RFC 2408 ISAKMP November 1998 never accept packets with a major version number larger than its own. o Minor Version (4 bits) - indicates the minor version of the ISAKMP protocol in use. Implementations based on this version of the ISAKMP Internet-Draft MUST set the Minor Version to 0. Implementations based on previous versions of ISAKMP Internet- Drafts MUST set the Minor Version to 1. Implementations SHOULD never accept packets with a minor version number larger than its own, given the major version numbers are identical. o Exchange Type (1 octet) - indicates the type of exchange being used. This dictates the message and payload orderings in the ISAKMP exchanges. Exchange Type Value NONE 0 Base 1 Identity Protection 2 Authentication Only 3 Aggressive 4 Informational 5 ISAKMP Future Use 6 - 31 DOI Specific Use 32 - 239 Private Use 240 - 255 o Flags (1 octet) - indicates specific options that are set for the ISAKMP exchange. The flags listed below are specified in the Flags field beginning with the least significant bit, i.e the Encryption bit is bit 0 of the Flags field, the Commit bit is bit 1 of the Flags field, and the Authentication Only bit is bit 2 of the Flags field. The remaining bits of the Flags field MUST be set to 0 prior to transmission. -- E(ncryption Bit) (1 bit) - If set (1), all payloads following the header are encrypted using the encryption algorithm identified in the ISAKMP SA. The ISAKMP SA Identifier is the combination of the initiator and responder cookie. It is RECOMMENDED that encryption of communications be done as soon as possible between the peers. For all ISAKMP exchanges described in section 4.1, the encryption SHOULD begin after both parties have exchanged Key Exchange payloads. If the E(ncryption Bit) is not set (0), the payloads are not encrypted. Maughan, et. al. Standards Track [Page 23] RFC 2408 ISAKMP November 1998 -- C(ommit Bit) (1 bit) - This bit is used to signal key exchange synchronization. It is used to ensure that encrypted material is not received prior to completion of the SA establishment. The Commit Bit can be set (at anytime) by either party participating in the SA establishment, and can be used during both phases of an ISAKMP SA establishment. However, the value MUST be reset after the Phase 1 negotiation. If set(1), the entity which did not set the Commit Bit MUST wait for an Informational Exchange containing a Notify payload (with the CONNECTED Notify Message) from the entity which set the Commit Bit. In this instance, the Message ID field of the Informational Exchange MUST contain the Message ID of the original ISAKMP Phase 2 SA negotiation. This is done to ensure that the Informational Exchange with the CONNECTED Notify Message can be associated with the correct Phase 2 SA. The receipt and processing of the Informational Exchange indicates that the SA establishment was successful and either entity can now proceed with encrypted traffic communication. In addition to synchronizing key exchange, the Commit Bit can be used to protect against loss of transmissions over unreliable networks and guard against the need for multiple re-transmissions. NOTE: It is always possible that the final message of an exchange can be lost. In this case, the entity expecting to receive the final message of an exchange would receive the Phase 2 SA negotiation message following a Phase 1 exchange or encrypted traffic following a Phase 2 exchange. Handling of this situation is not standardized, but we propose the following possibilities. If the entity awaiting the Informational Exchange can verify the received message (i.e. Phase 2 SA negotiation message or encrypted traffic), then they MAY consider the SA was established and continue processing. The other option is to retransmit the last ISAKMP message to force the other entity to retransmit the final message. This suggests that implementations may consider retaining the last message (locally) until they are sure the SA is established. -- A(uthentication Only Bit) (1 bit) - This bit is intended for use with the Informational Exchange with a Notify payload and will allow the transmission of information with integrity checking, but no encryption (e.g. "emergency mode"). Section 4.8 states that a Phase 2 Informational Exchange MUST be sent under the protection of an ISAKMP SA. This is the only exception to that policy. If the Authentication Only bit is set (1), only authentication security services will be applied to the entire Notify payload of the Informational Exchange and Maughan, et. al. Standards Track [Page 24] RFC 2408 ISAKMP November 1998 the payload will not be encrypted. o Message ID (4 octets) - Unique Message Identifier used to identify protocol state during Phase 2 negotiations. This value is randomly generated by the initiator of the Phase 2 negotiation. In the event of simultaneous SA establishments (i.e. collisions), the value of this field will likely be different because they are independently generated and, thus, two security associations will progress toward establishment. However, it is unlikely there will be absolute simultaneous establishments. During Phase 1 negotiations, the value MUST be set to 0. o Length (4 octets) - Length of total message (header + payloads) in octets. Encryption can expand the size of an ISAKMP message. 3.2 Generic Payload Header Each ISAKMP payload defined in sections 3.4 through 3.16 begins with a generic header, shown in Figure 3, which provides a payload "chaining" capability and clearly defines the boundaries of a payload. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 3: Generic Payload Header The Generic Payload Header fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. This field provides the "chaining" capability. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. 3.3 Data Attributes There are several instances within ISAKMP where it is necessary to represent Data Attributes. An example of this is the Security Association (SA) Attributes contained in the Transform payload Maughan, et. al. Standards Track [Page 25] RFC 2408 ISAKMP November 1998 (described in section 3.6). These Data Attributes are not an ISAKMP payload, but are contained within ISAKMP payloads. The format of the Data Attributes provides the flexibility for representation of many different types of information. There can be multiple Data Attributes within a payload. The length of the Data Attributes will either be 4 octets or defined by the Attribute Length field. This is done using the Attribute Format bit described below. Specific information about the attributes for each domain will be described in a DOI document, e.g. IPSEC DOI [IPDOI]. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ !A! Attribute Type ! AF=0 Attribute Length ! !F! ! AF=1 Attribute Value ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ . AF=0 Attribute Value . . AF=1 Not Transmitted . +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 4: Data Attributes The Data Attributes fields are defined as follows: o Attribute Type (2 octets) - Unique identifier for each type of attribute. These attributes are defined as part of the DOI- specific information. The most significant bit, or Attribute Format (AF), indicates whether the data attributes follow the Type/Length/Value (TLV) format or a shortened Type/Value (TV) format. If the AF bit is a zero (0), then the Data Attributes are of the Type/Length/Value (TLV) form. If the AF bit is a one (1), then the Data Attributes are of the Type/Value form. o Attribute Length (2 octets) - Length in octets of the Attribute Value. When the AF bit is a one (1), the Attribute Value is only 2 octets and the Attribute Length field is not present. o Attribute Value (variable length) - Value of the attribute associated with the DOI-specific Attribute Type. If the AF bit is a zero (0), this field has a variable length defined by the Attribute Length field. If the AF bit is a one (1), the Attribute Value has a length of 2 octets. Maughan, et. al. Standards Track [Page 26] RFC 2408 ISAKMP November 1998 3.4 Security Association Payload The Security Association Payload is used to negotiate security attributes and to indicate the Domain of Interpretation (DOI) and Situation under which the negotiation is taking place. Figure 5 shows the format of the Security Association payload. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Domain of Interpretation (DOI) ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Situation ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 5: Security Association Payload o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. This field MUST NOT contain the values for the Proposal or Transform payloads as they are considered part of the security association negotiation. For example, this field would contain the value "10" (Nonce payload) in the first message of a Base Exchange (see Section 4.4) and the value "0" in the first message of an Identity Protect Exchange (see Section 4.5). o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the entire Security Association payload, including the SA payload, all Proposal payloads, and all Transform payloads associated with the proposed Security Association. o Domain of Interpretation (4 octets) - Identifies the DOI (as described in Section 2.1) under which this negotiation is taking place. The DOI is a 32-bit unsigned integer. A DOI value of 0 during a Phase 1 exchange specifies a Generic ISAKMP SA which can be used for any protocol during the Phase 2 exchange. The necessary SA Attributes are defined in A.4. A DOI value of 1 is assigned to the IPsec DOI [IPDOI]. All other DOI values are reserved to IANA for future use. IANA will not normally assign a DOI value without referencing some public specification, such as Maughan, et. al. Standards Track [Page 27] RFC 2408 ISAKMP November 1998 an Internet RFC. Other DOI's can be defined using the description in appendix B. This field MUST be present within the Security Association payload. o Situation (variable length) - A DOI-specific field that identifies the situation under which this negotiation is taking place. The Situation is used to make policy decisions regarding the security attributes being negotiated. Specifics for the IETF IP Security DOI Situation are detailed in [IPDOI]. This field MUST be present within the Security Association payload. 3.5 Proposal Payload The Proposal Payload contains information used during Security Association negotiation. The proposal consists of security mechanisms, or transforms, to be used to secure the communications channel. Figure 6 shows the format of the Proposal Payload. A description of its use can be found in section 4.2. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Proposal # ! Protocol-Id ! SPI Size !# of Transforms! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! SPI (variable) ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 6: Proposal Payload Format The Proposal Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. This field MUST only contain the value "2" or "0". If there are additional Proposal payloads in the message, then this field will be 2. If the current Proposal payload is the last within the security association proposal, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the entire Proposal payload, including generic payload header, the Proposal payload, and all Transform payloads associated with this proposal. In the event there are multiple proposals with the same proposal number (see section 4.2), the Payload Length field Maughan, et. al. Standards Track [Page 28] RFC 2408 ISAKMP November 1998 only applies to the current Proposal payload and not to all Proposal payloads. o Proposal # (1 octet) - Identifies the Proposal number for the current payload. A description of the use of this field is found in section 4.2. o Protocol-Id (1 octet) - Specifies the protocol identifier for the current negotiation. Examples might include IPSEC ESP, IPSEC AH, OSPF, TLS, etc. o SPI Size (1 octet) - Length in octets of the SPI as defined by the Protocol-Id. In the case of ISAKMP, the Initiator and Responder cookie pair from the ISAKMP Header is the ISAKMP SPI, therefore, the SPI Size is irrelevant and MAY be from zero (0) to sixteen (16). If the SPI Size is non-zero, the content of the SPI field MUST be ignored. If the SPI Size is not a multiple of 4 octets it will have some impact on the SPI field and the alignment of all payloads in the message. The Domain of Interpretation (DOI) will dictate the SPI Size for other protocols. o # of Transforms (1 octet) - Specifies the number of transforms for the Proposal. Each of these is contained in a Transform payload. o SPI (variable) - The sending entity's SPI. In the event the SPI Size is not a multiple of 4 octets, there is no padding applied to the payload, however, it can be applied at the end of the message. The payload type for the Proposal Payload is two (2). 3.6 Transform Payload The Transform Payload contains information used during Security Association negotiation. The Transform payload consists of a specific security mechanism, or transforms, to be used to secure the communications channel. The Transform payload also contains the security association attributes associated with the specific transform. These SA attributes are DOI-specific. Figure 7 shows the format of the Transform Payload. A description of its use can be found in section 4.2. Maughan, et. al. Standards Track [Page 29] RFC 2408 ISAKMP November 1998 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Transform # ! Transform-Id ! RESERVED2 ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ SA Attributes ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 7: Transform Payload Format The Transform Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. This field MUST only contain the value "3" or "0". If there are additional Transform payloads in the proposal, then this field will be 3. If the current Transform payload is the last within the proposal, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header, Transform values, and all SA Attributes. o Transform # (1 octet) - Identifies the Transform number for the current payload. If there is more than one transform proposed for a specific protocol within the Proposal payload, then each Transform payload has a unique Transform number. A description of the use of this field is found in section 4.2. o Transform-Id (1 octet) - Specifies the Transform identifier for the protocol within the current proposal. These transforms are defined by the DOI and are dependent on the protocol being negotiated. o RESERVED2 (2 octets) - Unused, set to 0. o SA Attributes (variable length) - This field contains the security association attributes as defined for the transform given in the Transform-Id field. The SA Attributes SHOULD be represented using the Data Attributes format described in section 3.3. If the SA Attributes are not aligned on 4-byte boundaries, Maughan, et. al. Standards Track [Page 30] RFC 2408 ISAKMP November 1998 then subsequent payloads will not be aligned and any padding will be added at the end of the message to make the message 4-octet aligned. The payload type for the Transform Payload is three (3). 3.7 Key Exchange Payload The Key Exchange Payload supports a variety of key exchange techniques. Example key exchanges are Oakley [Oakley], Diffie- Hellman, the enhanced Diffie-Hellman key exchange described in X9.42 [ANSI], and the RSA-based key exchange used by PGP. Figure 8 shows the format of the Key Exchange payload. The Key Exchange Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the nextpayload in the message. If the current payload is the last in the message, then this field will be 0. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Key Exchange Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 8: Key Exchange Payload Format o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Key Exchange Data (variable length) - Data required to generate a session key. The interpretation of this data is specified by the DOI and the associated Key Exchange algorithm. This field may also contain pre-placed key indicators. The payload type for the Key Exchange Payload is four (4). Maughan, et. al. Standards Track [Page 31] RFC 2408 ISAKMP November 1998 3.8 Identification Payload The Identification Payload contains DOI-specific data used to exchange identification information. This information is used for determining the identities of communicating peers and may be used for determining authenticity of information. Figure 9 shows the format of the Identification Payload. The Identification Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o ID Type (1 octet) - Specifies the type of Identification being used. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ID Type ! DOI Specific ID Data ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Identification Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 9: Identification Payload Format This field is DOI-dependent. o DOI Specific ID Data (3 octets) - Contains DOI specific Identification data. If unused, then this field MUST be set to 0. o Identification Data (variable length) - Contains identity information. The values for this field are DOI-specific and the format is specified by the ID Type field. Specific details for the IETF IP Security DOI Identification Data are detailed in [IPDOI]. Maughan, et. al. Standards Track [Page 32] RFC 2408 ISAKMP November 1998 The payload type for the Identification Payload is five (5). 3.9 Certificate Payload The Certificate Payload provides a means to transport certificates or other certificate-related information via ISAKMP and can appear in any ISAKMP message. Certificate payloads SHOULD be included in an exchange whenever an appropriate directory service (e.g. Secure DNS [DNSSEC]) is not available to distribute certificates. The Certificate payload MUST be accepted at any point during an exchange. Figure 10 shows the format of the Certificate Payload. NOTE: Certificate types and formats are not generally bound to a DOI - it is expected that there will only be a few certificate types, and that most DOIs will accept all of these types. The Certificate Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Cert Encoding ! ! +-+-+-+-+-+-+-+-+ ! ~ Certificate Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 10: Certificate Payload Format o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Certificate Encoding (1 octet) - This field indicates the type of certificate or certificate-related information contained in the Certificate Data field. Maughan, et. al. Standards Track [Page 33] RFC 2408 ISAKMP November 1998 Certificate Type Value NONE 0 PKCS #7 wrapped X.509 certificate 1 PGP Certificate 2 DNS Signed Key 3 X.509 Certificate - Signature 4 X.509 Certificate - Key Exchange 5 Kerberos Tokens 6 Certificate Revocation List (CRL) 7 Authority Revocation List (ARL) 8 SPKI Certificate 9 X.509 Certificate - Attribute 10 RESERVED 11 - 255 o Certificate Data (variable length) - Actual encoding of certificate data. The type of certificate is indicated by the Certificate Encoding field. The payload type for the Certificate Payload is six (6). 3.10 Certificate Request Payload The Certificate Request Payload provides a means to request certificates via ISAKMP and can appear in any message. Certificate Request payloads SHOULD be included in an exchange whenever an appropriate directory service (e.g. Secure DNS [DNSSEC]) is not available to distribute certificates. The Certificate Request payload MUST be accepted at any point during the exchange. The responder to the Certificate Request payload MUST send its certificate, if certificates are supported, based on the values contained in the payload. If multiple certificates are required, then multiple Certificate Request payloads SHOULD be transmitted. Figure 11 shows the format of the Certificate Request Payload. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Cert. Type ! ! +-+-+-+-+-+-+-+-+ ! ~ Certificate Authority ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 11: Certificate Request Payload Format Maughan, et. al. Standards Track [Page 34] RFC 2408 ISAKMP November 1998 The Certificate Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Certificate Type (1 octet) - Contains an encoding of the type of certificate requested. Acceptable values are listed in section 3.9. o Certificate Authority (variable length) - Contains an encoding of an acceptable certificate authority for the type of certificate requested. As an example, for an X.509 certificate this field would contain the Distinguished Name encoding of the Issuer Name of an X.509 certificate authority acceptable to the sender of this payload. This would be included to assist the responder in determining how much of the certificate chain would need to be sent in response to this request. If there is no specific certificate authority requested, this field SHOULD not be included. The payload type for the Certificate Request Payload is seven (7). Maughan, et. al. Standards Track [Page 35] RFC 2408 ISAKMP November 1998 3.11 Hash Payload The Hash Payload contains data generated by the hash function (selected during the SA establishment exchange), over some part of the message and/or ISAKMP state. This payload may be used to verify the integrity of the data in an ISAKMP message or for authentication of the negotiating entities. Figure 12 shows the format of the Hash Payload. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Hash Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 12: Hash Payload Format The Hash Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Hash Data (variable length) - Data that results from applying the hash routine to the ISAKMP message and/or state. Maughan, et. al. Standards Track [Page 36] RFC 2408 ISAKMP November 1998 3.12 Signature Payload The Signature Payload contains data generated by the digital signature function (selected during the SA establishment exchange), over some part of the message and/or ISAKMP state. This payload is used to verify the integrity of the data in the ISAKMP message, and may be of use for non-repudiation services. Figure 13 shows the format of the Signature Payload. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Signature Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 13: Signature Payload Format The Signature Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Signature Data (variable length) - Data that results from applying the digital signature function to the ISAKMP message and/or state. The payload type for the Signature Payload is nine (9). 3.13 Nonce Payload The Nonce Payload contains random data used to guarantee liveness during an exchange and protect against replay attacks. Figure 14 shows the format of the Nonce Payload. If nonces are used by a particular key exchange, the use of the Nonce payload will be dictated by the key exchange. The nonces may be transmitted as part of the key exchange data, or as a separate payload. However, this is defined by the key exchange, not by ISAKMP. Maughan, et. al. Standards Track [Page 37] RFC 2408 ISAKMP November 1998 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Nonce Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 14: Nonce Payload Format The Nonce Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Nonce Data (variable length) - Contains the random data generated by the transmitting entity. The payload type for the Nonce Payload is ten (10). 3.14 Notification Payload The Notification Payload can contain both ISAKMP and DOI-specific data and is used to transmit informational data, such as error conditions, to an ISAKMP peer. It is possible to send multiple Notification payloads in a single ISAKMP message. Figure 15 shows the format of the Notification Payload. Notification which occurs during, or is concerned with, a Phase 1 negotiation is identified by the Initiator and Responder cookie pair in the ISAKMP Header. The Protocol Identifier, in this case, is ISAKMP and the SPI value is 0 because the cookie pair in the ISAKMP Header identifies the ISAKMP SA. If the notification takes place prior to the completed exchange of keying information, then the notification will be unprotected. Maughan, et. al. Standards Track [Page 38] RFC 2408 ISAKMP November 1998 Notification which occurs during, or is concerned with, a Phase 2 negotiation is identified by the Initiator and Responder cookie pair in the ISAKMP Header and the Message ID and SPI associated with the current negotiation. One example for this type of notification is to indicate why a proposal was rejected. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Domain of Interpretation (DOI) ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Protocol-ID ! SPI Size ! Notify Message Type ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Security Parameter Index (SPI) ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Notification Data ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 15: Notification Payload Format The Notification Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Domain of Interpretation (4 octets) - Identifies the DOI (as described in Section 2.1) under which this notification is taking place. For ISAKMP this value is zero (0) and for the IPSEC DOI it is one (1). Other DOI's can be defined using the description in appendix B. o Protocol-Id (1 octet) - Specifies the protocol identifier for the current notification. Examples might include ISAKMP, IPSEC ESP, IPSEC AH, OSPF, TLS, etc. Maughan, et. al. Standards Track [Page 39] RFC 2408 ISAKMP November 1998 o SPI Size (1 octet) - Length in octets of the SPI as defined by the Protocol-Id. In the case of ISAKMP, the Initiator and Responder cookie pair from the ISAKMP Header is the ISAKMP SPI, therefore, the SPI Size is irrelevant and MAY be from zero (0) to sixteen (16). If the SPI Size is non-zero, the content of the SPI field MUST be ignored. The Domain of Interpretation (DOI) will dictate the SPI Size for other protocols. o Notify Message Type (2 octets) - Specifies the type of notification message (see section 3.14.1). Additional text, if specified by the DOI, is placed in the Notification Data field. o SPI (variable length) - Security Parameter Index. The receiving entity's SPI. The use of the SPI field is described in section 2.4. The length of this field is determined by the SPI Size field and is not necessarily aligned to a 4 octet boundary. o Notification Data (variable length) - Informational or error data transmitted in addition to the Notify Message Type. Values for this field are DOI-specific. The payload type for the Notification Payload is eleven (11). 3.14.1 Notify Message Types Notification information can be error messages specifying why an SA could not be established. It can also be status data that a process managing an SA database wishes to communicate with a peer process. For example, a secure front end or security gateway may use the Notify message to synchronize SA communication. The table below lists the Nofitication messages and their corresponding values. Values in the Private Use range are expected to be DOI-specific values. NOTIFY MESSAGES - ERROR TYPES Errors Value INVALID-PAYLOAD-TYPE 1 DOI-NOT-SUPPORTED 2 SITUATION-NOT-SUPPORTED 3 INVALID-COOKIE 4 INVALID-MAJOR-VERSION 5 INVALID-MINOR-VERSION 6 INVALID-EXCHANGE-TYPE 7 INVALID-FLAGS 8 INVALID-MESSAGE-ID 9 INVALID-PROTOCOL-ID 10 INVALID-SPI 11 Maughan, et. al. Standards Track [Page 40] RFC 2408 ISAKMP November 1998 INVALID-TRANSFORM-ID 12 ATTRIBUTES-NOT-SUPPORTED 13 NO-PROPOSAL-CHOSEN 14 BAD-PROPOSAL-SYNTAX 15 PAYLOAD-MALFORMED 16 INVALID-KEY-INFORMATION 17 INVALID-ID-INFORMATION 18 INVALID-CERT-ENCODING 19 INVALID-CERTIFICATE 20 CERT-TYPE-UNSUPPORTED 21 INVALID-CERT-AUTHORITY 22 INVALID-HASH-INFORMATION 23 AUTHENTICATION-FAILED 24 INVALID-SIGNATURE 25 ADDRESS-NOTIFICATION 26 NOTIFY-SA-LIFETIME 27 CERTIFICATE-UNAVAILABLE 28 UNSUPPORTED-EXCHANGE-TYPE 29 UNEQUAL-PAYLOAD-LENGTHS 30 RESERVED (Future Use) 31 - 8191 Private Use 8192 - 16383 NOTIFY MESSAGES - STATUS TYPES Status Value CONNECTED 16384 RESERVED (Future Use) 16385 - 24575 DOI-specific codes 24576 - 32767 Private Use 32768 - 40959 RESERVED (Future Use) 40960 - 65535 3.15 Delete Payload The Delete Payload contains a protocol-specific security association identifier that the sender has removed from its security association database and is, therefore, no longer valid. Figure 16 shows the format of the Delete Payload. It is possible to send multiple SPIs in a Delete payload, however, each SPI MUST be for the same protocol. Mixing of Protocol Identifiers MUST NOT be performed with the Delete payload. Deletion which is concerned with an ISAKMP SA will contain a Protocol-Id of ISAKMP and the SPIs are the initiator and responder cookies from the ISAKMP Header. Deletion which is concerned with a Protocol SA, such as ESP or AH, will contain the Protocol-Id of that protocol (e.g. ESP, AH) and the SPI is the sending entity's SPI(s). Maughan, et. al. Standards Track [Page 41] RFC 2408 ISAKMP November 1998 NOTE: The Delete Payload is not a request for the responder to delete an SA, but an advisory from the initiator to the responder. If the responder chooses to ignore the message, the next communication from the responder to the initiator, using that security association, will fail. A responder is not expected to acknowledge receipt of a Delete payload. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Domain of Interpretation (DOI) ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Protocol-Id ! SPI Size ! # of SPIs ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Security Parameter Index(es) (SPI) ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 16: Delete Payload Format The Delete Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Domain of Interpretation (4 octets) - Identifies the DOI (as described in Section 2.1) under which this deletion is taking place. For ISAKMP this value is zero (0) and for the IPSEC DOI it is one (1). Other DOI's can be defined using the description in appendix B. o Protocol-Id (1 octet) - ISAKMP can establish security associations for various protocols, including ISAKMP and IPSEC. This field identifies which security association database to apply the delete request. Maughan, et. al. Standards Track [Page 42] RFC 2408 ISAKMP November 1998 o SPI Size (1 octet) - Length in octets of the SPI as defined by the Protocol-Id. In the case of ISAKMP, the Initiator and Responder cookie pair is the ISAKMP SPI. In this case, the SPI Size would be 16 octets for each SPI being deleted. o # of SPIs (2 octets) - The number of SPIs contained in the Delete payload. The size of each SPI is defined by the SPI Size field. o Security Parameter Index(es) (variable length) - Identifies the specific security association(s) to delete. Values for this field are DOI and protocol specific. The length of this field is determined by the SPI Size and # of SPIs fields. The payload type for the Delete Payload is twelve (12). 3.16 Vendor ID Payload The Vendor ID Payload contains a vendor defined constant. The constant is used by vendors to identify and recognize remote instances of their implementations. This mechanism allows a vendor to experiment with new features while maintaining backwards compatibility. This is not a general extension facility of ISAKMP. Figure 17 shows the format of the Vendor ID Payload. The Vendor ID payload is not an announcement from the sender that it will send private payload types. A vendor sending the Vendor ID MUST not make any assumptions about private payloads that it may send unless a Vendor ID is received as well. Multiple Vendor ID payloads MAY be sent. An implementation is NOT REQUIRED to understand any Vendor ID payloads. An implementation is NOT REQUIRED to send any Vendor ID payload at all. If a private payload was sent without prior agreement to send it, a compliant implementation may reject a proposal with a notify message of type INVALID-PAYLOAD-TYPE. If a Vendor ID payload is sent, it MUST be sent during the Phase 1 negotiation. Reception of a familiar Vendor ID payload in the Phase 1 negotiation allows an implementation to make use of Private USE payload numbers (128-255), described in section 3.1 for vendor specific extensions during Phase 2 negotiations. The definition of "familiar" is left to implementations to determine. Some vendors may wish to implement another vendor's extension prior to standardization. However, this practice SHOULD not be widespread and vendors should work towards standardization instead. The vendor defined constant MUST be unique. The choice of hash and text to hash is left to the vendor to decide. As an example, vendors could generate their vendor id by taking a plain (non-keyed) hash of a string containing the product name, and the version of the product. Maughan, et. al. Standards Track [Page 43] RFC 2408 ISAKMP November 1998 A hash is used instead of a vendor registry to avoid local cryptographic policy problems with having a list of "approved" products, to keep away from maintaining a list of vendors, and to allow classified products to avoid having to appear on any list. For instance: "Example Company IPsec. Version 97.1" (not including the quotes) has MD5 hash: 48544f9b1fe662af98b9b39e50c01a5a, when using MD5file. Vendors may include all of the hash, or just a portion of it, as the payload length will bound the data. There are no security implications of this hash, so its choice is arbitrary. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Next Payload ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ! ~ Vendor ID (VID) ~ ! ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Figure 17: Vendor ID Payload Format The Vendor ID Payload fields are defined as follows: o Next Payload (1 octet) - Identifier for the payload type of the next payload in the message. If the current payload is the last in the message, then this field will be 0. o RESERVED (1 octet) - Unused, set to 0. o Payload Length (2 octets) - Length in octets of the current payload, including the generic payload header. o Vendor ID (variable length) - Hash of the vendor string plus version (as described above). The payload type for the Vendor ID Payload is thirteen (13). 4 ISAKMP Exchanges ISAKMP supplies the basic syntax of a message exchange. The basic building blocks for ISAKMP messages are the payload types described in section 3. This section describes the procedures for SA Maughan, et. al. Standards Track [Page 44] RFC 2408 ISAKMP November 1998 establishment and SA modification, followed by a default set of exchanges that MAY be used for initial interoperability. Other exchanges will be defined depending on the DOI and key exchange. [IPDOI] and [IKE] are examples of how this is achieved. Appendix B explains the procedures for accomplishing these additions. 4.1 ISAKMP Exchange Types ISAKMP allows the creation of exchanges for the establishment of Security Associations and keying material. There are currently five default Exchange Types defined for ISAKMP. Sections 4.4 through 4.8 describe these exchanges. Exchanges define the content and ordering of ISAKMP messages during communications between peers. Most exchanges will include all the basic payload types - SA, KE, ID, SIG - and may include others. The primary difference between exchange types is the ordering of the messages and the payload ordering within each message. While the ordering of payloads within messages is not mandated, for processing efficiency it is RECOMMENDED that the Security Association payload be the first payload within an exchange. Processing of each payload within an exchange is described in section 5. Sections 4.4 through 4.8 provide a default set of ISAKMP exchanges. These exchanges provide different security protection for the exchange itself and information exchanged. The diagrams in each of the following sections show the message ordering for each exchange type as well as the payloads included in each message, and provide basic notes describing what has happened after each message exchange. None of the examples include any "optional payloads", like certificate and certificate request. Additionally, none of the examples include an initial exchange of ISAKMP Headers (containing initiator and responder cookies) which would provide protection against clogging (see section 2.5.3). The defined exchanges are not meant to satisfy all DOI and key exchange protocol requirements. If the defined exchanges meet the DOI requirements, then they can be used as outlined. If the defined exchanges do not meet the security requirements defined by the DOI, then the DOI MUST specify new exchange type(s) and the valid sequences of payloads that make up a successful exchange, and how to build and interpret those payloads. All ISAKMP implementations MUST implement the Informational Exchange and SHOULD implement the other four exchanges. However, this is dependent on the definition of the DOI and associated key exchange protocols. Maughan, et. al. Standards Track [Page 45] RFC 2408 ISAKMP November 1998 As discussed above, these exchange types can be used in either phase of negotiation. However, they may provide different security properties in each of the phases. With each of these exchanges, the combination of cookies and SPI fields identifies whether this exchange is being used in the first or second phase of a negotiation. 4.1.1 Notation The following notation is used to describe the ISAKMP exchange types, shown in the next section, with the message formats and associated payloads: HDR is an ISAKMP header whose exchange type defines the payload orderings SA is an SA negotiation payload with one or more Proposal and Transform payloads. An initiator MAY provide multiple proposals for negotiation; a responder MUST reply with only one. KE is the key exchange payload. IDx is the identity payload for "x". x can be: "ii" or "ir" for the ISAKMP initiator and responder, respectively, or x can be: "ui", "ur" (when the ISAKMP daemon is a proxy negotiator), for the user initiator and responder, respectively. HASH is the hash payload. SIG is the signature payload. The data to sign is exchange-specific. AUTH is a generic authentication mechanism, such as HASH or SIG. NONCE is the nonce payload. '*' signifies payload encryption after the ISAKMP header. This encryption MUST begin immediately after the ISAKMP header and all payloads following the ISAKMP header MUST be encrypted. => signifies "initiator to responder" communication <= signifies "responder to initiator" communication 4.2 Security Association Establishment The Security Association, Proposal, and Transform payloads are used to build ISAKMP messages for the negotiation and establishment of SAs. An SA establishment message consists of a single SA payload followed by at least one, and possibly many, Proposal payloads and at least one, and possibly many, Transform payloads associated with each Proposal payload. Because these payloads are considered together, the SA payload will point to any following payloads and not to the Proposal payload included with the SA payload. The SA Payload contains the DOI and Situation for the proposed SA. Each Proposal payload contains a Security Parameter Index (SPI) and ensures that the SPI is associated with the Protocol-Id in accordance with the Internet Security Architecture [SEC-ARCH]. Proposal payloads may or may not have the same SPI, as this is implementation dependent. Each Maughan, et. al. Standards Track [Page 46] RFC 2408 ISAKMP November 1998 Transform Payload contains the specific security mechanisms to be used for the designated protocol. It is expected that the Proposal and Transform payloads will be used only during SA establishment negotiation. The creation of payloads for security association negotiation and establishment described here in this section are applicable for all ISAKMP exchanges described later in sections 4.4 through 4.8. The examples shown in 4.2.1 contain only the SA, Proposal, and Transform payloads and do not contain other payloads that might exist for a given ISAKMP exchange. The Proposal payload provides the initiating entity with the capability to present to the responding entity the security protocols and associated security mechanisms for use with the security association being negotiated. If the SA establishment negotiation is for a combined protection suite consisting of multiple protocols, then there MUST be multiple Proposal payloads each with the same Proposal number. These proposals MUST be considered as a unit and MUST NOT be separated by a proposal with a different proposal number. The use of the same Proposal number in multiple Proposal payloads provides a logical AND operation, i.e. Protocol 1 AND Protocol 2. The first example below shows an ESP AND AH protection suite. If the SA establishment negotiation is for different protection suites, then there MUST be multiple Proposal payloads each with a monotonically increasing Proposal number. The different proposals MUST be presented in the initiator's preference order. The use of different Proposal numbers in multiple Proposal payloads provides a logical OR operation, i.e. Proposal 1 OR Proposal 2, where each proposal may have more than one protocol. The second example below shows either an AH AND ESP protection suite OR just an ESP protection suite. Note that the Next Payload field of the Proposal payload points to another Proposal payload (if it exists). The existence of a Proposal payload implies the existence of one or more Transform payloads. The Transform payload provides the initiating entity with the capability to present to the responding entity multiple mechanisms, or transforms, for a given protocol. The Proposal payload identifies a Protocol for which services and mechanisms are being negotiated. The Transform payload allows the initiating entity to present several possible supported transforms for that proposed protocol. There may be several transforms associated with a specific Proposal payload each identified in a separate Transform payload. The multiple transforms MUST be presented with monotonically increasing numbers in the initiator's preference order. The receiving entity MUST select a single transform for each protocol in a proposal or reject the entire proposal. The use of the Transform number in multiple Transform payloads provides a second level OR operation, i.e. Transform 1 OR Transform 2 OR Transform 3. Example 1 below shows two possible transforms for ESP and a single transform for AH. Example 2 below Maughan, et. al. Standards Track [Page 47] RFC 2408 ISAKMP November 1998 shows one transform for AH AND one transform for ESP OR two transforms for ESP alone. Note that the Next Payload field of the Transform payload points to another Transform payload or 0. The Proposal payload delineates the different proposals. When responding to a Security Association payload, the responder MUST send a Security Association payload with the selected proposal, which may consist of multiple Proposal payloads and their associated Transform payloads. Each of the Proposal payloads MUST contain a single Transform payload associated with the Protocol. The responder SHOULD retain the Proposal # field in the Proposal payload and the Transform # field in each Transform payload of the selected Proposal. Retention of Proposal and Transform numbers should speed the initiator's protocol processing by negating the need to compare the respondor's selection with every offered option. These values enable the initiator to perform the comparison directly and quickly. The initiator MUST verify that the Security Association payload received from the responder matches one of the proposals sent initially. 4.2.1 Security Association Establishment Examples This example shows a Proposal for a combined protection suite with two different protocols. The first protocol is presented with two transforms supported by the proposer. The second protocol is presented with a single transform. An example for this proposal might be: Protocol 1 is ESP with Transform 1 as 3DES and Transform 2 as DES AND Protocol 2 is AH with Transform 1 as SHA. The responder MUST select from the two transforms proposed for ESP. The resulting protection suite will be either (1) 3DES AND SHA OR (2) DES AND SHA, depending on which ESP transform was selected by the responder. Note this example is shown using the Base Exchange. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 /+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = Nonce ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ SA Pay ! Domain of Interpretation (DOI) ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! Situation ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = Proposal ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Prop 1 ! Proposal # = 1! Protocol-Id ! SPI Size !# of Trans. = 2! Prot 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SPI (variable) ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = Transform! RESERVED ! Payload Length ! Maughan, et. al. Standards Track [Page 48] RFC 2408 ISAKMP November 1998 / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 1 ! Transform # 1 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 2 ! Transform # 2 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Prop 1 ! Proposal # = 1! Protocol ID ! SPI Size !# of Trans. = 1! Prot 2 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SPI (variable) ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 1 ! Transform # 1 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! \+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ This second example shows a Proposal for two different protection suites. The SA Payload was omitted for space reasons. The first protection suite is presented with one transform for the first protocol and one transform for the second protocol. The second protection suite is presented with two transforms for a single protocol. An example for this proposal might be: Proposal 1 with Protocol 1 as AH with Transform 1 as MD5 AND Protocol 2 as ESP with Transform 1 as 3DES. This is followed by Proposal 2 with Protocol 1 as ESP with Transform 1 as DES and Transform 2 as 3DES. The responder MUST select from the two different proposals. If the second Proposal is selected, the responder MUST select from the two transforms for ESP. The resulting protection suite will be either (1) MD5 AND 3DES OR the selection between (2) DES OR (3) 3DES. 1 2 3 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 /+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = Proposal ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Prop 1 ! Proposal # = 1! Protocol ID ! SPI Size !# of Trans. = 1! Prot 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SPI (variable) ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! Maughan, et. al. Standards Track [Page 49] RFC 2408 ISAKMP November 1998 / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 1 ! Transform # 1 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = Proposal ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Prop 1 ! Proposal # = 1! Protocol ID ! SPI Size !# of Trans. = 1! Prot 2 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SPI (variable) ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 1 ! Transform # 1 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Prop 2 ! Proposal # = 2! Protocol ID ! SPI Size !# of Trans. = 2! Prot 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SPI (variable) ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = Transform! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 1 ! Transform # 1 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! >+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ / ! NP = 0 ! RESERVED ! Payload Length ! / +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Tran 2 ! Transform # 2 ! Transform ID ! RESERVED2 ! \ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ \ ! SA Attributes ! \+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 4.3 Security Association Modification Security Association modification within ISAKMP is accomplished by creating a new SA and initiating communications using that new SA. Deletion of the old SA can be done anytime after the new SA is established. Deletion of the old SA is dependent on local security policy. Modification of SAs by using a "Create New SA followed by Delete Old SA" method is done to avoid potential vulnerabilities in synchronizing modification of existing SA attributes. The procedure for creating new SAs is outlined in section 4.2. The procedure for deleting SAs is outlined in section 5.15. Maughan, et. al. Standards Track [Page 50] RFC 2408 ISAKMP November 1998 Modification of an ISAKMP SA (phase 1 negotiation) follows the same procedure as creation of an ISAKMP SA. There is no relationship between the two SAs and the initiator and responder cookie pairs SHOULD be different, as outlined in section 2.5.3. Modification of a Protocol SA (phase 2 negotiation) follows the same procedure as creation of a Protocol SA. The creation of a new SA is protected by the existing ISAKMP SA. There is no relationship between the two Protocol SAs. A protocol implementation SHOULD begin using the newly created SA for outbound traffic and SHOULD continue to support incoming traffic on the old SA until it is deleted or until traffic is received under the protection of the newly created SA. As stated previously in this section, deletion of an old SA is then dependent on local security policy. 4.4 Base Exchange The Base Exchange is designed to allow the Key Exchange and Authentication related information to be transmitted together. Combining the Key Exchange and Authentication-related information into one message reduces the number of round-trips at the expense of not providing identity protection. Identity protection is not provided because identities are exchanged before a common shared secret has been established and, therefore, encryption of the identities is not possible. The following diagram shows the messages with the possible payloads sent in each message and notes for an example of the Base Exchange. BASE EXCHANGE # Initiator Direction Responder NOTE (1) HDR; SA; NONCE => Begin ISAKMP-SA or Proxy negotiation (2) <= HDR; SA; NONCE Basic SA agreed upon (3) HDR; KE; => IDii; AUTH Key Generated (by responder) Initiator Identity Verified by Responder (4) <= HDR; KE; IDir; AUTH Responder Identity Verified by Initiator Key Generated (by initiator) SA established Maughan, et. al. Standards Track [Page 51] RFC 2408 ISAKMP November 1998 In the first message (1), the initiator generates a proposal it considers adequate to protect traffic for the given situation. The Security Association, Proposal, and Transform payloads are included in the Security Association payload (for notation purposes). Random information which is used to guarantee liveness and protect against replay attacks is also transmitted. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. In the second message (2), the responder indicates the protection suite it has accepted with the Security Association, Proposal, and Transform payloads. Again, random information which is used to guarantee liveness and protect against replay attacks is also transmitted. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. Local security policy dictates the action of the responder if no proposed protection suite is accepted. One possible action is the transmission of a Notify payload as part of an Informational Exchange. In the third (3) and fourth (4) messages, the initiator and responder, respectively, exchange keying material used to arrive at a common shared secret and identification information. This information is transmitted under the protection of the agreed upon authentication function. Local security policy dictates the action if an error occurs during these messages. One possible action is the transmission of a Notify payload as part of an Informational Exchange. 4.5 Identity Protection Exchange The Identity Protection Exchange is designed to separate the Key Exchange information from the Identity and Authentication related information. Separating the Key Exchange from the Identity and Authentication related information provides protection of the communicating identities at the expense of two additional messages. Identities are exchanged under the protection of a previously established common shared secret. The following diagram shows the messages with the possible payloads sent in each message and notes for an example of the Identity Protection Exchange. Maughan, et. al. Standards Track [Page 52] RFC 2408 ISAKMP November 1998 IDENTITY PROTECTION EXCHANGE # Initiator Direction Responder NOTE (1) HDR; SA => Begin ISAKMP-SA or Proxy negotiation (2) <= HDR; SA Basic SA agreed upon (3) HDR; KE; NONCE => (4) <= HDR; KE; NONCE Key Generated (by Initiator and Responder) (5) HDR*; IDii; AUTH => Initiator Identity Verified by Responder (6) <= HDR*; IDir; AUTH Responder Identity Verified by Initiator SA established In the first message (1), the initiator generates a proposal it considers adequate to protect traffic for the given situation. The Security Association, Proposal, and Transform payloads are included in the Security Association payload (for notation purposes). In the second message (2), the responder indicates the protection suite it has accepted with the Security Association, Proposal, and Transform payloads. Local security policy dictates the action of the responder if no proposed protection suite is accepted. One possible action is the transmission of a Notify payload as part of an Informational Exchange. In the third (3) and fourth (4) messages, the initiator and responder, respectively, exchange keying material used to arrive at a common shared secret and random information which is used to guarantee liveness and protect against replay attacks. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. Local security policy dictates the action if an error occurs during these messages. One possible action is the transmission of a Notify payload as part of an Informational Exchange. In the fifth (5) and sixth (6) messages, the initiator and responder, respectively, exchange identification information and the results of the agreed upon authentication function. This information is Maughan, et. al. Standards Track [Page 53] RFC 2408 ISAKMP November 1998 transmitted under the protection of the common shared secret. Local security policy dictates the action if an error occurs during these messages. One possible action is the transmission of a Notify payload as part of an Informational Exchange. 4.6 Authentication Only Exchange The Authentication Only Exchange is designed to allow only Authentication related information to be transmitted. The benefit of this exchange is the ability to perform only authentication without the computational expense of computing keys. Using this exchange during negotiation, none of the transmitted information will be encrypted. However, the information may be encrypted in other places. For example, if encryption is negotiated during the first phase of a negotiation and the authentication only exchange is used in the second phase of a negotiation, then the authentication only exchange will be encrypted by the ISAKMP SAs negotiated in the first phase. The following diagram shows the messages with possible payloads sent in each message and notes for an example of the Authentication Only Exchange. AUTHENTICATION ONLY EXCHANGE # Initiator Direction Responder NOTE (1) HDR; SA; NONCE => Begin ISAKMP-SA or Proxy negotiation (2) <= HDR; SA; NONCE; IDir; AUTH Basic SA agreed upon Responder Identity Verified by Initiator (3) HDR; IDii; AUTH => Initiator Identity Verified by Responder SA established In the first message (1), the initiator generates a proposal it considers adequate to protect traffic for the given situation. The Security Association, Proposal, and Transform payloads are included in the Security Association payload (for notation purposes). Random information which is used to guarantee liveness and protect against replay attacks is also transmitted. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. In the second message (2), the responder indicates the protection suite it has accepted with the Security Association, Proposal, and Transform payloads. Again, random information which is used to Maughan, et. al. Standards Track [Page 54] RFC 2408 ISAKMP November 1998 guarantee liveness and protect against replay attacks is also transmitted. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. Additionally, the responder transmits identification information. All of this information is transmitted under the protection of the agreed upon authentication function. Local security policy dictates the action of the responder if no proposed protection suite is accepted. One possible action is the transmission of a Notify payload as part of an Informational Exchange. In the third message (3), the initiator transmits identification information. This information is transmitted under the protection of the agreed upon authentication function. Local security policy dictates the action if an error occurs during these messages. One possible action is the transmission of a Notify payload as part of an Informational Exchange. 4.7 Aggressive Exchange The Aggressive Exchange is designed to allow the Security Association, Key Exchange and Authentication related payloads to be transmitted together. Combining the Security Association, Key Exchange, and Authentication-related information into one message reduces the number of round-trips at the expense of not providing identity protection. Identity protection is not provided because identities are exchanged before a common shared secret has been established and, therefore, encryption of the identities is not possible. Additionally, the Aggressive Exchange is attempting to establish all security relevant information in a single exchange. The following diagram shows the messages with possible payloads sent in each message and notes for an example of the Aggressive Exchange. Maughan, et. al. Standards Track [Page 55] RFC 2408 ISAKMP November 1998 AGGRESSIVE EXCHANGE # Initiator Direction Responder NOTE (1) HDR; SA; KE; => Begin ISAKMP-SA or Proxy negotiation NONCE; IDii and Key Exchange (2) <= HDR; SA; KE; NONCE; IDir; AUTH Initiator Identity Verified by Responder Key Generated Basic SA agreed upon (3) HDR*; AUTH => Responder Identity Verified by Initiator SA established In the first message (1), the initiator generates a proposal it considers adequate to protect traffic for the given situation. The Security Association, Proposal, and Transform payloads are included in the Security Association payload (for notation purposes). There can be only one Proposal and one Transform offered (i.e. no choices) in order for the aggressive exchange to work. Keying material used to arrive at a common shared secret and random information which is used to guarantee liveness and protect against replay attacks are also transmitted. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. Additionally, the initiator transmits identification information. In the second message (2), the responder indicates the protection suite it has accepted with the Security Association, Proposal, and Transform payloads. Keying material used to arrive at a common shared secret and random information which is used to guarantee liveness and protect against replay attacks is also transmitted. Random information provided by both parties SHOULD be used by the authentication mechanism to provide shared proof of participation in the exchange. Additionally, the responder transmits identification information. All of this information is transmitted under the protection of the agreed upon authentication function. Local security policy dictates the action of the responder if no proposed protection suite is accepted. One possible action is the transmission of a Notify payload as part of an Informational Exchange. Maughan, et. al. Standards Track [Page 56] RFC 2408 ISAKMP November 1998 In the third (3) message, the initiator transmits the results of the agreed upon authentication function. This information is transmitted under the protection of the common shared secret. Local security policy dictates the action if an error occurs during these messages. One possible action is the transmission of a Notify payload as part of an Informational Exchange. 4.8 Informational Exchange The Informational Exchange is designed as a one-way transmittal of information that can be used for security association management. The following diagram shows the messages with possible payloads sent in each message and notes for an example of the Informational Exchange. INFORMATIONAL EXCHANGE # Initiator Direction Responder NOTE (1) HDR*; N/D => Error Notification or Deletion In the first message (1), the initiator or responder transmits an ISAKMP Notify or Delete payload. If the Informational Exchange occurs prior to the exchange of keying meterial during an ISAKMP Phase 1 negotiation, there will be no protection provided for the Informational Exchange. Once keying material has been exchanged or an ISAKMP SA has been established, the Informational Exchange MUST be transmitted under the protection provided by the keying material or the ISAKMP SA. All exchanges are similar in that with the beginning of any exchange, cryptographic synchronization MUST occur. The Informational Exchange is an exchange and not an ISAKMP message. Thus, the generation of an Message ID (MID) for an Informational Exchange SHOULD be independent of IVs of other on-going communication. This will ensure cryptographic synchronization is maintained for existing communications and the Informational Exchange will be processed correctly. The only exception to this is when the Commit Bit of the ISAKMP Header is set. When the Commit Bit is set, the Message ID field of the Informational Exchange MUST contain the Message ID of the original ISAKMP Phase 2 SA negotiation, rather than a new Message ID (MID). This is done to ensure that the Informational Exchange with the CONNECTED Notify Message can be associated with the correct Phase 2 SA. For a description of the Commit Bit, see section 3.1. Maughan, et. al. Standards Track [Page 57] RFC 2408 ISAKMP November 1998 5 ISAKMP Payload Processing Section 3 describes the ISAKMP payloads. These payloads are used in the exchanges described in section 4 and can be used in exchanges defined for a specific DOI. This section describes the processing for each of the payloads. This section suggests the logging of events to a system audit file. This action is controlled by a system security policy and is, therefore, only a suggested action. 5.1 General Message Processing Every ISAKMP message has basic processing applied to insure protocol reliability, and to minimize threats, such as denial of service and replay attacks. All processing SHOULD include packet length checks to insure the packet received is at least as long as the length given in the ISAKMP Header. If the ISAKMP message length and the value in the Payload Length field of the ISAKMP Header are not the same, then the ISAKMP message MUST be rejected. The receiving entity (initiator or responder) MUST do the following: 1. The event, UNEQUAL PAYLOAD LENGTHS, MAY be logged in the appropriate system audit file. 2. An Informational Exchange with a Notification payload containing the UNEQUAL-PAYLOAD-LENGTHS message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. When transmitting an ISAKMP message, the transmitting entity (initiator or responder) MUST do the following: 1. Set a timer and initialize a retry counter. NOTE: Implementations MUST NOT use a fixed timer. Instead, transmission timer values should be adjusted dynamically based on measured round trip times. In addition, successive retransmissions of the same packet should be separated by increasingly longer time intervals (e.g., exponential backoff). 2. If the timer expires, the ISAKMP message is resent and the retry counter is decremented. 3. If the retry counter reaches zero (0), the event, RETRY LIMIT REACHED, MAY be logged in the appropriate system audit file. 4. The ISAKMP protocol machine clears all states and returns to IDLE. Maughan, et. al. Standards Track [Page 58] RFC 2408 ISAKMP November 1998 5.2 ISAKMP Header Processing When creating an ISAKMP message, the transmitting entity (initiator or responder) MUST do the following: 1. Create the respective cookie. See section 2.5.3 for details. 2. Determine the relevant security characteristics of the session (i.e. DOI and situation). 3. Construct an ISAKMP Header with fields as described in section 3.1. 4. Construct other ISAKMP payloads, depending on the exchange type. 5. Transmit the message to the destination host as described in section5.1. When an ISAKMP message is received, the receiving entity (initiator or responder) MUST do the following: 1. Verify the Initiator and Responder "cookies". If the cookie validation fails, the message is discarded and the following actions are taken: (a) The event, INVALID COOKIE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-COOKIE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Check the Next Payload field to confirm it is valid. If the Next Payload field validation fails, the message is discarded and the following actions are taken: (a) The event, INVALID NEXT PAYLOAD, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-PAYLOAD-TYPE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 3. Check the Major and Minor Version fields to confirm they are correct (see section 3.1). If the Version field validation fails, the message is discarded and the following actions are Maughan, et. al. Standards Track [Page 59] RFC 2408 ISAKMP November 1998 taken: (a) The event, INVALID ISAKMP VERSION, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-MAJOR-VERSION or INVALID-MINOR- VERSION message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 4. Check the Exchange Type field to confirm it is valid. If the Exchange Type field validation fails, the message is discarded and the following actions are taken: (a) The event, INVALID EXCHANGE TYPE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-EXCHANGE-TYPE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 5. Check the Flags field to ensure it contains correct values. If the Flags field validation fails, the message is discarded and the following actions are taken: (a) The event, INVALID FLAGS, MAY be logged in the appropriate systemaudit file. (b) An Informational Exchange with a Notification payload containing the INVALID-FLAGS message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 6. Check the Message ID field to ensure it contains correct values. If the Message ID validation fails, the message is discarded and the following actions are taken: (a) The event, INVALID MESSAGE ID, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-MESSAGE-ID message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 7. Processing of the ISAKMP message continues using the value in the Next Payload field. Maughan, et. al. Standards Track [Page 60] RFC 2408 ISAKMP November 1998 5.3 Generic Payload Header Processing When creating any of the ISAKMP Payloads described in sections 3.4 through 3.15 a Generic Payload Header is placed at the beginning of these payloads. When creating the Generic Payload Header, the transmitting entity (initiator or responder) MUST do the following: 1. Place the value of the Next Payload in the Next Payload field. These values are described in section 3.1. 2. Place the value zero (0) in the RESERVED field. 3. Place the length (in octets) of the payload in the Payload Length field. 4. Construct the payloads as defined in the remainder of this section. When any of the ISAKMP Payloads are received, the receiving entity (initiator or responder) MUST do the following: 1. Check the Next Payload field to confirm it is valid. If the Next Payload field validation fails, the message is discarded and the following actions are taken: (a) The event, INVALID NEXT PAYLOAD, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-PAYLOAD-TYPE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Verify the RESERVED field contains the value zero. If the value in the RESERVED field is not zero, the message is discarded and the following actions are taken: (a) The event, INVALID RESERVED FIELD, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the BAD-PROPOSAL-SYNTAX or PAYLOAD-MALFORMED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 3. Process the remaining payloads as defined by the Next Payload field. Maughan, et. al. Standards Track [Page 61] RFC 2408 ISAKMP November 1998 5.4 Security Association Payload Processing When creating a Security Association Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Domain of Interpretation for which this negotiation is being performed. 2. Determine the situation within the determined DOI for which this negotiation is being performed. 3. Determine the proposal(s) and transform(s) within the situation. These are described, respectively, in sections 3.5 and 3.6. 4. Construct a Security Association payload. 5. Transmit the message to the receiving entity as described in section 5.1. When a Security Association payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Domain of Interpretation (DOI) is supported. If the DOI determination fails, the message is discarded and the following actions are taken: (a) The event, INVALID DOI, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the DOI-NOT-SUPPORTED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Determine if the given situation can be protected. If the Situation determination fails, the message is discarded and the following actions are taken: (a) The event, INVALID SITUATION, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the SITUATION-NOT-SUPPORTED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 3. Process the remaining payloads (i.e. Proposal, Transform) of the Security Association Payload. If the Security Association Maughan, et. al. Standards Track [Page 62] RFC 2408 ISAKMP November 1998 Proposal (as described in sections 5.5 and 5.6) is not accepted, then the following actions are taken: (a) The event, INVALID PROPOSAL, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the NO-PROPOSAL-CHOSEN message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 5.5 Proposal Payload Processing When creating a Proposal Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Protocol for this proposal. 2. Determine the number of proposals to be offered for this protocol and the number of transforms for each proposal. Transforms are described in section 3.6. 3. Generate a unique pseudo-random SPI. 4. Construct a Proposal payload. When a Proposal payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Protocol is supported. If the Protocol-ID field is invalid, the payload is discarded and the following actions are taken: (a) The event, INVALID PROTOCOL, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-PROTOCOL-ID message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Determine if the SPI is valid. If the SPI is invalid, the payload is discarded and the following actions are taken: (a) The event, INVALID SPI, MAY be logged in the appropriate system audit file. Maughan, et. al. Standards Track [Page 63] RFC 2408 ISAKMP November 1998 (b) An Informational Exchange with a Notification payload containing the INVALID-SPI message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 3. Ensure the Proposals are presented according to the details given in section 3.5 and 4.2. If the proposals are not formed correctly, the following actions are taken: (a) Possible events, BAD PROPOSAL SYNTAX, INVALID PROPOSAL, are logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the BAD-PROPOSAL-SYNTAX or PAYLOAD-MALFORMED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 4. Process the Proposal and Transform payloads as defined by the Next Payload field. Examples of processing these payloads are given in section 4.2.1. 5.6 Transform Payload Processing When creating a Transform Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Transform # for this transform. 2. Determine the number of transforms to be offered for this proposal. Transforms are described in sections 3.6. 3. Construct a Transform payload. When a Transform payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Transform is supported. If the Transform-ID field contains an unknown or unsupported value, then that Transform payload MUST be ignored and MUST NOT cause the generation of an INVALID TRANSFORM event. If the Transform-ID field is invalid, the payload is discarded and the following actions are taken: (a) The event, INVALID TRANSFORM, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-TRANSFORM-ID message type MAY be sent Maughan, et. al. Standards Track [Page 64] RFC 2408 ISAKMP November 1998 to the transmitting entity. This action is dictated by a system security policy. 2. Ensure the Transforms are presented according to the details given in section 3.6 and 4.2. If the transforms are not formed correctly, the following actions are taken: (a) Possible events, BAD PROPOSAL SYNTAX, INVALID TRANSFORM, INVALID ATTRIBUTES, are logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the BAD-PROPOSAL-SYNTAX, PAYLOAD-MALFORMED or ATTRIBUTES-NOT-SUPPORTED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 3. Process the subsequent Transform and Proposal payloads as defined by the Next Payload field. Examples of processing these payloads are given in section 4.2.1. 5.7 Key Exchange Payload Processing When creating a Key Exchange Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Key Exchange to be used as defined by the DOI. 2. Determine the usage of the Key Exchange Data field as defined by the DOI. 3. Construct a Key Exchange payload. 4. Transmit the message to the receiving entity as described in section 5.1. When a Key Exchange payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Key Exchange is supported. If the Key Exchange determination fails, the message is discarded and the following actions are taken: (a) The event, INVALID KEY INFORMATION, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-KEY-INFORMATION message type MAY be Maughan, et. al. Standards Track [Page 65] RFC 2408 ISAKMP November 1998 sent to the transmitting entity. This action is dictated by a system security policy. 5.8 Identification Payload Processing When creating an Identification Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Identification information to be used as defined by the DOI (and possibly the situation). 2. Determine the usage of the Identification Data field as defined by the DOI. 3. Construct an Identification payload. 4. Transmit the message to the receiving entity as described in section 5.1. When an Identification payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Identification Type is supported. This may be based on the DOI and Situation. If the Identification determination fails, the message is discarded and the following actions are taken: (a) The event, INVALID ID INFORMATION, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-ID-INFORMATION message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 5.9 Certificate Payload Processing When creating a Certificate Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Certificate Encoding to be used. This may be specified by the DOI. 2. Ensure the existence of a certificate formatted as defined by the Certificate Encoding. 3. Construct a Certificate payload. Maughan, et. al. Standards Track [Page 66] RFC 2408 ISAKMP November 1998 4. Transmit the message to the receiving entity as described in section 5.1. When a Certificate payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Certificate Encoding is supported. If the Certificate Encoding is not supported, the payload is discarded and the following actions are taken: (a) The event, INVALID CERTIFICATE TYPE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-CERT-ENCODING message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Process the Certificate Data field. If the Certificate Data is invalid or improperly formatted, the payload is discarded and the following actions are taken: (a) The event, INVALID CERTIFICATE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-CERTIFICATE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 5.10 Certificate Request Payload Processing When creating a Certificate Request Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the type of Certificate Encoding to be requested. This may be specified by the DOI. 2. Determine the name of an acceptable Certificate Authority which is to be requested (if applicable). 3. Construct a Certificate Request payload. 4. Transmit the message to the receiving entity as described in section 5.1. When a Certificate Request payload is received, the receiving entity (initiator or responder) MUST do the following: Maughan, et. al. Standards Track [Page 67] RFC 2408 ISAKMP November 1998 1. Determine if the Certificate Encoding is supported. If the Certificate Encoding is invalid, the payload is discarded and the following actions are taken: (a) The event, INVALID CERTIFICATE TYPE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-CERT-ENCODING message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. If the Certificate Encoding is not supported, the payload is discarded and the following actions are taken: (a) The event, CERTIFICATE TYPE UNSUPPORTED, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the CERT-TYPE-UNSUPPORTED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Determine if the Certificate Authority is supported for the specified Certificate Encoding. If the Certificate Authority is invalid or improperly formatted, the payload is discarded and the following actions are taken: (a) The event, INVALID CERTIFICATE AUTHORITY, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-CERT-AUTHORITY message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 3. Process the Certificate Request. If a requested Certificate Type with the specified Certificate Authority is not available, then the payload is discarded and the following actions are taken: (a) The event, CERTIFICATE-UNAVAILABLE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the CERTIFICATE-UNAVAILABLE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. Maughan, et. al. Standards Track [Page 68] RFC 2408 ISAKMP November 1998 5.11 Hash Payload Processing When creating a Hash Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the Hash function to be used as defined by the SA negotiation. 2. Determine the usage of the Hash Data field as defined by the DOI. 3. Construct a Hash payload. 4. Transmit the message to the receiving entity as described in section 5.1. When a Hash payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Hash is supported. If the Hash determination fails, the message is discarded and the following actions are taken: (a) The event, INVALID HASH INFORMATION, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-HASH-INFORMATION message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Perform the Hash function as outlined in the DOI and/or Key Exchange protocol documents. If the Hash function fails, the message is discarded and the following actions are taken: (a) The event, INVALID HASH VALUE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the AUTHENTICATION-FAILED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 5.12 Signature Payload Processing When creating a Signature Payload, the transmitting entity (initiator or responder) MUST do the following: Maughan, et. al. Standards Track [Page 69] RFC 2408 ISAKMP November 1998 1. Determine the Signature function to be used as defined by the SA negotiation. 2. Determine the usage of the Signature Data field as defined by the DOI. 3. Construct a Signature payload. 4. Transmit the message to the receiving entity as described in section 5.1. When a Signature payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Signature is supported. If the Signature determination fails, the message is discarded and the following actions are taken: (a) The event, INVALID SIGNATURE INFORMATION, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the INVALID-SIGNATURE message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 2. Perform the Signature function as outlined in the DOI and/or Key Exchange protocol documents. If the Signature function fails, the message is discarded and the following actions are taken: (a) The event, INVALID SIGNATURE VALUE, MAY be logged in the appropriate system audit file. (b) An Informational Exchange with a Notification payload containing the AUTHENTICATION-FAILED message type MAY be sent to the transmitting entity. This action is dictated by a system security policy. 5.13 Nonce Payload Processing When creating a Nonce Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Create a unique random value to be used as a nonce. 2. Construct a Nonce payload. Maughan, et. al. Standards Track [Page 70] RFC 2408 ISAKMP November 1998 3. Transmit the message to the receiving entity as described in section 5.1. When a Nonce payload is received, the receiving entity (initiator or responder) MUST do the following: 1. There are no specific procedures for handling Nonce payloads. The procedures are defined by the exchange types (and possibly the DOI and Key Exchange descriptions). 5.14 Notification Payload Processing During communications it is possible that errors may occur. The Informational Exchange with a Notify Payload provides a controlled method of informing a peer entity that errors have occurred during protocol processing. It is RECOMMENDED that Notify Payloads be sent in a separate Informational Exchange rather than appending a Notify Payload to an existing exchange. When creating a Notification Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the DOI for this Notification. 2. Determine the Protocol-ID for this Notification. 3. Determine the SPI size based on the Protocol-ID field. This field is necessary because different security protocols have different SPI sizes. For example, ISAKMP combines the Initiator and Responder cookie pair (16 octets) as a SPI, while ESP and AH have 4 octet SPIs. 4. Determine the Notify Message Type based on the error or status message desired. 5. Determine the SPI which is associated with this notification. 6. Determine if additional Notification Data is to be included. This is additional information specified by the DOI. 7. Construct a Notification payload. 8. Transmit the message to the receiving entity as described in section 5.1. Because the Informational Exchange with a Notification payload is a unidirectional message a retransmission will not be performed. The local security policy will dictate the procedures for continuing. Maughan, et. al. Standards Track [Page 71] RFC 2408 ISAKMP November 1998 However, we RECOMMEND that a NOTIFICATION PAYLOAD ERROR event be logged in the appropriate system audit file by the receiving entity. If the Informational Exchange occurs prior to the exchange of keying material during an ISAKMP Phase 1 negotiation there will be no protection provided for the Informational Exchange. Once the keying material has been exchanged or the ISAKMP SA has been established, the Informational Exchange MUST be transmitted under the protection provided by the keying material or the ISAKMP SA. When a Notification payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Determine if the Informational Exchange has any protection applied to it by checking the Encryption Bit and the Authentication Only Bit in the ISAKMP Header. If the Encryption Bit is set, i.e. the Informational Exchange is encrypted, then the message MUST be decrypted using the (in-progress or completed) ISAKMP SA. Once the decryption is complete the processing can continue as described below. If the Authentication Only Bit is set, then the message MUST be authenticated using the (in-progress or completed) ISAKMP SA. Once the authentication is completed, the processing can continue as described below. If the Informational Exchange is not encrypted or authentication, the payload processing can continue as described below. 2. Determine if the Domain of Interpretation (DOI) is supported. If the DOI determination fails, the payload is discarded and the following action is taken: (a) The event, INVALID DOI, MAY be logged in the appropriate system audit file. 3. Determine if the Protocol-Id is supported. If the Protocol-Id determination fails, the payload is discarded and the following action is taken: (a) The event, INVALID PROTOCOL-ID, MAY be logged in the appropriate system audit file. 4. Determine if the SPI is valid. If the SPI is invalid, the payload is discarded and the following action is taken: (a) The event, INVALID SPI, MAY be logged in the appropriate system audit file. Maughan, et. al. Standards Track [Page 72] RFC 2408 ISAKMP November 1998 5. Determine if the Notify Message Type is valid. If the Notify Message Type is invalid, the payload is discarded and the following action is taken: (a) The event, INVALID MESSAGE TYPE, MAY be logged in the appropriate system audit file. 6. Process the Notification payload, including additional Notification Data, and take appropriate action, according to local security policy. 5.15 Delete Payload Processing During communications it is possible that hosts may be compromised or that information may be intercepted during transmission. Determining whether this has occurred is not an easy task and is outside the scope of this memo. However, if it is discovered that transmissions are being compromised, then it is necessary to establish a new SA and delete the current SA. The Informational Exchange with a Delete Payload provides a controlled method of informing a peer entity that the transmitting entity has deleted the SA(s). Deletion of Security Associations MUST always be performed under the protection of an ISAKMP SA. The receiving entity SHOULD clean up its local SA database. However, upon receipt of a Delete message the SAs listed in the Security Parameter Index (SPI) field of the Delete payload cannot be used with the transmitting entity. The SA Establishment procedure must be invoked to re-establish secure communications. When creating a Delete Payload, the transmitting entity (initiator or responder) MUST do the following: 1. Determine the DOI for this Deletion. 2. Determine the Protocol-ID for this Deletion. 3. Determine the SPI size based on the Protocol-ID field. This field is necessary because different security protocols have different SPI sizes. For example, ISAKMP combines the Initiator and Responder cookie pair (16 octets) as a SPI, while ESP and AH have 4 octet SPIs. 4. Determine the # of SPIs to be deleted for this protocol. 5. Determine the SPI(s) which is (are) associated with this deletion. Maughan, et. al. Standards Track [Page 73] RFC 2408 ISAKMP November 1998 6. Construct a Delete payload. 7. Transmit the message to the receiving entity as described in section 5.1. Because the Informational Exchange with a Delete payload is a unidirectional message a retransmission will not be performed. The local security policy will dictate the procedures for continuing. However, we RECOMMEND that a DELETE PAYLOAD ERROR event be logged in the appropriate system audit file by the receiving entity. As described above, the Informational Exchange with a Delete payload MUST be transmitted under the protection provided by an ISAKMP SA. When a Delete payload is received, the receiving entity (initiator or responder) MUST do the following: 1. Because the Informational Exchange is protected by some security service (e.g. authentication for an Auth-Only SA, encryption for other exchanges), the message MUST have these security services applied using the ISAKMP SA. Once the security service processing is complete the processing can continue as described below. Any errors that occur during the security service processing will be evident when checking information in the Delete payload. The local security policy SHOULD dictate any action to be taken as a result of security service processing errors. 2. Determine if the Domain of Interpretation (DOI) is supported. If the DOI determination fails, the payload is discarded and the following action is taken: (a) The event, INVALID DOI, MAY be logged in the appropriate system audit file. 3. Determine if the Protocol-Id is supported. If the Protocol-Id determination fails, the payload is discarded and the following action is taken: (a) The event, INVALID PROTOCOL-ID, MAY be logged in the appropriate system audit file. 4. Determine if the SPI is valid for each SPI included in the Delete payload. For each SPI that is invalid, the following action is taken: (a) The event, INVALID SPI, MAY be logged in the appropriate system audit file. Maughan, et. al. Standards Track [Page 74] RFC 2408 ISAKMP November 1998 5. Process the Delete payload and take appropriate action, according to local security policy. As described above, one appropriate action SHOULD include cleaning up the local SA database. 6 Conclusions The Internet Security Association and Key Management Protocol (ISAKMP) is a well designed protocol aimed at the Internet of the future. The massive growth of the Internet will lead to great diversity in network utilization, communications, security requirements, and security mechanisms. ISAKMP contains all the features that will be needed for this dynamic and expanding communications environment. ISAKMP's Security Association (SA) feature coupled with authentication and key establishment provides the security and flexibility that will be needed for future growth and diversity. This security diversity of multiple key exchange techniques, encryption algorithms, authentication mechanisms, security services, and security attributes will allow users to select the appropriate security for their network, communications, and security needs. The SA feature allows users to specify and negotiate security requirements with other users. An additional benefit of supporting multiple techniques in a single protocol is that as new techniques are developed they can easily be added to the protocol. This provides a path for the growth of Internet security services. ISAKMP supports both publicly or privately defined SAs, making it ideal for government, commercial, and private communications. ISAKMP provides the ability to establish SAs for multiple security protocols and applications. These protocols and applications may be session-oriented or sessionless. Having one SA establishment protocol that supports multiple security protocols eliminates the need for multiple, nearly identical authentication, key exchange and SA establishment protocols when more than one security protocol is in use or desired. Just as IP has provided the common networking layer for the Internet, a common security establishment protocol is needed if security is to become a reality on the Internet. ISAKMP provides the common base that allows all other security protocols to interoperate. ISAKMP follows good security design principles. It is not coupled to other insecure transport protocols, therefore it is not vulnerable or weakened by attacks on other protocols. Also, when more secure transport protocols are developed, ISAKMP can be easily migrated to them. ISAKMP also provides protection against protocol related attacks. This protection provides the assurance that the SAs and keys established are with the desired party and not with an attacker. Maughan, et. al. Standards Track [Page 75] RFC 2408 ISAKMP November 1998 ISAKMP also follows good protocol design principles. Protocol specific information only is in the protocol header, following the design principles of IPv6. The data transported by the protocol is separated into functional payloads. As the Internet grows and evolves, new payloads to support new security functionality can be added without modifying the entire protocol. Maughan, et. al. Standards Track [Page 76] RFC 2408 ISAKMP November 1998 A ISAKMP Security Association Attributes A.1 Background/Rationale As detailed in previous sections, ISAKMP is designed to provide a flexible and extensible framework for establishing and managing Security Associations and cryptographic keys. The framework provided by ISAKMP consists of header and payload definitions, exchange types for guiding message and payload exchanges, and general processing guidelines. ISAKMP does not define the mechanisms that will be used to establish and manage Security Associations and cryptographic keys in an authenticated and confidential manner. The definition of mechanisms and their application is the purview of individual Domains of Interpretation (DOIs). This section describes the ISAKMP values for the Internet IP Security DOI, supported security protocols, and identification values for ISAKMP Phase 1 negotiations. The Internet IP Security DOI is MANDATORY to implement for IP Security. [Oakley] and [IKE] describe, in detail, the mechanisms and their application for establishing and managing Security Associations and cryptographic keys for IP Security. A.2 Internet IP Security DOI Assigned Value As described in [IPDOI], the Internet IP Security DOI Assigned Number is one (1). A.3 Supported Security Protocols Values for supported security protocols are specified in the most recent "Assigned Numbers" RFC [STD-2]. Presented in the following table are the values for the security protocols supported by ISAKMP for the Internet IP Security DOI. Protocol Assigned Value RESERVED 0 ISAKMP 1 All DOIs MUST reserve ISAKMP with a Protocol-ID of 1. All other security protocols within that DOI will be numbered accordingly. Security protocol values 2-15359 are reserved to IANA for future use. Values 15360-16383 are permanently reserved for private use amongst mutually consenting implementations. Such private use values are unlikely to be interoperable across different implementations. Maughan, et. al. Standards Track [Page 77] RFC 2408 ISAKMP November 1998 A.4 ISAKMP Identification Type Values The following table lists the assigned values for the Identification Type field found in the Identification payload during a generic Phase 1 exchange, which is not for a specific protocol. ID Type Value ID_IPV4_ADDR 0 ID_IPV4_ADDR_SUBNET 1 ID_IPV6_ADDR 2 ID_IPV6_ADDR_SUBNET 3 A.4.1 ID_IPV4_ADDR The ID_IPV4_ADDR type specifies a single four (4) octet IPv4 address. A.4.2 ID_IPV4_ADDR_SUBNET The ID_IPV4_ADDR_SUBNET type specifies a range of IPv4 addresses, represented by two four (4) octet values. The first value is an IPv4 address. The second is an IPv4 network mask. Note that ones (1s) in the network mask indicate that the corresponding bit in the address is fixed, while zeros (0s) indicate a "wildcard" bit. A.4.3 ID_IPV6_ADDR The ID_IPV6_ADDR type specifies a single sixteen (16) octet IPv6 address. A.4.4 ID_IPV6_ADDR_SUBNET The ID_IPV6_ADDR_SUBNET type specifies a range of IPv6 addresses, represented by two sixteen (16) octet values. The first value is an IPv6 address. The second is an IPv6 network mask. Note that ones (1s) in the network mask indicate that the corresponding bit in the address is fixed, while zeros (0s) indicate a "wildcard" bit. Maughan, et. al. Standards Track [Page 78] RFC 2408 ISAKMP November 1998 B Defining a new Domain of Interpretation The Internet DOI may be sufficient to meet the security requirements of a large portion of the internet community. However, some groups may have a need to customize some aspect of a DOI, perhaps to add a different set of cryptographic algorithms, or perhaps because they want to make their security-relevant decisions based on something other than a host id or user id. Also, a particular group may have a need for a new exchange type, for example to support key management for multicast groups. This section discusses guidelines for defining a new DOI. The full specification for the Internet DOI can be found in [IPDOI]. Defining a new DOI is likely to be a time-consuming process. If at all possible, it is recommended that the designer begin with an existing DOI and customize only the parts that are unacceptable. If a designer chooses to start from scratch, the following MUST be defined: o A "situation": the set of information that will be used to determine the required security services. o The set of security policies that must be supported. o A scheme for naming security-relevant information, including encryption algorithms, key exchange algorithms, etc. o A syntax for the specification of proposed security services, attributes, and certificate authorities. o The specific formats of the various payload contents. o Additional exchange types, if required. B.1 Situation The situation is the basis for deciding how to protect a communications channel. It must contain all of the data that will be used to determine the types and strengths of protections applied in an SA. For example, a US Department of Defense DOI would probably use unpublished algorithms and have additional special attributes to negotiate. These additional security attributes would be included in the situation. Maughan, et. al. Standards Track [Page 79] RFC 2408 ISAKMP November 1998 B.2 Security Policies Security policies define how various types of information must be categorized and protected. The DOI must define the set of security policies supported, because both parties in a negotiation must trust that the other party understands a situation, and will protect information appropriately, both in transit and in storage. In a corporate setting, for example, both parties in a negotiation must agree to the meaning of the term "proprietary information" before they can negotiate how to protect it. Note that including the required security policies in the DOI only specifies that the participating hosts understand and implement those policies in a full system context. B.3 Naming Schemes Any DOI must define a consistent way to name cryptographic algorithms, certificate authorities, etc. This can usually be done by using IANA naming conventions, perhaps with some private extensions. B.4 Syntax for Specifying Security Services In addition to simply specifying how to name entities, the DOI must also specify the format for complete proposals of how to protect traffic under a given situation. B.5 Payload Specification The DOI must specify the format of each of the payload types. For several of the payload types, ISAKMP has included fields that would have to be present across all DOI (such as a certificate authority in the certificate payload, or a key exchange identifier in the key exchange payload). B.6 Defining new Exchange Types If the basic exchange types are inadequate to meet the requirements within a DOI, a designer can define up to thirteen extra exchange types per DOI. The designer creates a new exchange type by choosing an unused exchange type value, and defining a sequence of messages composed of strings of the ISAKMP payload types. Note that any new exchange types must be rigorously analyzed for vulnerabilities. Since this is an expensive and imprecise undertaking, a new exchange type should only be created when absolutely necessary. Maughan, et. al. Standards Track [Page 80] RFC 2408 ISAKMP November 1998 Security Considerations Cryptographic analysis techniques are improving at a steady pace. The continuing improvement in processing power makes once computationally prohibitive cryptographic attacks more realistic. New cryptographic algorithms and public key generation techniques are also being developed at a steady pace. New security services and mechanisms are being developed at an accelerated pace. A consistent method of choosing from a variety of security services and mechanisms and to exchange attributes required by the mechanisms is important to security in the complex structure of the Internet. However, a system that locks itself into a single cryptographic algorithm, key exchange technique, or security mechanism will become increasingly vulnerable as time passes. UDP is an unreliable datagram protocol and therefore its use in ISAKMP introduces a number of security considerations. Since UDP is unreliable, but a key management protocol must be reliable, the reliability is built into ISAKMP. While ISAKMP utilizes UDP as its transport mechanism, it doesn't rely on any UDP information (e.g. checksum, length) for its processing. Another issue that must be considered in the development of ISAKMP is the effect of firewalls on the protocol. Many firewalls filter out all UDP packets, making reliance on UDP questionable in certain environments. A number of very important security considerations are presented in [SEC-ARCH]. One bears repeating. Once a private session key is created, it must be safely stored. Failure to properly protect the private key from access both internal and external to the system completely nullifies any protection provided by the IP Security services. IANA Considerations This document contains many "magic" numbers to be maintained by the IANA. This section explains the criteria to be used by the IANA to assign additional numbers in each of these lists. Domain of Interpretation The Domain of Interpretation (DOI) is a 32-bit field which identifies the domain under which the security association negotiation is taking place. Requests for assignments of new DOIs must be accompanied by a standards-track RFC which describes the specific domain. Maughan, et. al. Standards Track [Page 81] RFC 2408 ISAKMP November 1998 Supported Security Protocols ISAKMP is designed to provide security association negotiation and key management for many security protocols. Requests for identifiers for additional security protocols must be accompanied by a standards-track RFC which describes the security protocol and its relationship to ISAKMP. Acknowledgements Dan Harkins, Dave Carrel, and Derrell Piper of Cisco Systems provided design assistance with the protocol and coordination for the [IKE] and [IPDOI] documents. Hilarie Orman, via the Oakley key exchange protocol, has significantly influenced the design of ISAKMP. Marsha Gross, Bill Kutz, Mike Oehler, Pete Sell, and Ruth Taylor provided significant input and review to this document. Scott Carlson ported the TIS DNSSEC prototype to FreeBSD for use with the ISAKMP prototype. Jeff Turner and Steve Smalley contributed to the prototype development and integration with ESP and AH. Mike Oehler and Pete Sell performed interoperability testing with other ISAKMP implementors. Thanks to Carl Muckenhirn of SPARTA, Inc. for his assistance with LaTeX. References [ANSI] ANSI, X9.42: Public Key Cryptography for the Financial Services Industry -- Establishment of Symmetric Algorithm Keys Using Diffie-Hellman, Working Draft, April 19, 1996. [BC] Ballardie, A., and J. Crowcroft, Multicast-specific Security Threats and Countermeasures, Proceedings of 1995 ISOC Symposium on Networks & Distributed Systems Security, pp. 17-30, Internet Society, San Diego, CA, February 1995. [Berge] Berge, N., "UNINETT PCA Policy Statements", RFC 1875, December 1995. Maughan, et. al. Standards Track [Page 82] RFC 2408 ISAKMP November 1998 [CW87] Clark, D.D. and D.R. Wilson, A Comparison of Commercial and Military Computer Security Policies, Proceedings of the IEEE Symposium on Security & Privacy, Oakland, CA, 1987, pp. 184-193. [DNSSEC] D. Eastlake III, Domain Name System Protocol Security Extensions, Work in Progress. [DOW92] Diffie, W., M.Wiener, P. Van Oorschot, Authentication and Authenticated Key Exchanges, Designs, Codes, and Cryptography, 2, 107-125, Kluwer Academic Publishers, 1992. [IAB] Bellovin, S., "Report of the IAB Security Architecture Workshop", RFC 2316, April 1998. [IKE] Harkins, D., and D. Carrel, "The Internet Key Exchange (IKE)", RFC 2409, November 1998. [IPDOI] Piper, D., "The Internet IP Security Domain of Interpretation for ISAKMP", RFC 2407, November 1998. [Karn] Karn, P., and B. Simpson, Photuris: Session Key Management Protocol, Work in Progress. [Kent94] Steve Kent, IPSEC SMIB, e-mail to ipsec@ans.net, August 10, 1994. [Oakley] Orman, H., "The Oakley Key Determination Protocol", RFC 2412, November 1998. [RFC-1422] Kent, S., "Privacy Enhancement for Internet Electronic Mail: Part II: Certificate-Based Key Management", RFC 1422, February 1993. [RFC-1949] Ballardie, A., "Scalable Multicast Key Distribution", RFC 1949, May 1996. [RFC-2093] Harney, H., and C. Muckenhirn, "Group Key Management Protocol (GKMP) Specification", RFC 2093, July 1997. [RFC-2094] Harney, H., and C. Muckenhirn, "Group Key Management Protocol (GKMP) Architecture", RFC 2094, July 1997. [RFC-2119] Bradner, S., "Key Words for use in RFCs to Indicate Requirement Levels", BCP 14, RFC 2119, March 1997. Maughan, et. al. Standards Track [Page 83] RFC 2408 ISAKMP November 1998 [Schneier] Bruce Schneier, Applied Cryptography - Protocols, Algorithms, and Source Code in C (Second Edition), John Wiley & Sons, Inc., 1996. [SEC-ARCH] Atkinson, R., and S. Kent, "Security Architecture for the Internet Protocol", RFC 2401, November 1998. [STD-2] Reynolds, J., and J. Postel, "Assigned Numbers", STD 2, RFC 1700, October 1994. See also: http://www.iana.org/numbers.html Maughan, et. al. Standards Track [Page 84] RFC 2408 ISAKMP November 1998 Authors' Addresses Douglas Maughan National Security Agency ATTN: R23 9800 Savage Road Ft. Meade, MD. 20755-6000 Phone: 301-688-0847 EMail:wdm@tycho.ncsc.mil Mark Schneider National Security Agency ATTN: R23 9800 Savage Road Ft. Meade, MD. 20755-6000 Phone: 301-688-0851 EMail:mss@tycho.ncsc.mil Mark Schertler Securify, Inc. 2415-B Charleston Road Mountain View, CA 94043 Phone: 650-934-9303 EMail:mjs@securify.com Jeff Turner RABA Technologies, Inc. 10500 Little Patuxent Parkway Columbia, MD. 21044 Phone: 410-715-9399 EMail:jeff.turner@raba.com Maughan, et. al. Standards Track [Page 85] RFC 2408 ISAKMP November 1998 Full Copyright Statement Copyright (C) The Internet Society (1998). All Rights Reserved. This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English. The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns. This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Maughan, et. al. Standards Track [Page 86] fiked-0.0.5+git20120331.1.e6a5109/doc/rfc2409.txt0000644000000000000000000027134511735550573014675 0ustar00 Network Working Group D. Harkins Request for Comments: 2409 D. Carrel Category: Standards Track cisco Systems November 1998 The Internet Key Exchange (IKE) Status of this Memo This document specifies an Internet standards track protocol for the Internet community, and requests discussion and suggestions for improvements. Please refer to the current edition of the "Internet Official Protocol Standards" (STD 1) for the standardization state and status of this protocol. Distribution of this memo is unlimited. Copyright Notice Copyright (C) The Internet Society (1998). All Rights Reserved. Table Of Contents 1 Abstract........................................................ 2 2 Discussion...................................................... 2 3 Terms and Definitions........................................... 3 3.1 Requirements Terminology...................................... 3 3.2 Notation...................................................... 3 3.3 Perfect Forward Secrecty...................................... 5 3.4 Security Association.......................................... 5 4 Introduction.................................................... 5 5 Exchanges....................................................... 8 5.1 Authentication with Digital Signatures........................ 10 5.2 Authentication with Public Key Encryption..................... 12 5.3 A Revised method of Authentication with Public Key Encryption. 13 5.4 Authentication with a Pre-Shared Key.......................... 16 5.5 Quick Mode.................................................... 16 5.6 New Group Mode................................................ 20 5.7 ISAKMP Informational Exchanges................................ 20 6 Oakley Groups................................................... 21 6.1 First Oakley Group............................................ 21 6.2 Second Oakley Group........................................... 22 6.3 Third Oakley Group............................................ 22 6.4 Fourth Oakley Group........................................... 23 7 Payload Explosion of Complete Exchange.......................... 23 7.1 Phase 1 with Main Mode........................................ 23 7.2 Phase 2 with Quick Mode....................................... 25 8 Perfect Forward Secrecy Example................................. 27 9 Implementation Hints............................................ 27 Harkins & Carrel Standards Track [Page 1] RFC 2409 IKE November 1998 10 Security Considerations........................................ 28 11 IANA Considerations............................................ 30 12 Acknowledgments................................................ 31 13 References..................................................... 31 Appendix A........................................................ 33 Appendix B........................................................ 37 Authors' Addresses................................................ 40 Authors' Note..................................................... 40 Full Copyright Statement.......................................... 41 1. Abstract ISAKMP ([MSST98]) provides a framework for authentication and key exchange but does not define them. ISAKMP is designed to be key exchange independant; that is, it is designed to support many different key exchanges. Oakley ([Orm96]) describes a series of key exchanges-- called "modes"-- and details the services provided by each (e.g. perfect forward secrecy for keys, identity protection, and authentication). SKEME ([SKEME]) describes a versatile key exchange technique which provides anonymity, repudiability, and quick key refreshment. This document describes a protocol using part of Oakley and part of SKEME in conjunction with ISAKMP to obtain authenticated keying material for use with ISAKMP, and for other security associations such as AH and ESP for the IETF IPsec DOI. 2. Discussion This memo describes a hybrid protocol. The purpose is to negotiate, and provide authenticated keying material for, security associations in a protected manner. Processes which implement this memo can be used for negotiating virtual private networks (VPNs) and also for providing a remote user from a remote site (whose IP address need not be known beforehand) access to a secure host or network. Client negotiation is supported. Client mode is where the negotiating parties are not the endpoints for which security association negotiation is taking place. When used in client mode, the identities of the end parties remain hidden. Harkins & Carrel Standards Track [Page 2] RFC 2409 IKE November 1998 This does not implement the entire Oakley protocol, but only a subset necessary to satisfy its goals. It does not claim conformance or compliance with the entire Oakley protocol nor is it dependant in any way on the Oakley protocol. Likewise, this does not implement the entire SKEME protocol, but only the method of public key encryption for authentication and its concept of fast re-keying using an exchange of nonces. This protocol is not dependant in any way on the SKEME protocol. 3. Terms and Definitions 3.1 Requirements Terminology Keywords "MUST", "MUST NOT", "REQUIRED", "SHOULD", "SHOULD NOT" and "MAY" that appear in this document are to be interpreted as described in [Bra97]. 3.2 Notation The following notation is used throughout this memo. HDR is an ISAKMP header whose exchange type is the mode. When writen as HDR* it indicates payload encryption. SA is an SA negotiation payload with one or more proposals. An initiator MAY provide multiple proposals for negotiation; a responder MUST reply with only one.

_b indicates the body of payload

-- the ISAKMP generic vpayload is not included. SAi_b is the entire body of the SA payload (minus the ISAKMP generic header)-- i.e. the DOI, situation, all proposals and all transforms offered by the Initiator. CKY-I and CKY-R are the Initiator's cookie and the Responder's cookie, respectively, from the ISAKMP header. g^xi and g^xr are the Diffie-Hellman ([DH]) public values of the initiator and responder respectively. g^xy is the Diffie-Hellman shared secret. KE is the key exchange payload which contains the public information exchanged in a Diffie-Hellman exchange. There is no particular encoding (e.g. a TLV) used for the data of a KE payload. Harkins & Carrel Standards Track [Page 3] RFC 2409 IKE November 1998 Nx is the nonce payload; x can be: i or r for the ISAKMP initiator and responder respectively. IDx is the identification payload for "x". x can be: "ii" or "ir" for the ISAKMP initiator and responder respectively during phase one negotiation; or "ui" or "ur" for the user initiator and responder respectively during phase two. The ID payload format for the Internet DOI is defined in [Pip97]. SIG is the signature payload. The data to sign is exchange- specific. CERT is the certificate payload. HASH (and any derivitive such as HASH(2) or HASH_I) is the hash payload. The contents of the hash are specific to the authentication method. prf(key, msg) is the keyed pseudo-random function-- often a keyed hash function-- used to generate a deterministic output that appears pseudo-random. prf's are used both for key derivations and for authentication (i.e. as a keyed MAC). (See [KBC96]). SKEYID is a string derived from secret material known only to the active players in the exchange. SKEYID_e is the keying material used by the ISAKMP SA to protect the confidentiality of its messages. SKEYID_a is the keying material used by the ISAKMP SA to authenticate its messages. SKEYID_d is the keying material used to derive keys for non-ISAKMP security associations. y indicates that "x" is encrypted with the key "y". --> signifies "initiator to responder" communication (requests). <-- signifies "responder to initiator" communication (replies). | signifies concatenation of information-- e.g. X | Y is the concatentation of X with Y. [x] indicates that x is optional. Harkins & Carrel Standards Track [Page 4] RFC 2409 IKE November 1998 Message encryption (when noted by a '*' after the ISAKMP header) MUST begin immediately after the ISAKMP header. When communication is protected, all payloads following the ISAKMP header MUST be encrypted. Encryption keys are generated from SKEYID_e in a manner that is defined for each algorithm. 3.3 Perfect Forward Secrecy When used in the memo Perfect Forward Secrecy (PFS) refers to the notion that compromise of a single key will permit access to only data protected by a single key. For PFS to exist the key used to protect transmission of data MUST NOT be used to derive any additional keys, and if the key used to protect transmission of data was derived from some other keying material, that material MUST NOT be used to derive any more keys. Perfect Forward Secrecy for both keys and identities is provided in this protocol. (Sections 5.5 and 8). 3.4 Security Association A security association (SA) is a set of policy and key(s) used to protect information. The ISAKMP SA is the shared policy and key(s) used by the negotiating peers in this protocol to protect their communication. 4. Introduction Oakley and SKEME each define a method to establish an authenticated key exchange. This includes payloads construction, the information payloads carry, the order in which they are processed and how they are used. While Oakley defines "modes", ISAKMP defines "phases". The relationship between the two is very straightforward and IKE presents different exchanges as modes which operate in one of two phases. Phase 1 is where the two ISAKMP peers establish a secure, authenticated channel with which to communicate. This is called the ISAKMP Security Association (SA). "Main Mode" and "Aggressive Mode" each accomplish a phase 1 exchange. "Main Mode" and "Aggressive Mode" MUST ONLY be used in phase 1. Phase 2 is where Security Associations are negotiated on behalf of services such as IPsec or any other service which needs key material and/or parameter negotiation. "Quick Mode" accomplishes a phase 2 exchange. "Quick Mode" MUST ONLY be used in phase 2. Harkins & Carrel Standards Track [Page 5] RFC 2409 IKE November 1998 "New Group Mode" is not really a phase 1 or phase 2. It follows phase 1, but serves to establish a new group which can be used in future negotiations. "New Group Mode" MUST ONLY be used after phase 1. The ISAKMP SA is bi-directional. That is, once established, either party may initiate Quick Mode, Informational, and New Group Mode Exchanges. Per the base ISAKMP document, the ISAKMP SA is identified by the Initiator's cookie followed by the Responder's cookie-- the role of each party in the phase 1 exchange dictates which cookie is the Initiator's. The cookie order established by the phase 1 exchange continues to identify the ISAKMP SA regardless of the direction the Quick Mode, Informational, or New Group exchange. In other words, the cookies MUST NOT swap places when the direction of the ISAKMP SA changes. With the use of ISAKMP phases, an implementation can accomplish very fast keying when necessary. A single phase 1 negotiation may be used for more than one phase 2 negotiation. Additionally a single phase 2 negotiation can request multiple Security Associations. With these optimizations, an implementation can see less than one round trip per SA as well as less than one DH exponentiation per SA. "Main Mode" for phase 1 provides identity protection. When identity protection is not needed, "Aggressive Mode" can be used to reduce round trips even further. Developer hints for doing these optimizations are included below. It should also be noted that using public key encryption to authenticate an Aggressive Mode exchange will still provide identity protection. This protocol does not define its own DOI per se. The ISAKMP SA, established in phase 1, MAY use the DOI and situation from a non- ISAKMP service (such as the IETF IPSec DOI [Pip97]). In this case an implementation MAY choose to restrict use of the ISAKMP SA for establishment of SAs for services of the same DOI. Alternately, an ISAKMP SA MAY be established with the value zero in both the DOI and situation (see [MSST98] for a description of these fields) and in this case implementations will be free to establish security services for any defined DOI using this ISAKMP SA. If a DOI of zero is used for establishment of a phase 1 SA, the syntax of the identity payloads used in phase 1 is that defined in [MSST98] and not from any DOI-- e.g. [Pip97]-- which may further expand the syntax and semantics of identities. The following attributes are used by IKE and are negotiated as part of the ISAKMP Security Association. (These attributes pertain only to the ISAKMP Security Association and not to any Security Associations that ISAKMP may be negotiating on behalf of other services.) Harkins & Carrel Standards Track [Page 6] RFC 2409 IKE November 1998 - encryption algorithm - hash algorithm - authentication method - information about a group over which to do Diffie-Hellman. All of these attributes are mandatory and MUST be negotiated. In addition, it is possible to optionally negotiate a psuedo-random function ("prf"). (There are currently no negotiable pseudo-random functions defined in this document. Private use attribute values can be used for prf negotiation between consenting parties). If a "prf" is not negotiation, the HMAC (see [KBC96]) version of the negotiated hash algorithm is used as a pseudo-random function. Other non- mandatory attributes are described in Appendix A. The selected hash algorithm MUST support both native and HMAC modes. The Diffie-Hellman group MUST be either specified using a defined group description (section 6) or by defining all attributes of a group (section 5.6). Group attributes (such as group type or prime-- see Appendix A) MUST NOT be offered in conjunction with a previously defined group (either a reserved group description or a private use description that is established after conclusion of a New Group Mode exchange). IKE implementations MUST support the following attribute values: - DES [DES] in CBC mode with a weak, and semi-weak, key check (weak and semi-weak keys are referenced in [Sch96] and listed in Appendix A). The key is derived according to Appendix B. - MD5 [MD5] and SHA [SHA}. - Authentication via pre-shared keys. - MODP over default group number one (see below). In addition, IKE implementations SHOULD support: 3DES for encryption; Tiger ([TIGER]) for hash; the Digital Signature Standard, RSA [RSA] signatures and authentication with RSA public key encryption; and MODP group number 2. IKE implementations MAY support any additional encryption algorithms defined in Appendix A and MAY support ECP and EC2N groups. The IKE modes described here MUST be implemented whenever the IETF IPsec DOI [Pip97] is implemented. Other DOIs MAY use the modes described here. Harkins & Carrel Standards Track [Page 7] RFC 2409 IKE November 1998 5. Exchanges There are two basic methods used to establish an authenticated key exchange: Main Mode and Aggressive Mode. Each generates authenticated keying material from an ephemeral Diffie-Hellman exchange. Main Mode MUST be implemented; Aggressive Mode SHOULD be implemented. In addition, Quick Mode MUST be implemented as a mechanism to generate fresh keying material and negotiate non-ISAKMP security services. In addition, New Group Mode SHOULD be implemented as a mechanism to define private groups for Diffie-Hellman exchanges. Implementations MUST NOT switch exchange types in the middle of an exchange. Exchanges conform to standard ISAKMP payload syntax, attribute encoding, timeouts and retransmits of messages, and informational messages-- e.g a notify response is sent when, for example, a proposal is unacceptable, or a signature verification or decryption was unsuccessful, etc. The SA payload MUST precede all other payloads in a phase 1 exchange. Except where otherwise noted, there are no requirements for ISAKMP payloads in any message to be in any particular order. The Diffie-Hellman public value passed in a KE payload, in either a phase 1 or phase 2 exchange, MUST be the length of the negotiated Diffie-Hellman group enforced, if necessary, by pre-pending the value with zeros. The length of nonce payload MUST be between 8 and 256 bytes inclusive. Main Mode is an instantiation of the ISAKMP Identity Protect Exchange: The first two messages negotiate policy; the next two exchange Diffie-Hellman public values and ancillary data (e.g. nonces) necessary for the exchange; and the last two messages authenticate the Diffie-Hellman Exchange. The authentication method negotiated as part of the initial ISAKMP exchange influences the composition of the payloads but not their purpose. The XCHG for Main Mode is ISAKMP Identity Protect. Similarly, Aggressive Mode is an instantiation of the ISAKMP Aggressive Exchange. The first two messages negotiate policy, exchange Diffie-Hellman public values and ancillary data necessary for the exchange, and identities. In addition the second message authenticates the responder. The third message authenticates the initiator and provides a proof of participation in the exchange. The XCHG for Aggressive Mode is ISAKMP Aggressive. The final message MAY NOT be sent under protection of the ISAKMP SA allowing each party to Harkins & Carrel Standards Track [Page 8] RFC 2409 IKE November 1998 postpone exponentiation, if desired, until negotiation of this exchange is complete. The graphic depictions of Aggressive Mode show the final payload in the clear; it need not be. Exchanges in IKE are not open ended and have a fixed number of messages. Receipt of a Certificate Request payload MUST NOT extend the number of messages transmitted or expected. Security Association negotiation is limited with Aggressive Mode. Due to message construction requirements the group in which the Diffie- Hellman exchange is performed cannot be negotiated. In addition, different authentication methods may further constrain attribute negotiation. For example, authentication with public key encryption cannot be negotiated and when using the revised method of public key encryption for authentication the cipher and hash cannot be negotiated. For situations where the rich attribute negotiation capabilities of IKE are required Main Mode may be required. Quick Mode and New Group Mode have no analog in ISAKMP. The XCHG values for Quick Mode and New Group Mode are defined in Appendix A. Main Mode, Aggressive Mode, and Quick Mode do security association negotiation. Security Association offers take the form of Tranform Payload(s) encapsulated in Proposal Payload(s) encapsulated in Security Association (SA) payload(s). If multiple offers are being made for phase 1 exchanges (Main Mode and Aggressive Mode) they MUST take the form of multiple Transform Payloads for a single Proposal Payload in a single SA payload. To put it another way, for phase 1 exchanges there MUST NOT be multiple Proposal Payloads for a single SA payload and there MUST NOT be multiple SA payloads. This document does not proscribe such behavior on offers in phase 2 exchanges. There is no limit on the number of offers the initiator may send to the responder but conformant implementations MAY choose to limit the number of offers it will inspect for performance reasons. During security association negotiation, initiators present offers for potential security associations to responders. Responders MUST NOT modify attributes of any offer, attribute encoding excepted (see Appendix A). If the initiator of an exchange notices that attribute values have changed or attributes have been added or deleted from an offer made, that response MUST be rejected. Four different authentication methods are allowed with either Main Mode or Aggressive Mode-- digital signature, two forms of authentication with public key encryption, or pre-shared key. The value SKEYID is computed seperately for each authentication method. Harkins & Carrel Standards Track [Page 9] RFC 2409 IKE November 1998 For signatures: SKEYID = prf(Ni_b | Nr_b, g^xy) For public key encryption: SKEYID = prf(hash(Ni_b | Nr_b), CKY-I | CKY-R) For pre-shared keys: SKEYID = prf(pre-shared-key, Ni_b | Nr_b) The result of either Main Mode or Aggressive Mode is three groups of authenticated keying material: SKEYID_d = prf(SKEYID, g^xy | CKY-I | CKY-R | 0) SKEYID_a = prf(SKEYID, SKEYID_d | g^xy | CKY-I | CKY-R | 1) SKEYID_e = prf(SKEYID, SKEYID_a | g^xy | CKY-I | CKY-R | 2) and agreed upon policy to protect further communications. The values of 0, 1, and 2 above are represented by a single octet. The key used for encryption is derived from SKEYID_e in an algorithm-specific manner (see appendix B). To authenticate either exchange the initiator of the protocol generates HASH_I and the responder generates HASH_R where: HASH_I = prf(SKEYID, g^xi | g^xr | CKY-I | CKY-R | SAi_b | IDii_b ) HASH_R = prf(SKEYID, g^xr | g^xi | CKY-R | CKY-I | SAi_b | IDir_b ) For authentication with digital signatures, HASH_I and HASH_R are signed and verified; for authentication with either public key encryption or pre-shared keys, HASH_I and HASH_R directly authenticate the exchange. The entire ID payload (including ID type, port, and protocol but excluding the generic header) is hashed into both HASH_I and HASH_R. As mentioned above, the negotiated authentication method influences the content and use of messages for Phase 1 Modes, but not their intent. When using public keys for authentication, the Phase 1 exchange can be accomplished either by using signatures or by using public key encryption (if the algorithm supports it). Following are Phase 1 exchanges with different authentication options. 5.1 IKE Phase 1 Authenticated With Signatures Using signatures, the ancillary information exchanged during the second roundtrip are nonces; the exchange is authenticated by signing a mutually obtainable hash. Main Mode with signature authentication is described as follows: Harkins & Carrel Standards Track [Page 10] RFC 2409 IKE November 1998 Initiator Responder ----------- ----------- HDR, SA --> <-- HDR, SA HDR, KE, Ni --> <-- HDR, KE, Nr HDR*, IDii, [ CERT, ] SIG_I --> <-- HDR*, IDir, [ CERT, ] SIG_R Aggressive mode with signatures in conjunction with ISAKMP is described as follows: Initiator Responder ----------- ----------- HDR, SA, KE, Ni, IDii --> <-- HDR, SA, KE, Nr, IDir, [ CERT, ] SIG_R HDR, [ CERT, ] SIG_I --> In both modes, the signed data, SIG_I or SIG_R, is the result of the negotiated digital signature algorithm applied to HASH_I or HASH_R respectively. In general the signature will be over HASH_I and HASH_R as above using the negotiated prf, or the HMAC version of the negotiated hash function (if no prf is negotiated). However, this can be overridden for construction of the signature if the signature algorithm is tied to a particular hash algorithm (e.g. DSS is only defined with SHA's 160 bit output). In this case, the signature will be over HASH_I and HASH_R as above, except using the HMAC version of the hash algorithm associated with the signature method. The negotiated prf and hash function would continue to be used for all other prescribed pseudo- random functions. Since the hash algorithm used is already known there is no need to encode its OID into the signature. In addition, there is no binding between the OIDs used for RSA signatures in PKCS #1 and those used in this document. Therefore, RSA signatures MUST be encoded as a private key encryption in PKCS #1 format and not as a signature in PKCS #1 format (which includes the OID of the hash algorithm). DSS signatures MUST be encoded as r followed by s. One or more certificate payloads MAY be optionally passed. Harkins & Carrel Standards Track [Page 11] RFC 2409 IKE November 1998 5.2 Phase 1 Authenticated With Public Key Encryption Using public key encryption to authenticate the exchange, the ancillary information exchanged is encrypted nonces. Each party's ability to reconstruct a hash (proving that the other party decrypted the nonce) authenticates the exchange. In order to perform the public key encryption, the initiator must already have the responder's public key. In the case where the responder has multiple public keys, a hash of the certificate the initiator is using to encrypt the ancillary information is passed as part of the third message. In this way the responder can determine which corresponding private key to use to decrypt the encrypted payloads and identity protection is retained. In addition to the nonce, the identities of the parties (IDii and IDir) are also encrypted with the other party's public key. If the authentication method is public key encryption, the nonce and identity payloads MUST be encrypted with the public key of the other party. Only the body of the payloads are encrypted, the payload headers are left in the clear. When using encryption for authentication, Main Mode is defined as follows. Initiator Responder ----------- ----------- HDR, SA --> <-- HDR, SA HDR, KE, [ HASH(1), ] PubKey_r, PubKey_r --> HDR, KE, PubKey_i, <-- PubKey_i HDR*, HASH_I --> <-- HDR*, HASH_R Aggressive Mode authenticated with encryption is described as follows: Initiator Responder ----------- ----------- HDR, SA, [ HASH(1),] KE, Pubkey_r, Pubkey_r --> HDR, SA, KE, PubKey_i, <-- PubKey_i, HASH_R HDR, HASH_I --> Harkins & Carrel Standards Track [Page 12] RFC 2409 IKE November 1998 Where HASH(1) is a hash (using the negotiated hash function) of the certificate which the initiator is using to encrypt the nonce and identity. RSA encryption MUST be encoded in PKCS #1 format. While only the body of the ID and nonce payloads is encrypted, the encrypted data must be preceded by a valid ISAKMP generic header. The payload length is the length of the entire encrypted payload plus header. The PKCS #1 encoding allows for determination of the actual length of the cleartext payload upon decryption. Using encryption for authentication provides for a plausably deniable exchange. There is no proof (as with a digital signature) that the conversation ever took place since each party can completely reconstruct both sides of the exchange. In addition, security is added to secret generation since an attacker would have to successfully break not only the Diffie-Hellman exchange but also both RSA encryptions. This exchange was motivated by [SKEME]. Note that, unlike other authentication methods, authentication with public key encryption allows for identity protection with Aggressive Mode. 5.3 Phase 1 Authenticated With a Revised Mode of Public Key Encryption Authentication with Public Key Encryption has significant advantages over authentication with signatures (see section 5.2 above). Unfortunately, this is at the cost of 4 public key operations-- two public key encryptions and two private key decryptions. This authentication mode retains the advantages of authentication using public key encryption but does so with half the public key operations. In this mode, the nonce is still encrypted using the public key of the peer, however the peer's identity (and the certificate if it is sent) is encrypted using the negotiated symmetric encryption algorithm (from the SA payload) with a key derived from the nonce. This solution adds minimal complexity and state yet saves two costly public key operations on each side. In addition, the Key Exchange payload is also encrypted using the same derived key. This provides additional protection against cryptanalysis of the Diffie-Hellman exchange. As with the public key encryption method of authentication (section 5.2), a HASH payload may be sent to identify a certificate if the responder has multiple certificates which contain useable public keys (e.g. if the certificate is not for signatures only, either due to certificate restrictions or algorithmic restrictions). If the HASH Harkins & Carrel Standards Track [Page 13] RFC 2409 IKE November 1998 payload is sent it MUST be the first payload of the second message exchange and MUST be followed by the encrypted nonce. If the HASH payload is not sent, the first payload of the second message exchange MUST be the encrypted nonce. In addition, the initiator my optionally send a certificate payload to provide the responder with a public key with which to respond. When using the revised encryption mode for authentication, Main Mode is defined as follows. Initiator Responder ----------- ----------- HDR, SA --> <-- HDR, SA HDR, [ HASH(1), ] Pubkey_r, Ke_i, Ke_i, [<Ke_i] --> HDR, PubKey_i, Ke_r, <-- Ke_r, HDR*, HASH_I --> <-- HDR*, HASH_R Aggressive Mode authenticated with the revised encryption method is described as follows: Initiator Responder ----------- ----------- HDR, SA, [ HASH(1),] Pubkey_r, Ke_i, Ke_i [, Ke_i ] --> HDR, SA, PubKey_i, Ke_r, Ke_r, <-- HASH_R HDR, HASH_I --> where HASH(1) is identical to section 5.2. Ke_i and Ke_r are keys to the symmetric encryption algorithm negotiated in the SA payload exchange. Only the body of the payloads are encrypted (in both public key and symmetric operations), the generic payload headers are left in the clear. The payload length includes that added to perform encryption. The symmetric cipher keys are derived from the decrypted nonces as follows. First the values Ne_i and Ne_r are computed: Harkins & Carrel Standards Track [Page 14] RFC 2409 IKE November 1998 Ne_i = prf(Ni_b, CKY-I) Ne_r = prf(Nr_b, CKY-R) The keys Ke_i and Ke_r are then taken from Ne_i and Ne_r respectively in the manner described in Appendix B used to derive symmetric keys for use with the negotiated encryption algorithm. If the length of the output of the negotiated prf is greater than or equal to the key length requirements of the cipher, Ke_i and Ke_r are derived from the most significant bits of Ne_i and Ne_r respectively. If the desired length of Ke_i and Ke_r exceed the length of the output of the prf the necessary number of bits is obtained by repeatedly feeding the results of the prf back into itself and concatenating the result until the necessary number has been achieved. For example, if the negotiated encryption algorithm requires 320 bits of key and the output of the prf is only 128 bits, Ke_i is the most significant 320 bits of K, where K = K1 | K2 | K3 and K1 = prf(Ne_i, 0) K2 = prf(Ne_i, K1) K3 = prf(Ne_i, K2) For brevity, only derivation of Ke_i is shown; Ke_r is identical. The length of the value 0 in the computation of K1 is a single octet. Note that Ne_i, Ne_r, Ke_i, and Ke_r are all ephemeral and MUST be discarded after use. Save the requirements on the location of the optional HASH payload and the mandatory nonce payload there are no further payload requirements. All payloads-- in whatever order-- following the encrypted nonce MUST be encrypted with Ke_i or Ke_r depending on the direction. If CBC mode is used for the symmetric encryption then the initialization vectors (IVs) are set as follows. The IV for encrypting the first payload following the nonce is set to 0 (zero). The IV for subsequent payloads encrypted with the ephemeral symmetric cipher key, Ke_i, is the last ciphertext block of the previous payload. Encrypted payloads are padded up to the nearest block size. All padding bytes, except for the last one, contain 0x00. The last byte of the padding contains the number of the padding bytes used, excluding the last one. Note that this means there will always be padding. Harkins & Carrel Standards Track [Page 15] RFC 2409 IKE November 1998 5.4 Phase 1 Authenticated With a Pre-Shared Key A key derived by some out-of-band mechanism may also be used to authenticate the exchange. The actual establishment of this key is out of the scope of this document. When doing a pre-shared key authentication, Main Mode is defined as follows: Initiator Responder ---------- ----------- HDR, SA --> <-- HDR, SA HDR, KE, Ni --> <-- HDR, KE, Nr HDR*, IDii, HASH_I --> <-- HDR*, IDir, HASH_R Aggressive mode with a pre-shared key is described as follows: Initiator Responder ----------- ----------- HDR, SA, KE, Ni, IDii --> <-- HDR, SA, KE, Nr, IDir, HASH_R HDR, HASH_I --> When using pre-shared key authentication with Main Mode the key can only be identified by the IP address of the peers since HASH_I must be computed before the initiator has processed IDir. Aggressive Mode allows for a wider range of identifiers of the pre-shared secret to be used. In addition, Aggressive Mode allows two parties to maintain multiple, different pre-shared keys and identify the correct one for a particular exchange. 5.5 Phase 2 - Quick Mode Quick Mode is not a complete exchange itself (in that it is bound to a phase 1 exchange), but is used as part of the SA negotiation process (phase 2) to derive keying material and negotiate shared policy for non-ISAKMP SAs. The information exchanged along with Quick Mode MUST be protected by the ISAKMP SA-- i.e. all payloads except the ISAKMP header are encrypted. In Quick Mode, a HASH payload MUST immediately follow the ISAKMP header and a SA payload MUST immediately follow the HASH. This HASH authenticates the message and also provides liveliness proofs. Harkins & Carrel Standards Track [Page 16] RFC 2409 IKE November 1998 The message ID in the ISAKMP header identifies a Quick Mode in progress for a particular ISAKMP SA which itself is identified by the cookies in the ISAKMP header. Since each instance of a Quick Mode uses a unique initialization vector (see Appendix B) it is possible to have multiple simultaneous Quick Modes, based off a single ISAKMP SA, in progress at any one time. Quick Mode is essentially a SA negotiation and an exchange of nonces that provides replay protection. The nonces are used to generate fresh key material and prevent replay attacks from generating bogus security associations. An optional Key Exchange payload can be exchanged to allow for an additional Diffie-Hellman exchange and exponentiation per Quick Mode. While use of the key exchange payload with Quick Mode is optional it MUST be supported. Base Quick Mode (without the KE payload) refreshes the keying material derived from the exponentiation in phase 1. This does not provide PFS. Using the optional KE payload, an additional exponentiation is performed and PFS is provided for the keying material. The identities of the SAs negotiated in Quick Mode are implicitly assumed to be the IP addresses of the ISAKMP peers, without any implied constraints on the protocol or port numbers allowed, unless client identifiers are specified in Quick Mode. If ISAKMP is acting as a client negotiator on behalf of another party, the identities of the parties MUST be passed as IDci and then IDcr. Local policy will dictate whether the proposals are acceptable for the identities specified. If the client identities are not acceptable to the Quick Mode responder (due to policy or other reasons), a Notify payload with Notify Message Type INVALID-ID-INFORMATION (18) SHOULD be sent. The client identities are used to identify and direct traffic to the appropriate tunnel in cases where multiple tunnels exist between two peers and also to allow for unique and shared SAs with different granularities. All offers made during a Quick Mode are logically related and must be consistant. For example, if a KE payload is sent, the attribute describing the Diffie-Hellman group (see section 6.1 and [Pip97]) MUST be included in every transform of every proposal of every SA being negotiated. Similarly, if client identities are used, they MUST apply to every SA in the negotiation. Quick Mode is defined as follows: Harkins & Carrel Standards Track [Page 17] RFC 2409 IKE November 1998 Initiator Responder ----------- ----------- HDR*, HASH(1), SA, Ni [, KE ] [, IDci, IDcr ] --> <-- HDR*, HASH(2), SA, Nr [, KE ] [, IDci, IDcr ] HDR*, HASH(3) --> Where: HASH(1) is the prf over the message id (M-ID) from the ISAKMP header concatenated with the entire message that follows the hash including all payload headers, but excluding any padding added for encryption. HASH(2) is identical to HASH(1) except the initiator's nonce-- Ni, minus the payload header-- is added after M-ID but before the complete message. The addition of the nonce to HASH(2) is for a liveliness proof. HASH(3)-- for liveliness-- is the prf over the value zero represented as a single octet, followed by a concatenation of the message id and the two nonces-- the initiator's followed by the responder's-- minus the payload header. In other words, the hashes for the above exchange are: HASH(1) = prf(SKEYID_a, M-ID | SA | Ni [ | KE ] [ | IDci | IDcr ) HASH(2) = prf(SKEYID_a, M-ID | Ni_b | SA | Nr [ | KE ] [ | IDci | IDcr ) HASH(3) = prf(SKEYID_a, 0 | M-ID | Ni_b | Nr_b) With the exception of the HASH, SA, and the optional ID payloads, there are no payload ordering restrictions on Quick Mode. HASH(1) and HASH(2) may differ from the illustration above if the order of payloads in the message differs from the illustrative example or if any optional payloads, for example a notify payload, have been chained to the message. If PFS is not needed, and KE payloads are not exchanged, the new keying material is defined as KEYMAT = prf(SKEYID_d, protocol | SPI | Ni_b | Nr_b). If PFS is desired and KE payloads were exchanged, the new keying material is defined as KEYMAT = prf(SKEYID_d, g(qm)^xy | protocol | SPI | Ni_b | Nr_b) where g(qm)^xy is the shared secret from the ephemeral Diffie-Hellman exchange of this Quick Mode. In either case, "protocol" and "SPI" are from the ISAKMP Proposal Payload that contained the negotiated Transform. Harkins & Carrel Standards Track [Page 18] RFC 2409 IKE November 1998 A single SA negotiation results in two security assocations-- one inbound and one outbound. Different SPIs for each SA (one chosen by the initiator, the other by the responder) guarantee a different key for each direction. The SPI chosen by the destination of the SA is used to derive KEYMAT for that SA. For situations where the amount of keying material desired is greater than that supplied by the prf, KEYMAT is expanded by feeding the results of the prf back into itself and concatenating results until the required keying material has been reached. In other words, KEYMAT = K1 | K2 | K3 | ... where K1 = prf(SKEYID_d, [ g(qm)^xy | ] protocol | SPI | Ni_b | Nr_b) K2 = prf(SKEYID_d, K1 | [ g(qm)^xy | ] protocol | SPI | Ni_b | Nr_b) K3 = prf(SKEYID_d, K2 | [ g(qm)^xy | ] protocol | SPI | Ni_b | Nr_b) etc. This keying material (whether with PFS or without, and whether derived directly or through concatenation) MUST be used with the negotiated SA. It is up to the service to define how keys are derived from the keying material. In the case of an ephemeral Diffie-Hellman exchange in Quick Mode, the exponential (g(qm)^xy) is irretreivably removed from the current state and SKEYID_e and SKEYID_a (derived from phase 1 negotiation) continue to protect and authenticate the ISAKMP SA and SKEYID_d continues to be used to derive keys. Using Quick Mode, multiple SA's and keys can be negotiated with one exchange as follows: Initiator Responder ----------- ----------- HDR*, HASH(1), SA0, SA1, Ni, [, KE ] [, IDci, IDcr ] --> <-- HDR*, HASH(2), SA0, SA1, Nr, [, KE ] [, IDci, IDcr ] HDR*, HASH(3) --> The keying material is derived identically as in the case of a single SA. In this case (negotiation of two SA payloads) the result would be four security associations-- two each way for both SAs. Harkins & Carrel Standards Track [Page 19] RFC 2409 IKE November 1998 5.6 New Group Mode New Group Mode MUST NOT be used prior to establishment of an ISAKMP SA. The description of a new group MUST only follow phase 1 negotiation. (It is not a phase 2 exchange, though). Initiator Responder ----------- ----------- HDR*, HASH(1), SA --> <-- HDR*, HASH(2), SA where HASH(1) is the prf output, using SKEYID_a as the key, and the message-ID from the ISAKMP header concatenated with the entire SA proposal, body and header, as the data; HASH(2) is the prf output, using SKEYID_a as the key, and the message-ID from the ISAKMP header concatenated with the reply as the data. In other words the hashes for the above exchange are: HASH(1) = prf(SKEYID_a, M-ID | SA) HASH(2) = prf(SKEYID_a, M-ID | SA) The proposal will specify the characteristics of the group (see appendix A, "Attribute Assigned Numbers"). Group descriptions for private Groups MUST be greater than or equal to 2^15. If the group is not acceptable, the responder MUST reply with a Notify payload with the message type set to ATTRIBUTES-NOT-SUPPORTED (13). ISAKMP implementations MAY require private groups to expire with the SA under which they were established. Groups may be directly negotiated in the SA proposal with Main Mode. To do this the component parts-- for a MODP group, the type, prime and generator; for a EC2N group the type, the Irreducible Polynomial, Group Generator One, Group Generator Two, Group Curve A, Group Curve B and Group Order-- are passed as SA attributes (see Appendix A). Alternately, the nature of the group can be hidden using New Group Mode and only the group identifier is passed in the clear during phase 1 negotiation. 5.7 ISAKMP Informational Exchanges This protocol protects ISAKMP Informational Exchanges when possible. Once the ISAKMP security association has been established (and SKEYID_e and SKEYID_a have been generated) ISAKMP Information Exchanges, when used with this protocol, are as follows: Harkins & Carrel Standards Track [Page 20] RFC 2409 IKE November 1998 Initiator Responder ----------- ----------- HDR*, HASH(1), N/D --> where N/D is either an ISAKMP Notify Payload or an ISAKMP Delete Payload and HASH(1) is the prf output, using SKEYID_a as the key, and a M-ID unique to this exchange concatenated with the entire informational payload (either a Notify or Delete) as the data. In other words, the hash for the above exchange is: HASH(1) = prf(SKEYID_a, M-ID | N/D) As noted the message ID in the ISAKMP header-- and used in the prf computation-- is unique to this exchange and MUST NOT be the same as the message ID of another phase 2 exchange which generated this informational exchange. The derivation of the initialization vector, used with SKEYID_e to encrypt this message, is described in Appendix B. If the ISAKMP security association has not yet been established at the time of the Informational Exchange, the exchange is done in the clear without an accompanying HASH payload. 6 Oakley Groups With IKE, the group in which to do the Diffie-Hellman exchange is negotiated. Four groups-- values 1 through 4-- are defined below. These groups originated with the Oakley protocol and are therefore called "Oakley Groups". The attribute class for "Group" is defined in Appendix A. All values 2^15 and higher are used for private group identifiers. For a discussion on the strength of the default Oakley groups please see the Security Considerations section below. These groups were all generated by Richard Schroeppel at the University of Arizona. Properties of these groups are described in [Orm96]. 6.1 First Oakley Default Group Oakley implementations MUST support a MODP group with the following prime and generator. This group is assigned id 1 (one). The prime is: 2^768 - 2 ^704 - 1 + 2^64 * { [2^638 pi] + 149686 } Its hexadecimal value is Harkins & Carrel Standards Track [Page 21] RFC 2409 IKE November 1998 FFFFFFFF FFFFFFFF C90FDAA2 2168C234 C4C6628B 80DC1CD1 29024E08 8A67CC74 020BBEA6 3B139B22 514A0879 8E3404DD EF9519B3 CD3A431B 302B0A6D F25F1437 4FE1356D 6D51C245 E485B576 625E7EC6 F44C42E9 A63A3620 FFFFFFFF FFFFFFFF The generator is: 2. 6.2 Second Oakley Group IKE implementations SHOULD support a MODP group with the following prime and generator. This group is assigned id 2 (two). The prime is 2^1024 - 2^960 - 1 + 2^64 * { [2^894 pi] + 129093 }. Its hexadecimal value is FFFFFFFF FFFFFFFF C90FDAA2 2168C234 C4C6628B 80DC1CD1 29024E08 8A67CC74 020BBEA6 3B139B22 514A0879 8E3404DD EF9519B3 CD3A431B 302B0A6D F25F1437 4FE1356D 6D51C245 E485B576 625E7EC6 F44C42E9 A637ED6B 0BFF5CB6 F406B7ED EE386BFB 5A899FA5 AE9F2411 7C4B1FE6 49286651 ECE65381 FFFFFFFF FFFFFFFF The generator is 2 (decimal) 6.3 Third Oakley Group IKE implementations SHOULD support a EC2N group with the following characteristics. This group is assigned id 3 (three). The curve is based on the Galois Field GF[2^155]. The field size is 155. The irreducible polynomial for the field is: u^155 + u^62 + 1. The equation for the elliptic curve is: y^2 + xy = x^3 + ax^2 + b. Field Size: 155 Group Prime/Irreducible Polynomial: 0x0800000000000000000000004000000000000001 Group Generator One: 0x7b Group Curve A: 0x0 Group Curve B: 0x07338f Group Order: 0X0800000000000000000057db5698537193aef944 The data in the KE payload when using this group is the value x from the solution (x,y), the point on the curve chosen by taking the randomly chosen secret Ka and computing Ka*P, where * is the repetition of the group addition and double operations, P is the curve point with x coordinate equal to generator 1 and the y Harkins & Carrel Standards Track [Page 22] RFC 2409 IKE November 1998 coordinate determined from the defining equation. The equation of curve is implicitly known by the Group Type and the A and B coefficients. There are two possible values for the y coordinate; either one can be used successfully (the two parties need not agree on the selection). 6.4 Fourth Oakley Group IKE implementations SHOULD support a EC2N group with the following characteristics. This group is assigned id 4 (four). The curve is based on the Galois Field GF[2^185]. The field size is 185. The irreducible polynomial for the field is: u^185 + u^69 + 1. The equation for the elliptic curve is: y^2 + xy = x^3 + ax^2 + b. Field Size: 185 Group Prime/Irreducible Polynomial: 0x020000000000000000000000000000200000000000000001 Group Generator One: 0x18 Group Curve A: 0x0 Group Curve B: 0x1ee9 Group Order: 0X01ffffffffffffffffffffffdbf2f889b73e484175f94ebc The data in the KE payload when using this group will be identical to that as when using Oakley Group 3 (three). Other groups can be defined using New Group Mode. These default groups were generated by Richard Schroeppel at the University of Arizona. Properties of these primes are described in [Orm96]. 7. Payload Explosion for a Complete IKE Exchange This section illustrates how the IKE protocol is used to: - establish a secure and authenticated channel between ISAKMP processes (phase 1); and - generate key material for, and negotiate, an IPsec SA (phase 2). 7.1 Phase 1 using Main Mode The following diagram illustrates the payloads exchanged between the two parties in the first round trip exchange. The initiator MAY propose several proposals; the responder MUST reply with one. Harkins & Carrel Standards Track [Page 23] RFC 2409 IKE November 1998 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ISAKMP Header with XCHG of Main Mode, ~ ~ and Next Payload of ISA_SA ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Domain of Interpretation ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Situation ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Proposal #1 ! PROTO_ISAKMP ! SPI size = 0 | # Transforms ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_TRANS ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Transform #1 ! KEY_OAKLEY | RESERVED2 ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ prefered SA attributes ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Transform #2 ! KEY_OAKLEY | RESERVED2 ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ alternate SA attributes ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ The responder replies in kind but selects, and returns, one transform proposal (the ISAKMP SA attributes). The second exchange consists of the following payloads: 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ISAKMP Header with XCHG of Main Mode, ~ ~ and Next Payload of ISA_KE ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_NONCE ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ D-H Public Value (g^xi from initiator g^xr from responder) ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Ni (from initiator) or Nr (from responder) ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Harkins & Carrel Standards Track [Page 24] RFC 2409 IKE November 1998 The shared keys, SKEYID_e and SKEYID_a, are now used to protect and authenticate all further communication. Note that both SKEYID_e and SKEYID_a are unauthenticated. 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ISAKMP Header with XCHG of Main Mode, ~ ~ and Next Payload of ISA_ID and the encryption bit set ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_SIG ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ Identification Data of the ISAKMP negotiator ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ signature verified by the public key of the ID above ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ The key exchange is authenticated over a signed hash as described in section 5.1. Once the signature has been verified using the authentication algorithm negotiated as part of the ISAKMP SA, the shared keys, SKEYID_e and SKEYID_a can be marked as authenticated. (For brevity, certificate payloads were not exchanged). 7.2 Phase 2 using Quick Mode The following payloads are exchanged in the first round of Quick Mode with ISAKMP SA negotiation. In this hypothetical exchange, the ISAKMP negotiators are proxies for other parties which have requested authentication. 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ISAKMP Header with XCHG of Quick Mode, ~ ~ Next Payload of ISA_HASH and the encryption bit set ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_SA ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ keyed hash of message ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_NONCE ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Domain Of Interpretation ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Situation ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ Harkins & Carrel Standards Track [Page 25] RFC 2409 IKE November 1998 ! Proposal #1 ! PROTO_IPSEC_AH! SPI size = 4 | # Transforms ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ SPI (4 octets) ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_TRANS ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Transform #1 ! AH_SHA | RESERVED2 ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! other SA attributes ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! Transform #2 ! AH_MD5 | RESERVED2 ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! other SA attributes ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_ID ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ nonce ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! ISA_ID ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ID of source for which ISAKMP is a client ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ID of destination for which ISAKMP is a client ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ where the contents of the hash are described in 5.5 above. The responder replies with a similar message which only contains one transform-- the selected AH transform. Upon receipt, the initiator can provide the key engine with the negotiated security association and the keying material. As a check against replay attacks, the responder waits until receipt of the next message. 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ ISAKMP Header with XCHG of Quick Mode, ~ ~ Next Payload of ISA_HASH and the encryption bit set ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ! 0 ! RESERVED ! Payload Length ! +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ ~ hash data ~ +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ where the contents of the hash are described in 5.5 above. Harkins & Carrel Standards Track [Page 26] RFC 2409 IKE November 1998 8. Perfect Forward Secrecy Example This protocol can provide PFS of both keys and identities. The identies of both the ISAKMP negotiating peer and, if applicable, the identities for whom the peers are negotiating can be protected with PFS. To provide Perfect Forward Secrecy of both keys and all identities, two parties would perform the following: o A Main Mode Exchange to protect the identities of the ISAKMP peers. This establishes an ISAKMP SA. o A Quick Mode Exchange to negotiate other security protocol protection. This establishes a SA on each end for this protocol. o Delete the ISAKMP SA and its associated state. Since the key for use in the non-ISAKMP SA was derived from the single ephemeral Diffie-Hellman exchange PFS is preserved. To provide Perfect Forward Secrecy of merely the keys of a non-ISAKMP security association, it in not necessary to do a phase 1 exchange if an ISAKMP SA exists between the two peers. A single Quick Mode in which the optional KE payload is passed, and an additional Diffie- Hellman exchange is performed, is all that is required. At this point the state derived from this Quick Mode must be deleted from the ISAKMP SA as described in section 5.5. 9. Implementation Hints Using a single ISAKMP Phase 1 negotiation makes subsequent Phase 2 negotiations extremely quick. As long as the Phase 1 state remains cached, and PFS is not needed, Phase 2 can proceed without any exponentiation. How many Phase 2 negotiations can be performed for a single Phase 1 is a local policy issue. The decision will depend on the strength of the algorithms being used and level of trust in the peer system. An implementation may wish to negotiate a range of SAs when performing Quick Mode. By doing this they can speed up the "re- keying". Quick Mode defines how KEYMAT is defined for a range of SAs. When one peer feels it is time to change SAs they simply use the next one within the stated range. A range of SAs can be established by negotiating multiple SAs (identical attributes, different SPIs) with one Quick Mode. Harkins & Carrel Standards Track [Page 27] RFC 2409 IKE November 1998 An optimization that is often useful is to establish Security Associations with peers before they are needed so that when they become needed they are already in place. This ensures there would be no delays due to key management before initial data transmission. This optimization is easily implemented by setting up more than one Security Association with a peer for each requested Security Association and caching those not immediately used. Also, if an ISAKMP implementation is alerted that a SA will soon be needed (e.g. to replace an existing SA that will expire in the near future), then it can establish the new SA before that new SA is needed. The base ISAKMP specification describes conditions in which one party of the protocol may inform the other party of some activity-- either deletion of a security association or in response to some error in the protocol such as a signature verification failed or a payload failed to decrypt. It is strongly suggested that these Informational exchanges not be responded to under any circumstances. Such a condition may result in a "notify war" in which failure to understand a message results in a notify to the peer who cannot understand it and sends his own notify back which is also not understood. 10. Security Considerations This entire memo discusses a hybrid protocol, combining parts of Oakley and parts of SKEME with ISAKMP, to negotiate, and derive keying material for, security associations in a secure and authenticated manner. Confidentiality is assured by the use of a negotiated encryption algorithm. Authentication is assured by the use of a negotiated method: a digital signature algorithm; a public key algorithm which supports encryption; or, a pre-shared key. The confidentiality and authentication of this exchange is only as good as the attributes negotiated as part of the ISAKMP security association. Repeated re-keying using Quick Mode can consume the entropy of the Diffie-Hellman shared secret. Implementors should take note of this fact and set a limit on Quick Mode Exchanges between exponentiations. This memo does not prescribe such a limit. Perfect Forward Secrecy (PFS) of both keying material and identities is possible with this protocol. By specifying a Diffie-Hellman group, and passing public values in KE payloads, ISAKMP peers can establish PFS of keys-- the identities would be protected by SKEYID_e from the ISAKMP SA and would therefore not be protected by PFS. If PFS of both keying material and identities is desired, an ISAKMP peer MUST Harkins & Carrel Standards Track [Page 28] RFC 2409 IKE November 1998 establish only one non-ISAKMP security association (e.g. IPsec Security Association) per ISAKMP SA. PFS for keys and identities is accomplished by deleting the ISAKMP SA (and optionally issuing a DELETE message) upon establishment of the single non-ISAKMP SA. In this way a phase one negotiation is uniquely tied to a single phase two negotiation, and the ISAKMP SA established during phase one negotiation is never used again. The strength of a key derived from a Diffie-Hellman exchange using any of the groups defined here depends on the inherent strength of the group, the size of the exponent used, and the entropy provided by the random number generator used. Due to these inputs it is difficult to determine the strength of a key for any of the defined groups. The default Diffie-Hellman group (number one) when used with a strong random number generator and an exponent no less than 160 bits is sufficient to use for DES. Groups two through four provide greater security. Implementations should make note of these conservative estimates when establishing policy and negotiating security parameters. Note that these limitations are on the Diffie-Hellman groups themselves. There is nothing in IKE which prohibits using stronger groups nor is there anything which will dilute the strength obtained from stronger groups. In fact, the extensible framework of IKE encourages the definition of more groups; use of elliptical curve groups will greatly increase strength using much smaller numbers. For situations where defined groups provide insufficient strength New Group Mode can be used to exchange a Diffie-Hellman group which provides the necessary strength. In is incumbent upon implementations to check the primality in groups being offered and independently arrive at strength estimates. It is assumed that the Diffie-Hellman exponents in this exchange are erased from memory after use. In particular, these exponents must not be derived from long-lived secrets like the seed to a pseudo-random generator. IKE exchanges maintain running initialization vectors (IV) where the last ciphertext block of the last message is the IV for the next message. To prevent retransmissions (or forged messages with valid cookies) from causing exchanges to get out of sync IKE implementations SHOULD NOT update their running IV until the decrypted message has passed a basic sanity check and has been determined to actually advance the IKE state machine-- i.e. it is not a retransmission. Harkins & Carrel Standards Track [Page 29] RFC 2409 IKE November 1998 While the last roundtrip of Main Mode (and optionally the last message of Aggressive Mode) is encrypted it is not, strictly speaking, authenticated. An active substitution attack on the ciphertext could result in payload corruption. If such an attack corrupts mandatory payloads it would be detected by an authentication failure, but if it corrupts any optional payloads (e.g. notify payloads chained onto the last message of a Main Mode exchange) it might not be detectable. 11. IANA Considerations This document contains many "magic numbers" to be maintained by the IANA. This section explains the criteria to be used by the IANA to assign additional numbers in each of these lists. 11.1 Attribute Classes Attributes negotiated in this protocol are identified by their class. Requests for assignment of new classes must be accompanied by a standards-track RFC which describes the use of this attribute. 11.2 Encryption Algorithm Class Values of the Encryption Algorithm Class define an encryption algorithm to use when called for in this document. Requests for assignment of new encryption algorithm values must be accompanied by a reference to a standards-track or Informational RFC or a reference to published cryptographic literature which describes this algorithm. 11.3 Hash Algorithm Values of the Hash Algorithm Class define a hash algorithm to use when called for in this document. Requests for assignment of new hash algorithm values must be accompanied by a reference to a standards- track or Informational RFC or a reference to published cryptographic literature which describes this algorithm. Due to the key derivation and key expansion uses of HMAC forms of hash algorithms in IKE, requests for assignment of new hash algorithm values must take into account the cryptographic properties-- e.g it's resistance to collision-- of the hash algorithm itself. 11.4 Group Description and Group Type Values of the Group Description Class identify a group to use in a Diffie-Hellman exchange. Values of the Group Type Class define the type of group. Requests for assignment of new groups must be accompanied by a reference to a standards-track or Informational RFC which describes this group. Requests for assignment of new group Harkins & Carrel Standards Track [Page 30] RFC 2409 IKE November 1998 types must be accompanied by a reference to a standards-track or Informational RFC or by a reference to published cryptographic or mathmatical literature which describes the new type. 11.5 Life Type Values of the Life Type Class define a type of lifetime to which the ISAKMP Security Association applies. Requests for assignment of new life types must be accompanied by a detailed description of the units of this type and its expiry. 12. Acknowledgements This document is the result of close consultation with Hugo Krawczyk, Douglas Maughan, Hilarie Orman, Mark Schertler, Mark Schneider, and Jeff Turner. It relies on protocols which were written by them. Without their interest and dedication, this would not have been written. Special thanks Rob Adams, Cheryl Madson, Derrell Piper, Harry Varnis, and Elfed Weaver for technical input, encouragement, and various sanity checks along the way. We would also like to thank the many members of the IPSec working group that contributed to the development of this protocol over the past year. 13. References [CAST] Adams, C., "The CAST-128 Encryption Algorithm", RFC 2144, May 1997. [BLOW] Schneier, B., "The Blowfish Encryption Algorithm", Dr. Dobb's Journal, v. 19, n. 4, April 1994. [Bra97] Bradner, S., "Key Words for use in RFCs to indicate Requirement Levels", BCP 14, RFC 2119, March 1997. [DES] ANSI X3.106, "American National Standard for Information Systems-Data Link Encryption", American National Standards Institute, 1983. [DH] Diffie, W., and Hellman M., "New Directions in Cryptography", IEEE Transactions on Information Theory, V. IT-22, n. 6, June 1977. Harkins & Carrel Standards Track [Page 31] RFC 2409 IKE November 1998 [DSS] NIST, "Digital Signature Standard", FIPS 186, National Institute of Standards and Technology, U.S. Department of Commerce, May, 1994. [IDEA] Lai, X., "On the Design and Security of Block Ciphers," ETH Series in Information Processing, v. 1, Konstanz: Hartung- Gorre Verlag, 1992 [KBC96] Krawczyk, H., Bellare, M., and R. Canetti, "HMAC: Keyed- Hashing for Message Authentication", RFC 2104, February 1997. [SKEME] Krawczyk, H., "SKEME: A Versatile Secure Key Exchange Mechanism for Internet", from IEEE Proceedings of the 1996 Symposium on Network and Distributed Systems Security. [MD5] Rivest, R., "The MD5 Message Digest Algorithm", RFC 1321, April 1992. [MSST98] Maughhan, D., Schertler, M., Schneider, M., and J. Turner, "Internet Security Association and Key Management Protocol (ISAKMP)", RFC 2408, November 1998. [Orm96] Orman, H., "The Oakley Key Determination Protocol", RFC 2412, November 1998. [PKCS1] RSA Laboratories, "PKCS #1: RSA Encryption Standard", November 1993. [Pip98] Piper, D., "The Internet IP Security Domain Of Interpretation for ISAKMP", RFC 2407, November 1998. [RC5] Rivest, R., "The RC5 Encryption Algorithm", Dr. Dobb's Journal, v. 20, n. 1, January 1995. [RSA] Rivest, R., Shamir, A., and Adleman, L., "A Method for Obtaining Digital Signatures and Public-Key Cryptosystems", Communications of the ACM, v. 21, n. 2, February 1978. [Sch96] Schneier, B., "Applied Cryptography, Protocols, Algorithms, and Source Code in C", 2nd edition. [SHA] NIST, "Secure Hash Standard", FIPS 180-1, National Institue of Standards and Technology, U.S. Department of Commerce, May 1994. [TIGER] Anderson, R., and Biham, E., "Fast Software Encryption", Springer LNCS v. 1039, 1996. Harkins & Carrel Standards Track [Page 32] RFC 2409 IKE November 1998 Appendix A This is a list of DES Weak and Semi-Weak keys. The keys come from [Sch96]. All keys are listed in hexidecimal. DES Weak Keys 0101 0101 0101 0101 1F1F 1F1F E0E0 E0E0 E0E0 E0E0 1F1F 1F1F FEFE FEFE FEFE FEFE DES Semi-Weak Keys 01FE 01FE 01FE 01FE 1FE0 1FE0 0EF1 0EF1 01E0 01E0 01F1 01F1 1FFE 1FFE 0EFE 0EFE 011F 011F 010E 010E E0FE E0FE F1FE F1FE FE01 FE01 FE01 FE01 E01F E01F F10E F10E E001 E001 F101 F101 FE1F FE1F FE0E FE0E 1F01 1F01 0E01 0E01 FEE0 FEE0 FEF1 FEF1 Attribute Assigned Numbers Attributes negotiated during phase one use the following definitions. Phase two attributes are defined in the applicable DOI specification (for example, IPsec attributes are defined in the IPsec DOI), with the exception of a group description when Quick Mode includes an ephemeral Diffie-Hellman exchange. Attribute types can be either Basic (B) or Variable-length (V). Encoding of these attributes is defined in the base ISAKMP specification as Type/Value (Basic) and Type/Length/Value (Variable). Attributes described as basic MUST NOT be encoded as variable. Variable length attributes MAY be encoded as basic attributes if their value can fit into two octets. If this is the case, an attribute offered as variable (or basic) by the initiator of this protocol MAY be returned to the initiator as a basic (or variable). Harkins & Carrel Standards Track [Page 33] RFC 2409 IKE November 1998 Attribute Classes class value type ------------------------------------------------------------------- Encryption Algorithm 1 B Hash Algorithm 2 B Authentication Method 3 B Group Description 4 B Group Type 5 B Group Prime/Irreducible Polynomial 6 V Group Generator One 7 V Group Generator Two 8 V Group Curve A 9 V Group Curve B 10 V Life Type 11 B Life Duration 12 V PRF 13 B Key Length 14 B Field Size 15 B Group Order 16 V values 17-16383 are reserved to IANA. Values 16384-32767 are for private use among mutually consenting parties. Class Values - Encryption Algorithm Defined In DES-CBC 1 RFC 2405 IDEA-CBC 2 Blowfish-CBC 3 RC5-R16-B64-CBC 4 3DES-CBC 5 CAST-CBC 6 values 7-65000 are reserved to IANA. Values 65001-65535 are for private use among mutually consenting parties. - Hash Algorithm Defined In MD5 1 RFC 1321 SHA 2 FIPS 180-1 Tiger 3 See Reference [TIGER] values 4-65000 are reserved to IANA. Values 65001-65535 are for private use among mutually consenting parties. Harkins & Carrel Standards Track [Page 34] RFC 2409 IKE November 1998 - Authentication Method pre-shared key 1 DSS signatures 2 RSA signatures 3 Encryption with RSA 4 Revised encryption with RSA 5 values 6-65000 are reserved to IANA. Values 65001-65535 are for private use among mutually consenting parties. - Group Description default 768-bit MODP group (section 6.1) 1 alternate 1024-bit MODP group (section 6.2) 2 EC2N group on GP[2^155] (section 6.3) 3 EC2N group on GP[2^185] (section 6.4) 4 values 5-32767 are reserved to IANA. Values 32768-65535 are for private use among mutually consenting parties. - Group Type MODP (modular exponentiation group) 1 ECP (elliptic curve group over GF[P]) 2 EC2N (elliptic curve group over GF[2^N]) 3 values 4-65000 are reserved to IANA. Values 65001-65535 are for private use among mutually consenting parties. - Life Type seconds 1 kilobytes 2 values 3-65000 are reserved to IANA. Values 65001-65535 are for private use among mutually consenting parties. For a given "Life Type" the value of the "Life Duration" attribute defines the actual length of the SA life-- either a number of seconds, or a number of kbytes protected. - PRF There are currently no pseudo-random functions defined. values 1-65000 are reserved to IANA. Values 65001-65535 are for private use among mutually consenting parties. Harkins & Carrel Standards Track [Page 35] RFC 2409 IKE November 1998 - Key Length When using an Encryption Algorithm that has a variable length key, this attribute specifies the key length in bits. (MUST use network byte order). This attribute MUST NOT be used when the specified Encryption Algorithm uses a fixed length key. - Field Size The field size, in bits, of a Diffie-Hellman group. - Group Order The group order of an elliptical curve group. Note the length of this attribute depends on the field size. Additional Exchanges Defined-- XCHG values Quick Mode 32 New Group Mode 33 Harkins & Carrel Standards Track [Page 36] RFC 2409 IKE November 1998 Appendix B This appendix describes encryption details to be used ONLY when encrypting ISAKMP messages. When a service (such as an IPSEC transform) utilizes ISAKMP to generate keying material, all encryption algorithm specific details (such as key and IV generation, padding, etc...) MUST be defined by that service. ISAKMP does not purport to ever produce keys that are suitable for any encryption algorithm. ISAKMP produces the requested amount of keying material from which the service MUST generate a suitable key. Details, such as weak key checks, are the responsibility of the service. Use of negotiated PRFs may require the PRF output to be expanded due to the PRF feedback mechanism employed by this document. For example, if the (ficticious) DOORAK-MAC requires 24 bytes of key but produces only 8 bytes of output, the output must be expanded three times before being used as the key for another instance of itself. The output of a PRF is expanded by feeding back the results of the PRF into itself to generate successive blocks. These blocks are concatenated until the requisite number of bytes has been acheived. For example, for pre-shared key authentication with DOORAK-MAC as the negotiated PRF: BLOCK1-8 = prf(pre-shared-key, Ni_b | Nr_b) BLOCK9-16 = prf(pre-shared-key, BLOCK1-8 | Ni_b | Nr_b) BLOCK17-24 = prf(pre-shared-key, BLOCK9-16 | Ni_b | Nr_b) and SKEYID = BLOCK1-8 | BLOCK9-16 | BLOCK17-24 so therefore to derive SKEYID_d: BLOCK1-8 = prf(SKEYID, g^xy | CKY-I | CKY-R | 0) BLOCK9-16 = prf(SKEYID, BLOCK1-8 | g^xy | CKY-I | CKY-R | 0) BLOCK17-24 = prf(SKEYID, BLOCK9-16 | g^xy | CKY-I | CKY-R | 0) and SKEYID_d = BLOCK1-8 | BLOCK9-16 | BLOCK17-24 Subsequent PRF derivations are done similarly. Encryption keys used to protect the ISAKMP SA are derived from SKEYID_e in an algorithm-specific manner. When SKEYID_e is not long enough to supply all the necessary keying material an algorithm requires, the key is derived from feeding the results of a pseudo- random function into itself, concatenating the results, and taking the highest necessary bits. Harkins & Carrel Standards Track [Page 37] RFC 2409 IKE November 1998 For example, if (ficticious) algorithm AKULA requires 320-bits of key (and has no weak key check) and the prf used to generate SKEYID_e only generates 120 bits of material, the key for AKULA, would be the first 320-bits of Ka, where: Ka = K1 | K2 | K3 and K1 = prf(SKEYID_e, 0) K2 = prf(SKEYID_e, K1) K3 = prf(SKEYID_e, K2) where prf is the negotiated prf or the HMAC version of the negotiated hash function (if no prf was negotiated) and 0 is represented by a single octet. Each result of the prf provides 120 bits of material for a total of 360 bits. AKULA would use the first 320 bits of that 360 bit string. In phase 1, material for the initialization vector (IV material) for CBC mode encryption algorithms is derived from a hash of a concatenation of the initiator's public Diffie-Hellman value and the responder's public Diffie-Hellman value using the negotiated hash algorithm. This is used for the first message only. Each message should be padded up to the nearest block size using bytes containing 0x00. The message length in the header MUST include the length of the pad since this reflects the size of the ciphertext. Subsequent messages MUST use the last CBC encryption block from the previous message as their initialization vector. In phase 2, material for the initialization vector for CBC mode encryption of the first message of a Quick Mode exchange is derived from a hash of a concatenation of the last phase 1 CBC output block and the phase 2 message id using the negotiated hash algorithm. The IV for subsequent messages within a Quick Mode exchange is the CBC output block from the previous message. Padding and IVs for subsequent messages are done as in phase 1. After the ISAKMP SA has been authenticated all Informational Exchanges are encrypted using SKEYID_e. The initiaization vector for these exchanges is derived in exactly the same fashion as that for a Quick Mode-- i.e. it is derived from a hash of a concatenation of the last phase 1 CBC output block and the message id from the ISAKMP header of the Informational Exchange (not the message id from the message that may have prompted the Informational Exchange). Note that the final phase 1 CBC output block, the result of encryption/decryption of the last phase 1 message, must be retained in the ISAKMP SA state to allow for generation of unique IVs for each Quick Mode. Each post- phase 1 exchange (Quick Modes and Harkins & Carrel Standards Track [Page 38] RFC 2409 IKE November 1998 Informational Exchanges) generates IVs independantly to prevent IVs from getting out of sync when two different exchanges are started simultaneously. In all cases, there is a single bidirectional cipher/IV context. Having each Quick Mode and Informational Exchange maintain a unique context prevents IVs from getting out of sync. The key for DES-CBC is derived from the first eight (8) non-weak and non-semi-weak (see Appendix A) bytes of SKEYID_e. The IV is the first 8 bytes of the IV material derived above. The key for IDEA-CBC is derived from the first sixteen (16) bytes of SKEYID_e. The IV is the first eight (8) bytes of the IV material derived above. The key for Blowfish-CBC is either the negotiated key size, or the first fifty-six (56) bytes of a key (if no key size is negotiated) derived in the aforementioned pseudo-random function feedback method. The IV is the first eight (8) bytes of the IV material derived above. The key for RC5-R16-B64-CBC is the negotiated key size, or the first sixteen (16) bytes of a key (if no key size is negotiated) derived from the aforementioned pseudo-random function feedback method if necessary. The IV is the first eight (8) bytes of the IV material derived above. The number of rounds MUST be 16 and the block size MUST be 64. The key for 3DES-CBC is the first twenty-four (24) bytes of a key derived in the aforementioned pseudo-random function feedback method. 3DES-CBC is an encrypt-decrypt-encrypt operation using the first, middle, and last eight (8) bytes of the entire 3DES-CBC key. The IV is the first eight (8) bytes of the IV material derived above. The key for CAST-CBC is either the negotiated key size, or the first sixteen (16) bytes of a key derived in the aforementioned pseudo- random function feedback method. The IV is the first eight (8) bytes of the IV material derived above. Support for algorithms other than DES-CBC is purely optional. Some optional algorithms may be subject to intellectual property claims. Harkins & Carrel Standards Track [Page 39] RFC 2409 IKE November 1998 Authors' Addresses Dan Harkins cisco Systems 170 W. Tasman Dr. San Jose, California, 95134-1706 United States of America Phone: +1 408 526 4000 EMail: dharkins@cisco.com Dave Carrel 76 Lippard Ave. San Francisco, CA 94131-2947 United States of America Phone: +1 415 337 8469 EMail: carrel@ipsec.org Authors' Note The authors encourage independent implementation, and interoperability testing, of this hybrid protocol. Harkins & Carrel Standards Track [Page 40] RFC 2409 IKE November 1998 Full Copyright Statement Copyright (C) The Internet Society (1998). All Rights Reserved. This document and translations of it may be copied and furnished to others, and derivative works that comment on or otherwise explain it or assist in its implementation may be prepared, copied, published and distributed, in whole or in part, without restriction of any kind, provided that the above copyright notice and this paragraph are included on all such copies and derivative works. However, this document itself may not be modified in any way, such as by removing the copyright notice or references to the Internet Society or other Internet organizations, except as needed for the purpose of developing Internet standards in which case the procedures for copyrights defined in the Internet Standards process must be followed, or as required to translate it into languages other than English. The limited permissions granted above are perpetual and will not be revoked by the Internet Society or its successors or assigns. This document and the information contained herein is provided on an "AS IS" basis and THE INTERNET SOCIETY AND THE INTERNET ENGINEERING TASK FORCE DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTY THAT THE USE OF THE INFORMATION HEREIN WILL NOT INFRINGE ANY RIGHTS OR ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Harkins & Carrel Standards Track [Page 41] fiked-0.0.5+git20120331.1.e6a5109/vpnc/GNUmakefile0000644000000000000000000000215211735550573015302 0ustar00# fiked - a fake IKE PSK+XAUTH daemon based on vpnc # Copyright (C) 2005, Daniel Roethlisberger # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, see http://www.gnu.org/copyleft/ # inherit from parent CC?=gcc CFLAGS?=-g -Wall -pedantic CSTD?=-std=c99 COPTS?=-I/usr/local/include all: libvpnc.a libvpnc.a: isakmp-pkt.o math_group.o dh.o $(AR) cru $@ $^ isakmp-pkt.o: isakmp-pkt.c isakmp-pkt.h isakmp.h $(CC) $(CFLAGS) $(CSTD) $(COPTS) -c -o $@ $< %.o: %.c %.h $(CC) $(CFLAGS) $(CSTD) $(COPTS) -c -o $@ $< clean: rm -rf *.o *.a *.core .PHONY: all clean fiked-0.0.5+git20120331.1.e6a5109/vpnc/NOTICE0000644000000000000000000000130111735550573014127 0ustar00The source code in this directory was taken from VPNC SVN. Note that the ISAKMP packet handling code was modified in order to accomodate encrypted payloads in isakmp_packet structures. The inner workings of the parse and flatten routines were changed accordingly, and some more functions were exposed in the external interface. VPNC is a VPN client compatible with Cisco's EasyVPN equipment. It supports IPSec (ESP) with Mode Configuration and Xauth. Supports only shared-secret IPSec authentication with Xauth, AES, 3DES, 1DES, MD5, SHA1, DH1/2/5 and IP tunneling. Author: Maurice Massar WWW: http://www.unix-ag.uni-kl.de/~massar/vpnc/ SVN: http://svn.unix-ag.uni-kl.de/vpnc/ fiked-0.0.5+git20120331.1.e6a5109/vpnc/dh.c0000644000000000000000000000703011735550573013767 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: dh.c 24 2004-06-10 09:19:53Z massar $ */ /* borrowed from isakmpd-20030718 (-; */ /* $OpenBSD: dh.c,v 1.8 2003/06/03 14:28:16 ho Exp $ */ /* $EOM: dh.c,v 1.5 1999/04/17 23:20:22 niklas Exp $ */ /* * Copyright (c) 1998 Niels Provos. All rights reserved. * Copyright (c) 1999 Niklas Hallqvist. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This code was written under funding by Ericsson Radio Systems. */ #include "math_group.h" #include "dh.h" /* * Returns the length of our exchange value. */ int dh_getlen(struct group *group) { return group->getlen(group); } /* * Creates the exchange value we are offering to the other party. * Each time this function is called a new value is created, that * means the application has to save the exchange value itself, * dh_create_exchange should only be called once. */ int dh_create_exchange(struct group *group, unsigned char *buf) { if (group->setrandom(group, group->c)) return -1; if (group->operation(group, group->a, group->gen, group->c)) return -1; group->getraw(group, group->a, buf); return 0; } /* * Creates the Diffie-Hellman shared secret in 'secret', where 'exchange' * is the exchange value offered by the other party. No length verification * is done for the value, the application has to do that. */ int dh_create_shared(struct group *group, unsigned char *secret, unsigned char *exchange) { if (group->setraw(group, group->b, exchange, group->getlen(group))) return -1; if (group->operation(group, group->a, group->b, group->c)) return -1; group->getraw(group, group->a, secret); return 0; } fiked-0.0.5+git20120331.1.e6a5109/vpnc/dh.h0000644000000000000000000000506111735550573013776 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: dh.h 24 2004-06-10 09:19:53Z massar $ */ /* borrowed from isakmpd-20030718 (-; */ /* $OpenBSD: dh.h,v 1.5 2003/06/03 14:28:16 ho Exp $ */ /* $EOM: dh.h,v 1.4 1999/04/17 23:20:24 niklas Exp $ */ /* * Copyright (c) 1998 Niels Provos. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This code was written under funding by Ericsson Radio Systems. */ #ifndef __DH_H__ #define __DH_H__ #include struct group; int dh_getlen(struct group *); int dh_create_exchange(struct group *, unsigned char *); int dh_create_shared(struct group *, unsigned char *, unsigned char *); #endif fiked-0.0.5+git20120331.1.e6a5109/vpnc/isakmp-pkt.c0000644000000000000000000006077611735550573015474 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: isakmp-pkt.c 61 2005-09-20 11:30:30Z massar $ */ /* ISAKMP packing and unpacking routines. Copyright (C) 2002 Geoffrey Keating Copyright (C) 2003-2005 Maurice Massar This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #include #include #include #include #include #include #include "isakmp-pkt.h" #define xallocc(X) calloc(1, X) #define DEBUG(X,Y) #define hex_dump(X,Y,Z) static int opt_debug = 0; void error(int status, int errornum, const char *fmt, ...) { char *buf2; va_list ap; va_start(ap, fmt); vasprintf(&buf2, fmt, ap); va_end(ap); fprintf(stderr, "%s", buf2); if (errornum) fprintf(stderr, ": %s\n", strerror(errornum)); free(buf2); if (status) exit(status); } struct flow { size_t len; uint8_t *base; uint8_t *end; }; static uint8_t *flow_reserve_p(struct flow *f, size_t sz) { size_t l = f->end - f->base; if (l + sz > f->len) { size_t new_len = f->len == 0 ? 128 : f->len; while (l + sz >= new_len) new_len *= 2; if (f->base == NULL) f->base = malloc(new_len); else f->base = realloc(f->base, new_len); if (f->base == NULL) error(1, errno, "alloc of %lud bytes failed", (unsigned long)new_len); memset(f->base + f->len, 0, new_len - f->len); f->end = f->base + l; f->len = new_len; } f->end += sz; return f->end - sz; } static size_t flow_reserve(struct flow *f, size_t sz) { uint8_t *p = flow_reserve_p(f, sz); return p - f->base; } static void flow_x(struct flow *f, uint8_t * data, size_t data_len) { memcpy(flow_reserve_p(f, data_len), data, data_len); } static void flow_1(struct flow *f, uint8_t d) { flow_reserve_p(f, 1)[0] = d; } static void flow_2(struct flow *f, uint16_t d) { uint8_t dd[2]; dd[0] = d >> 8; dd[1] = d; flow_x(f, dd, sizeof(dd)); } static void flow_4(struct flow *f, uint32_t d) { uint8_t dd[4]; dd[0] = d >> 24; dd[1] = d >> 16; dd[2] = d >> 8; dd[3] = d; flow_x(f, dd, sizeof(dd)); } static void init_flow(struct flow *f) { memset(f, 0, sizeof(*f)); } static void flow_attribute(struct flow *f, struct isakmp_attribute *p) { for (; p; p = p->next) switch (p->af) { case isakmp_attr_lots: flow_2(f, p->type); flow_2(f, p->u.lots.length); flow_x(f, p->u.lots.data, p->u.lots.length); break; case isakmp_attr_16: flow_2(f, p->type | 0x8000); flow_2(f, p->u.attr_16); break; case isakmp_attr_2x8: flow_2(f, p->type | 0x8000); flow_x(f, p->u.attr_2x8, 2); break; default: abort(); } } static void flow_payload(struct flow *f, struct isakmp_payload *p) { size_t lpos; size_t baselen; if (p == NULL) return; baselen = f->end - f->base; if (p->next == NULL) flow_1(f, 0); else flow_1(f, p->next->type); flow_1(f, 0); lpos = flow_reserve(f, 2); switch (p->type) { case ISAKMP_PAYLOAD_SA: flow_4(f, p->u.sa.doi); flow_4(f, p->u.sa.situation); flow_payload(f, p->u.sa.proposals); break; case ISAKMP_PAYLOAD_P: flow_1(f, p->u.p.number); flow_1(f, p->u.p.prot_id); flow_1(f, p->u.p.spi_size); { uint8_t num_xform = 0; struct isakmp_payload *xform; for (xform = p->u.p.transforms; xform; xform = xform->next) num_xform++; flow_1(f, num_xform); } flow_x(f, p->u.p.spi, p->u.p.spi_size); flow_payload(f, p->u.p.transforms); break; case ISAKMP_PAYLOAD_T: flow_1(f, p->u.t.number); flow_1(f, p->u.t.id); flow_2(f, 0); flow_attribute(f, p->u.t.attributes); break; case ISAKMP_PAYLOAD_KE: case ISAKMP_PAYLOAD_HASH: case ISAKMP_PAYLOAD_SIG: case ISAKMP_PAYLOAD_NONCE: case ISAKMP_PAYLOAD_VID: case ISAKMP_PAYLOAD_NAT_D: case ISAKMP_PAYLOAD_NAT_D_OLD: flow_x(f, p->u.ke.data, p->u.ke.length); break; case ISAKMP_PAYLOAD_ID: flow_1(f, p->u.id.type); flow_1(f, p->u.id.protocol); flow_2(f, p->u.id.port); flow_x(f, p->u.id.data, p->u.id.length); break; case ISAKMP_PAYLOAD_CERT: case ISAKMP_PAYLOAD_CR: flow_1(f, p->u.cert.encoding); flow_x(f, p->u.cert.data, p->u.cert.length); break; case ISAKMP_PAYLOAD_N: flow_4(f, p->u.n.doi); flow_1(f, p->u.n.protocol); flow_1(f, p->u.n.spi_length); flow_2(f, p->u.n.type); flow_x(f, p->u.n.spi, p->u.n.spi_length); flow_x(f, p->u.n.data, p->u.n.data_length); break; case ISAKMP_PAYLOAD_D: flow_4(f, p->u.d.doi); flow_1(f, p->u.d.protocol); flow_1(f, p->u.d.spi_length); flow_2(f, p->u.d.num_spi); if (p->u.d.spi_length > 0) { int i; for (i = 0; i < p->u.d.num_spi; i++) flow_x(f, p->u.d.spi[i], p->u.d.spi_length); } break; case ISAKMP_PAYLOAD_MODECFG_ATTR: flow_1(f, p->u.modecfg.type); flow_1(f, 0); flow_2(f, p->u.modecfg.id); flow_attribute(f, p->u.modecfg.attributes); break; default: abort(); } f->base[lpos] = (f->end - f->base - baselen) >> 8; f->base[lpos + 1] = (f->end - f->base - baselen); flow_payload(f, p->next); } void flatten_isakmp_payload(struct isakmp_payload *p, uint8_t ** result, size_t * size, size_t blksz) { struct flow f; init_flow(&f); flow_payload(&f, p); if(blksz) { flow_reserve(&f, (blksz - ((f.end - f.base) % blksz)) % blksz); } *result = f.base; *size = f.end - f.base; } void flatten_isakmp_packet(struct isakmp_packet *p, uint8_t ** result, size_t * size, size_t blksz) { struct flow f; size_t lpos; init_flow(&f); flow_x(&f, p->i_cookie, ISAKMP_COOKIE_LENGTH); flow_x(&f, p->r_cookie, ISAKMP_COOKIE_LENGTH); if (p->flags & ISAKMP_FLAG_E) flow_1(&f, p->u.enc.type); else if (p->u.payload == NULL) flow_1(&f, 0); else flow_1(&f, p->u.payload->type); flow_1(&f, p->isakmp_version); flow_1(&f, p->exchange_type); flow_1(&f, p->flags); flow_4(&f, p->message_id); lpos = flow_reserve(&f, 4); if (p->flags & ISAKMP_FLAG_E) { flow_x(&f, p->u.enc.data, p->u.enc.length); } else { flow_payload(&f, p->u.payload); } f.base[lpos] = (f.end - f.base) >> 24; f.base[lpos + 1] = (f.end - f.base) >> 16; f.base[lpos + 2] = (f.end - f.base) >> 8; f.base[lpos + 3] = (f.end - f.base); *result = f.base; *size = f.end - f.base; /*DUMP*/ if (opt_debug >= 3) { printf("\n sending: ========================>\n"); free_isakmp_packet(parse_isakmp_packet(f.base, f.end - f.base, NULL)); } } struct isakmp_attribute *new_isakmp_attribute(uint16_t type, struct isakmp_attribute *next) { struct isakmp_attribute *r = xallocc(sizeof(struct isakmp_attribute)); r->type = type; r->next = next; return r; } struct isakmp_attribute *new_isakmp_attribute_16(uint16_t type, uint16_t data, struct isakmp_attribute *next) { struct isakmp_attribute *r = xallocc(sizeof(struct isakmp_attribute)); r->next = next; r->type = type; r->af = isakmp_attr_16; r->u.attr_16 = data; return r; } struct isakmp_packet *new_isakmp_packet(void) { return xallocc(sizeof(struct isakmp_packet)); } struct isakmp_payload *new_isakmp_payload(uint8_t type) { struct isakmp_payload *result = xallocc(sizeof(struct isakmp_payload)); result->type = type; return result; } struct isakmp_payload *new_isakmp_data_payload(uint8_t type, const void *data, size_t data_length) { struct isakmp_payload *result = xallocc(sizeof(struct isakmp_payload)); if (type != ISAKMP_PAYLOAD_KE && type != ISAKMP_PAYLOAD_HASH && type != ISAKMP_PAYLOAD_SIG && type != ISAKMP_PAYLOAD_NONCE && type != ISAKMP_PAYLOAD_VID && type != ISAKMP_PAYLOAD_NAT_D && type != ISAKMP_PAYLOAD_NAT_D_OLD) abort(); if (data_length >= 16384) abort(); result->type = type; result->u.ke.length = data_length; result->u.ke.data = xallocc(data_length); memcpy(result->u.ke.data, data, data_length); return result; } void free_isakmp_payload(struct isakmp_payload *p) { struct isakmp_payload *nxt; if (p == NULL) return; switch (p->type) { case ISAKMP_PAYLOAD_SA: free_isakmp_payload(p->u.sa.proposals); break; case ISAKMP_PAYLOAD_P: free(p->u.p.spi); free_isakmp_payload(p->u.p.transforms); break; case ISAKMP_PAYLOAD_T: { struct isakmp_attribute *att, *natt; for (att = p->u.t.attributes; att; att = natt) { natt = att->next; if (att->af == isakmp_attr_lots) free(att->u.lots.data); free(att); } } break; case ISAKMP_PAYLOAD_KE: case ISAKMP_PAYLOAD_HASH: case ISAKMP_PAYLOAD_SIG: case ISAKMP_PAYLOAD_NONCE: case ISAKMP_PAYLOAD_VID: case ISAKMP_PAYLOAD_NAT_D: case ISAKMP_PAYLOAD_NAT_D_OLD: free(p->u.ke.data); break; case ISAKMP_PAYLOAD_ID: free(p->u.id.data); break; case ISAKMP_PAYLOAD_CERT: case ISAKMP_PAYLOAD_CR: free(p->u.cert.data); break; case ISAKMP_PAYLOAD_N: free(p->u.n.spi); free(p->u.n.data); break; case ISAKMP_PAYLOAD_D: if (p->u.d.spi) { int i; for (i = 0; i < p->u.d.num_spi; i++) free(p->u.d.spi[i]); free(p->u.d.spi); } break; case ISAKMP_PAYLOAD_MODECFG_ATTR: { struct isakmp_attribute *att, *natt; for (att = p->u.modecfg.attributes; att; att = natt) { natt = att->next; if (att->af == isakmp_attr_lots) free(att->u.lots.data); if (att->af == isakmp_attr_acl) free(att->u.acl.acl_ent); free(att); } } break; default: abort(); } nxt = p->next; free(p); free_isakmp_payload(nxt); } void free_isakmp_packet(struct isakmp_packet *p) { if (p == NULL) return; if(p->flags & ISAKMP_FLAG_E) free(p->u.enc.data); else free_isakmp_payload(p->u.payload); free(p); } #define fetch4() \ (data += 4, data_len -= 4, \ (uint32_t)(data[-4]) << 24 | (uint32_t)(data[-3]) << 16 \ | (uint32_t)(data[-2]) << 8 | data[-1]) #define fetch2() \ (data += 2, data_len -= 2, \ (uint16_t)(data[-2]) << 8 | data[-1]) #define fetch1() (data_len--, *data++) #define fetchn(d,n) \ (memcpy ((d), data, (n)), data += (n), data_len -= (n)) static struct isakmp_attribute *parse_isakmp_attributes(const uint8_t ** data_p, size_t data_len, int * reject) { const uint8_t *data = *data_p; struct isakmp_attribute *r; uint16_t type, length; int i; if (data_len < 4) return NULL; r = new_isakmp_attribute(0, NULL); type = fetch2(); length = fetch2(); if (type & 0x8000) { r->type = type & ~0x8000; hex_dump("t.attributes.type", &r->type, UINT16); r->af = isakmp_attr_16; r->u.attr_16 = length; if ((ISAKMP_XAUTH_ATTRIB_TYPE <= r->type) && (r->type <= ISAKMP_XAUTH_ATTRIB_ANSWER) && (opt_debug < 99)) DEBUG(3, printf("(not dumping xauth data)\n")); else hex_dump("t.attributes.u.attr_16", &r->u.attr_16, UINT16); } else { r->type = type; hex_dump("t.attributes.type", &r->type, UINT16); r->af = isakmp_attr_lots; r->u.lots.length = length; if ((ISAKMP_XAUTH_ATTRIB_TYPE <= r->type) && (r->type <= ISAKMP_XAUTH_ATTRIB_ANSWER) && (opt_debug < 99)) DEBUG(3, printf("(not dumping xauth data length)\n")); else hex_dump("t.attributes.u.lots.length", &r->u.lots.length, UINT16); if (data_len < length) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } if (r->type == ISAKMP_MODECFG_ATTRIB_CISCO_SPLIT_INC) { r->af = isakmp_attr_acl; r->u.acl.count = length / (4+4+2+2+2); if (r->u.acl.count * (4+4+2+2+2) != length) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } r->u.acl.acl_ent = xallocc(r->u.acl.count * sizeof(struct acl_ent_s)); for (i = 0; i < r->u.acl.count; i++) { fetchn(&r->u.acl.acl_ent[i].addr.s_addr, 4); fetchn(&r->u.acl.acl_ent[i].mask.s_addr, 4); r->u.acl.acl_ent[i].protocol = fetch2(); r->u.acl.acl_ent[i].sport = fetch2(); r->u.acl.acl_ent[i].dport = fetch2(); hex_dump("t.attributes.u.acl.addr", &r->u.acl.acl_ent[i].addr.s_addr, 4); hex_dump("t.attributes.u.acl.mask", &r->u.acl.acl_ent[i].mask.s_addr, 4); hex_dump("t.attributes.u.acl.protocol", &r->u.acl.acl_ent[i].protocol, UINT16); hex_dump("t.attributes.u.acl.sport", &r->u.acl.acl_ent[i].sport, UINT16); hex_dump("t.attributes.u.acl.dport", &r->u.acl.acl_ent[i].dport, UINT16); } } else { r->u.lots.data = xallocc(length); fetchn(r->u.lots.data, length); if ((ISAKMP_XAUTH_ATTRIB_TYPE <= type) && (type <= ISAKMP_XAUTH_ATTRIB_ANSWER) && (opt_debug < 99)) DEBUG(3, printf("(not dumping xauth data)\n")); else hex_dump("t.attributes.u.lots.data", r->u.lots.data, r->u.lots.length); } } r->next = parse_isakmp_attributes(&data, data_len, reject); *data_p = data; return r; } struct isakmp_payload *parse_isakmp_payload(uint8_t type, const uint8_t ** data_p, size_t * data_len_p, int * reject) { const uint8_t *data = *data_p; size_t data_len = *data_len_p; struct isakmp_payload *r; uint8_t next_type; size_t length, olength; static const uint16_t min_payload_len[ISAKMP_PAYLOAD_MODECFG_ATTR + 1] = { 4, 12, 8, 8, 4, 8, 5, 5, 4, 4, 4, 12, 12, 4, 8 }; hex_dump("PARSING PAYLOAD type", &type, UINT8); if (type == 0) return NULL; if (type <= ISAKMP_PAYLOAD_MODECFG_ATTR) { if (data_len < min_payload_len[type]) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return NULL; } } else if (data_len < 4) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return NULL; } r = new_isakmp_payload(type); next_type = fetch1(); hex_dump("next_type", &next_type, UINT8); if (fetch1() != 0) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } length = fetch2(); hex_dump("length", &length, UINT16); if (length > data_len + 4 || ((type <= ISAKMP_PAYLOAD_MODECFG_ATTR)&&(length < min_payload_len[type])) || (length < 4)) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } olength = length; switch (type) { case ISAKMP_PAYLOAD_SA: r->u.sa.doi = fetch4(); hex_dump("sa.doi", &r->u.sa.doi, UINT32); if (r->u.sa.doi != ISAKMP_DOI_IPSEC) { *reject = ISAKMP_N_DOI_NOT_SUPPORTED; return r; } r->u.sa.situation = fetch4(); hex_dump("sa.situation", &r->u.sa.situation, UINT32); if (r->u.sa.situation != ISAKMP_IPSEC_SIT_IDENTITY_ONLY) { *reject = ISAKMP_N_SITUATION_NOT_SUPPORTED; return r; } *reject = 0; length -= 12; r->u.sa.proposals = parse_isakmp_payload(ISAKMP_PAYLOAD_P, &data, &length, reject); if (*reject != 0) return r; /* Allow trailing garbage at end of payload. */ data_len -= olength - 12; break; case ISAKMP_PAYLOAD_P: if (next_type != ISAKMP_PAYLOAD_P && next_type != 0) { *reject = ISAKMP_N_INVALID_PAYLOAD_TYPE; return r; } { uint8_t num_xform; struct isakmp_payload *xform; r->u.p.number = fetch1(); hex_dump("p.number", &r->u.p.number, UINT8); r->u.p.prot_id = fetch1(); hex_dump("p.prot_id", &r->u.p.prot_id, UINT8); r->u.p.spi_size = fetch1(); hex_dump("p.spi_size", &r->u.p.spi_size, UINT8); num_xform = fetch1(); hex_dump("length", &num_xform, UINT8); if (data_len < r->u.p.spi_size) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } r->u.p.spi = xallocc(r->u.p.spi_size); fetchn(r->u.p.spi, r->u.p.spi_size); hex_dump("p.spi", r->u.p.spi, r->u.p.spi_size); length -= 8 + r->u.p.spi_size; r->u.p.transforms = parse_isakmp_payload(ISAKMP_PAYLOAD_T, &data, &length, reject); for (xform = r->u.p.transforms; xform; xform = xform->next) if (num_xform-- == 0) break; if (num_xform != 0) { *reject = ISAKMP_N_BAD_PROPOSAL_SYNTAX; return r; } /* Allow trailing garbage at end of payload. */ data_len -= olength - 8 - r->u.p.spi_size; } break; case ISAKMP_PAYLOAD_T: if (next_type != ISAKMP_PAYLOAD_T && next_type != 0) { *reject = ISAKMP_N_INVALID_PAYLOAD_TYPE; return r; } r->u.t.number = fetch1(); hex_dump("t.number", &r->u.t.number, UINT8); r->u.t.id = fetch1(); hex_dump("t.id", &r->u.t.id, UINT8); if (fetch2() != 0) { *reject = ISAKMP_N_BAD_PROPOSAL_SYNTAX; return r; } length -= 8; r->u.t.attributes = parse_isakmp_attributes(&data, length, reject); data_len -= olength - 8; break; case ISAKMP_PAYLOAD_KE: case ISAKMP_PAYLOAD_HASH: case ISAKMP_PAYLOAD_SIG: case ISAKMP_PAYLOAD_NONCE: case ISAKMP_PAYLOAD_VID: case ISAKMP_PAYLOAD_NAT_D: case ISAKMP_PAYLOAD_NAT_D_OLD: r->u.ke.length = length - 4; r->u.ke.data = xallocc(r->u.ke.length); fetchn(r->u.ke.data, r->u.ke.length); hex_dump("ke.data", r->u.ke.data, r->u.ke.length); break; case ISAKMP_PAYLOAD_ID: r->u.id.type = fetch1(); hex_dump("id.type", &r->u.id.type, UINT8); r->u.id.protocol = fetch1(); hex_dump("id.protocol", &r->u.id.protocol, UINT8); r->u.id.port = fetch2(); hex_dump("id.port", &r->u.id.port, sizeof(r->u.id.port)); r->u.id.length = length - 8; r->u.id.data = xallocc(r->u.id.length); fetchn(r->u.id.data, r->u.id.length); hex_dump("id.data", r->u.id.data, r->u.id.length); break; case ISAKMP_PAYLOAD_CERT: case ISAKMP_PAYLOAD_CR: r->u.cert.encoding = fetch1(); hex_dump("cert.encoding", &r->u.cert.encoding, UINT8); r->u.cert.length = length - 5; fetchn(r->u.cert.data, r->u.cert.length); hex_dump("cert.data", r->u.cert.data, r->u.cert.length); break; case ISAKMP_PAYLOAD_N: r->u.n.doi = fetch4(); hex_dump("n.doi", &r->u.n.doi, UINT32); r->u.n.protocol = fetch1(); hex_dump("n.protocol", &r->u.n.protocol, UINT8); r->u.n.spi_length = fetch1(); hex_dump("n.spi_length", &r->u.n.spi_length, UINT8); r->u.n.type = fetch2(); hex_dump("n.type", &r->u.n.type, UINT16); if (r->u.n.spi_length + 12u > length) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } r->u.n.spi = xallocc(r->u.n.spi_length); fetchn(r->u.n.spi, r->u.n.spi_length); hex_dump("n.spi", r->u.n.spi, r->u.n.spi_length); r->u.n.data_length = length - 12 - r->u.n.spi_length; r->u.n.data = xallocc(r->u.n.data_length); fetchn(r->u.n.data, r->u.n.data_length); hex_dump("n.data", r->u.n.data, r->u.n.data_length); break; case ISAKMP_PAYLOAD_D: r->u.n.doi = fetch4(); /*FIXME: huuuh? */ hex_dump("n.doi", &r->u.n.doi, UINT32); r->u.n.protocol = fetch1(); hex_dump("n.protocol", &r->u.n.protocol, UINT8); r->u.n.spi_length = fetch1(); hex_dump("n.spi_length", &r->u.n.spi_length, UINT8); r->u.d.num_spi = fetch2(); hex_dump("d.num_spi", &r->u.d.num_spi, UINT16); if (r->u.d.num_spi * r->u.n.spi_length + 12u != length) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } r->u.d.spi = xallocc(sizeof(uint8_t *) * r->u.d.num_spi); { int i; for (i = 0; i < r->u.d.num_spi; i++) { r->u.d.spi[i] = xallocc(r->u.d.spi_length); fetchn(r->u.d.spi[i], r->u.d.spi_length); hex_dump("d.spi", r->u.d.spi[i], r->u.d.spi_length); } } break; case ISAKMP_PAYLOAD_MODECFG_ATTR: r->u.modecfg.type = fetch1(); hex_dump("modecfg.type", &r->u.modecfg.type, UINT8); if (fetch1() != 0) { *reject = ISAKMP_N_PAYLOAD_MALFORMED; return r; } r->u.t.id = fetch2(); hex_dump("t.id", &r->u.t.id, UINT16); length -= 8; r->u.t.attributes = parse_isakmp_attributes(&data, length, reject); data_len -= olength - 8; break; default: r->u.ke.length = length - 4; r->u.ke.data = xallocc(r->u.ke.length); fetchn(r->u.ke.data, r->u.ke.length); hex_dump("UNKNOWN.data", r->u.ke.data, r->u.ke.length); break; } *data_p = data; *data_len_p = data_len; hex_dump("DONE PARSING PAYLOAD type", &type, UINT8); r->next = parse_isakmp_payload(next_type, data_p, data_len_p, reject); return r; } struct isakmp_packet *parse_isakmp_packet(const uint8_t * data, size_t data_len, int * reject) { int reason = 0; uint8_t payload; struct isakmp_packet *r = new_isakmp_packet(); size_t o_data_len = data_len; size_t isakmp_data_len; if (data_len < ISAKMP_PAYLOAD_O) { DEBUG(2, printf("packet to short: len = %lld < min = %lld\n", (long long) data_len, (long long)ISAKMP_PAYLOAD_O)); reason = ISAKMP_N_UNEQUAL_PAYLOAD_LENGTHS; goto error; } DEBUG(3, printf("\nBEGIN_PARSE\n")); fetchn(r->i_cookie, ISAKMP_COOKIE_LENGTH); hex_dump("i_cookie", r->i_cookie, ISAKMP_COOKIE_LENGTH); fetchn(r->r_cookie, ISAKMP_COOKIE_LENGTH); hex_dump("r_cookie", r->r_cookie, ISAKMP_COOKIE_LENGTH); payload = fetch1(); hex_dump("payload", &payload, UINT8); r->isakmp_version = fetch1(); hex_dump("isakmp_version", &r->isakmp_version, UINT8); if (r->isakmp_version > ISAKMP_VERSION) { if ((r->isakmp_version & 0xF0) >= (ISAKMP_VERSION & 0xF0)) reason = ISAKMP_N_INVALID_MAJOR_VERSION; else reason = ISAKMP_N_INVALID_MINOR_VERSION; goto error; } r->exchange_type = fetch1(); hex_dump("exchange_type", &r->exchange_type, UINT8); r->flags = fetch1(); hex_dump("flags", &r->flags, UINT8); r->message_id = fetch4(); hex_dump("message_id", &r->message_id, sizeof(r->message_id)); isakmp_data_len = fetch4(); hex_dump("len", &isakmp_data_len, UINT32); if (o_data_len < isakmp_data_len) { /* != */ DEBUG(2, printf("isakmp length does not match packet length: isakmp = %lld != datalen = %lld\n", (long long)isakmp_data_len, (long long)o_data_len)); reason = ISAKMP_N_UNEQUAL_PAYLOAD_LENGTHS; goto error; } data_len -= o_data_len - isakmp_data_len; /* ignore padding */ if(r->flags & ISAKMP_FLAG_E) { r->u.enc.data = malloc(data_len); memcpy(r->u.enc.data, data, data_len); r->u.enc.length = data_len; r->u.enc.type = payload; } else r->u.payload = parse_isakmp_payload(payload, &data, &data_len, &reason); if (reason != 0) goto error; DEBUG(3, printf("PARSE_OK\n\n")); return r; error: free_isakmp_packet(r); if (reject) *reject = reason; return NULL; } void test_pack_unpack(void) { static const uint8_t pack[] = { 0x7f, 0xba, 0x51, 0x29, 0x11, 0x9e, 0x76, 0xf7, 0x9a, 0x71, 0xee, 0x70, 0xaa, 0x82, 0xb9, 0x7f, 0x01, 0x10, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x4c, 0x04, 0x00, 0x00, 0x2c, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x01, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x01, 0x00, 0x00, 0x80, 0x01, 0x00, 0x05, 0x80, 0x02, 0x00, 0x01, 0x80, 0x04, 0x00, 0x02, 0x80, 0x03, 0x00, 0x01, 0x0a, 0x00, 0x00, 0x84, 0x1b, 0x1d, 0x4b, 0x29, 0x0e, 0x29, 0xb9, 0x6f, 0x18, 0x34, 0xd1, 0x2d, 0xba, 0x92, 0x7c, 0x53, 0x35, 0x76, 0x0e, 0x3b, 0x25, 0x92, 0x4f, 0x7c, 0x1e, 0x31, 0x41, 0x8c, 0xb9, 0xe3, 0xda, 0xf7, 0x53, 0xd3, 0x22, 0x8e, 0xff, 0xeb, 0xed, 0x5b, 0x95, 0x56, 0x8d, 0xba, 0xa8, 0xe3, 0x2a, 0x9b, 0xb4, 0x04, 0x5c, 0x90, 0xf0, 0xfe, 0x92, 0xc8, 0x57, 0xa2, 0xc6, 0x0c, 0x85, 0xbb, 0x56, 0xe8, 0x1c, 0xa7, 0x2c, 0x57, 0x04, 0xb6, 0xe0, 0x43, 0x82, 0xe1, 0x9f, 0x0b, 0xa6, 0x8b, 0xce, 0x7f, 0x9b, 0x75, 0xbb, 0xd3, 0xff, 0x0e, 0x89, 0x19, 0xaf, 0xc6, 0x2e, 0xf6, 0x92, 0x06, 0x46, 0x4f, 0xc7, 0x97, 0x22, 0xf4, 0xa6, 0xf9, 0x26, 0x34, 0x04, 0x33, 0x89, 0x34, 0xa9, 0x2f, 0x81, 0x92, 0xd3, 0x21, 0x4f, 0x45, 0xbe, 0x38, 0x12, 0x26, 0xec, 0x87, 0x45, 0xdd, 0x10, 0x1c, 0xd6, 0x16, 0x05, 0x00, 0x00, 0x18, 0x77, 0xdf, 0x37, 0x3c, 0x03, 0x02, 0xe2, 0xc8, 0xe1, 0x2f, 0x92, 0xf0, 0x2e, 0xa2, 0xa6, 0x00, 0x17, 0x8f, 0xdf, 0xb4, 0x08, 0x00, 0x00, 0x0c, 0x01, 0x11, 0x01, 0xf4, 0xcd, 0xb4, 0x53, 0x6d, 0x0d, 0x00, 0x00, 0x14, 0x07, 0x47, 0x8d, 0xa7, 0x0b, 0xd6, 0xd1, 0x66, 0x7a, 0xaf, 0x2e, 0x61, 0x2a, 0x91, 0x80, 0x94, 0x0d, 0x00, 0x00, 0x14, 0x12, 0xf5, 0xf2, 0x8c, 0x45, 0x71, 0x68, 0xa9, 0x70, 0x2d, 0x9f, 0xe2, 0x74, 0xcc, 0x01, 0x00, 0x0d, 0x00, 0x00, 0x0c, 0x09, 0x00, 0x26, 0x89, 0xdf, 0xd6, 0xb7, 0x12, 0x0d, 0x00, 0x00, 0x14, 0xaf, 0xca, 0xd7, 0x13, 0x68, 0xa1, 0xf1, 0xc9, 0x6b, 0x86, 0x96, 0xfc, 0x77, 0x57, 0x01, 0x00, 0x00, 0x00, 0x00, 0x14, 0x1f, 0x07, 0xf7, 0x0e, 0xaa, 0x65, 0x14, 0xd3, 0xb0, 0xfa, 0x96, 0x54, 0x2a, 0x50, 0x03, 0x05 }; uint8_t *unpack; size_t unpack_len; struct isakmp_packet *p; int reject; p = parse_isakmp_packet(pack, sizeof(pack), &reject); flatten_isakmp_packet(p, &unpack, &unpack_len, 8); if (unpack_len != sizeof(pack) || memcmp(unpack, pack, sizeof(pack)) != 0) abort(); free(unpack); free_isakmp_packet(p); } fiked-0.0.5+git20120331.1.e6a5109/vpnc/isakmp-pkt.h0000644000000000000000000001122611735550573015463 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: isakmp-pkt.h 61 2005-09-20 11:30:30Z massar $ */ /* ISAKMP packing and unpacking routines. Copyright (C) 2002 Geoffrey Keating Copyright (C) 2003-2005 Maurice Massar This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef __ISAKMP_PKT_H__ #define __ISAKMP_PKT_H__ #if defined(__linux__) #include #endif #include #include #include #include "isakmp.h" struct isakmp_attribute { struct isakmp_attribute *next; uint16_t type; enum { isakmp_attr_lots, isakmp_attr_16, isakmp_attr_2x8, isakmp_attr_acl } af; union { uint16_t attr_16; uint8_t attr_2x8[2]; struct { uint16_t length; uint8_t *data; } lots; struct { uint16_t count; struct acl_ent_s { struct in_addr addr, mask; uint16_t protocol, sport, dport; } *acl_ent; } acl; } u; }; struct isakmp_payload { struct isakmp_payload *next; enum isakmp_payload_enum type; union { struct { uint32_t doi; uint32_t situation; struct isakmp_payload *proposals; } sa; struct { uint8_t number; uint8_t prot_id; uint8_t spi_size; uint8_t *spi; struct isakmp_payload *transforms; } p; struct { uint8_t number; uint8_t id; struct isakmp_attribute *attributes; } t; struct { uint16_t length; uint8_t *data; } ke, hash, sig, nonce, vid, natd; struct { uint8_t type; uint8_t protocol; uint16_t port; uint16_t length; uint8_t *data; } id; struct { uint8_t encoding; uint16_t length; uint8_t *data; } cert, cr; struct { uint32_t doi; uint8_t protocol; uint8_t spi_length; uint8_t *spi; uint16_t type; uint16_t data_length; uint8_t *data; } n; struct { uint32_t doi; uint8_t protocol; uint8_t spi_length; uint16_t num_spi; uint8_t **spi; } d; struct { uint8_t type; uint16_t id; struct isakmp_attribute *attributes; } modecfg; } u; }; struct isakmp_packet { uint8_t i_cookie[ISAKMP_COOKIE_LENGTH]; uint8_t r_cookie[ISAKMP_COOKIE_LENGTH]; uint8_t isakmp_version; uint8_t exchange_type; uint8_t flags; uint32_t message_id; union { struct isakmp_payload *payload; struct { uint8_t *data; uint16_t length; uint8_t type; } enc; } u; }; extern struct isakmp_packet *new_isakmp_packet(void); extern struct isakmp_payload *new_isakmp_payload(uint8_t type); extern struct isakmp_payload *new_isakmp_data_payload(uint8_t type, const void *data, size_t data_length); extern struct isakmp_attribute *new_isakmp_attribute(uint16_t type, struct isakmp_attribute *next); extern struct isakmp_attribute *new_isakmp_attribute_16(uint16_t type, uint16_t data, struct isakmp_attribute *next); extern void free_isakmp_packet(struct isakmp_packet *p); extern void free_isakmp_payload(struct isakmp_payload *p); extern void flatten_isakmp_payload(struct isakmp_payload *p, uint8_t ** result, size_t * size, size_t blksz); extern void flatten_isakmp_packet(struct isakmp_packet *p, uint8_t ** result, size_t * size, size_t blksz); extern struct isakmp_payload *parse_isakmp_payload(uint8_t type, const uint8_t ** data_p, size_t * data_len_p, int * reject); extern struct isakmp_packet *parse_isakmp_packet(const uint8_t * data, size_t data_len, int * reject); extern void test_pack_unpack(void); #endif fiked-0.0.5+git20120331.1.e6a5109/vpnc/isakmp.h0000644000000000000000000002646011735550573014675 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: isakmp.h 61 2005-09-20 11:30:30Z massar $ */ /* ISAKMP constants. Copyright (C) 2002 Geoffrey Keating This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef __ISAKMP_H__ #define __ISAKMP_H__ /* Flag bits for header. */ #define ISAKMP_FLAG_E 0x1 #define ISAKMP_FLAG_C 0x2 #define ISAKMP_FLAG_A 0x4 /* Payload types */ enum isakmp_payload_enum { ISAKMP_PAYLOAD_NONE = 0, ISAKMP_PAYLOAD_SA, ISAKMP_PAYLOAD_P, ISAKMP_PAYLOAD_T, ISAKMP_PAYLOAD_KE, ISAKMP_PAYLOAD_ID, ISAKMP_PAYLOAD_CERT, ISAKMP_PAYLOAD_CR, ISAKMP_PAYLOAD_HASH, ISAKMP_PAYLOAD_SIG, ISAKMP_PAYLOAD_NONCE, ISAKMP_PAYLOAD_N, ISAKMP_PAYLOAD_D, ISAKMP_PAYLOAD_VID, ISAKMP_PAYLOAD_MODECFG_ATTR, ISAKMP_PAYLOAD_NAT_D, ISAKMP_PAYLOAD_NAT_OA, ISAKMP_PAYLOAD_NAT_D_OLD = 0x82 }; /* Exchange types. */ enum isakmp_exchange_enum { ISAKMP_EXCHANGE_NONE = 0, ISAKMP_EXCHANGE_BASE, ISAKMP_EXCHANGE_IDENTITY, ISAKMP_EXCHANGE_AUTH_ONLY, ISAKMP_EXCHANGE_AGGRESSIVE, ISAKMP_EXCHANGE_INFORMATIONAL, ISAKMP_EXCHANGE_MODECFG_TRANSACTION, ISAKMP_EXCHANGE_IKE_QUICK = 32, ISAKMP_EXCHANGE_IKE_NEW_GROUP }; /* DOI types. */ enum isakmp_doi_enum { ISAKMP_DOI_GENERIC = 0, ISAKMP_DOI_IPSEC }; /* Notify message types. */ enum isakmp_notify_enum { ISAKMP_N_INVALID_PAYLOAD_TYPE = 1, ISAKMP_N_DOI_NOT_SUPPORTED, ISAKMP_N_SITUATION_NOT_SUPPORTED, ISAKMP_N_INVALID_COOKIE, ISAKMP_N_INVALID_MAJOR_VERSION, ISAKMP_N_INVALID_MINOR_VERSION, ISAKMP_N_INVALID_EXCHANGE_TYPE, ISAKMP_N_INVALID_FLAGS, ISAKMP_N_INVALID_MESSAGE_ID, ISAKMP_N_INVALID_PROTOCOL_ID, ISAKMP_N_INVALID_SPI, ISAKMP_N_INVALID_TRANSFORM_ID, ISAKMP_N_ATTRIBUTES_NOT_SUPPORTED, ISAKMP_N_NO_PROPOSAL_CHOSEN, ISAKMP_N_BAD_PROPOSAL_SYNTAX, ISAKMP_N_PAYLOAD_MALFORMED, ISAKMP_N_INVALID_KEY_INFORMATION, ISAKMP_N_INVALID_ID_INFORMATION, ISAKMP_N_INVALID_CERT_ENCODING, ISAKMP_N_INVALID_CERTIFICATE, ISAKMP_N_CERT_TYPE_UNSUPPORTED, ISAKMP_N_INVALID_CERT_AUTHORITY, ISAKMP_N_INVALID_HASH_INFORMATION, ISAKMP_N_AUTHENTICATION_FAILED, ISAKMP_N_INVALID_SIGNATURE, ISAKMP_N_ADDRESS_NOTIFICATION, ISAKMP_N_NOTIFY_SA_LIFETIME, ISAKMP_N_CERTIFICATE_UNAVAILABLE, ISAKMP_N_UNSUPPORTED_EXCHANGE_TYPE, ISAKMP_N_UNEQUAL_PAYLOAD_LENGTHS, ISAKMP_N_CONNECTED = 16384, ISAKMP_N_IPSEC_RESPONDER_LIFETIME = 24576, ISAKMP_N_IPSEC_REPLAY_STATUS, ISAKMP_N_IPSEC_INITIAL_CONTACT, ISAKMP_N_CISCO_LOAD_BALANCE = 40501, ISAKMP_N_CISCO_HEARTBEAT = 40756 }; /* IKE attribute types. */ enum ike_attr_enum { IKE_ATTRIB_ENC = 1, IKE_ATTRIB_HASH, IKE_ATTRIB_AUTH_METHOD, IKE_ATTRIB_GROUP_DESC, IKE_ATTRIB_GROUP_TYPE, IKE_ATTRIB_GROUP_PRIME, IKE_ATTRIB_GROUP_GEN_1, IKE_ATTRIB_GROUP_GEN_2, IKE_ATTRIB_GROUP_CURVE_A, IKE_ATTRIB_GROUP_CURVE_B, IKE_ATTRIB_LIFE_TYPE, IKE_ATTRIB_LIFE_DURATION, IKE_ATTRIB_PRF, IKE_ATTRIB_KEY_LENGTH, IKE_ATTRIB_FIELD_SIZE, IKE_ATTRIB_GROUP_ORDER, IKE_ATTRIB_BLOCK_SIZE }; /* IKE encryption algorithm IDs. */ enum ike_enc_enum { IKE_ENC_DES_CBC = 1, IKE_ENC_IDEA_CBC, IKE_ENC_BLOWFISH_CBC, IKE_ENC_RC5_R16_B16_CBC, IKE_ENC_3DES_CBC, IKE_ENC_CAST_CBC, IKE_ENC_AES_CBC }; /* IKE hash algorithm IDs. */ enum ike_hash_enum { IKE_HASH_MD5 = 1, IKE_HASH_SHA, IKE_HASH_TIGER, IKE_HASH_SHA2_256, IKE_HASH_SHA2_384, IKE_HASH_SHA2_512 }; /* IKE authentication method IDs. */ enum ike_auth_enum { IKE_AUTH_PRESHARED = 1, IKE_AUTH_DSS, IKE_AUTH_RSA_SIG, IKE_AUTH_RSA_ENC, IKE_AUTH_RSA_ENC_2, IKE_AUTH_EL_GAMAL_ENC, IKE_AUTH_EL_GAMAL_ENC_REV, IKE_AUTH_ECDSA_SIG, IKE_AUTH_XAUTHInitPreShared = 65001, IKE_AUTH_XAUTHRespPreShared, IKE_AUTH_XAUTHInitDSS, IKE_AUTH_XAUTHRespDSS, IKE_AUTH_XAUTHInitRSA, IKE_AUTH_XAUTHRespRSA, IKE_AUTH_XAUTHInitRSAEncryption, IKE_AUTH_XAUTHRespRSAEncryption, IKE_AUTH_XAUTHInitRSARevisedEncryption, IKE_AUTH_XAUTHRespRSARevisedEncryption }; /* IKE group IDs. */ enum ike_group_enum { IKE_GROUP_MODP_768 = 1, IKE_GROUP_MODP_1024, IKE_GROUP_EC2N_155, IKE_GROUP_EC2N_185, IKE_GROUP_MODP_1536, IKE_GROUP_EC2N_163sect, IKE_GROUP_EC2N_163K, IKE_GROUP_EC2N_283sect, IKE_GROUP_EC2N_283K, IKE_GROUP_EC2N_409sect, IKE_GROUP_EC2N_409K, IKE_GROUP_EC2N_571sect, IKE_GROUP_EC2N_571K }; /* IKE group type IDs. */ enum ike_group_type_enum { IKE_GROUP_TYPE_MODP = 1, IKE_GROUP_TYPE_ECP, IKE_GROUP_TYPE_EC2N }; /* IKE life type IDs. */ enum ike_life_enum { IKE_LIFE_TYPE_SECONDS = 1, IKE_LIFE_TYPE_K }; /* IPSEC situation masks. */ enum isakmp_ipsect_sit_enum { ISAKMP_IPSEC_SIT_IDENTITY_ONLY = 0x1, ISAKMP_IPSEC_SIT_SECRECY = 0x2, ISAKMP_IPSEC_SIT_INTEGRITY = 0x4 }; /* IPSEC Identification types. */ enum isakmp_ipsec_id_enum { ISAKMP_IPSEC_ID_RESERVED = 0, ISAKMP_IPSEC_ID_IPV4_ADDR, ISAKMP_IPSEC_ID_FQDN, ISAKMP_IPSEC_ID_USER_FQDN, ISAKMP_IPSEC_ID_IPV4_ADDR_SUBNET, ISAKMP_IPSEC_ID_IPV6_ADDR, ISAKMP_IPSEC_ID_IPV6_ADDR_SUBNET, ISAKMP_IPSEC_ID_IPV4_ADDR_RANGE, ISAKMP_IPSEC_ID_IPV6_ADDR_RANGE, ISAKMP_IPSEC_ID_DER_ASN1_DN, ISAKMP_IPSEC_ID_DER_ASN1_GN, ISAKMP_IPSEC_ID_KEY_ID }; /* IPSEC protocol IDs. */ enum isakmp_ipsec_proto_enum { ISAKMP_IPSEC_PROTO_RESERVED = 0, ISAKMP_IPSEC_PROTO_ISAKMP, ISAKMP_IPSEC_PROTO_IPSEC_AH, ISAKMP_IPSEC_PROTO_IPSEC_ESP, ISAKMP_IPSEC_PROTO_IPCOMP }; /* IPSEC transform IDs. */ enum isakmp_ipsec_key_enum { ISAKMP_IPSEC_KEY_RESERVED = 0, ISAKMP_IPSEC_KEY_IKE }; /* IPSEC AH IDs. */ enum isakmp_ipsec_ah_enum { ISAKMP_IPSEC_AH_RESERVED = 0, ISAKMP_IPSEC_AH_MD5 = 2, ISAKMP_IPSEC_AH_SHA, ISAKMP_IPSEC_AH_DES, ISAKMP_IPSEC_AH_SHA2_256, ISAKMP_IPSEC_AH_SHA2_384, ISAKMP_IPSEC_AH_SHA2_512, ISAKMP_IPSEC_AH_RIPEMD }; /* IPSEC ESP IDs. */ enum isakmp_ipsec_esp_enum { ISAKMP_IPSEC_ESP_RESERVED = 0, ISAKMP_IPSEC_ESP_DES_IV64, ISAKMP_IPSEC_ESP_DES, ISAKMP_IPSEC_ESP_3DES, ISAKMP_IPSEC_ESP_RC5, ISAKMP_IPSEC_ESP_IDEA, ISAKMP_IPSEC_ESP_CAST, ISAKMP_IPSEC_ESP_BLOWFISH, ISAKMP_IPSEC_ESP_3IDEA, ISAKMP_IPSEC_ESP_DES_IV32, ISAKMP_IPSEC_ESP_RC4, ISAKMP_IPSEC_ESP_NULL, ISAKMP_IPSEC_ESP_AES, ISAKMP_IPSEC_ESP_AES_128_CTR, ISAKMP_IPSEC_ESP_AES_MARS = 249, ISAKMP_IPSEC_ESP_AES_RC6, ISAKMP_IPSEC_ESP_AES_RIJNDAEL, ISAKMP_IPSEC_ESP_AES_SERPENT, ISAKMP_IPSEC_ESP_AES_TWOFISH }; /* IPSEC attribute types. */ enum isakmp_ipsec_attr_enum { ISAKMP_IPSEC_ATTRIB_SA_LIFE_TYPE = 1, ISAKMP_IPSEC_ATTRIB_SA_LIFE_DURATION, ISAKMP_IPSEC_ATTRIB_GROUP_DESC, ISAKMP_IPSEC_ATTRIB_ENCAP_MODE, ISAKMP_IPSEC_ATTRIB_AUTH_ALG, ISAKMP_IPSEC_ATTRIB_KEY_LENGTH, ISAKMP_IPSEC_ATTRIB_KEY_ROUNDS, ISAKMP_IPSEC_ATTRIB_COMP_DICT_SIZE, ISAKMP_IPSEC_ATTRIB_COMP_PRIVATE_ALG, ISAKMP_IPSEC_ATTRIB_ECN_TUNNEL }; /* IPSEC compression IDs. */ enum isakmp_ipsec_ipcomp_enum { ISAKMP_IPSEC_IPCOMP_RESERVED = 0, ISAKMP_IPSEC_IPCOMP_OUI, ISAKMP_IPSEC_IPCOMP_DEFLATE, ISAKMP_IPSEC_IPCOMP_LZS, ISAKMP_IPSEC_IPCOMP_V42BIS }; /* IPSEC lifetime attribute values. */ enum ipsec_life_enum { IPSEC_LIFE_SECONDS = 1, IPSEC_LIFE_K }; /* IPSEC encapsulation attribute numbers. */ enum ipsec_encap_enum { IPSEC_ENCAP_TUNNEL = 1, IPSEC_ENCAP_TRANSPORT, IPSEC_ENCAP_UDP_TUNNEL, IPSEC_ENCAP_UDP_TRANSPORT, IPSEC_ENCAP_UDP_TUNNEL_OLD = 61443, IPSEC_ENCAP_UDP_TRANSPORT_OLD }; /* IPSEC authentication attribute numbers. */ enum ipsec_auth_enum { IPSEC_AUTH_HMAC_MD5 = 1, IPSEC_AUTH_HMAC_SHA, IPSEC_AUTH_DES_MAC, IPSEC_AUTH_KPDK }; /* Other numbers. */ #define ISAKMP_COOKIE_LENGTH 8 #define ISAKMP_VERSION 0x10 /* offsets */ #define ISAKMP_I_COOKIE_O 0 #define ISAKMP_R_COOKIE_O 8 #define ISAKMP_EXCHANGE_TYPE_O 18 #define ISAKMP_FLAGS_O 19 #define ISAKMP_MESSAGE_ID_O 20 #define ISAKMP_LENGTH_O 24 #define ISAKMP_PAYLOAD_O 28 /* Support for draft-ietf-ipsec-isakmp-xauth-06.txt (yuk). */ #define XAUTH_VENDOR_ID { 0x09, 0x00, 0x26, 0x89, 0xDF, 0xD6, 0xB7, 0x12 } /* From dead-peer-detection RFC 3706 */ #define DPD_VENDOR_ID { 0xAF, 0xCA, 0xD7, 0x13, 0x68, 0xA1, 0xF1, 0xC9, \ 0x6B, 0x86, 0x96, 0xFC, 0x77, 0x57, 0x01, 0x00} #define UNITY_VENDOR_ID { 0x12, 0xF5, 0xF2, 0x8C, 0x45, 0x71, 0x68, 0xA9, \ 0x70, 0x2D, 0x9F, 0xE2, 0x74, 0xCC, 0x01, 0x00 } #define UNKNOWN_VENDOR_ID { 0x12, 0x6E, 0x1F, 0x57, 0x72, 0x91, 0x15, 0x3B, \ 0x20, 0x48, 0x5F, 0x7F, 0x15, 0x5B, 0x4B, 0xC8 } /* Support for draft-ietf-ipsec-nat-t-ike-02 */ #define NATT_VENDOR_ID { 0x90, 0xCB, 0x80, 0x91, 0x3E, 0xBB, 0x69, 0x6E, \ 0x08, 0x63, 0x81, 0xB5, 0xEC, 0x42, 0x7B, 0x1F } /* Support for draft-ietf-ipsec-isakmp-mode-cfg-05.txt (yuk). */ enum isakmp_modecfg_cfg_enum { ISAKMP_MODECFG_CFG_REQUEST = 1, ISAKMP_MODECFG_CFG_REPLY, ISAKMP_MODECFG_CFG_SET, ISAKMP_MODECFG_CFG_ACK }; enum isakmp_modecfg_attrib_enum { ISAKMP_MODECFG_ATTRIB_INTERNAL_IP4_ADDRESS = 1, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP4_NETMASK, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP4_DNS, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP4_NBNS, ISAKMP_MODECFG_ATTRIB_INTERNAL_ADDRESS_EXPIRY, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP4_DHCP, ISAKMP_MODECFG_ATTRIB_APPLICATION_VERSION, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP6_ADDRESS, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP6_NETMASK, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP6_DNS, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP6_NBNS, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP6_DHCP, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP4_SUBNET, ISAKMP_MODECFG_ATTRIB_SUPPORTED_ATTRIBUTES, ISAKMP_MODECFG_ATTRIB_INTERNAL_IP6_SUBNET, ISAKMP_XAUTH_ATTRIB_TYPE = 0x4088, ISAKMP_XAUTH_ATTRIB_USER_NAME, ISAKMP_XAUTH_ATTRIB_USER_PASSWORD, ISAKMP_XAUTH_ATTRIB_PASSCODE, ISAKMP_XAUTH_ATTRIB_MESSAGE, ISAKMP_XAUTH_ATTRIB_CHALLENGE, ISAKMP_XAUTH_ATTRIB_DOMAIN, ISAKMP_XAUTH_ATTRIB_STATUS, ISAKMP_XAUTH_ATTRIB_NEXT_PIN, ISAKMP_XAUTH_ATTRIB_ANSWER, /* TYPE .. ANSWER is excluded from dump */ ISAKMP_MODECFG_ATTRIB_CISCO_BANNER = 0x7000, ISAKMP_MODECFG_ATTRIB_CISCO_SAVE_PW, ISAKMP_MODECFG_ATTRIB_CISCO_DEF_DOMAIN, ISAKMP_MODECFG_ATTRIB_CISCO_SPLIT_DNS, ISAKMP_MODECFG_ATTRIB_CISCO_SPLIT_INC, ISAKMP_MODECFG_ATTRIB_CISCO_UDP_ENCAP_PORT, ISAKMP_MODECFG_ATTRIB_CISCO_UNKNOWN, /* whatever 0x7006 is... */ ISAKMP_MODECFG_ATTRIB_CISCO_DO_PFS, ISAKMP_MODECFG_ATTRIB_CISCO_FW_TYPE, ISAKMP_MODECFG_ATTRIB_CISCO_BACKUP_SERVER, ISAKMP_MODECFG_ATTRIB_CISCO_DDNS_HOSTNAME, ISAKMP_XAUTH_ATTRIB_CISCOEXT_VENDOR = 0x7d88 /* strange cisco things ... need docs! */ }; #endif fiked-0.0.5+git20120331.1.e6a5109/vpnc/math_group.c0000644000000000000000000002226611735550573015551 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: math_group.c 62 2005-09-22 16:50:22Z massar $ */ /* borrowed from isakmpd-20030718 (-; */ /* $OpenBSD: math_group.c,v 1.18 2003/06/03 14:28:16 ho Exp $ */ /* $EOM: math_group.c,v 1.25 2000/04/07 19:53:26 niklas Exp $ */ /* * Copyright (c) 1998 Niels Provos. All rights reserved. * Copyright (c) 1999, 2000 Niklas Hallqvist. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This code was written under funding by Ericsson Radio Systems. */ #include #include #include #include #include #include #include "math_group.h" /* We do not want to export these definitions. */ int modp_getlen(struct group *); void modp_getraw(struct group *, gcry_mpi_t, unsigned char *); int modp_setraw(struct group *, gcry_mpi_t, unsigned char *, int); int modp_setrandom(struct group *, gcry_mpi_t); int modp_operation(struct group *, gcry_mpi_t, gcry_mpi_t, gcry_mpi_t); struct modp_group { gcry_mpi_t gen; /* Generator */ gcry_mpi_t p; /* Prime */ gcry_mpi_t a, b, c, d; }; /* * This module provides access to the operations on the specified group * and is absolutly free of any cryptographic devices. This is math :-). */ /* Describe preconfigured MODP groups */ /* * The Generalized Number Field Sieve has an asymptotic running time * of: O(exp(1.9223 * (ln q)^(1/3) (ln ln q)^(2/3))), where q is the * group order, e.g. q = 2**768. */ struct modp_dscr oakley_modp[] = { { OAKLEY_GRP_1, 72, /* This group is insecure, only sufficient for DES */ "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" "E485B576625E7EC6F44C42E9A63A3620FFFFFFFFFFFFFFFF", "2" }, { OAKLEY_GRP_2, 82, /* This group is a bit better */ "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE65381" "FFFFFFFFFFFFFFFF", "2" }, { OAKLEY_GRP_5, 102, /* This group is yet a bit better, but non-standard */ "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1" "29024E088A67CC74020BBEA63B139B22514A08798E3404DD" "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245" "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED" "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D" "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F" "83655D23DCA3AD961C62F356208552BB9ED529077096966D" "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF", "2" }, }; /* XXX I want to get rid of the casting here. */ struct group groups[] = { { MODP, OAKLEY_GRP_1, 0, &oakley_modp[0], 0, 0, 0, 0, 0, (int (*)(struct group *))modp_getlen, (void (*)(struct group *, void *, unsigned char *))modp_getraw, (int (*)(struct group *, void *, unsigned char *, int))modp_setraw, (int (*)(struct group *, void *))modp_setrandom, (int (*)(struct group *, void *, void *, void *))modp_operation }, { MODP, OAKLEY_GRP_2, 0, &oakley_modp[1], 0, 0, 0, 0, 0, (int (*)(struct group *))modp_getlen, (void (*)(struct group *, void *, unsigned char *))modp_getraw, (int (*)(struct group *, void *, unsigned char *, int))modp_setraw, (int (*)(struct group *, void *))modp_setrandom, (int (*)(struct group *, void *, void *, void *))modp_operation }, { MODP, OAKLEY_GRP_5, 0, &oakley_modp[2], 0, 0, 0, 0, 0, (int (*)(struct group *))modp_getlen, (void (*)(struct group *, void *, unsigned char *))modp_getraw, (int (*)(struct group *, void *, unsigned char *, int))modp_setraw, (int (*)(struct group *, void *))modp_setrandom, (int (*)(struct group *, void *, void *, void *))modp_operation }, }; /* * Initialize the group structure for later use, * this is done by converting the values given in the describtion * and converting them to their native representation. */ void group_init(void) { int i; for (i = sizeof(groups) / sizeof(groups[0]) - 1; i >= 0; i--) { assert(groups[i].type == MODP); modp_init(&groups[i]); /* Initialize an over GF(p) */ } } struct group *group_get(int id) { struct group *new, *clone; assert(id >= 1); assert(id <= (int)(sizeof(groups) / sizeof(groups[0]))); clone = &groups[id - 1]; new = malloc(sizeof *new); assert(new); assert(clone->type == MODP); new = modp_clone(new, clone); return new; } void group_free(struct group *grp) { assert(grp->type == MODP); modp_free(grp); free(grp); } struct group *modp_clone(struct group *new, struct group *clone) { struct modp_group *new_grp, *clone_grp = clone->group; new_grp = malloc(sizeof *new_grp); assert(new_grp); memcpy(new, clone, sizeof(struct group)); new->group = new_grp; new_grp->p = gcry_mpi_copy(clone_grp->p); new_grp->gen = gcry_mpi_copy(clone_grp->gen); new_grp->a = gcry_mpi_new(clone->bits); new_grp->b = gcry_mpi_new(clone->bits); new_grp->c = gcry_mpi_new(clone->bits); new->gen = new_grp->gen; new->a = new_grp->a; new->b = new_grp->b; new->c = new_grp->c; return new; } void modp_free(struct group *old) { struct modp_group *grp = old->group; gcry_mpi_release(grp->p); gcry_mpi_release(grp->gen); gcry_mpi_release(grp->a); gcry_mpi_release(grp->b); gcry_mpi_release(grp->c); free(grp); } void modp_init(struct group *group) { struct modp_dscr *dscr = (struct modp_dscr *)group->group; struct modp_group *grp; grp = malloc(sizeof *grp); assert(grp); group->bits = dscr->bits; gcry_mpi_scan(&grp->p, GCRYMPI_FMT_HEX, (const unsigned char*)dscr->prime, 0, NULL); gcry_mpi_scan(&grp->gen, GCRYMPI_FMT_HEX, (const unsigned char *)dscr->gen, 0, NULL); grp->a = gcry_mpi_new(group->bits); grp->b = gcry_mpi_new(group->bits); grp->c = gcry_mpi_new(group->bits); group->gen = grp->gen; group->a = grp->a; group->b = grp->b; group->c = grp->c; group->group = grp; } int modp_getlen(struct group *group) { struct modp_group *grp = (struct modp_group *)group->group; return (gcry_mpi_get_nbits(grp->p) + 7) / 8; } void modp_getraw(struct group *grp, gcry_mpi_t v, unsigned char *d) { size_t l, l2; unsigned char *tmp; int ret; l = grp->getlen(grp); ret = gcry_mpi_aprint(GCRYMPI_FMT_STD, &tmp, &l2, v); memcpy(d, tmp + (l2 - l), l); gcry_free(tmp); #if 0 { char *p; gcry_mpi_aprint(GCRYMPI_FMT_HEX, (void **)&p, NULL, v); printf("export %d - %d(%d):\n%s\n", l, l2, ret, p); gcry_free(p); } #endif } int modp_setraw(struct group *grp, gcry_mpi_t d, unsigned char *s, int l) { int i; grp = 0; /* unused */ gcry_mpi_set_ui(d, 0); for (i = 0; i < l; i++) { gcry_mpi_mul_2exp(d, d, 8); gcry_mpi_add_ui(d, d, s[i]); } #if 0 { char *p; gcry_mpi_aprint(GCRYMPI_FMT_HEX, (void **)&p, NULL, d); printf("import %d:\n%s\n", l, p); gcry_free(p); } #endif return 0; } int modp_setrandom(struct group *grp, gcry_mpi_t d) { int i, l = grp->getlen(grp); uint32_t tmp = 0; gcry_mpi_set_ui(d, 0); for (i = 0; i < l; i++) { if (i % 4) gcry_randomize((unsigned char *)&tmp, sizeof(tmp), GCRY_STRONG_RANDOM); gcry_mpi_mul_2exp(d, d, 8); gcry_mpi_add_ui(d, d, tmp & 0xFF); tmp >>= 8; } return 0; } int modp_operation(struct group *group, gcry_mpi_t d, gcry_mpi_t a, gcry_mpi_t e) { struct modp_group *grp = (struct modp_group *)group->group; gcry_mpi_powm(d, a, e, grp->p); return 0; } fiked-0.0.5+git20120331.1.e6a5109/vpnc/math_group.h0000644000000000000000000000701211735550573015546 0ustar00/* * fiked - a fake IKE PSK+XAUTH daemon based on vpnc * Copyright (C) 2005, Daniel Roethlisberger * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, see http://www.gnu.org/copyleft/ * * $VPNC: math_group.h 57 2005-08-10 15:17:10Z massar $ */ /* borrowed from isakmpd-20030718 (-; */ /* $OpenBSD: math_group.h,v 1.7 2003/06/03 14:28:16 ho Exp $ */ /* $EOM: math_group.h,v 1.7 1999/04/17 23:20:40 niklas Exp $ */ /* * Copyright (c) 1998 Niels Provos. All rights reserved. * Copyright (c) 1999 Niklas Hallqvist. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ /* * This code was written under funding by Ericsson Radio Systems. */ #ifndef __MATH_GROUP_H__ #define __MATH_GROUP_H__ enum groups { MODP /* F_p, Z modulo a prime */ }; #define OAKLEY_GRP_1 1 #define OAKLEY_GRP_2 2 #define OAKLEY_GRP_5 3 /* * The group on which diffie hellmann calculations are done. */ struct group { enum groups type; int id; /* Group ID */ int bits; /* Number of key bits provided by this group */ void *group; void *a, *b, *c, *d; void *gen; /* Group Generator */ int (*getlen) (struct group *); void (*getraw) (struct group *, void *, unsigned char *); int (*setraw) (struct group *, void *, unsigned char *, int); int (*setrandom) (struct group *, void *); int (*operation) (struct group *, void *, void *, void *); }; /* Description of F_p for Boot-Strapping */ struct modp_dscr { int id; int bits; /* Key Bits provided by this group */ const char *prime; /* Prime */ const char *gen; /* Generator */ }; /* Prototypes */ void group_init(void); void group_free(struct group *); struct group *group_get(int); void modp_free(struct group *); struct group *modp_clone(struct group *, struct group *); void modp_init(struct group *); #endif /* _MATH_GROUP_H_ */