Kerberos IV code, based on a merge of fixed code from KTH and original

4.4BSD Lite code (international edition).  Provides all functionality
from the original 4.4BSD code plus standard Kerberos elements that were
omitted in the 4.4BSD code.

29 files changed, 3353 insertions, 0 deletions

diff --git a/kerberosIV/des/3cbc_enc.c b/kerberosIV/des/3cbc_enc.c
new file mode 100644
index 00000000000..1451983c8aa
--- /dev/null
+++ b/kerberosIV/des/3cbc_enc.c
@@ -0,0 +1,52 @@
+/*	$Id: 3cbc_enc.c,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+static void 
+xp(des_cblock *arg)
+{
+  unsigned char *a = (unsigned char *) arg;
+  int i;
+  for(i=0; i<8; i++) printf("%02X",a[i]);printf("\n");
+}
+
+int des_3cbc_encrypt(des_cblock (*input), des_cblock (*output), long int length, struct des_ks_struct *ks1, struct des_ks_struct *ks2, des_cblock (*iv1), des_cblock (*iv2), int encrypt)
+{
+  int off=length/8-1;
+  des_cblock niv1,niv2;
+
+  printf("3cbc\n");
+  xp(iv1);
+  xp(iv1);
+  xp(iv2);
+  xp(input);
+  if (encrypt == DES_ENCRYPT)
+    {
+      des_cbc_encrypt(input,output,length,ks1,iv1,encrypt);
+      if (length >= sizeof(des_cblock))
+	memcpy(niv1,output[off],sizeof(des_cblock));
+      des_cbc_encrypt(output,output,length,ks2,iv1,!encrypt);
+      des_cbc_encrypt(output,output,length,ks1,iv2, encrypt);
+      if (length >= sizeof(des_cblock))
+	memcpy(niv2,output[off],sizeof(des_cblock));
+      memcpy(*iv1,niv1,sizeof(des_cblock));
+    }
+  else
+    {
+      if (length >= sizeof(des_cblock))
+	memcpy(niv1,input[off],sizeof(des_cblock));
+      des_cbc_encrypt(input,output,length,ks1,iv1,encrypt);
+      des_cbc_encrypt(output,output,length,ks2,iv2,!encrypt);
+      if (length >= sizeof(des_cblock))
+	memcpy(niv2,output[off],sizeof(des_cblock));
+      des_cbc_encrypt(output,output,length,ks1,iv2, encrypt);
+    }
+  memcpy(iv1,niv1,sizeof(des_cblock));
+  memcpy(iv2,niv2,sizeof(des_cblock));
+  xp(iv1);
+  xp(iv1);
+  xp(iv2);
+  xp(output);
+  return(0);
+}
diff --git a/kerberosIV/des/3ecb_enc.c b/kerberosIV/des/3ecb_enc.c
new file mode 100644
index 00000000000..e08bc79fa63
--- /dev/null
+++ b/kerberosIV/des/3ecb_enc.c
@@ -0,0 +1,27 @@
+/*	$Id: 3ecb_enc.c,v 1.1 1995/12/14 06:52:45 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+int des_3ecb_encrypt(des_cblock (*input), des_cblock (*output), struct des_ks_struct *ks1, struct des_ks_struct *ks2, int encrypt)
+{
+  register u_int32_t l0,l1;
+  register unsigned char *in,*out;
+  u_int32_t ll[2];
+
+  in=(unsigned char *)input;
+  out=(unsigned char *)output;
+  c2l(in,l0);
+  c2l(in,l1);
+  ll[0]=l0;
+  ll[1]=l1;
+  des_encrypt(ll,ll,ks1,encrypt);
+  des_encrypt(ll,ll,ks2,!encrypt);
+  des_encrypt(ll,ll,ks1,encrypt);
+  l0=ll[0];
+  l1=ll[1];
+  l2c(l0,out);
+  l2c(l1,out);
+  return(0);
+}
+
diff --git a/kerberosIV/des/ARTISTIC b/kerberosIV/des/ARTISTIC
new file mode 100644
index 00000000000..eb6707109df
--- /dev/null
+++ b/kerberosIV/des/ARTISTIC
@@ -0,0 +1,103 @@
+			 The "Artistic License"
+
+				Preamble
+
+The intent of this document is to state the conditions under which a
+Package may be copied, such that the Copyright Holder maintains some
+semblance of artistic control over the development of the package,
+while giving the users of the package the right to use and distribute
+the Package in a more-or-less customary fashion, plus the right to make
+reasonable modifications.
+
+Definitions:
+
+	"Package" refers to the collection of files distributed by the
+	Copyright Holder, and derivatives of that collection of files
+	created through textual modification.
+
+	"Standard Version" refers to such a Package if it has not been
+	modified, or has been modified in accordance with the wishes
+	of the Copyright Holder as specified below.
+
+	"Copyright Holder" is whoever is named in the copyright or
+	copyrights for the package.
+
+	"You" is you, if you're thinking about copying or distributing
+	this Package.
+
+	"Reasonable copying fee" is whatever you can justify on the
+	basis of media cost, duplication charges, time of people involved,
+	and so on.  (You will not be required to justify it to the
+	Copyright Holder, but only to the computing community at large
+	as a market that must bear the fee.)
+
+	"Freely Available" means that no fee is charged for the item
+	itself, though there may be fees involved in handling the item.
+	It also means that recipients of the item may redistribute it
+	under the same conditions they received it.
+
+1. You may make and give away verbatim copies of the source form of the
+Standard Version of this Package without restriction, provided that you
+duplicate all of the original copyright notices and associated disclaimers.
+
+2. You may apply bug fixes, portability fixes and other modifications
+derived from the Public Domain or from the Copyright Holder.  A Package
+modified in such a way shall still be considered the Standard Version.
+
+3. You may otherwise modify your copy of this Package in any way, provided
+that you insert a prominent notice in each changed file stating how and
+when you changed that file, and provided that you do at least ONE of the
+following:
+
+    a) place your modifications in the Public Domain or otherwise make them
+    Freely Available, such as by posting said modifications to Usenet or
+    an equivalent medium, or placing the modifications on a major archive
+    site such as uunet.uu.net, or by allowing the Copyright Holder to include
+    your modifications in the Standard Version of the Package.
+
+    b) use the modified Package only within your corporation or organization.
+
+    c) rename any non-standard executables so the names do not conflict
+    with standard executables, which must also be provided, and provide
+    a separate manual page for each non-standard executable that clearly
+    documents how it differs from the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+4. You may distribute the programs of this Package in object code or
+executable form, provided that you do at least ONE of the following:
+
+    a) distribute a Standard Version of the executables and library files,
+    together with instructions (in the manual page or equivalent) on where
+    to get the Standard Version.
+
+    b) accompany the distribution with the machine-readable source of
+    the Package with your modifications.
+
+    c) give non-standard executables non-standard names, and clearly
+    document the differences in manual pages (or equivalent), together
+    with instructions on where to get the Standard Version.
+
+    d) make other distribution arrangements with the Copyright Holder.
+
+5. You may charge a reasonable copying fee for any distribution of this
+Package.  You may charge any fee you choose for support of this
+Package.  You may not charge a fee for this Package itself.  However,
+you may distribute this Package in aggregate with other (possibly
+commercial) programs as part of a larger (possibly commercial) software
+distribution provided that you do not advertise this Package as a
+product of your own.
+
+6. Any programs linked with this library do not automatically fall
+under the copyright of this Package, but belong to whomever generated
+them, and may be sold commercially, and may be aggregated with this
+Package.
+
+7. The name of the Copyright Holder may not be used to endorse or promote
+products derived from this software without specific prior written permission.
+
+8. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+				The End
diff --git a/kerberosIV/des/CHANGES b/kerberosIV/des/CHANGES
new file mode 100644
index 00000000000..4f441fae2d4
--- /dev/null
+++ b/kerberosIV/des/CHANGES
@@ -0,0 +1,16 @@
+The main changes in this package since it was last posted to
+comp.sources.misc are
+
+The main changes are
+- Major changes to the Copyright restrictions.
+- Lots and lots of features added to the des(1) command, including
+  - Triple DES, both triple ECB and triple CBC options.
+  - uuencodeing/uudecoding built in to des(1).
+  - generate checksums.
+  - hex keys.
+- Cleaned up the prototypes in des.h
+- Filenames are now mostly <= 8 characters long.
+- OFB, CFB, triple ECB and triple CBC modes of DES added to the library.
+- Compiles and runs of all 64bit machines I could test the code on
+  (Cray, ETA10, DEC Alpha).
+- It really does work with kerberos v 4 now :-).
diff --git a/kerberosIV/des/COPYING b/kerberosIV/des/COPYING
new file mode 100644
index 00000000000..9b1a9329f15
--- /dev/null
+++ b/kerberosIV/des/COPYING
@@ -0,0 +1,489 @@
+Copyright (C) 1993 Eric Young
+
+This is a DES implementation written by Eric Young (eay@psych.psy.uq.oz.au)
+The implementation was written so as to conform with the manual entry
+for the des_crypt(3) library routines from MIT's project Athena.
+
+
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1991 Free Software Foundation, Inc.
+                    675 Mass Ave, Cambridge, MA 02139, USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the library GPL.  It is
+ numbered 2 because it goes with version 2 of the ordinary GPL.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Library General Public License, applies to some
+specially designated Free Software Foundation software, and to any
+other libraries whose authors decide to use it.  You can use it for
+your libraries, 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 library, or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link a program with the library, you must provide
+complete object files to the recipients so that they can relink them
+with the library, after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  Our method of protecting your rights has two steps: (1) copyright
+the library, and (2) offer you this license which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  Also, for each distributor's protection, we want to make certain
+that everyone understands that there is no warranty for this free
+library.  If the library is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original
+version, 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 companies distributing free
+software will individually obtain patent licenses, thus in effect
+transforming the program into proprietary software.  To prevent this,
+we have made it clear that any patent must be licensed for everyone's
+free use or not licensed at all.
+
+  Most GNU software, including some libraries, is covered by the ordinary
+GNU General Public License, which was designed for utility programs.  This
+license, the GNU Library General Public License, applies to certain
+designated libraries.  This license is quite different from the ordinary
+one; be sure to read it in full, and don't assume that anything in it is
+the same as in the ordinary license.
+
+  The reason we have a separate public license for some libraries is that
+they blur the distinction we usually make between modifying or adding to a
+program and simply using it.  Linking a program with a library, without
+changing the library, is in some sense simply using the library, and is
+analogous to running a utility program or application program.  However, in
+a textual and legal sense, the linked executable is a combined work, a
+derivative of the original library, and the ordinary General Public License
+treats it as such.
+
+  Because of this blurred distinction, using the ordinary General
+Public License for libraries did not effectively promote software
+sharing, because most developers did not use the libraries.  We
+concluded that weaker conditions might promote sharing better.
+
+  However, unrestricted linking of non-free programs would deprive the
+users of those programs of all benefit from the free status of the
+libraries themselves.  This Library General Public License is intended to
+permit developers of non-free programs to use free libraries, while
+preserving your freedom as a user of such programs to change the free
+libraries that are incorporated in them.  (We have not seen how to achieve
+this as regards changes in header files, but we have achieved it as regards
+changes in the actual functions of the Library.)  The hope is that this
+will lead to faster development of free libraries.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, while the latter only
+works together with the library.
+
+  Note that it is possible for a library to be covered by the ordinary
+General Public License rather than by this special one.
+
+		  GNU LIBRARY GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library which
+contains a notice placed by the copyright holder or other authorized
+party saying it may be distributed under the terms of this Library
+General Public License (also called "this License").  Each licensee is
+addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, 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 library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete 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 distribute a copy of this License along with the
+Library.
+
+  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 Library or any portion
+of it, thus forming a work based on the Library, 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) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+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 Library, 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 Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you 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.
+
+  If distribution of 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 satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also compile or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    c) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    d) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  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.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library 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.
+
+  9. 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 Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+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.
+
+  11. 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 Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library 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 Library.
+
+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.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library 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.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Library 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 Library
+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 Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+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
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "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
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. 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 LIBRARY 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
+LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+     Appendix: How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  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.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Library General Public
+    License as published by the Free Software Foundation; either
+    version 2 of the License, or (at your option) any later version.
+
+    This library 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
+    Library General Public License for more details.
+
+    You should have received a copy of the GNU Library General Public
+    License along with this library; if not, write to the Free
+    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
diff --git a/kerberosIV/des/Makefile b/kerberosIV/des/Makefile
new file mode 100644
index 00000000000..0dcbaf887bf
--- /dev/null
+++ b/kerberosIV/des/Makefile
@@ -0,0 +1,16 @@
+#	$Id: Makefile,v 1.1 1995/12/14 06:52:44 tholo Exp $
+
+LIB=	des
+SRCS=	3cbc_enc.c 3ecb_enc.c cbc_cksm.c cbc_enc.c cfb_enc.c \
+	ecb_enc.c enc_read.c enc_writ.c key_par.c ofb_enc.c \
+	pcbc_enc.c qud_cksm.c random_key.c read_pwd.c rnd_keys.c \
+	set_key.c str2key.c
+CFLAGS+=-I${.CURDIR}
+MAN=	des_crypt.3
+MLINKS+=des_crypt.3 des_read_password.3 des_crypt.3 des_string_to_key.3 \
+	des_crypt.3 des_random_key.3 des_crypt.3 des_set_key.3 \
+	des_crypt.3 des_ecb_encrypt.3 des_crypt.3 des_cbc_encrypt.3 \
+	des_crypt.3 des_pcbc_encrypt.3 des_crypt.3 des_cbc_cksum.3 \
+	des_crypt.3 des_quad_cksum.3
+
+.include <bsd.lib.mk>
diff --git a/kerberosIV/des/README b/kerberosIV/des/README
new file mode 100644
index 00000000000..ee1fa0c0a16
--- /dev/null
+++ b/kerberosIV/des/README
@@ -0,0 +1,55 @@
+			libdes, Version 3.00 93/10/07
+
+		Copyright (c) 1993, Eric Young
+			  All rights reserved.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either:
+    
+	a) the GNU General Public License as published by the Free
+	Software Foundation; either version 1, or (at your option) any
+	later version, or
+
+	b) the "Artistic License" which comes with this Kit.
+
+    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 either
+    the GNU General Public License or the Artistic License for more details.
+
+    You should have received a copy of the Artistic License with this
+    Kit, in the file named "Artistic".  If not, I'll be glad to provide one.
+
+    You should also have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+---
+This kit builds a DES encryption library and a DES encryption program.
+It suports ecb, cbc, ofb, cfb, triple ecb, triple cbc and MIT's pcbc
+encryption modes and also has a fast implementation of crypt(3).
+It contains support routines to read keys from a terminal,
+generate a random key, generate a key from an arbitary length string,
+read/write encrypted data from/to a file descriptor.
+
+The implementation was written so as to conform with the manual entry
+for the des_crypt(3) library routines from MIT's project Athena.
+
+destest should be run after compilation to test the des routines.
+rpw should be run after compilation to test the read password routines.
+The des program is a replacement for the sun des command.  I believe it
+conforms to the sun version.
+
+The Imakefile is setup for use in the kerberos distribution.
+
+These routines are best compiled with gcc or any other good
+optimising compiler.
+Just turn you optimiser up to the highest settings and run destest
+after the build to make sure everything works.
+
+I believe these routines are close to the fastest and most portable DES
+routines that use small lookup tables (4.5k) that are publicly available.
+The fcrypt routine is faster than ufc's fcrypt (when compiling with
+gcc2 -O2) on the sparc 2 (1410 vs 1270) but is not so good on other machines
+(on a sun3/260 168 vs 336).
+
+Eric Young (eay@psych.psy.uq.oz.au)
diff --git a/kerberosIV/des/VERSION b/kerberosIV/des/VERSION
new file mode 100644
index 00000000000..21e3b8dbadb
--- /dev/null
+++ b/kerberosIV/des/VERSION
@@ -0,0 +1,185 @@
+Release apon comp.sources.misc
+Version 3.01 08/10/93
+	Added des_3cbc_encrypt()
+
+Version 3.00 07/10/93
+	Fixed up documentation.
+	quad_cksum definitly compatable with MIT's now.
+
+Version 2.30 24/08/93
+	Tripple DES now defaults to tripple cbc but can do tripple ecb
+	 with the -b flag.
+	Fixed some MSDOS uuen/uudecoding problems, thanks to
+	Added prototypes.
+	
+Version 2.22 29/06/93
+	Fixed a bug in des_is_weak_key() which stopped it working :-(
+	thanks to engineering@MorningStar.Com.
+
+Version 2.21 03/06/93
+	des(1) with no arguments gives quite a bit of help.
+	Added -c (generate ckecksum) flag to des(1).
+	Added -3 (tripple DES) flag to des(1).
+	Added cfb and ofb routines to the library.
+
+Version 2.20 11/03/93
+	Added -u (uuencode) flag to des(1).
+	I have been playing with byte order in quad_cksum to make it
+	 compatible with MIT's version.  All I can say is aviod this
+	 function if possible since MIT's output is endian dependent.
+
+Version 2.12 14/10/92
+	Added MSDOS specific macro in ecb_encrypt which gives a %70
+	 speed up when the code is compiled with turbo C.
+
+Version 2.11 12/10/92
+	Speedup in set_key (recoding of PC-1)
+	 I now do it in 47 simple operations, down from 60.
+	 Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
+	 for motivating me to look for a faster system :-)
+	 The speedup is probably less that 1% but it is still 13
+	 instructions less :-).
+
+Version 2.10 06/10/92
+	The code now works on the 64bit ETA10 and CRAY without modifications or
+	 #defines.  I believe the code should work on any machine that
+	 defines long, int or short to be 8 bytes long.
+	Thanks to Shabbir J. Safdar (shabby@mentor.cc.purdue.edu)
+	 for helping me fix the code to run on 64bit machines (he had
+	 access to an ETA10).
+	Thanks also to John Fletcher <john_fletcher@lccmail.ocf.llnl.gov>
+	 for testing the routines on a CRAY.
+	read_password.c has been renamed to read_passwd.c
+	string_to_key.c has been renamed to string2key.c
+
+Version 2.00 14/09/92
+	Made mods so that the library should work on 64bit CPU's.
+	Removed all my uchar and ulong defs.  To many different
+	 versions of unix define them in their header files in too many
+	 different combinations :-)
+	IRIX - Sillicon Graphics mods (mostly in read_password.c).
+	 Thanks to Andrew Daviel (advax@erich.triumf.ca)
+
+Version 1.99 26/08/92
+	Fixed a bug or 2 in enc_read.c
+	Fixed a bug in enc_write.c
+	Fixed a pseudo bug in fcrypt.c (very obscure).
+
+Version 1.98 31/07/92
+	Support for the ETA10.  This is a strange machine that defines
+	longs and ints as 8 bytes and shorts as 4 bytes.
+	Since I do evil things with long * that assume that they are 4
+	bytes.  Look in the Makefile for the option to compile for
+	this machine.  quad_cksum appears to have problems but I
+	will don't have the time to fix it right now, and this is not
+	a function that uses DES and so will not effect the main uses
+	of the library.
+
+Version 1.97 20/05/92 eay
+	Fixed the Imakefile and made some changes to des.h to fix some
+	problems when building this package with Kerberos v 4.
+
+Version 1.96 18/05/92 eay
+	Fixed a small bug in string_to_key() where problems could
+	occur if des_check_key was set to true and the string
+	generated a weak key.
+
+Patch2 posted to comp.sources.misc
+Version 1.95 13/05/92 eay
+	Added an alternative version of the D_ENCRYPT macro in
+	ecb_encrypt and fcrypt.  Depending on the compiler, one version or the
+	other will be faster.  This was inspired by 
+	Dana How <how@isl.stanford.edu>, and her pointers about doing the
+	*(ulong *)((uchar *)ptr+(value&0xfc))
+	vs
+	ptr[value&0x3f]
+	to stop the C compiler doing a <<2 to convert the long array index.
+
+Version 1.94 05/05/92 eay
+	Fixed an incompatibility between my string_to_key and the MIT
+	 version.  When the key is longer than 8 chars, I was wrapping
+	 with a different method.  To use the old version, define
+	 OLD_STR_TO_KEY in the makefile.  Thanks to
+	 viktor@newsu.shearson.com (Viktor Dukhovni).
+
+Version 1.93 28/04/92 eay
+	Fixed the VMS mods so that echo is now turned off in
+	 read_password.  Thanks again to brennan@coco.cchs.su.oz.AU.
+	MSDOS support added.  The routines can be compiled with
+	 Turbo C (v2.0) and MSC (v5.1).  Make sure MSDOS is defined.
+
+Patch1 posted to comp.sources.misc
+Version 1.92 13/04/92 eay
+	Changed D_ENCRYPT so that the rotation of R occurs outside of
+	 the loop.  This required rotating all the longs in sp.h (now
+	 called spr.h). Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
+	speed.c has been changed so it will work without SIGALRM.  If
+	 times(3) is not present it will try to use ftime() instead.
+
+Version 1.91 08/04/92 eay
+	Added -E/-D options to des(1) so it can use string_to_key.
+	Added SVR4 mods suggested by witr@rwwa.COM
+	Added VMS mods suggested by brennan@coco.cchs.su.oz.AU.  If
+	anyone knows how to turn of tty echo in VMS please tell me or
+	implement it yourself :-).
+	Changed FILE *IN/*OUT to *DES_IN/*DES_OUT since it appears VMS
+	does not like IN/OUT being used.
+
+Libdes posted to comp.sources.misc
+Version 1.9 24/03/92 eay
+	Now contains a fast small crypt replacement.
+	Added des(1) command.
+	Added des_rw_mode so people can use cbc encryption with
+	enc_read and enc_write.
+
+Version 1.8 15/10/91 eay
+	Bug in cbc_cksum.
+	Many thanks to Keith Reynolds (keithr@sco.COM) for pointing this
+	one out.
+
+Version 1.7 24/09/91 eay
+	Fixed set_key :-)
+	set_key is 4 times faster and takes less space.
+	There are a few minor changes that could be made.
+
+Version 1.6 19/09/1991 eay
+	Finally go IP and FP finished.
+	Now I need to fix set_key.
+	This version is quite a bit faster that 1.51
+
+Version 1.52 15/06/1991 eay
+	20% speedup in ecb_encrypt by changing the E bit selection
+	to use 2 32bit words.  This also required modification of the
+	sp table.  There is still a way to speedup the IP and IP-1
+	(hints from outer@sq.com) still working on this one :-(.
+
+Version 1.51 07/06/1991 eay
+	Faster des_encrypt by loop unrolling
+	Fixed bug in quad_cksum.c (thanks to hughes@logos.ucs.indiana.edu)
+
+Version 1.50 28/05/1991 eay
+	Optimized the code a bit more for the sparc.  I have improved the
+	speed of the inner des_encrypt by speeding up the initial and
+	final permutations.
+
+Version 1.40 23/10/1990 eay
+	Fixed des_random_key, it did not produce a random key :-(
+
+Version 1.30  2/10/1990 eay
+	Have made des_quad_cksum the same as MIT's, the full package
+	should be compatible with MIT's
+	Have tested on a DECstation 3100
+	Still need to fix des_set_key (make it faster).
+	Does des_cbc_encrypts at 70.5k/sec on a 3100.
+
+Version 1.20 18/09/1990 eay
+	Fixed byte order dependencies.
+	Fixed (I hope) all the word alignment problems.
+	Speedup in des_ecb_encrypt.
+
+Version 1.10 11/09/1990 eay
+	Added des_enc_read and des_enc_write.
+	Still need to fix des_quad_cksum.
+	Still need to document des_enc_read and des_enc_write.
+
+Version 1.00 27/08/1990 eay
diff --git a/kerberosIV/des/cbc_cksm.c b/kerberosIV/des/cbc_cksm.c
new file mode 100644
index 00000000000..d1c3a6d51c4
--- /dev/null
+++ b/kerberosIV/des/cbc_cksm.c
@@ -0,0 +1,46 @@
+/*	$Id: cbc_cksm.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+u_int32_t des_cbc_cksum(des_cblock (*input), des_cblock (*output), long int length, struct des_ks_struct *schedule, des_cblock (*ivec))
+{
+  register u_int32_t tout0,tout1,tin0,tin1;
+  register long l=length;
+  u_int32_t tin[2],tout[2];
+  unsigned char *in,*out,*iv;
+
+  in=(unsigned char *)input;
+  out=(unsigned char *)output;
+  iv=(unsigned char *)ivec;
+
+  c2l(iv,tout0);
+  c2l(iv,tout1);
+  for (; l>0; l-=8)
+    {
+      if (l >= 8)
+	{
+	  c2l(in,tin0);
+	  c2l(in,tin1);
+	}
+      else
+	c2ln(in,tin0,tin1,l);
+			
+      tin0^=tout0;
+      tin1^=tout1;
+      tin[0]=tin0;
+      tin[1]=tin1;
+      des_encrypt(tin,tout,
+		  schedule,DES_ENCRYPT);
+      /* fix 15/10/91 eay - thanks to keithr@sco.COM */
+      tout0=tout[0];
+      tout1=tout[1];
+    }
+  if (out != NULL)
+    {
+      l2c(tout0,out);
+      l2c(tout1,out);
+    }
+  tout0=tin0=tin1=tin[0]=tin[1]=tout[0]=tout[1]=0;
+  return(tout1);
+}
diff --git a/kerberosIV/des/cbc_enc.c b/kerberosIV/des/cbc_enc.c
new file mode 100644
index 00000000000..abfb89c7aa8
--- /dev/null
+++ b/kerberosIV/des/cbc_enc.c
@@ -0,0 +1,73 @@
+/*	$Id: cbc_enc.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+int des_cbc_encrypt(des_cblock (*input), des_cblock (*output), long int length, struct des_ks_struct *schedule, des_cblock (*ivec), int encrypt)
+{
+  register u_int32_t tin0,tin1;
+  register u_int32_t tout0,tout1,xor0,xor1;
+  register unsigned char *in,*out;
+  register long l=length;
+  u_int32_t tout[2],tin[2];
+  unsigned char *iv;
+
+  in=(unsigned char *)input;
+  out=(unsigned char *)output;
+  iv=(unsigned char *)ivec;
+
+  if (encrypt)
+    {
+      c2l(iv,tout0);
+      c2l(iv,tout1);
+      for (; l>0; l-=8)
+	{
+	  if (l >= 8)
+	    {
+	      c2l(in,tin0);
+	      c2l(in,tin1);
+	    }
+	  else
+	    c2ln(in,tin0,tin1,l);
+	  tin0^=tout0;
+	  tin1^=tout1;
+	  tin[0]=tin0;
+	  tin[1]=tin1;
+	  des_encrypt(tin,tout,
+		      schedule,encrypt);
+	  tout0=tout[0];
+	  tout1=tout[1];
+	  l2c(tout0,out);
+	  l2c(tout1,out);
+	}
+    }
+  else
+    {
+      c2l(iv,xor0);
+      c2l(iv,xor1);
+      for (; l>0; l-=8)
+	{
+	  c2l(in,tin0);
+	  c2l(in,tin1);
+	  tin[0]=tin0;
+	  tin[1]=tin1;
+	  des_encrypt(tin,tout,
+		      schedule,encrypt);
+	  tout0=tout[0]^xor0;
+	  tout1=tout[1]^xor1;
+	  if (l >= 8)
+	    {
+	      l2c(tout0,out);
+	      l2c(tout1,out);
+	    }
+	  else
+	    l2cn(tout0,tout1,out,l);
+	  xor0=tin0;
+	  xor1=tin1;
+	}
+    }
+  tin0=tin1=tout0=tout1=xor0=xor1=0;
+  tin[0]=tin[1]=tout[0]=tout[1]=0;
+  return(0);
+}
+
diff --git a/kerberosIV/des/cfb_enc.c b/kerberosIV/des/cfb_enc.c
new file mode 100644
index 00000000000..50eab207602
--- /dev/null
+++ b/kerberosIV/des/cfb_enc.c
@@ -0,0 +1,100 @@
+/*	$Id: cfb_enc.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+/* The input and output are loaded in multiples of 8 bits.
+ * What this means is that if you hame numbits=12 and length=2
+ * the first 12 bits will be retrieved from the first byte and half
+ * the second.  The second 12 bits will come from the 3rd and half the 4th
+ * byte.
+ */
+int des_cfb_encrypt(unsigned char *in, unsigned char *out, int numbits, long int length, struct des_ks_struct *schedule, des_cblock (*ivec), int encrypt)
+{
+  register u_int32_t d0,d1,v0,v1,n=(numbits+7)/8;
+  register u_int32_t mask0,mask1;
+  register long l=length;
+  register int num=numbits;
+  u_int32_t ti[2],to[2];
+  unsigned char *iv;
+
+  if (num > 64) return(0);
+  if (num > 32)
+    {
+      mask0=0xffffffff;
+      if (num == 64)
+	mask1=mask0;
+      else
+	mask1=(1L<<(num-32))-1;
+    }
+  else
+    {
+      if (num == 32)
+	mask0=0xffffffff;
+      else
+	mask0=(1L<<num)-1;
+      mask1=0x00000000;
+    }
+
+  iv=(unsigned char *)ivec;
+  c2l(iv,v0);
+  c2l(iv,v1);
+  if (encrypt)
+    {
+      while (l-- > 0)
+	{
+	  ti[0]=v0;
+	  ti[1]=v1;
+	  des_encrypt(ti,to,
+		      schedule,DES_ENCRYPT);
+	  c2ln(in,d0,d1,n);
+	  in+=n;
+	  d0=(d0^to[0])&mask0;
+	  d1=(d1^to[1])&mask1;
+	  l2cn(d0,d1,out,n);
+	  out+=n;
+	  if (num > 32)
+	    {
+	      v0=((v1>>(num-32))|(d0<<(64-num)))&0xffffffff;
+	      v1=((d0>>(num-32))|(d1<<(64-num)))&0xffffffff;
+	    }
+	  else
+	    {
+	      v0=((v0>>num)|(v1<<(32-num)))&0xffffffff;
+	      v1=((v1>>num)|(d0<<(32-num)))&0xffffffff;
+	    }
+	}
+    }
+  else
+    {
+      while (l-- > 0)
+	{
+	  ti[0]=v0;
+	  ti[1]=v1;
+	  des_encrypt(ti,to,
+		      schedule,DES_ENCRYPT);
+	  c2ln(in,d0,d1,n);
+	  in+=n;
+	  if (num > 32)
+	    {
+	      v0=((v1>>(num-32))|(d0<<(64-num)))&0xffffffff;
+	      v1=((d0>>(num-32))|(d1<<(64-num)))&0xffffffff;
+	    }
+	  else
+	    {
+	      v0=((v0>>num)|(v1<<(32-num)))&0xffffffff;
+	      v1=((v1>>num)|(d0<<(32-num)))&0xffffffff;
+	    }
+	  d0=(d0^to[0])&mask0;
+	  d1=(d1^to[1])&mask1;
+	  l2cn(d0,d1,out,n);
+	  out+=n;
+	}
+    }
+  iv=(unsigned char *)ivec;
+  l2c(v0,iv);
+  l2c(v1,iv);
+  v0=v1=d0=d1=ti[0]=ti[1]=to[0]=to[1]=0;
+  return(0);
+}
+
diff --git a/kerberosIV/des/des_crypt.3 b/kerberosIV/des/des_crypt.3
new file mode 100644
index 00000000000..41a572ed53b
--- /dev/null
+++ b/kerberosIV/des/des_crypt.3
@@ -0,0 +1,379 @@
+.\" Copyright 1989 by the Massachusetts Institute of Technology.
+.\"
+.\" For copying and distribution information,
+.\" please see the file <mit-copyright.h>.
+.\"
+.\"	$Id: des_crypt.3,v 1.1 1995/12/14 06:52:44 tholo Exp $
+.TH DES_CRYPT 3  "Kerberos Version 4.0" "MIT Project Athena"
+.SH NAME
+des_read_password, des_string_to_key, des_random_key, des_set_key,
+des_ecb_encrypt, des_cbc_encrypt, des_pcbc_encrypt, des_cbc_cksum,
+des_quad_cksum, \- (new) DES encryption
+.SH SYNOPSIS
+.nf
+.nj
+.ft B
+#include <des.h>
+.PP
+.ft B
+.B int des_read_password(key,prompt,verify)
+des_cblock *key;
+char *prompt;
+int verify;
+.PP
+.ft B
+int des_string_to_key(str,key)
+char *str;
+des_cblock key;
+.PP
+.ft B
+int des_random_key(key)
+des_cblock *key;
+.PP
+.ft B
+int des_set_key(key,schedule)
+des_cblock *key;
+des_key_schedule schedule;
+.PP
+.ft B
+int des_ecb_encrypt(input,output,schedule,encrypt)
+des_cblock *input;
+des_cblock *output;
+des_key_schedule schedule;
+int encrypt;
+.PP
+.ft B
+int des_cbc_encrypt(input,output,length,schedule,ivec,encrypt)
+des_cblock *input;
+des_cblock *output;
+long length;
+des_key_schedule schedule;
+des_cblock *ivec;
+int encrypt;
+.PP
+.ft B
+int des_pcbc_encrypt(input,output,length,schedule,ivec,encrypt)
+des_cblock *input;
+des_cblock *output;
+long length;
+des_key_schedule schedule;
+des_cblock *ivec;
+int encrypt;
+.PP
+.ft B
+unsigned long des_cbc_cksum(input,output,length,schedule,ivec)
+des_cblock *input;
+des_cblock *output;
+long length;
+des_key_schedule schedule;
+des_cblock *ivec;
+.PP
+.ft B
+unsigned long quad_cksum(input,output,length,out_count,seed)
+des_cblock *input;
+des_cblock *output;
+long length;
+int out_count;
+des_cblock *seed;
+.PP
+.fi
+.SH DESCRIPTION
+This library supports various DES encryption related operations. It differs
+from the
+.I crypt, setkey, and encrypt
+library routines in that it provides
+a true DES encryption, without modifying the algorithm,
+and executes much faster.
+.PP
+For each key that may be simultaneously active, create a
+.B des_key_schedule
+struct,
+defined in "des.h". Next, create key schedules (from the 8-byte keys) as
+needed, via
+.I des_set_key,
+prior to using the encryption or checksum routines. Then
+setup the input and output areas.  Make sure to note the restrictions
+on lengths being multiples of eight bytes. Finally, invoke the
+encryption/decryption routines,
+.I des_ecb_encrypt
+or
+.I des_cbc_encrypt
+or
+.I des_pcbc_encrypt,
+or, to generate a cryptographic checksum, use
+.I quad_cksum
+(fast) or
+.I des_cbc_cksum
+(slow).
+.PP
+A
+.I des_cblock
+struct is an 8 byte block used as the fundamental unit for DES data and
+keys, and is defined as:
+.PP
+.B	typedef	unsigned char des_cblock[8];
+.PP
+and a
+.I des_key_schedule,
+is defined as:
+.PP
+.B	typedef	struct des_ks_struct {des_cblock _;}  des_key_schedule[16];
+.PP
+.I des_read_password
+writes the string specified by
+.I prompt
+to the standard
+output, turns off echo (if possible)
+and reads an input string from standard input until terminated with a newline.
+If
+.I verify
+is non-zero, it prompts and reads input again, for use
+in applications such as changing a password; both
+versions are compared, and the input is requested repeatedly until they
+match.  Then
+.I des_read_password
+converts the input string into a valid DES key, internally
+using the
+.I des_string_to_key
+routine.  The newly created key is copied to the
+area pointed to by the
+.I key
+argument.
+.I des_read_password
+returns a zero if no errors occurred, or a -1
+indicating that an error
+occurred trying to manipulate the terminal echo.
+.PP
+.PP
+.I des_string_to_key
+converts an arbitrary length null-terminated string
+to an 8 byte DES key, with odd byte parity, per FIPS specification.
+A one-way function is used to convert the string to a key, making it
+very difficult to reconstruct the string from the key.
+The
+.I str
+argument is a pointer to the string, and
+.I key
+should
+point to a
+.I des_cblock
+supplied by the caller to receive the generated key.
+No meaningful value is returned. Void is not used for compatibility with
+other compilers.
+.PP
+.PP
+.I des_random_key
+generates a random DES encryption key (eight bytes), set to odd parity per
+FIPS
+specifications.
+This routine uses the current time, process id, and a counter
+as a seed for the random number generator.
+The caller must	supply space for the output key, pointed to
+by argument
+.I key,
+then after calling
+.I des_random_key
+should
+call the
+.I des_set_key
+routine when needed.
+No meaningful value is returned.  Void is not used for compatibility
+with other compilers.
+.PP
+.PP
+.I des_set_key
+calculates a key schedule from all eight bytes of the input key, pointed
+to by the
+.I key
+argument, and outputs the schedule into the
+.I des_key_schedule
+indicated by the
+.I schedule
+argument. Make sure to pass a valid eight byte
+key; no padding is done.  The key schedule may then be used in subsequent
+encryption/decryption/checksum operations.  Many key schedules may be
+cached for later use.  The user is responsible to clear keys and schedules
+as soon as no longer needed, to prevent their disclosure.
+The routine also checks the key
+parity, and returns a zero if the key parity is correct (odd), a -1
+indicating a key parity error, or a -2 indicating use of an illegal
+weak key. If an error is returned, the key schedule was not created.
+.PP
+.PP
+.I des_ecb_encrypt
+is the basic DES encryption routine that encrypts or decrypts a single 8-byte
+block in
+.B electronic code book
+mode.  It always transforms the input data, pointed to by
+.I input,
+into the output data, pointed to by the
+.I output
+argument.
+.PP
+If the
+.I encrypt
+argument is non-zero, the
+.I input
+(cleartext) is encrypted into the
+.I output
+(ciphertext) using the key_schedule specified by the
+.I schedule
+argument, previously set via
+.I des_set_key
+.PP
+If encrypt is zero, the
+.I input
+(now ciphertext) is decrypted into the
+.I output
+(now cleartext).
+.PP
+Input and output may overlap.
+.PP
+No meaningful value is returned.  Void is not used for compatibility
+with other compilers.
+.PP
+.PP
+.I des_cbc_encrypt
+encrypts/decrypts using the
+.B cipher-block-chaining mode of DES.
+If the
+.I encrypt
+argument is non-zero, the routine cipher-block-chain encrypts
+the cleartext data pointed to by the
+.I input
+argument into the ciphertext pointed to by the
+.I output
+argument, using the key schedule provided by the
+.I schedule
+argument, and initialization vector provided by the
+.I ivec
+argument.
+If the
+.I length
+argument is not an integral
+multiple of eight bytes, the last block is copied to a temp and zero
+filled (highest addresses).  The output is ALWAYS an integral multiple
+of eight bytes.
+.PP
+If
+.I encrypt
+is zero, the routine cipher-block chain decrypts the (now) ciphertext
+data pointed to by the
+.I input
+argument into (now) cleartext pointed to by the
+.I output
+argument using the key schedule provided by the
+.I schedule
+argument, and initialization vector provided by the
+.I ivec
+argument. Decryption ALWAYS operates on integral
+multiples of 8 bytes, so it will round the
+.I length
+provided up to the
+appropriate multiple. Consequently, it will always produce the rounded-up
+number of bytes of output cleartext. The application must determine if
+the output cleartext was zero-padded due to original cleartext lengths that
+were not integral multiples of 8.
+.PP
+No errors or meaningful values are returned.  Void is not used for
+compatibility with other compilers.
+.PP
+A characteristic of cbc mode is that changing a single bit of the
+cleartext, then encrypting using cbc mode,
+affects ALL the subsequent ciphertext.  This makes cryptanalysis
+much more difficult. However, modifying a single bit of the ciphertext,
+then decrypting, only affects the resulting cleartext from
+the modified block and the succeeding block.  Therefore,
+.I des_pcbc_encrypt
+is STRONGLY recommended for applications where
+indefinite propagation of errors is required in order to detect modifications.
+.PP
+.PP
+.I des_pcbc_encrypt
+encrypts/decrypts using a modified block chaining mode. Its calling
+sequence is identical to
+.I des_cbc_encrypt.
+It differs in its error propagation characteristics.
+.PP
+.I des_pcbc_encrypt
+is highly recommended for most encryption purposes, in that
+modification of a single bit of the ciphertext will affect ALL the
+subsequent (decrypted) cleartext. Similarly, modifying a single bit of
+the cleartext will affect ALL the subsequent (encrypted) ciphertext.
+"PCBC" mode, on encryption, "xors" both the
+cleartext of block N and the ciphertext resulting from block N with the
+cleartext for block N+1 prior to encrypting block N+1.
+.PP
+.I des_cbc_cksum
+produces an 8 byte cryptographic checksum by cipher-block-chain
+encrypting the cleartext data pointed to by the
+.I input
+argument. All of the ciphertext output is discarded, except the
+last 8-byte ciphertext block, which is written into the area pointed to by
+the
+.I output
+argument.
+It uses the key schedule,
+provided by the
+.I schedule
+argument and initialization vector provided by the
+.I ivec
+argument.
+If the
+.I length
+argument is not an integral
+multiple of eight bytes, the last cleartext block is copied to a temp and zero
+filled (highest addresses).  The output is ALWAYS eight bytes.
+.PP
+The routine also returns an unsigned long, which is the last (highest address)
+half of the 8 byte checksum computed.
+.PP
+.PP
+.I quad_cksum
+produces a checksum by chaining quadratic operations on the cleartext data
+pointed to by the
+.I input
+argument. The
+.I length
+argument specifies the length of the
+input -- only exactly that many bytes are included for the checksum,
+without any padding.
+.PP
+The algorithm may be iterated over the same input data, if the
+.I out_count
+argument is 2, 3 or 4, and the optional
+.I output
+argument is a non-null pointer .
+The default is one iteration, and it will not run
+more than 4 times. Multiple iterations run slower, but provide
+a longer checksum if desired. The
+.I seed
+argument provides an 8-byte seed for the first iteration. If multiple iterations are
+requested, the results of one iteration are automatically used as
+the seed for the next iteration.
+.PP
+It returns both an unsigned long checksum value, and
+if the
+.I output
+argument is not a null pointer, up to 16 bytes of
+the computed checksum are written into the output.
+.PP
+.PP
+.SH FILES
+/usr/include/des.h
+.br
+/usr/lib/libdes.a
+.SH "SEE ALSO"
+.SH DIAGNOSTICS
+.SH BUGS
+This software has not yet been compiled or tested on machines other than the
+VAX and the IBM PC.
+.SH AUTHORS
+Steve Miller, MIT Project Athena/Digital Equipment Corporation
+.SH RESTRICTIONS
+COPYRIGHT 1985,1986 Massachusetts Institute of Technology
+.PP
+This software may not be exported outside of the US without a special
+license from the US Dept of Commerce. It may be replaced by any secret
+key block cipher with block length and key length of 8 bytes, as long
+as the interface is the same as described here.
diff --git a/kerberosIV/des/des_locl.h b/kerberosIV/des/des_locl.h
new file mode 100644
index 00000000000..b8215f62411
--- /dev/null
+++ b/kerberosIV/des/des_locl.h
@@ -0,0 +1,174 @@
+/*	$Id: des_locl.h,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+
+#ifndef __des_locl_h
+#define __des_locl_h
+
+#include <sys/cdefs.h>
+
+#include <stdio.h>
+#include <memory.h>
+
+#include <sys/types.h>
+#include <unistd.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <time.h>
+
+#include "kerberosIV/des.h"
+
+#define ITERATIONS 16
+#define HALF_ITERATIONS 8
+
+/* used in des_read and des_write */
+#define MAXWRITE	(1024*16)
+#define BSIZE		(MAXWRITE+4)
+
+#define c2l(c,l)	(l =((u_int32_t)(*((c)++)))    , \
+			 l|=((u_int32_t)(*((c)++)))<< 8, \
+			 l|=((u_int32_t)(*((c)++)))<<16, \
+			 l|=((u_int32_t)(*((c)++)))<<24)
+
+/* NOTE - c is not incremented as per c2l */
+#define c2ln(c,l1,l2,n)	{ \
+			c+=n; \
+			l1=l2=0; \
+			switch (n) { \
+			case 8: l2|=((u_int32_t)(*(--(c))))<<24; \
+			case 7: l2|=((u_int32_t)(*(--(c))))<<16; \
+			case 6: l2|=((u_int32_t)(*(--(c))))<< 8; \
+			case 5: l2|=((u_int32_t)(*(--(c))));     \
+			case 4: l1|=((u_int32_t)(*(--(c))))<<24; \
+			case 3: l1|=((u_int32_t)(*(--(c))))<<16; \
+			case 2: l1|=((u_int32_t)(*(--(c))))<< 8; \
+			case 1: l1|=((u_int32_t)(*(--(c))));     \
+				} \
+			}
+
+#define l2c(l,c)	(*((c)++)=(unsigned char)(((l)    )&0xff), \
+			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
+			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
+			 *((c)++)=(unsigned char)(((l)>>24)&0xff))
+
+/* replacements for htonl and ntohl since I have no idea what to do
+ * when faced with machines with 8 byte longs. */
+#define HDRSIZE 4
+
+#define n2l(c,l)	(l =((u_int32_t)(*((c)++)))<<24, \
+			 l|=((u_int32_t)(*((c)++)))<<16, \
+			 l|=((u_int32_t)(*((c)++)))<< 8, \
+			 l|=((u_int32_t)(*((c)++))))
+
+#define l2n(l,c)	(*((c)++)=(unsigned char)(((l)>>24)&0xff), \
+			 *((c)++)=(unsigned char)(((l)>>16)&0xff), \
+			 *((c)++)=(unsigned char)(((l)>> 8)&0xff), \
+			 *((c)++)=(unsigned char)(((l)    )&0xff))
+
+/* NOTE - c is not incremented as per l2c */
+#define l2cn(l1,l2,c,n)	{ \
+			c+=n; \
+			switch (n) { \
+			case 8: *(--(c))=(unsigned char)(((l2)>>24)&0xff); \
+			case 7: *(--(c))=(unsigned char)(((l2)>>16)&0xff); \
+			case 6: *(--(c))=(unsigned char)(((l2)>> 8)&0xff); \
+			case 5: *(--(c))=(unsigned char)(((l2)    )&0xff); \
+			case 4: *(--(c))=(unsigned char)(((l1)>>24)&0xff); \
+			case 3: *(--(c))=(unsigned char)(((l1)>>16)&0xff); \
+			case 2: *(--(c))=(unsigned char)(((l1)>> 8)&0xff); \
+			case 1: *(--(c))=(unsigned char)(((l1)    )&0xff); \
+				} \
+			}
+
+/* The changes to this macro may help or hinder, depending on the
+ * compiler and the achitecture.  gcc2 always seems to do well :-).
+ * Inspired by Dana How <how@isl.stanford.edu>
+ * DO NOT use the alternative version on machines with 8 byte longs. */
+#ifdef ALT_ECB
+#define D_ENCRYPT(L,R,S) \
+	u=((R^s[S  ])<<2);	\
+	t= R^s[S+1]; \
+	t=((t>>2)+(t<<30)); \
+	L^= \
+	*(u_int32_t *)(des_SP+0x0100+((t    )&0xfc))+ \
+	*(u_int32_t *)(des_SP+0x0300+((t>> 8)&0xfc))+ \
+	*(u_int32_t *)(des_SP+0x0500+((t>>16)&0xfc))+ \
+	*(u_int32_t *)(des_SP+0x0700+((t>>24)&0xfc))+ \
+	*(u_int32_t *)(des_SP+       ((u    )&0xfc))+ \
+  	*(u_int32_t *)(des_SP+0x0200+((u>> 8)&0xfc))+ \
+  	*(u_int32_t *)(des_SP+0x0400+((u>>16)&0xfc))+ \
+ 	*(u_int32_t *)(des_SP+0x0600+((u>>24)&0xfc));
+#else /* original version */
+#ifdef MSDOS
+#define D_ENCRYPT(L,R,S)	\
+	U.l=R^s[S+1]; \
+	T.s[0]=((U.s[0]>>4)|(U.s[1]<<12))&0x3f3f; \
+	T.s[1]=((U.s[1]>>4)|(U.s[0]<<12))&0x3f3f; \
+	U.l=(R^s[S  ])&0x3f3f3f3f; \
+	L^=	des_SPtrans[1][(T.c[0])]| \
+		des_SPtrans[3][(T.c[1])]| \
+		des_SPtrans[5][(T.c[2])]| \
+		des_SPtrans[7][(T.c[3])]| \
+		des_SPtrans[0][(U.c[0])]| \
+		des_SPtrans[2][(U.c[1])]| \
+		des_SPtrans[4][(U.c[2])]| \
+		des_SPtrans[6][(U.c[3])];
+#else
+#define D_ENCRYPT(L,R,S)	\
+	u=(R^s[S  ]); \
+	t=R^s[S+1]; \
+	t=((t>>4)+(t<<28)); \
+	L^=	des_SPtrans[1][(t    )&0x3f]| \
+		des_SPtrans[3][(t>> 8)&0x3f]| \
+		des_SPtrans[5][(t>>16)&0x3f]| \
+		des_SPtrans[7][(t>>24)&0x3f]| \
+		des_SPtrans[0][(u    )&0x3f]| \
+		des_SPtrans[2][(u>> 8)&0x3f]| \
+		des_SPtrans[4][(u>>16)&0x3f]| \
+		des_SPtrans[6][(u>>24)&0x3f];
+#endif
+#endif
+
+	/* IP and FP
+	 * The problem is more of a geometric problem that random bit fiddling.
+	 0  1  2  3  4  5  6  7      62 54 46 38 30 22 14  6
+	 8  9 10 11 12 13 14 15      60 52 44 36 28 20 12  4
+	16 17 18 19 20 21 22 23      58 50 42 34 26 18 10  2
+	24 25 26 27 28 29 30 31  to  56 48 40 32 24 16  8  0
+
+	32 33 34 35 36 37 38 39      63 55 47 39 31 23 15  7
+	40 41 42 43 44 45 46 47      61 53 45 37 29 21 13  5
+	48 49 50 51 52 53 54 55      59 51 43 35 27 19 11  3
+	56 57 58 59 60 61 62 63      57 49 41 33 25 17  9  1
+
+	The output has been subject to swaps of the form
+	0 1 -> 3 1 but the odd and even bits have been put into
+	2 3    2 0
+	different words.  The main trick is to remember that
+	t=((l>>size)^r)&(mask);
+	r^=t;
+	l^=(t<<size);
+	can be used to swap and move bits between words.
+
+	So l =  0  1  2  3  r = 16 17 18 19
+	        4  5  6  7      20 21 22 23
+	        8  9 10 11      24 25 26 27
+	       12 13 14 15      28 29 30 31
+	becomes (for size == 2 and mask == 0x3333)
+	   t =   2^16  3^17 -- --   l =  0  1 16 17  r =  2  3 18 19
+		 6^20  7^21 -- --        4  5 20 21       6  7 22 23
+		10^24 11^25 -- --        8  9 24 25      10 11 24 25
+		14^28 15^29 -- --       12 13 28 29      14 15 28 29
+
+	Thanks for hints from Richard Outerbridge - he told me IP&FP
+	could be done in 15 xor, 10 shifts and 5 ands.
+	When I finally started to think of the problem in 2D
+	I first got ~42 operations without xors.  When I remembered
+	how to use xors :-) I got it to its final state.
+	*/
+#define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
+	(b)^=(t),\
+	(a)^=((t)<<(n)))
+
+
+#endif /*  __des_locl_h */
diff --git a/kerberosIV/des/ecb_enc.c b/kerberosIV/des/ecb_enc.c
new file mode 100644
index 00000000000..af1fc96e519
--- /dev/null
+++ b/kerberosIV/des/ecb_enc.c
@@ -0,0 +1,111 @@
+/*	$Id: ecb_enc.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+#include "spr.h"
+
+int des_ecb_encrypt(des_cblock (*input), des_cblock (*output), struct des_ks_struct *ks, int encrypt)
+{
+  register u_int32_t l0,l1;
+  register unsigned char *in,*out;
+  u_int32_t ll[2];
+
+  in=(unsigned char *)input;
+  out=(unsigned char *)output;
+  c2l(in,l0);
+  c2l(in,l1);
+  ll[0]=l0;
+  ll[1]=l1;
+  des_encrypt(ll,ll,ks,encrypt);
+  l0=ll[0];
+  l1=ll[1];
+  l2c(l0,out);
+  l2c(l1,out);
+  l0=l1=ll[0]=ll[1]=0;
+  return(0);
+}
+
+int des_encrypt(u_int32_t *input, u_int32_t *output, struct des_ks_struct *ks, int encrypt)
+{
+  register u_int32_t l,r,t,u;
+#ifdef ALT_ECB
+  register unsigned char *des_SP=(unsigned char *)des_SPtrans;
+#endif
+#ifdef MSDOS
+  union fudge {
+    u_int32_t  l;
+    unsigned short s[2];
+    unsigned char  c[4];
+  } U,T;
+#endif
+  register int i;
+  register u_int32_t *s;
+
+  l=input[0];
+  r=input[1];
+
+  /* do IP */
+  PERM_OP(r,l,t, 4,0x0f0f0f0f);
+  PERM_OP(l,r,t,16,0x0000ffff);
+  PERM_OP(r,l,t, 2,0x33333333);
+  PERM_OP(l,r,t, 8,0x00ff00ff);
+  PERM_OP(r,l,t, 1,0x55555555);
+  /* r and l are reversed - remember that :-) - fix
+   * it in the next step */
+
+  /* Things have been modified so that the initial rotate is
+   * done outside the loop.  This required the
+   * des_SPtrans values in sp.h to be rotated 1 bit to the right.
+   * One perl script later and things have a 5% speed up on a sparc2.
+   * Thanks to Richard Outerbridge <71755.204@CompuServe.COM>
+   * for pointing this out. */
+  t=(r<<1)|(r>>31);
+  r=(l<<1)|(l>>31);
+  l=t;
+
+  /* clear the top bits on machines with 8byte longs */
+  l&=0xffffffff;
+  r&=0xffffffff;
+
+  s=(u_int32_t *)ks;
+  /* I don't know if it is worth the effort of loop unrolling the
+   * inner loop */
+  if (encrypt)
+    {
+      for (i=0; i<32; i+=4)
+	{
+	  D_ENCRYPT(l,r,i+0);	/*  1 */
+	  D_ENCRYPT(r,l,i+2);	/*  2 */
+	}
+    }
+  else
+    {
+      for (i=30; i>0; i-=4)
+	{
+	  D_ENCRYPT(l,r,i-0);	/* 16 */
+	  D_ENCRYPT(r,l,i-2);	/* 15 */
+	}
+    }
+  l=(l>>1)|(l<<31);
+  r=(r>>1)|(r<<31);
+  /* clear the top bits on machines with 8byte longs */
+  l&=0xffffffff;
+  r&=0xffffffff;
+
+  /* swap l and r
+   * we will not do the swap so just remember they are
+   * reversed for the rest of the subroutine
+   * luckily FP fixes this problem :-) */
+
+  PERM_OP(r,l,t, 1,0x55555555);
+  PERM_OP(l,r,t, 8,0x00ff00ff);
+  PERM_OP(r,l,t, 2,0x33333333);
+  PERM_OP(l,r,t,16,0x0000ffff);
+  PERM_OP(r,l,t, 4,0x0f0f0f0f);
+
+  output[0]=l;
+  output[1]=r;
+  l=r=t=u=0;
+  return(0);
+}
+
diff --git a/kerberosIV/des/enc_read.c b/kerberosIV/des/enc_read.c
new file mode 100644
index 00000000000..aaa3dd89faf
--- /dev/null
+++ b/kerberosIV/des/enc_read.c
@@ -0,0 +1,156 @@
+/*	$Id: enc_read.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+
+#include "des_locl.h"
+#include <unistd.h>
+#include <errno.h>
+
+/* This has some uglies in it but it works - even over sockets. */
+extern int errno;
+int des_rw_mode=DES_PCBC_MODE;
+
+int des_enc_read(int fd, char *buf, int len, struct des_ks_struct *sched, des_cblock (*iv))
+{
+  /* data to be unencrypted */
+  int net_num=0;
+  unsigned char net[BSIZE];
+  /* extra unencrypted data 
+   * for when a block of 100 comes in but is des_read one byte at
+   * a time. */
+  static char unnet[BSIZE];
+  static int unnet_start=0;
+  static int unnet_left=0;
+  int i;
+  long num=0,rnum;
+  unsigned char *p;
+
+  /* left over data from last decrypt */
+  if (unnet_left != 0)
+    {
+      if (unnet_left < len)
+	{
+	  /* we still still need more data but will return
+	   * with the number of bytes we have - should always
+	   * check the return value */
+	  memcpy(buf,&(unnet[unnet_start]),unnet_left);
+	  /* eay 26/08/92 I had the next 2 lines
+	   * reversed :-( */
+	  i=unnet_left;
+	  unnet_start=unnet_left=0;
+	}
+      else
+	{
+	  memcpy(buf,&(unnet[unnet_start]),len);
+	  unnet_start+=len;
+	  unnet_left-=len;
+	  i=len;
+	}
+      return(i);
+    }
+
+  /* We need to get more data. */
+  if (len > MAXWRITE) len=MAXWRITE;
+
+  /* first - get the length */
+  net_num=0;
+  while (net_num < HDRSIZE) 
+    {
+      i=read(fd,&(net[net_num]),HDRSIZE-net_num);
+      if ((i == -1) && (errno == EINTR)) continue;
+      if (i <= 0) return(0);
+      net_num+=i;
+    }
+
+  /* we now have at net_num bytes in net */
+  p=net;
+  num=0;
+  n2l(p,num);
+  /* num should be rounded up to the next group of eight
+   * we make sure that we have read a multiple of 8 bytes from the net.
+   */
+  if ((num > MAXWRITE) || (num < 0)) /* error */
+    return(-1);
+  rnum=(num < 8)?8:((num+7)/8*8);
+
+  net_num=0;
+  while (net_num < rnum)
+    {
+      i=read(fd,&(net[net_num]),rnum-net_num);
+      if ((i == -1) && (errno == EINTR)) continue;
+      if (i <= 0) return(0);
+      net_num+=i;
+    }
+
+  /* Check if there will be data left over. */
+  if (len < num)
+    {
+      if (des_rw_mode & DES_PCBC_MODE)
+	des_pcbc_encrypt((des_cblock *)net,(des_cblock *)unnet,
+		     num,sched,iv,DES_DECRYPT);
+      else
+	des_cbc_encrypt((des_cblock *)net,(des_cblock *)unnet,
+		    num,sched,iv,DES_DECRYPT);
+      memcpy(buf,unnet,len);
+      unnet_start=len;
+      unnet_left=num-len;
+
+      /* The following line is done because we return num
+       * as the number of bytes read. */
+      num=len;
+    }
+  else
+    {
+      /* >output is a multiple of 8 byes, if len < rnum
+       * >we must be careful.  The user must be aware that this
+       * >routine will write more bytes than he asked for.
+       * >The length of the buffer must be correct.
+       * FIXED - Should be ok now 18-9-90 - eay */
+      if (len < rnum)
+	{
+	  char tmpbuf[BSIZE];
+
+	  if (des_rw_mode & DES_PCBC_MODE)
+	    des_pcbc_encrypt((des_cblock *)net,
+			 (des_cblock *)tmpbuf,
+			 num,sched,iv,DES_DECRYPT);
+	  else
+	    des_cbc_encrypt((des_cblock *)net,
+			(des_cblock *)tmpbuf,
+			num,sched,iv,DES_DECRYPT);
+
+	  /* eay 26/08/92 fix a bug that returned more
+	   * bytes than you asked for (returned len bytes :-( */
+	  memcpy(buf,tmpbuf,num);
+	}
+      else if (num >= 8)
+	{
+	  if (des_rw_mode & DES_PCBC_MODE)
+	    des_pcbc_encrypt((des_cblock *)net,
+			 (des_cblock *)buf,num,sched,iv,
+			 DES_DECRYPT);
+	  else
+	    des_cbc_encrypt((des_cblock *)net,
+			(des_cblock *)buf,num,sched,iv,
+			DES_DECRYPT);
+	}
+      else
+	{
+	  if (des_rw_mode & DES_PCBC_MODE)
+	    des_pcbc_encrypt((des_cblock *)net,
+			 (des_cblock *)buf,8,sched,iv,
+			 DES_DECRYPT);
+	  else
+	    des_cbc_encrypt((des_cblock *)net,
+			(des_cblock *)buf,8,sched,iv,
+			DES_DECRYPT);
+#ifdef LEFT_JUSTIFIED
+	  memcpy(buf, buf, num);
+#else
+	  memcpy(buf, buf+(8-num), num);
+#endif
+	}
+    }
+  return(num);
+}
+
diff --git a/kerberosIV/des/enc_writ.c b/kerberosIV/des/enc_writ.c
new file mode 100644
index 00000000000..984098cd2fe
--- /dev/null
+++ b/kerberosIV/des/enc_writ.c
@@ -0,0 +1,95 @@
+/*	$Id: enc_writ.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+
+#include "des_locl.h"
+#include <unistd.h>
+#include <errno.h>
+
+int des_enc_write(int fd, char *buf, int len, struct des_ks_struct *sched, des_cblock (*iv))
+{
+  long rnum;
+  int i,j,k,outnum;
+  char outbuf[BSIZE+HDRSIZE];
+  char shortbuf[8];
+  char *p;
+  static int start=1;
+
+  /* If we are sending less than 8 bytes, the same char will look
+   * the same if we don't pad it out with random bytes */
+  if (start)
+    {
+      start=0;
+      srand(time(NULL));
+    }
+
+  /* lets recurse if we want to send the data in small chunks */
+  if (len > MAXWRITE)
+    {
+      j=0;
+      for (i=0; i<len; i+=k)
+	{
+	  k=des_enc_write(fd,&(buf[i]),
+			  ((len-i) > MAXWRITE)?MAXWRITE:(len-i),sched,iv);
+	  if (k < 0)
+	    return(k);
+	  else
+	    j+=k;
+	}
+      return(j);
+    }
+
+  /* write length first */
+  p=outbuf;
+  l2n(len,p);
+
+  /* pad short strings */
+  if (len < 8)
+    {
+#ifdef LEFT_JUSTIFIED
+      p=shortbuf;
+      memcpy(shortbuf,buf,len);
+      for (i=len; i<8; i++)
+	shortbuf[i]=rand();
+      rnum=8;
+#else
+      p=shortbuf;
+      for (i=0; i<8-len; i++)
+	shortbuf[i]=rand();
+      memcpy(shortbuf + 8 - len, buf, len);
+      rnum=8;
+#endif
+    }
+  else
+    {
+      p=buf;
+      rnum=((len+7)/8*8);	/* round up to nearest eight */
+    }
+
+  if (des_rw_mode & DES_PCBC_MODE)
+    des_pcbc_encrypt((des_cblock *)p,(des_cblock *)&(outbuf[HDRSIZE]),
+		 (long)((len<8)?8:len),sched,iv,DES_ENCRYPT); 
+  else
+    des_cbc_encrypt((des_cblock *)p,(des_cblock *)&(outbuf[HDRSIZE]),
+		(long)((len<8)?8:len),sched,iv,DES_ENCRYPT); 
+
+  /* output */
+  outnum=rnum+HDRSIZE;
+
+  for (j=0; j<outnum; j+=i)
+    {
+      /* eay 26/08/92 I was not doing writing from where we
+       * got upto. */
+      i=write(fd,&(outbuf[j]),(int)(outnum-j));
+      if (i == -1)
+	{
+	  if (errno == EINTR)
+	    i=0;
+	  else			/* This is really a bad error - very bad
+				 * It will stuff-up both ends. */
+	    return(-1);
+	}
+    }
+
+  return(len);
+}
diff --git a/kerberosIV/des/key_par.c b/kerberosIV/des/key_par.c
new file mode 100644
index 00000000000..ff76947e275
--- /dev/null
+++ b/kerberosIV/des/key_par.c
@@ -0,0 +1,15 @@
+/*	$Id: key_par.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+#include "des_locl.h"
+
+/* MIT Link and source compatibility */
+
+#ifdef des_fixup_key_parity
+#undef des_fixup_key_parity
+#endif /* des_fixup_key_parity */
+
+void
+des_fixup_key_parity(des_cblock *key)
+{
+  des_set_odd_parity(key);
+}
diff --git a/kerberosIV/des/ofb_enc.c b/kerberosIV/des/ofb_enc.c
new file mode 100644
index 00000000000..84df7f8b7f8
--- /dev/null
+++ b/kerberosIV/des/ofb_enc.c
@@ -0,0 +1,63 @@
+/*	$Id: ofb_enc.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+/* The input and output are loaded in multiples of 8 bits.
+ * What this means is that if you hame numbits=12 and length=2
+ * the first 12 bits will be retrieved from the first byte and half
+ * the second.  The second 12 bits will come from the 3rd and half the 4th
+ * byte.
+ */
+int des_ofb_encrypt(unsigned char *in, unsigned char *out, int numbits, long int length, struct des_ks_struct *schedule, des_cblock (*ivec))
+{
+  register u_int32_t d0,d1,v0,v1,n=(numbits+7)/8;
+  register u_int32_t mask0,mask1;
+  register long l=length;
+  register int num=numbits;
+  u_int32_t ti[2];
+  unsigned char *iv;
+
+  if (num > 64) return(0);
+  if (num > 32)
+    {
+      mask0=0xffffffff;
+      if (num >= 64)
+	mask1=mask0;
+      else
+	mask1=(1L<<(num-32))-1;
+    }
+  else
+    {
+      if (num == 32)
+	mask0=0xffffffff;
+      else
+	mask0=(1L<<num)-1;
+      mask1=0x00000000;
+    }
+
+  iv=(unsigned char *)ivec;
+  c2l(iv,v0);
+  c2l(iv,v1);
+  ti[0]=v0;
+  ti[1]=v1;
+  while (l-- > 0)
+    {
+      des_encrypt(ti,ti,
+		  schedule,DES_ENCRYPT);
+      c2ln(in,d0,d1,n);
+      in+=n;
+      d0=(d0^ti[0])&mask0;
+      d1=(d1^ti[1])&mask1;
+      l2cn(d0,d1,out,n);
+      out+=n;
+    }
+  v0=ti[0];
+  v1=ti[1];
+  iv=(unsigned char *)ivec;
+  l2c(v0,iv);
+  l2c(v1,iv);
+  v0=v1=d0=d1=ti[0]=ti[1]=0;
+  return(0);
+}
+
diff --git a/kerberosIV/des/pcbc_enc.c b/kerberosIV/des/pcbc_enc.c
new file mode 100644
index 00000000000..0000fc0c305
--- /dev/null
+++ b/kerberosIV/des/pcbc_enc.c
@@ -0,0 +1,68 @@
+/*	$Id: pcbc_enc.c,v 1.1 1995/12/14 06:52:44 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+int des_pcbc_encrypt(des_cblock (*input), des_cblock (*output), long int length, struct des_ks_struct *schedule, des_cblock (*ivec), int encrypt)
+{
+  register u_int32_t sin0,sin1,xor0,xor1,tout0,tout1;
+  u_int32_t tin[2],tout[2];
+  unsigned char *in,*out,*iv;
+
+  in=(unsigned char *)input;
+  out=(unsigned char *)output;
+  iv=(unsigned char *)ivec;
+
+  if (encrypt)
+    {
+      c2l(iv,xor0);
+      c2l(iv,xor1);
+      for (; length>0; length-=8)
+	{
+	  if (length >= 8)
+	    {
+	      c2l(in,sin0);
+	      c2l(in,sin1);
+	    }
+	  else
+	    c2ln(in,sin0,sin1,length);
+	  tin[0]=sin0^xor0;
+	  tin[1]=sin1^xor1;
+	  des_encrypt(tin,tout,
+		      schedule,encrypt);
+	  tout0=tout[0];
+	  tout1=tout[1];
+	  xor0=sin0^tout[0];
+	  xor1=sin1^tout[1];
+	  l2c(tout0,out);
+	  l2c(tout1,out);
+	}
+    }
+  else
+    {
+      c2l(iv,xor0); c2l(iv,xor1);
+      for (; length>0; length-=8)
+	{
+	  c2l(in,sin0);
+	  c2l(in,sin1);
+	  tin[0]=sin0;
+	  tin[1]=sin1;
+	  des_encrypt(tin,tout,
+		      schedule,encrypt);
+	  tout0=tout[0]^xor0;
+	  tout1=tout[1]^xor1;
+	  if (length >= 8)
+	    {
+	      l2c(tout0,out);
+	      l2c(tout1,out);
+	    }
+	  else
+	    l2cn(tout0,tout1,out,length);
+	  xor0=tout0^sin0;
+	  xor1=tout1^sin1;
+	}
+    }
+  tin[0]=tin[1]=tout[0]=tout[1]=0;
+  sin0=sin1=xor0=xor1=tout0=tout1=0;
+  return(0);
+}
diff --git a/kerberosIV/des/podd.h b/kerberosIV/des/podd.h
new file mode 100644
index 00000000000..aa15729398c
--- /dev/null
+++ b/kerberosIV/des/podd.h
@@ -0,0 +1,20 @@
+/*	$Id: podd.h,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+static unsigned char odd_parity[256]={
+  1,  1,  2,  2,  4,  4,  7,  7,  8,  8, 11, 11, 13, 13, 14, 14,
+ 16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
+ 32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
+ 49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
+ 64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
+ 81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
+ 97, 97, 98, 98,100,100,103,103,104,104,107,107,109,109,110,110,
+112,112,115,115,117,117,118,118,121,121,122,122,124,124,127,127,
+128,128,131,131,133,133,134,134,137,137,138,138,140,140,143,143,
+145,145,146,146,148,148,151,151,152,152,155,155,157,157,158,158,
+161,161,162,162,164,164,167,167,168,168,171,171,173,173,174,174,
+176,176,179,179,181,181,182,182,185,185,186,186,188,188,191,191,
+193,193,194,194,196,196,199,199,200,200,203,203,205,205,206,206,
+208,208,211,211,213,213,214,214,217,217,218,218,220,220,223,223,
+224,224,227,227,229,229,230,230,233,233,234,234,236,236,239,239,
+241,241,242,242,244,244,247,247,248,248,251,251,253,253,254,254};
diff --git a/kerberosIV/des/qud_cksm.c b/kerberosIV/des/qud_cksm.c
new file mode 100644
index 00000000000..a4178d1197b
--- /dev/null
+++ b/kerberosIV/des/qud_cksm.c
@@ -0,0 +1,84 @@
+/* Copyright (C) 1993 Eric Young - see README for more details */
+/* From "Message Authentication"  R.R. Jueneman, S.M. Matyas, C.H. Meyer
+ * IEEE Communications Magazine Sept 1985 Vol. 23 No. 9 p 29-40
+ * This module in only based on the code in this paper and is
+ * almost definitely not the same as the MIT implementation.
+ *
+ *	$Id: qud_cksm.c,v 1.1 1995/12/14 06:52:43 tholo Exp $
+ */
+#include "des_locl.h"
+
+/* bug fix for dos - 7/6/91 - Larry hughes@logos.ucs.indiana.edu */
+#define B0(a)	(((u_int32_t)(a)))
+#define B1(a)	(((u_int32_t)(a))<<8)
+#define B2(a)	(((u_int32_t)(a))<<16)
+#define B3(a)	(((u_int32_t)(a))<<24)
+
+/* used to scramble things a bit */
+/* Got the value MIT uses via brute force :-) 2/10/90 eay */
+#define NOISE	((u_int32_t)83653421)
+
+u_int32_t des_quad_cksum(des_cblock (*input), des_cblock (*output), long int length, int out_count, des_cblock (*seed))
+{
+  u_int32_t z0,z1,t0,t1;
+  int i;
+  long l=0;
+  unsigned char *cp;
+  unsigned char *lp;
+
+  if (out_count < 1) out_count=1;
+  lp=(unsigned char *)output;
+
+  z0=B0((*seed)[0])|B1((*seed)[1])|B2((*seed)[2])|B3((*seed)[3]);
+  z1=B0((*seed)[4])|B1((*seed)[5])|B2((*seed)[6])|B3((*seed)[7]);
+
+  for (i=0; ((i<4)&&(i<out_count)); i++)
+    {
+      cp=(unsigned char *)input;
+      l=length;
+      while (l > 0)
+	{
+	  if (l > 1)
+	    {
+	      t0= (u_int32_t)(*(cp++));
+	      t0|=(u_int32_t)B1(*(cp++));
+	      l--;
+	    }
+	  else
+	    t0= (u_int32_t)(*(cp++));
+	  l--;
+	  /* add */
+	  t0+=z0;
+	  t0&=0xffffffff;
+	  t1=z1;
+	  /* square, well sort of square */
+	  z0=((((t0*t0)&0xffffffff)+((t1*t1)&0xffffffff))
+	      &0xffffffff)%0x7fffffff; 
+	  z1=((t0*((t1+NOISE)&0xffffffff))&0xffffffff)%0x7fffffff;
+	}
+      if (lp != NULL)
+	{
+	  /* I believe I finally have things worked out.
+	   * The MIT library assumes that the checksum
+	   * is one huge number and it is returned in a
+	   * host dependant byte order.
+	   */
+	  static u_int32_t l=1;
+	  static unsigned char *c=(unsigned char *)&l;
+
+	  if (c[0])
+	    {
+	      l2c(z0,lp);
+	      l2c(z1,lp);
+	    }
+	  else
+	    {
+	      lp=output[out_count-i-1];
+	      l2n(z1,lp);
+	      l2n(z0,lp);
+	    }
+	}
+    }
+  return(z0);
+}
+
diff --git a/kerberosIV/des/random_key.c b/kerberosIV/des/random_key.c
new file mode 100644
index 00000000000..f878824e4f8
--- /dev/null
+++ b/kerberosIV/des/random_key.c
@@ -0,0 +1,34 @@
+/*	$Id: random_key.c,v 1.1 1995/12/14 06:52:45 tholo Exp $	*/
+
+/* Copyright (C) 1992 Eric Young - see COPYING for more details */
+#include "des_locl.h"
+
+void des_random_key(ret)
+des_cblock ret;
+	{
+	des_key_schedule ks;
+	static u_int32_t c=0;
+	static pid_t pid=0;
+	static des_cblock data={0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
+	des_cblock key;
+
+#ifdef MSDOS
+	pid=1;
+#else
+	if (!pid) pid=getpid();
+#endif
+	((u_int32_t *)key)[0]=(u_int32_t)time(NULL);
+	((u_int32_t *)key)[1]=(u_int32_t)((pid)|((c++)<<16));
+
+	des_set_odd_parity((des_cblock *)data);
+	des_set_key((des_cblock *)data,ks);
+	des_cbc_cksum((des_cblock *)key,(des_cblock *)key,
+		(int32_t)sizeof(key),ks,(des_cblock *)data);
+	des_set_odd_parity((des_cblock *)key);
+	des_cbc_cksum((des_cblock *)key,(des_cblock *)key,
+		(int32_t)sizeof(key),ks,(des_cblock *)data);
+
+	bcopy(key,ret,sizeof(key));
+	bzero(key,sizeof(key));
+	bzero(ks,sizeof(ks));
+	}
diff --git a/kerberosIV/des/read_pwd.c b/kerberosIV/des/read_pwd.c
new file mode 100644
index 00000000000..a3232643214
--- /dev/null
+++ b/kerberosIV/des/read_pwd.c
@@ -0,0 +1,285 @@
+/*	$Id: read_pwd.c,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+/* 06-Apr-92 Luke Brennan    Support for VMS */
+#include "des_locl.h"
+#include <string.h>
+#include <signal.h>
+#include <setjmp.h>
+
+/* Ick! */
+#if defined(__svr4__) || defined(__sgi) || defined(linux)
+#define TERMIO
+#endif
+
+#ifndef VMS
+#ifndef MSDOS
+#ifdef TERMIO
+#include <termio.h>
+#define sgttyb termio
+#define sg_flags c_lflag
+#define TIOCGETP TCGETA
+#define TIOCSETP TCSETA
+#else /* !TERMIO */
+#include <sgtty.h>
+#endif
+#include <sys/ioctl.h>
+#else /* MSDOS */
+#define fgets(a,b,c) noecho_fgets(a,b,c)
+#endif
+#else /* VMS */
+#include <ssdef.h>
+#include <iodef.h>
+#include <ttdef.h>
+#include <descrip.h>
+struct IOSB {
+	short iosb$w_value;
+	short iosb$w_count;
+	long  iosb$l_info;
+	};
+#endif
+#ifndef NSIG
+#define NSIG 32
+#endif
+
+static void read_till_nl();
+static int read_pw();
+static void recsig();
+static void pushsig();
+static void popsig();
+#ifdef MSDOS
+static int noecho_fgets();
+#endif
+
+static void (*savsig[NSIG])();
+static jmp_buf save;
+
+int des_read_password(key,prompt,verify)
+des_cblock *key;
+char *prompt;
+int verify;
+	{
+	int ok;
+	char buf[BUFSIZ],buff[BUFSIZ];
+
+	if ((ok=read_pw(buf,buff,BUFSIZ,prompt,verify)) == 0)
+		des_string_to_key(buf,key);
+	bzero(buf,BUFSIZ);
+	bzero(buff,BUFSIZ);
+	return(ok);
+	}
+
+int des_read_2passwords(key1,key2,prompt,verify)
+des_cblock *key1;
+des_cblock *key2;
+char *prompt;
+int verify;
+	{
+	int ok;
+	char buf[BUFSIZ],buff[BUFSIZ];
+
+	if ((ok=read_pw(buf,buff,BUFSIZ,prompt,verify)) == 0)
+		des_string_to_2keys(buf,key1,key2);
+	bzero(buf,BUFSIZ);
+	bzero(buff,BUFSIZ);
+	return(ok);
+	}
+
+int des_read_pw_string(buf,length,prompt,verify)
+char *buf;
+int length;
+char *prompt;
+int verify;
+	{
+	char buff[BUFSIZ];
+	int ret;
+
+	ret=read_pw(buf,buff,(length>BUFSIZ)?BUFSIZ:length,prompt,verify);
+	bzero(buff,BUFSIZ);
+	return(ret);
+	}
+
+static void read_till_nl(in)
+FILE *in;
+	{
+#define SIZE 4
+	char buf[SIZE+1];
+
+	do	{
+		fgets(buf,SIZE,in);
+		} while (strchr(buf,'\n') == NULL);
+	}
+
+/* return 0 if ok, 1 (or -1) otherwise */
+static int read_pw(buf,buff,size,prompt,verify)
+char *buf,*buff;
+int size;
+char *prompt;
+int verify;
+	{
+#ifndef VMS
+#ifndef MSDOS
+	struct sgttyb tty_orig,tty_new;
+#endif /* !MSDOS */
+#else
+	struct IOSB iosb;
+	$DESCRIPTOR(terminal,"TT");
+	long tty_orig[3], tty_new[3];
+	long status;
+	unsigned short channel = 0;
+#endif
+	int ok=0;
+	char *p;
+	int ps=0;
+	FILE *tty;
+
+#ifndef MSDOS
+	if ((tty=fopen("/dev/tty","r")) == NULL)
+		tty=stdin;
+#else /* MSDOS */
+	if ((tty=fopen("con","r")) == NULL)
+		tty=stdin;
+#endif /* MSDOS */
+#ifndef VMS
+#ifdef TIOCGETP
+	if (ioctl(fileno(tty),TIOCGETP,(char *)&tty_orig) == -1)
+		return(-1);
+	bcopy(&(tty_orig),&(tty_new),sizeof(tty_orig));
+#endif
+#else /* VMS */
+	status = SYS$ASSIGN(&terminal,&channel,0,0);
+	if (status != SS$_NORMAL)
+		return(-1);
+	status=SYS$QIOW(0,channel,IO$_SENSEMODE,&iosb,0,0,tty_orig,12,0,0,0,0);
+	if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL))
+		return(-1);
+#endif
+
+	if (setjmp(save))
+		{
+		ok=0;
+		goto error;
+		}
+	pushsig();
+	ps=1;
+#ifndef VMS
+#ifndef MSDOS
+	tty_new.sg_flags &= ~ECHO;
+#endif /* !MSDOS */
+#ifdef TIOCSETP
+	if (ioctl(fileno(tty),TIOCSETP,(char *)&tty_new) == -1)
+		return(-1);
+#endif
+#else /* VMS */
+	tty_new[0] = tty_orig[0];
+	tty_new[1] = tty_orig[1] | TT$M_NOECHO;
+	tty_new[2] = tty_orig[2];
+	status = SYS$QIOW(0,channel,IO$_SETMODE,&iosb,0,0,tty_new,12,0,0,0,0);
+	if ((status != SS$_NORMAL) || (iosb.iosb$w_value != SS$_NORMAL))
+		return(-1);
+#endif /* VMS */
+	ps=2;
+
+	while (!ok)
+		{
+		fputs(prompt,stderr);
+		fflush(stderr);
+
+		buf[0]='\0';
+		fgets(buf,size,tty);
+		if (feof(tty)) goto error;
+		if ((p=(char *)strchr(buf,'\n')) != NULL)
+			*p='\0';
+		else	read_till_nl(tty);
+		if (verify)
+			{
+			fprintf(stderr,"\nVerifying password %s",prompt);
+			fflush(stderr);
+			buff[0]='\0';
+			fgets(buff,size,tty);
+			if (feof(tty)) goto error;
+			if ((p=(char *)strchr(buff,'\n')) != NULL)
+				*p='\0';
+			else	read_till_nl(tty);
+				
+			if (strcmp(buf,buff) != 0)
+				{
+				fprintf(stderr,"\nVerify failure - try again\n");
+				fflush(stderr);
+				continue;
+				}
+			}
+		ok=1;
+		}
+
+error:
+	fprintf(stderr,"\n");
+	/* What can we do if there is an error? */
+#ifndef VMS
+#ifdef TIOCSETP
+	if (ps >= 2) ioctl(fileno(tty),TIOCSETP,(char *)&tty_orig);
+#endif
+#else /* VMS */
+	if (ps >= 2)
+		status = SYS$QIOW(0,channel,IO$_SETMODE,&iosb,0,0
+			,tty_orig,12,0,0,0,0);
+#endif /* VMS */
+	
+	if (ps >= 1) popsig();
+	if (stdin != tty) fclose(tty);
+#ifdef VMS
+	status = SYS$DASSGN(channel);
+#endif
+	return(!ok);
+	}
+
+static void pushsig()
+	{
+	int i;
+
+	for (i=0; i<NSIG; i++)
+		savsig[i]=signal(i,recsig);
+	}
+
+static void popsig()
+	{
+	int i;
+
+	for (i=0; i<NSIG; i++)
+		signal(i,savsig[i]);
+	}
+
+static void recsig()
+	{
+	longjmp(save,1);
+	}
+
+#ifdef MSDOS
+static int noecho_fgets(buf,size,tty)
+char *buf;
+int size;
+FILE *tty;
+	{
+	int i;
+	char *p;
+
+	p=buf;
+	for (;;)
+		{
+		if (size == 0)
+			{
+			*p='\0';
+			break;
+			}
+		size--;
+		i=getch();
+		if (i == '\r') i='\n';
+		*(p++)=i;
+		if (i == '\n')
+			{
+			*p='\0';
+			break;
+			}
+		}
+	}
+#endif
diff --git a/kerberosIV/des/rnd_keys.c b/kerberosIV/des/rnd_keys.c
new file mode 100644
index 00000000000..ccc68aa3afc
--- /dev/null
+++ b/kerberosIV/des/rnd_keys.c
@@ -0,0 +1,125 @@
+/*	$Id: rnd_keys.c,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see COPYING for more details */
+#include "des_locl.h"
+#include <sys/time.h>
+
+#include <unistd.h>
+
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+
+/*
+ * Create a sequence of random 64 bit blocks.
+ * The sequence is indexed with a long long and 
+ * based on an initial des key used as a seed.
+ */
+static des_key_schedule sequence_seed;
+static u_int32_t sequence_index[2];
+
+/*
+ * In case the generator does not get inited use this for backup.
+ */
+static int initialized;
+static des_cblock default_seed = {0x01,0x23,0x45,0x67,0x89,0xab,0xcd,0xef};
+static void
+do_initialize()
+{
+  des_set_odd_parity(&default_seed);
+  des_set_random_generator_seed(&default_seed);
+}
+
+#define zero_long_long(ll) do { ll[0] = ll[1] = 0; } while (0)
+
+#define incr_long_long(ll) do { if (++ll[0] == 0) ++ll[1]; } while (0)
+
+#define des_set_sequence_number(ll) \
+do { \
+       memcpy((char *)sequence_index, (ll), sizeof(sequence_index)); \
+     } while (0)
+
+#define des_generate_random_block(ret) \
+do { \
+       des_ecb_encrypt((des_cblock *) sequence_index, (ret), sequence_seed, DES_ENCRYPT); \
+	 incr_long_long(sequence_index); \
+     } while (0)
+
+void
+des_set_random_generator_seed(des_cblock *seed)
+{
+  des_key_sched(seed, sequence_seed);
+  zero_long_long(sequence_index);
+  initialized = 1;
+}
+
+/*
+ * Generate a sequence of random des keys
+ * using the random block sequence, fixup
+ * parity and skip weak keys.
+ */
+int
+des_new_random_key(des_cblock *key)
+{
+  if (!initialized)
+    do_initialize();
+
+ try_again:
+  des_generate_random_block(key);
+  /* random key must have odd parity and not be weak */
+  des_set_odd_parity(key);
+  if (des_is_weak_key(key))
+    goto try_again;
+  return(0);
+}
+
+/*
+ * des_init_random_number_generator:
+ *
+ *    This routine takes a secret key possibly shared by a number
+ * of servers and uses it to generate a random number stream that is
+ * not shared by any of the other servers.  It does this by using the current
+ * process id, host id, and the current time to the nearest second.  The
+ * resulting stream seed is not useful information for cracking the secret
+ * key.   Moreover, this routine keeps no copy of the secret key.
+ *
+ */
+void 
+des_init_random_number_generator(des_cblock *seed)
+{
+  struct timeval now;
+  static long uniq[2];
+  des_cblock new_key;
+  long gethostid(void);
+
+  gettimeofday(&now, (struct timezone *)0);
+  if (!uniq[0])
+    {
+      struct hostent *hent;
+      char hostname[100];
+      gethostname(hostname, sizeof(hostname));
+      hent = gethostbyname(hostname);
+      if (hent != NULL)
+	bcopy(hent->h_addr_list[0], &uniq[0], sizeof(uniq[0]));
+      else
+	uniq[0] = gethostid();
+#ifdef MSDOS
+      uniq[1] = 1;
+#else
+      uniq[1] = getpid();
+#endif
+    }
+
+  /* Pick a unique random key from the shared sequence. */
+  des_set_random_generator_seed(seed);
+  des_set_sequence_number((unsigned char *)uniq);
+  des_new_random_key(&new_key);
+
+  /* Select a new nonshared sequence, */
+  des_set_random_generator_seed(&new_key);
+
+  /* and use the current time to pick a key for the new sequence. */
+  des_set_sequence_number((unsigned char *)&now);
+  des_new_random_key(&new_key);
+  des_set_random_generator_seed(&new_key);
+}
diff --git a/kerberosIV/des/set_key.c b/kerberosIV/des/set_key.c
new file mode 100644
index 00000000000..8b46c1ce27b
--- /dev/null
+++ b/kerberosIV/des/set_key.c
@@ -0,0 +1,179 @@
+/*	$Id: set_key.c,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+/* set_key.c v 1.4 eay 24/9/91
+ * 1.4 Speed up by 400% :-)
+ * 1.3 added register declarations.
+ * 1.2 unrolled make_key_sched a bit more
+ * 1.1 added norm_expand_bits
+ * 1.0 First working version
+ */
+#include "des_locl.h"
+#include "podd.h"
+#include "sk.h"
+
+static int check_parity(des_cblock (*key));
+
+int des_check_key=0;
+
+void des_set_odd_parity(des_cblock (*key))
+{
+  int i;
+
+  for (i=0; i<DES_KEY_SZ; i++)
+    (*key)[i]=odd_parity[(*key)[i]];
+}
+
+static int check_parity(des_cblock (*key))
+{
+  int i;
+
+  for (i=0; i<DES_KEY_SZ; i++)
+    {
+      if ((*key)[i] != odd_parity[(*key)[i]])
+	return(0);
+    }
+  return(1);
+}
+
+/* Weak and semi week keys as take from
+ * %A D.W. Davies
+ * %A W.L. Price
+ * %T Security for Computer Networks
+ * %I John Wiley & Sons
+ * %D 1984
+ * Many thanks to smb@ulysses.att.com (Steven Bellovin) for the reference
+ * (and actual cblock values).
+ */
+#define NUM_WEAK_KEY	16
+static des_cblock weak_keys[NUM_WEAK_KEY]={
+  /* weak keys */
+  0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
+  0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,0xFE,
+  0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,0x1F,
+  0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,0xE0,
+  /* semi-weak keys */
+  0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE,
+  0xFE,0x01,0xFE,0x01,0xFE,0x01,0xFE,0x01,
+  0x1F,0xE0,0x1F,0xE0,0x0E,0xF1,0x0E,0xF1,
+  0xE0,0x1F,0xE0,0x1F,0xF1,0x0E,0xF1,0x0E,
+  0x01,0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1,
+  0xE0,0x01,0xE0,0x01,0xF1,0x01,0xF1,0x01,
+  0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E,0xFE,
+  0xFE,0x1F,0xFE,0x1F,0xFE,0x0E,0xFE,0x0E,
+  0x01,0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E,
+  0x1F,0x01,0x1F,0x01,0x0E,0x01,0x0E,0x01,
+  0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1,0xFE,
+  0xFE,0xE0,0xFE,0xE0,0xFE,0xF1,0xFE,0xF1};
+
+int des_is_weak_key(des_cblock (*key))
+{
+  int i;
+
+  for (i=0; i<NUM_WEAK_KEY; i++)
+    /* Added == 0 to comparision, I obviously don't run
+     * this section very often :-(, thanks to
+     * engineering@MorningStar.Com for the fix
+     * eay 93/06/29 */
+    if (memcmp(weak_keys[i],key,sizeof(key)) == 0) return(1);
+  return(0);
+}
+
+/* NOW DEFINED IN des_local.h
+ * See ecb_encrypt.c for a pseudo description of these macros. 
+ * #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
+			       * 	(b)^=(t),\
+			       * 	(a)=((a)^((t)<<(n))))
+			       */
+
+#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
+			   (a)=(a)^(t)^(t>>(16-(n))))
+
+static char shifts2[16]={0,0,1,1,1,1,1,1,0,1,1,1,1,1,1,0};
+
+/* return 0 if key parity is odd (correct),
+ * return -1 if key parity error,
+ * return -2 if illegal weak key.
+ */
+int des_set_key(des_cblock (*key), struct des_ks_struct *schedule)
+{
+  register u_int32_t c,d,t,s;
+  register unsigned char *in;
+  register u_int32_t *k;
+  register int i;
+
+  if (des_check_key)
+    {
+      if (!check_parity(key))
+	return(-1);
+
+      if (des_is_weak_key(key))
+	return(-2);
+    }
+
+  k=(u_int32_t *)schedule;
+  in=(unsigned char *)key;
+
+  c2l(in,c);
+  c2l(in,d);
+
+  /* do PC1 in 60 simple operations */ 
+  /*	PERM_OP(d,c,t,4,0x0f0f0f0f);
+	HPERM_OP(c,t,-2, 0xcccc0000);
+	HPERM_OP(c,t,-1, 0xaaaa0000);
+	HPERM_OP(c,t, 8, 0x00ff0000);
+	HPERM_OP(c,t,-1, 0xaaaa0000);
+	HPERM_OP(d,t,-8, 0xff000000);
+	HPERM_OP(d,t, 8, 0x00ff0000);
+	HPERM_OP(d,t, 2, 0x33330000);
+	d=((d&0x00aa00aa)<<7)|((d&0x55005500)>>7)|(d&0xaa55aa55);
+	d=(d>>8)|((c&0xf0000000)>>4);
+	c&=0x0fffffff; */
+
+  /* I now do it in 47 simple operations :-)
+   * Thanks to John Fletcher (john_fletcher@lccmail.ocf.llnl.gov)
+   * for the inspiration. :-) */
+  PERM_OP (d,c,t,4,0x0f0f0f0f);
+  HPERM_OP(c,t,-2,0xcccc0000);
+  HPERM_OP(d,t,-2,0xcccc0000);
+  PERM_OP (d,c,t,1,0x55555555);
+  PERM_OP (c,d,t,8,0x00ff00ff);
+  PERM_OP (d,c,t,1,0x55555555);
+  d=	(((d&0x000000ff)<<16)| (d&0x0000ff00)     |
+	 ((d&0x00ff0000)>>16)|((c&0xf0000000)>>4));
+  c&=0x0fffffff;
+
+  for (i=0; i<ITERATIONS; i++)
+    {
+      if (shifts2[i])
+	{ c=((c>>2)|(c<<26)); d=((d>>2)|(d<<26)); }
+      else
+	{ c=((c>>1)|(c<<27)); d=((d>>1)|(d<<27)); }
+      c&=0x0fffffff;
+      d&=0x0fffffff;
+      /* could be a few less shifts but I am to lazy at this
+       * point in time to investigate */
+      s=	des_skb[0][ (c    )&0x3f                ]|
+	des_skb[1][((c>> 6)&0x03)|((c>> 7)&0x3c)]|
+	  des_skb[2][((c>>13)&0x0f)|((c>>14)&0x30)]|
+	    des_skb[3][((c>>20)&0x01)|((c>>21)&0x06) |
+		       ((c>>22)&0x38)];
+      t=	des_skb[4][ (d    )&0x3f                ]|
+	des_skb[5][((d>> 7)&0x03)|((d>> 8)&0x3c)]|
+	  des_skb[6][ (d>>15)&0x3f                ]|
+	    des_skb[7][((d>>21)&0x0f)|((d>>22)&0x30)];
+
+      /* table contained 0213 4657 */
+      *(k++)=((t<<16)|(s&0x0000ffff))&0xffffffff;
+      s=     ((s>>16)|(t&0xffff0000));
+		
+      s=(s<<4)|(s>>28);
+      *(k++)=s&0xffffffff;
+    }
+  return(0);
+}
+
+int des_key_sched(des_cblock *key, des_key_schedule schedule)
+{
+  return(des_set_key(key, (struct des_ks_struct *)schedule));
+}
diff --git a/kerberosIV/des/shlib_version b/kerberosIV/des/shlib_version
new file mode 100644
index 00000000000..d9961ea9fef
--- /dev/null
+++ b/kerberosIV/des/shlib_version
@@ -0,0 +1,2 @@
+major=4
+minor=0
diff --git a/kerberosIV/des/sk.h b/kerberosIV/des/sk.h
new file mode 100644
index 00000000000..faf1b8a88cb
--- /dev/null
+++ b/kerberosIV/des/sk.h
@@ -0,0 +1,141 @@
+/*	$Id: sk.h,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+static u_int32_t des_skb[8][64]={
+/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
+0x00000000,0x00000010,0x20000000,0x20000010,
+0x00010000,0x00010010,0x20010000,0x20010010,
+0x00000800,0x00000810,0x20000800,0x20000810,
+0x00010800,0x00010810,0x20010800,0x20010810,
+0x00000020,0x00000030,0x20000020,0x20000030,
+0x00010020,0x00010030,0x20010020,0x20010030,
+0x00000820,0x00000830,0x20000820,0x20000830,
+0x00010820,0x00010830,0x20010820,0x20010830,
+0x00080000,0x00080010,0x20080000,0x20080010,
+0x00090000,0x00090010,0x20090000,0x20090010,
+0x00080800,0x00080810,0x20080800,0x20080810,
+0x00090800,0x00090810,0x20090800,0x20090810,
+0x00080020,0x00080030,0x20080020,0x20080030,
+0x00090020,0x00090030,0x20090020,0x20090030,
+0x00080820,0x00080830,0x20080820,0x20080830,
+0x00090820,0x00090830,0x20090820,0x20090830,
+/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
+0x00000000,0x02000000,0x00002000,0x02002000,
+0x00200000,0x02200000,0x00202000,0x02202000,
+0x00000004,0x02000004,0x00002004,0x02002004,
+0x00200004,0x02200004,0x00202004,0x02202004,
+0x00000400,0x02000400,0x00002400,0x02002400,
+0x00200400,0x02200400,0x00202400,0x02202400,
+0x00000404,0x02000404,0x00002404,0x02002404,
+0x00200404,0x02200404,0x00202404,0x02202404,
+0x10000000,0x12000000,0x10002000,0x12002000,
+0x10200000,0x12200000,0x10202000,0x12202000,
+0x10000004,0x12000004,0x10002004,0x12002004,
+0x10200004,0x12200004,0x10202004,0x12202004,
+0x10000400,0x12000400,0x10002400,0x12002400,
+0x10200400,0x12200400,0x10202400,0x12202400,
+0x10000404,0x12000404,0x10002404,0x12002404,
+0x10200404,0x12200404,0x10202404,0x12202404,
+/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
+0x00000000,0x00000001,0x00040000,0x00040001,
+0x01000000,0x01000001,0x01040000,0x01040001,
+0x00000002,0x00000003,0x00040002,0x00040003,
+0x01000002,0x01000003,0x01040002,0x01040003,
+0x00000200,0x00000201,0x00040200,0x00040201,
+0x01000200,0x01000201,0x01040200,0x01040201,
+0x00000202,0x00000203,0x00040202,0x00040203,
+0x01000202,0x01000203,0x01040202,0x01040203,
+0x08000000,0x08000001,0x08040000,0x08040001,
+0x09000000,0x09000001,0x09040000,0x09040001,
+0x08000002,0x08000003,0x08040002,0x08040003,
+0x09000002,0x09000003,0x09040002,0x09040003,
+0x08000200,0x08000201,0x08040200,0x08040201,
+0x09000200,0x09000201,0x09040200,0x09040201,
+0x08000202,0x08000203,0x08040202,0x08040203,
+0x09000202,0x09000203,0x09040202,0x09040203,
+/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
+0x00000000,0x00100000,0x00000100,0x00100100,
+0x00000008,0x00100008,0x00000108,0x00100108,
+0x00001000,0x00101000,0x00001100,0x00101100,
+0x00001008,0x00101008,0x00001108,0x00101108,
+0x04000000,0x04100000,0x04000100,0x04100100,
+0x04000008,0x04100008,0x04000108,0x04100108,
+0x04001000,0x04101000,0x04001100,0x04101100,
+0x04001008,0x04101008,0x04001108,0x04101108,
+0x00020000,0x00120000,0x00020100,0x00120100,
+0x00020008,0x00120008,0x00020108,0x00120108,
+0x00021000,0x00121000,0x00021100,0x00121100,
+0x00021008,0x00121008,0x00021108,0x00121108,
+0x04020000,0x04120000,0x04020100,0x04120100,
+0x04020008,0x04120008,0x04020108,0x04120108,
+0x04021000,0x04121000,0x04021100,0x04121100,
+0x04021008,0x04121008,0x04021108,0x04121108,
+/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
+0x00000000,0x10000000,0x00010000,0x10010000,
+0x00000004,0x10000004,0x00010004,0x10010004,
+0x20000000,0x30000000,0x20010000,0x30010000,
+0x20000004,0x30000004,0x20010004,0x30010004,
+0x00100000,0x10100000,0x00110000,0x10110000,
+0x00100004,0x10100004,0x00110004,0x10110004,
+0x20100000,0x30100000,0x20110000,0x30110000,
+0x20100004,0x30100004,0x20110004,0x30110004,
+0x00001000,0x10001000,0x00011000,0x10011000,
+0x00001004,0x10001004,0x00011004,0x10011004,
+0x20001000,0x30001000,0x20011000,0x30011000,
+0x20001004,0x30001004,0x20011004,0x30011004,
+0x00101000,0x10101000,0x00111000,0x10111000,
+0x00101004,0x10101004,0x00111004,0x10111004,
+0x20101000,0x30101000,0x20111000,0x30111000,
+0x20101004,0x30101004,0x20111004,0x30111004,
+/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
+0x00000000,0x08000000,0x00000008,0x08000008,
+0x00000400,0x08000400,0x00000408,0x08000408,
+0x00020000,0x08020000,0x00020008,0x08020008,
+0x00020400,0x08020400,0x00020408,0x08020408,
+0x00000001,0x08000001,0x00000009,0x08000009,
+0x00000401,0x08000401,0x00000409,0x08000409,
+0x00020001,0x08020001,0x00020009,0x08020009,
+0x00020401,0x08020401,0x00020409,0x08020409,
+0x02000000,0x0A000000,0x02000008,0x0A000008,
+0x02000400,0x0A000400,0x02000408,0x0A000408,
+0x02020000,0x0A020000,0x02020008,0x0A020008,
+0x02020400,0x0A020400,0x02020408,0x0A020408,
+0x02000001,0x0A000001,0x02000009,0x0A000009,
+0x02000401,0x0A000401,0x02000409,0x0A000409,
+0x02020001,0x0A020001,0x02020009,0x0A020009,
+0x02020401,0x0A020401,0x02020409,0x0A020409,
+/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
+0x00000000,0x00000100,0x00080000,0x00080100,
+0x01000000,0x01000100,0x01080000,0x01080100,
+0x00000010,0x00000110,0x00080010,0x00080110,
+0x01000010,0x01000110,0x01080010,0x01080110,
+0x00200000,0x00200100,0x00280000,0x00280100,
+0x01200000,0x01200100,0x01280000,0x01280100,
+0x00200010,0x00200110,0x00280010,0x00280110,
+0x01200010,0x01200110,0x01280010,0x01280110,
+0x00000200,0x00000300,0x00080200,0x00080300,
+0x01000200,0x01000300,0x01080200,0x01080300,
+0x00000210,0x00000310,0x00080210,0x00080310,
+0x01000210,0x01000310,0x01080210,0x01080310,
+0x00200200,0x00200300,0x00280200,0x00280300,
+0x01200200,0x01200300,0x01280200,0x01280300,
+0x00200210,0x00200310,0x00280210,0x00280310,
+0x01200210,0x01200310,0x01280210,0x01280310,
+/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
+0x00000000,0x04000000,0x00040000,0x04040000,
+0x00000002,0x04000002,0x00040002,0x04040002,
+0x00002000,0x04002000,0x00042000,0x04042000,
+0x00002002,0x04002002,0x00042002,0x04042002,
+0x00000020,0x04000020,0x00040020,0x04040020,
+0x00000022,0x04000022,0x00040022,0x04040022,
+0x00002020,0x04002020,0x00042020,0x04042020,
+0x00002022,0x04002022,0x00042022,0x04042022,
+0x00000800,0x04000800,0x00040800,0x04040800,
+0x00000802,0x04000802,0x00040802,0x04040802,
+0x00002800,0x04002800,0x00042800,0x04042800,
+0x00002802,0x04002802,0x00042802,0x04042802,
+0x00000820,0x04000820,0x00040820,0x04040820,
+0x00000822,0x04000822,0x00040822,0x04040822,
+0x00002820,0x04002820,0x00042820,0x04042820,
+0x00002822,0x04002822,0x00042822,0x04042822,
+};
diff --git a/kerberosIV/des/spr.h b/kerberosIV/des/spr.h
new file mode 100644
index 00000000000..574bd211ce8
--- /dev/null
+++ b/kerberosIV/des/spr.h
@@ -0,0 +1,147 @@
+/*	$Id: spr.h,v 1.1 1995/12/14 06:52:43 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+static u_int32_t des_SPtrans[8][64]={
+/* nibble 0 */
+0x00820200, 0x00020000, 0x80800000, 0x80820200,
+0x00800000, 0x80020200, 0x80020000, 0x80800000,
+0x80020200, 0x00820200, 0x00820000, 0x80000200,
+0x80800200, 0x00800000, 0x00000000, 0x80020000,
+0x00020000, 0x80000000, 0x00800200, 0x00020200,
+0x80820200, 0x00820000, 0x80000200, 0x00800200,
+0x80000000, 0x00000200, 0x00020200, 0x80820000,
+0x00000200, 0x80800200, 0x80820000, 0x00000000,
+0x00000000, 0x80820200, 0x00800200, 0x80020000,
+0x00820200, 0x00020000, 0x80000200, 0x00800200,
+0x80820000, 0x00000200, 0x00020200, 0x80800000,
+0x80020200, 0x80000000, 0x80800000, 0x00820000,
+0x80820200, 0x00020200, 0x00820000, 0x80800200,
+0x00800000, 0x80000200, 0x80020000, 0x00000000,
+0x00020000, 0x00800000, 0x80800200, 0x00820200,
+0x80000000, 0x80820000, 0x00000200, 0x80020200,
+
+/* nibble 1 */
+0x10042004, 0x00000000, 0x00042000, 0x10040000,
+0x10000004, 0x00002004, 0x10002000, 0x00042000,
+0x00002000, 0x10040004, 0x00000004, 0x10002000,
+0x00040004, 0x10042000, 0x10040000, 0x00000004,
+0x00040000, 0x10002004, 0x10040004, 0x00002000,
+0x00042004, 0x10000000, 0x00000000, 0x00040004,
+0x10002004, 0x00042004, 0x10042000, 0x10000004,
+0x10000000, 0x00040000, 0x00002004, 0x10042004,
+0x00040004, 0x10042000, 0x10002000, 0x00042004,
+0x10042004, 0x00040004, 0x10000004, 0x00000000,
+0x10000000, 0x00002004, 0x00040000, 0x10040004,
+0x00002000, 0x10000000, 0x00042004, 0x10002004,
+0x10042000, 0x00002000, 0x00000000, 0x10000004,
+0x00000004, 0x10042004, 0x00042000, 0x10040000,
+0x10040004, 0x00040000, 0x00002004, 0x10002000,
+0x10002004, 0x00000004, 0x10040000, 0x00042000,
+
+/* nibble 2 */
+0x41000000, 0x01010040, 0x00000040, 0x41000040,
+0x40010000, 0x01000000, 0x41000040, 0x00010040,
+0x01000040, 0x00010000, 0x01010000, 0x40000000,
+0x41010040, 0x40000040, 0x40000000, 0x41010000,
+0x00000000, 0x40010000, 0x01010040, 0x00000040,
+0x40000040, 0x41010040, 0x00010000, 0x41000000,
+0x41010000, 0x01000040, 0x40010040, 0x01010000,
+0x00010040, 0x00000000, 0x01000000, 0x40010040,
+0x01010040, 0x00000040, 0x40000000, 0x00010000,
+0x40000040, 0x40010000, 0x01010000, 0x41000040,
+0x00000000, 0x01010040, 0x00010040, 0x41010000,
+0x40010000, 0x01000000, 0x41010040, 0x40000000,
+0x40010040, 0x41000000, 0x01000000, 0x41010040,
+0x00010000, 0x01000040, 0x41000040, 0x00010040,
+0x01000040, 0x00000000, 0x41010000, 0x40000040,
+0x41000000, 0x40010040, 0x00000040, 0x01010000,
+
+/* nibble 3 */
+0x00100402, 0x04000400, 0x00000002, 0x04100402,
+0x00000000, 0x04100000, 0x04000402, 0x00100002,
+0x04100400, 0x04000002, 0x04000000, 0x00000402,
+0x04000002, 0x00100402, 0x00100000, 0x04000000,
+0x04100002, 0x00100400, 0x00000400, 0x00000002,
+0x00100400, 0x04000402, 0x04100000, 0x00000400,
+0x00000402, 0x00000000, 0x00100002, 0x04100400,
+0x04000400, 0x04100002, 0x04100402, 0x00100000,
+0x04100002, 0x00000402, 0x00100000, 0x04000002,
+0x00100400, 0x04000400, 0x00000002, 0x04100000,
+0x04000402, 0x00000000, 0x00000400, 0x00100002,
+0x00000000, 0x04100002, 0x04100400, 0x00000400,
+0x04000000, 0x04100402, 0x00100402, 0x00100000,
+0x04100402, 0x00000002, 0x04000400, 0x00100402,
+0x00100002, 0x00100400, 0x04100000, 0x04000402,
+0x00000402, 0x04000000, 0x04000002, 0x04100400,
+
+/* nibble 4 */
+0x02000000, 0x00004000, 0x00000100, 0x02004108,
+0x02004008, 0x02000100, 0x00004108, 0x02004000,
+0x00004000, 0x00000008, 0x02000008, 0x00004100,
+0x02000108, 0x02004008, 0x02004100, 0x00000000,
+0x00004100, 0x02000000, 0x00004008, 0x00000108,
+0x02000100, 0x00004108, 0x00000000, 0x02000008,
+0x00000008, 0x02000108, 0x02004108, 0x00004008,
+0x02004000, 0x00000100, 0x00000108, 0x02004100,
+0x02004100, 0x02000108, 0x00004008, 0x02004000,
+0x00004000, 0x00000008, 0x02000008, 0x02000100,
+0x02000000, 0x00004100, 0x02004108, 0x00000000,
+0x00004108, 0x02000000, 0x00000100, 0x00004008,
+0x02000108, 0x00000100, 0x00000000, 0x02004108,
+0x02004008, 0x02004100, 0x00000108, 0x00004000,
+0x00004100, 0x02004008, 0x02000100, 0x00000108,
+0x00000008, 0x00004108, 0x02004000, 0x02000008,
+
+/* nibble 5 */
+0x20000010, 0x00080010, 0x00000000, 0x20080800,
+0x00080010, 0x00000800, 0x20000810, 0x00080000,
+0x00000810, 0x20080810, 0x00080800, 0x20000000,
+0x20000800, 0x20000010, 0x20080000, 0x00080810,
+0x00080000, 0x20000810, 0x20080010, 0x00000000,
+0x00000800, 0x00000010, 0x20080800, 0x20080010,
+0x20080810, 0x20080000, 0x20000000, 0x00000810,
+0x00000010, 0x00080800, 0x00080810, 0x20000800,
+0x00000810, 0x20000000, 0x20000800, 0x00080810,
+0x20080800, 0x00080010, 0x00000000, 0x20000800,
+0x20000000, 0x00000800, 0x20080010, 0x00080000,
+0x00080010, 0x20080810, 0x00080800, 0x00000010,
+0x20080810, 0x00080800, 0x00080000, 0x20000810,
+0x20000010, 0x20080000, 0x00080810, 0x00000000,
+0x00000800, 0x20000010, 0x20000810, 0x20080800,
+0x20080000, 0x00000810, 0x00000010, 0x20080010,
+
+/* nibble 6 */
+0x00001000, 0x00000080, 0x00400080, 0x00400001,
+0x00401081, 0x00001001, 0x00001080, 0x00000000,
+0x00400000, 0x00400081, 0x00000081, 0x00401000,
+0x00000001, 0x00401080, 0x00401000, 0x00000081,
+0x00400081, 0x00001000, 0x00001001, 0x00401081,
+0x00000000, 0x00400080, 0x00400001, 0x00001080,
+0x00401001, 0x00001081, 0x00401080, 0x00000001,
+0x00001081, 0x00401001, 0x00000080, 0x00400000,
+0x00001081, 0x00401000, 0x00401001, 0x00000081,
+0x00001000, 0x00000080, 0x00400000, 0x00401001,
+0x00400081, 0x00001081, 0x00001080, 0x00000000,
+0x00000080, 0x00400001, 0x00000001, 0x00400080,
+0x00000000, 0x00400081, 0x00400080, 0x00001080,
+0x00000081, 0x00001000, 0x00401081, 0x00400000,
+0x00401080, 0x00000001, 0x00001001, 0x00401081,
+0x00400001, 0x00401080, 0x00401000, 0x00001001,
+
+/* nibble 7 */
+0x08200020, 0x08208000, 0x00008020, 0x00000000,
+0x08008000, 0x00200020, 0x08200000, 0x08208020,
+0x00000020, 0x08000000, 0x00208000, 0x00008020,
+0x00208020, 0x08008020, 0x08000020, 0x08200000,
+0x00008000, 0x00208020, 0x00200020, 0x08008000,
+0x08208020, 0x08000020, 0x00000000, 0x00208000,
+0x08000000, 0x00200000, 0x08008020, 0x08200020,
+0x00200000, 0x00008000, 0x08208000, 0x00000020,
+0x00200000, 0x00008000, 0x08000020, 0x08208020,
+0x00008020, 0x08000000, 0x00000000, 0x00208000,
+0x08200020, 0x08008020, 0x08008000, 0x00200020,
+0x08208000, 0x00000020, 0x00200020, 0x08008000,
+0x08208020, 0x00200000, 0x08200000, 0x08000020,
+0x00208000, 0x00008020, 0x08008020, 0x08200000,
+0x00000020, 0x08208000, 0x00208020, 0x00000000,
+0x08000000, 0x08200020, 0x00008000, 0x00208020};
diff --git a/kerberosIV/des/str2key.c b/kerberosIV/des/str2key.c
new file mode 100644
index 00000000000..da864f30dbd
--- /dev/null
+++ b/kerberosIV/des/str2key.c
@@ -0,0 +1,113 @@
+/*	$Id: str2key.c,v 1.1 1995/12/14 06:52:45 tholo Exp $	*/
+
+/* Copyright (C) 1993 Eric Young - see README for more details */
+#include "des_locl.h"
+
+extern int des_check_key;
+
+int des_string_to_key(char *str, des_cblock (*key))
+{
+  des_key_schedule ks;
+  int i,length;
+  register unsigned char j;
+
+  memset(key,0,8);
+  length=strlen(str);
+#ifdef OLD_STR_TO_KEY
+  for (i=0; i<length; i++)
+    (*key)[i%8]^=(str[i]<<1);
+#else  /* MIT COMPATIBLE */
+  for (i=0; i<length; i++)
+    {
+      j=str[i];
+      if ((i%16) < 8)
+	(*key)[i%8]^=(j<<1);
+      else
+	{
+	  /* Reverse the bit order 05/05/92 eay */
+	  j=((j<<4)&0xf0)|((j>>4)&0x0f);
+	  j=((j<<2)&0xcc)|((j>>2)&0x33);
+	  j=((j<<1)&0xaa)|((j>>1)&0x55);
+	  (*key)[7-(i%8)]^=j;
+	}
+    }
+#endif
+  des_set_odd_parity((des_cblock *)key);
+  i=des_check_key;
+  des_check_key=0;
+  des_set_key((des_cblock *)key,ks);
+  des_check_key=i;
+  des_cbc_cksum((des_cblock *)str,(des_cblock *)key,(long)length,ks,
+		(des_cblock *)key);
+  memset(ks,0,sizeof(ks));
+  des_set_odd_parity((des_cblock *)key);
+  return(0);
+}
+
+int des_string_to_2keys(char *str, des_cblock (*key1), des_cblock (*key2))
+{
+  des_key_schedule ks;
+  int i,length;
+  register unsigned char j;
+
+  memset(key1,0,8);
+  memset(key2,0,8);
+  length=strlen(str);
+#ifdef OLD_STR_TO_KEY
+  if (length <= 8)
+    {
+      for (i=0; i<length; i++)
+	{
+	  (*key2)[i]=(*key1)[i]=(str[i]<<1);
+	}
+    }
+  else
+    {
+      for (i=0; i<length; i++)
+	{
+	  if ((i/8)&1)
+	    (*key2)[i%8]^=(str[i]<<1);
+	  else
+	    (*key1)[i%8]^=(str[i]<<1);
+	}
+    }
+#else  /* MIT COMPATIBLE */
+  for (i=0; i<length; i++)
+    {
+      j=str[i];
+      if ((i%32) < 16)
+	{
+	  if ((i%16) < 8)
+	    (*key1)[i%8]^=(j<<1);
+	  else
+	    (*key2)[i%8]^=(j<<1);
+	}
+      else
+	{
+	  j=((j<<4)&0xf0)|((j>>4)&0x0f);
+	  j=((j<<2)&0xcc)|((j>>2)&0x33);
+	  j=((j<<1)&0xaa)|((j>>1)&0x55);
+	  if ((i%16) < 8)
+	    (*key1)[7-(i%8)]^=j;
+	  else
+	    (*key2)[7-(i%8)]^=j;
+	}
+    }
+  if (length <= 8) memcpy(key2,key1,8);
+#endif
+  des_set_odd_parity((des_cblock *)key1);
+  des_set_odd_parity((des_cblock *)key2);
+  i=des_check_key;
+  des_check_key=0;
+  des_set_key((des_cblock *)key1,ks);
+  des_cbc_cksum((des_cblock *)str,(des_cblock *)key1,(long)length,ks,
+		(des_cblock *)key1);
+  des_set_key((des_cblock *)key2,ks);
+  des_cbc_cksum((des_cblock *)str,(des_cblock *)key2,(long)length,ks,
+		(des_cblock *)key2);
+  des_check_key=i;
+  memset(ks,0,sizeof(ks));
+  des_set_odd_parity(key1);
+  des_set_odd_parity(key2);
+  return(0);
+}