INFO-DIR-SECTION Security
START-INFO-DIR-ENTRY
* Heimdal: (heimdal).           The Kerberos 5 distribution from KTH
END-INFO-DIR-ENTRY


File: heimdal.info,  Node: Top,  Next: Introduction,  Prev: (dir),  Up: (dir)

Heimdal
*******

This manual for version 7.8.0 of Heimdal.

* Menu:

* Introduction::
* What is Kerberos?::
* Building and Installing::
* Setting up a realm::
* Applications::
* Things in search for a better place::
* Kerberos 4 issues::
* Windows compatibility::
* Programming with Kerberos::
* Migration::
* Acknowledgments::
* Copyrights and Licenses::

 --- The Detailed Node Listing ---

Setting up a realm

* Configuration file::
* Creating the database::
* Modifying the database::
* keytabs::
* Remote administration::
* Password changing::
* Testing clients and servers::
* Slave Servers::
* Incremental propagation::
* Encryption types and salting::
* Credential cache server - KCM::
* Cross realm::
* Transit policy::
* Setting up DNS::
* Using LDAP to store the database::
* Providing Kerberos credentials to servers and programs::
* Setting up PK-INIT::
* Debugging Kerberos problems::

Applications

* Authentication modules::
* AFS::

Authentication modules

* Digital SIA::
* IRIX::

Kerberos 4 issues

* Principal conversion issues::
* Converting a version 4 database::

Windows compatibility

* Configuring Windows to use a Heimdal KDC::
* Inter-Realm keys (trust) between Windows and a Heimdal KDC::
* Create account mappings::
* Encryption types::
* Authorisation data::
* Quirks of Windows 2000 KDC::
* Useful links when reading about the Windows::

Programming with Kerberos


File: heimdal.info,  Node: Introduction,  Next: What is Kerberos?,  Prev: Top,  Up: Top

1 Introduction
**************

What is Heimdal?
================

Heimdal is a free implementation of Kerberos 5. The goals are to:

   * have an implementation that can be freely used by anyone

   * be protocol compatible with existing implementations and, if not in
     conflict, with RFC 4120 (and any future updated RFC). RFC 4120
     replaced RFC 1510.

   * be reasonably compatible with the M.I.T Kerberos V5 API

   * have support for Kerberos V5 over GSS-API (RFC1964)

   * include the most important and useful application programs (rsh,
     telnet, popper, etc.)

   * include enough backwards compatibility with Kerberos V4

Status
======

Heimdal has the following features (this does not mean any of this
works):

   * a stub generator and a library to encode/decode/whatever ASN.1/DER
     stuff

   * a `libkrb5' library that should be possible to get to work with
     simple applications

   * a GSS-API library

   * `kinit', `klist', `kdestroy'

   * `telnet', `telnetd'

   * `rsh', `rshd'

   * `popper', `push' (a movemail equivalent)

   * `ftp', and `ftpd'

   * a library `libkafs' for authenticating to AFS and a program
     `afslog' that uses it

   * some simple test programs

   * a KDC that supports most things,

   * simple programs for distributing databases between a KDC master and
     slaves

   * a password changing daemon `kpasswdd', library functions for
     changing passwords and a simple client

   * some kind of administration system

   * Kerberos V4 support in many of the applications.

Bug reports
===========

If you find bugs in this software, make sure it is a genuine bug and not
just a part of the code that isn't implemented.

Bug reports should be sent to <heimdal-bugs@h5l.org>. Please include
information on what machine and operating system (including version)
you are running, what you are trying to do, what happens, what you
think should have happened, an example for us to repeat, the output you
get when trying the example, and a patch for the problem if you have
one. Please make any patches with `diff -u' or `diff -c'.

Suggestions, comments and other non bug reports are also welcome.

Mailing list
============

There are two mailing lists with talk about Heimdal.
<heimdal-announce@sics.se> is a low-volume announcement list, while
<heimdal-discuss@sics.se> is for general discussion.  Send a message to
<majordomo@sics.se> to subscribe.

Heimdal source code, binaries and the manual
============================================

The source code for heimdal, links to binaries and the manual (this
document) can be found on our web-page at
`http://www.pdc.kth.se/heimdal/'.


File: heimdal.info,  Node: What is Kerberos?,  Next: Building and Installing,  Prev: Introduction,  Up: Top

2 What is Kerberos?
*******************

     Now this Cerberus had three heads of dogs,
             the tail of a dragon, and on his back the
             heads of all sorts of snakes.
             -- Pseudo-Apollodorus Library 2.5.12

Kerberos is a system for authenticating users and services on a network.
It is built upon the assumption that the network is "unsafe".  For
example, data sent over the network can be eavesdropped and altered, and
addresses can also be faked.  Therefore they cannot be used for
authentication purposes.  

Kerberos is a trusted third-party service.  That means that there is a
third party (the kerberos server) that is trusted by all the entities on
the network (users and services, usually called "principals").  All
principals share a secret password (or key) with the kerberos server and
this enables principals to verify that the messages from the kerberos
server are authentic.  Thus trusting the kerberos server, users and
services can authenticate each other.

2.1 Basic mechanism
===================

     *Note* This discussion is about Kerberos version 4, but version 5
     works similarly.

In Kerberos, principals use "tickets" to prove that they are who they
claim to be. In the following example, A is the initiator of the
authentication exchange, usually a user, and B is the service that A
wishes to use.

To obtain a ticket for a specific service, A sends a ticket request to
the kerberos server. The request contains A's and B's names (along with
some other fields). The kerberos server checks that both A and B are
valid principals.

Having verified the validity of the principals, it creates a packet
containing A's and B's names, A's network address (A<ADDR>), the
current time (T<ISSUE>), the lifetime of the ticket (LIFE), and a
secret "session key" (K<AB>). This packet is encrypted with B's secret
key (K<B>).  The actual ticket (T<AB>) looks like this: ({A, B,
A<ADDR>, T<ISSUE>, LIFE, K<AB>}K<B>).

The reply to A consists of the ticket (T<AB>), B's name, the current
time, the lifetime of the ticket, and the session key, all encrypted in
A's secret key ({B, T<ISSUE>, LIFE, K<AB>, T<AB>}K<A>). A decrypts the
reply and retains it for later use.


Before sending a message to B, A creates an authenticator consisting of
A's name, A's address, the current time, and a "checksum" chosen by A,
all encrypted with the secret session key ({A, A<ADDR>, T<CURRENT>,
CHECKSUM}K<AB>). This is sent together with the ticket received from
the kerberos server to B.  Upon reception, B decrypts the ticket using
B's secret key.  Since the ticket contains the session key that the
authenticator was encrypted with, B can now also decrypt the
authenticator. To verify that A really is A, B now has to compare the
contents of the ticket with that of the authenticator. If everything
matches, B now considers A as properly authenticated.

2.2 Different attacks
=====================

Impersonating A
---------------

An impostor, C could steal the authenticator and the ticket as it is
transmitted across the network, and use them to impersonate A. The
address in the ticket and the authenticator was added to make it more
difficult to perform this attack.  To succeed C will have to either use
the same machine as A or fake the source addresses of the packets. By
including the time stamp in the authenticator, C does not have much
time in which to mount the attack.

Impersonating B
---------------

C can hijack B's network address, and when A sends her credentials, C
just pretend to verify them. C can't be sure that she is talking to A.

2.3 Defence strategies
======================

It would be possible to add a "replay cache" to the server side.  The
idea is to save the authenticators sent during the last few minutes, so
that B can detect when someone is trying to retransmit an already used
message. This is somewhat impractical (mostly regarding efficiency),
and is not part of Kerberos 4; MIT Kerberos 5 contains it.

To authenticate B, A might request that B sends something back that
proves that B has access to the session key. An example of this is the
checksum that A sent as part of the authenticator. One typical
procedure is to add one to the checksum, encrypt it with the session
key and send it back to A.  This is called "mutual authentication".

The session key can also be used to add cryptographic checksums to the
messages sent between A and B (known as "message integrity").
Encryption can also be added ("message confidentiality"). This is
probably the best approach in all cases.  

2.4 Further reading
===================

The original paper on Kerberos from 1988 is `Kerberos: An
Authentication Service for Open Network Systems', by Jennifer Steiner,
Clifford Neuman and Jeffrey I. Schiller.

A less technical description can be found in `Designing an
Authentication System: a Dialogue in Four Scenes' by Bill Bryant, also
from 1988.

These documents can be found on our web-page at
`http://www.pdc.kth.se/kth-krb/'.


File: heimdal.info,  Node: Building and Installing,  Next: Setting up a realm,  Prev: What is Kerberos?,  Up: Top

3 Building and Installing
*************************

Build and install instructions are located here:

`http://www.h5l.org/compile.html'

Prebuilt packages is located here:

`http://www.h5l.org/binaries.html'


File: heimdal.info,  Node: Setting up a realm,  Next: Applications,  Prev: Building and Installing,  Up: Top

4 Setting up a realm
********************

A realm is an administrative domain.  The name of a Kerberos realm is
usually the Internet domain name in uppercase.  Call your realm the same
as your Internet domain name if you do not have strong reasons for not
doing so.  It will make life easier for you and everyone else.

* Menu:

* Configuration file::
* Creating the database::
* Modifying the database::
* Checking the setup::
* keytabs::
* Remote administration::
* Password changing::
* Testing clients and servers::
* Slave Servers::
* Incremental propagation::
* Encryption types and salting::
* Credential cache server - KCM::
* Cross realm::
* Transit policy::
* Setting up DNS::
* Using LDAP to store the database::
* Providing Kerberos credentials to servers and programs::
* Setting up PK-INIT::
* Debugging Kerberos problems::


File: heimdal.info,  Node: Configuration file,  Next: Creating the database,  Prev: Setting up a realm,  Up: Setting up a realm

4.1 Configuration file
======================

To setup a realm you will first have to create a configuration file:
`/etc/krb5.conf'. The `krb5.conf' file can contain many configuration
options, some of which are described here.

There is a sample `krb5.conf' supplied with the distribution.

The configuration file is a hierarchical structure consisting of
sections, each containing a list of bindings (either variable
assignments or subsections). A section starts with `[`section-name']'.
A binding consists of a left hand side, an equal sign (`=') and a right
hand side (the left hand side tag must be separated from the equal sign
with some whitespace). Subsections have a `{' as the first
non-whitespace character after the equal sign. All other bindings are
treated as variable assignments. The value of a variable extends to the
end of the line.

     [section1]
             a-subsection = {
                     var = value1
                     other-var = value with {}
                     sub-sub-section = {
                             var = 123
                     }
             }
             var = some other value
     [section2]
             var = yet another value

In this manual, names of sections and bindings will be given as strings
separated by slashes (`/'). The `other-var' variable will thus be
`section1/a-subsection/other-var'.

For in-depth information about the contents of the configuration file,
refer to the `krb5.conf' manual page. Some of the more important
sections are briefly described here.

The `libdefaults' section contains a list of library configuration
parameters, such as the default realm and the timeout for KDC
responses. The `realms' section contains information about specific
realms, such as where they hide their KDC. This section serves the same
purpose as the Kerberos 4 `krb.conf' file, but can contain more
information. Finally the `domain_realm' section contains a list of
mappings from domains to realms, equivalent to the Kerberos 4
`krb.realms' file.

To continue with the realm setup, you will have to create a
configuration file, with contents similar to the following.

     [libdefaults]
             default_realm = MY.REALM
     [realms]
             MY.REALM = {
                     kdc = my.kdc my.slave.kdc
                     kdc = my.third.kdc
                     kdc = 130.237.237.17
                     kdc = [2001:6b0:1:ea::100]:88
             }
     [domain_realm]
             .my.domain = MY.REALM

If you use a realm name equal to your domain name, you can omit the
`libdefaults', and `domain_realm', sections. If you have a DNS
SRV-record for your realm, or your Kerberos server has DNS CNAME
`kerberos.my.realm', you can omit the `realms' section too.

If you want to use a different configuration file then the default you
can point a file with the environment variable `KRB5_CONFIG'.

     env KRB5_CONFIG=$HOME/etc/krb5.conf kinit user@REALM


File: heimdal.info,  Node: Creating the database,  Next: Modifying the database,  Prev: Configuration file,  Up: Setting up a realm

4.2 Creating the database
=========================

The database library will look for the database in the directory
`/var/heimdal', so you should probably create that directory.  Make
sure the directory has restrictive permissions.

     # mkdir /var/heimdal
     # chmod og-rwx /var/heimdal

Heimdal supports various database backends: lmdb (LMDB), db3 (Berkeley
DB 3.x, 4.x, or 5.x), db1 (Berkeley DB 2.x), sqlite (SQLite3), and ldap
(LDAP).  The default is db3, and is selected at build time from one of
lmdb, db3, or db1.

These defaults can be overriden in the 'database' key in the `kdc'
section of the configuration.

     [kdc]
             database = {
                     dbname = lmdb:/path/to/db-file
                     realm = REALM
                     acl_file = /path/to/kadmind.acl
                     mkey_file = /path/to/mkey
                     log_file = /path/to/iprop-log-file
             }

To use LDAP, see *Note Using LDAP to store the database::.

The keys of all the principals are stored in the database.  If you
choose to, these can be encrypted with a master key.  You do not have to
remember this key (or password), but just to enter it once and it will
be stored in a file (`/var/heimdal/m-key').  If you want to have a
master key, run `kstash' to create this master key:

     # kstash
     Master key:
     Verifying password - Master key:

If you want to generate a random master key you can use the
`--random-key' flag to kstash. This will make sure you have a good key
on which attackers can't do a dictionary attack.

If you have a master key, make sure you make a backup of your master
key file; without it backups of the database are of no use.

To initialise the database use the `kadmin' program, with the `-l'
option (to enable local database mode). First issue a `init MY.REALM'
command. This will create the database and insert default principals
for that realm. You can have more than one realm in one database, so
`init' does not destroy any old database.

Before creating the database, `init' will ask you some questions about
maximum ticket lifetimes.

After creating the database you should probably add yourself to it. You
do this with the `add' command. It takes as argument the name of a
principal. The principal should contain a realm, so if you haven't set
up a default realm, you will need to explicitly include the realm.

     # kadmin -l
     kadmin> init MY.REALM
     Realm max ticket life [unlimited]:
     Realm max renewable ticket life [unlimited]:
     kadmin> add me
     Max ticket life [unlimited]:
     Max renewable life [unlimited]:
     Attributes []:
     Password:
     Verifying password - Password:

Now start the KDC and try getting a ticket.

     # kdc &
     # kinit me
     me@MY.REALMS's Password:
     # klist
     Credentials cache: /tmp/krb5cc_0
             Principal: me@MY.REALM

       Issued           Expires          Principal
     Aug 25 07:25:55  Aug 25 17:25:55  krbtgt/MY.REALM@MY.REALM

If you are curious you can use the `dump' command to list all the
entries in the database.  It should look something similar to the
following example (note that the entries here are truncated for
typographical reasons):

     kadmin> dump
     me@MY.REALM 1:0:1:0b01d3cb7c293b57:-:0:7:8aec316b9d1629e3baf8 ...
     kadmin/admin@MY.REALM 1:0:1:e5c8a2675b37a443:-:0:7:cb913ebf85 ...
     krbtgt/MY.REALM@MY.REALM 1:0:1:52b53b61c875ce16:-:0:7:c8943be ...
     kadmin/changepw@MY.REALM 1:0:1:f48c8af2b340e9fb:-:0:7:e3e6088 ...


File: heimdal.info,  Node: Modifying the database,  Next: Checking the setup,  Prev: Creating the database,  Up: Setting up a realm

4.3 Modifying the database
==========================

All modifications of principals are done with with kadmin.

A principal has several attributes and lifetimes associated with it.

Principals are added, renamed, modified, and deleted with the kadmin
commands `add', `rename', `modify', `delete'.  Both interactive editing
and command line flags can be used (use -help to list the available
options).

There are different kinds of types for the fields in the database;
attributes, absolute time times and relative times.

4.3.1 Attributes
----------------

When doing interactive editing, attributes are listed with `?'.

The attributes are given in a comma (`,') separated list.  Attributes
are removed from the list by prefixing them with `-'.

     kadmin> modify me
     Max ticket life [1 day]:
     Max renewable life [1 week]:
     Principal expiration time [never]:
     Password expiration time [never]:
     Attributes [disallow-renewable]: requires-pre-auth,-disallow-renewable
     kadmin> get me
                 Principal: me@MY.REALM
     [...]
                Attributes: requires-pre-auth

4.3.2 Absolute times
--------------------

The format for absolute times are any of the following:

     never
     now
     YYYY-mm-dd
     YYYY-mm-dd HH:MM:SS

4.3.3 Relative times
--------------------

The format for relative times are any of the following combined:

     N year
     M month
     O day
     P hour
     Q minute
     R second


File: heimdal.info,  Node: Checking the setup,  Next: keytabs,  Prev: Modifying the database,  Up: Setting up a realm

4.4 Checking the setup
======================

There are two tools that can check the consistency of the Kerberos
configuration file and the Kerberos database.

The Kerberos configuration file is checked using `verify_krb5_conf'.
The tool checks for common errors, but commonly there are several
uncommon configuration entries that are never added to the tool and
thus generates "unknown entry" warnings.  This is usually nothing to
worry about.

The database check is built into the kadmin tool. It will check for
common configuration error that will cause problems later. Common check
are for existence and flags on important principals. The database check
by run by the following command :

     kadmin -l check REALM.EXAMPLE.ORG


File: heimdal.info,  Node: keytabs,  Next: Remote administration,  Prev: Checking the setup,  Up: Setting up a realm

4.5 keytabs
===========

To extract a service ticket from the database and put it in a keytab,
you need to first create the principal in the database with `add'
(using the `--random-key' flag to get a random key) and then extract it
with `ext_keytab'.

     kadmin> add --random-key host/my.host.name
     Max ticket life [unlimited]:
     Max renewable life [unlimited]:
     Attributes []:
     kadmin> ext host/my.host.name
     kadmin> exit
     # ktutil list
     Version  Type             Principal
          1   des-cbc-md5      host/my.host.name@MY.REALM
          1   des-cbc-md4      host/my.host.name@MY.REALM
          1   des-cbc-crc      host/my.host.name@MY.REALM
          1   des3-cbc-sha1    host/my.host.name@MY.REALM


File: heimdal.info,  Node: Remote administration,  Next: Password changing,  Prev: keytabs,  Up: Setting up a realm

4.6 Remote administration
=========================

The administration server, `kadmind', can be started by `inetd' (which
isn't recommended) or run as a normal daemon. If you want to start it
from `inetd' you should add a line similar to the one below to your
`/etc/inetd.conf'.

     kerberos-adm stream     tcp     nowait  root /usr/heimdal/libexec/kadmind kadmind

You might need to add `kerberos-adm' to your `/etc/services' as
`749/tcp'.

Access to the administration server is controlled by an ACL file,
(default `/var/heimdal/kadmind.acl'.) The file has the following syntax:
     principal       [priv1,priv2,...]       [glob-pattern]

The matching is from top to bottom for matching principals (and if
given, glob-pattern).  When there is a match, the access rights of that
line are applied.

The privileges you can assign to a principal are: `add',
`change-password' (or `cpw' for short), `delete', `get', `list', and
`modify', or the special privilege `all'. All of these roughly
correspond to the different commands in `kadmin'.

If a GLOB-PATTERN is given on a line, it restricts the access rights
for the principal to only apply for subjects that match the pattern.
The patterns are of the same type as those used in shell globbing, see
fnmatch(3).

In the example below `lha/admin' can change every principal in the
database. `jimmy/admin' can only modify principals that belong to the
realm `E.KTH.SE'. `mille/admin' is working at the help desk, so he
should only be able to change the passwords for single component
principals (ordinary users). He will not be able to change any `/admin'
principal.

     lha/admin@E.KTH.SE	all
     jimmy/admin@E.KTH.SE	all		*@E.KTH.SE
     jimmy/admin@E.KTH.SE	all		*/*@E.KTH.SE
     mille/admin@E.KTH.SE	change-password	*@E.KTH.SE


File: heimdal.info,  Node: Password changing,  Next: Testing clients and servers,  Prev: Remote administration,  Up: Setting up a realm

4.7 Password changing
=====================

To allow users to change their passwords, you should run `kpasswdd'.
It is not run from `inetd'.

You might need to add `kpasswd' to your `/etc/services' as `464/udp'.
If your realm is not setup to use DNS, you might also need to add a
`kpasswd_server' entry to the realm configuration in `/etc/krb5.conf'
on client machines:

     [realms]
             MY.REALM = {
                     kdc = my.kdc my.slave.kdc
                     kpasswd_server = my.kdc
             }

4.7.1 Password quality assurance
--------------------------------

It is important that users have good passwords, both to make it harder
to guess them and to avoid off-line attacks (although
pre-authentication provides some defence against off-line attacks).  To
ensure that the users choose good passwords, you can enable password
quality controls in `kpasswdd' and `kadmind'.  The controls themselves
are done in a shared library or an external program that is used by
`kpasswdd'.  To configure in these controls, add lines similar to the
following to your `/etc/krb5.conf':

     [password_quality]
     	policies = external-check builtin:minimum-length modulename:policyname
     	external_program = /bin/false
     	policy_libraries = LIBRARY1.SO LIBRARY2.SO

In `[password_quality]policies' the module name is optional if the
policy name is unique in all modules (members of `policy_libraries').
All built-in policies can be qualified with a module name of `builtin'
to unambiguously specify the built-in policy and not a policy by the
same name from a loaded module.

The built-in policies are

   * external-check

     Executes the program specified by
     `[password_quality]external_program'.

     A number of key/value pairs are passed as input to the program,
     one per line, ending with the string `end'.  The key/value lines
     are of the form
          principal: PRINCIPAL
          new-password: PASSWORD
     where PASSWORD is the password to check for the previous PRINCIPAL.

     If the external application approves the password, it should return
     `APPROVED' on standard out and exit with exit code 0.  If it
     doesn't approve the password, an one line error message explaining
     the problem should be returned on standard error and the
     application should exit with exit code 0.  In case of a fatal
     error, the application should, if possible, print an error message
     on standard error and exit with a non-zero error code.

   * minimum-length

     The minimum length password quality check reads the configuration
     file stanza `[password_quality]min_length' and requires the
     password to be at least this length.

   * character-class

     The character-class password quality check reads the configuration
     file stanza `[password_quality]min_classes'. The policy requires
     the password to have characters from at least that many character
     classes. Default value if not given is 3.

     The four different characters classes are, uppercase, lowercase,
     number, special characters.


If you want to write your own shared object to check password policies,
see the manual page `kadm5_pwcheck(3)'.

Code for a password quality checking function that uses the cracklib
library can be found in `lib/kadm5/sample_password_check.c' in the
source code distribution.  It requires that the cracklib library be
built with the patch available at
`ftp://ftp.pdc.kth.se/pub/krb/src/cracklib.patch'.

A sample policy external program is included in
`lib/kadm5/check-cracklib.pl'.

If no password quality checking function is configured, the only check
performed is that the password is at least six characters long.

To check the password policy settings, use the command
`verify-password-quality' in `kadmin' program. The password
verification is only performed locally, on the client.  It may be
convenient to set the environment variable `KRB5_CONFIG' to point to a
test version of `krb5.conf' while you're testing the
`[password_quality]' stanza that way.


File: heimdal.info,  Node: Testing clients and servers,  Next: Slave Servers,  Prev: Password changing,  Up: Setting up a realm

4.8 Testing clients and servers
===============================

Now you should be able to run all the clients and servers.  Refer to the
appropriate man pages for information on how to use them.


File: heimdal.info,  Node: Slave Servers,  Next: Incremental propagation,  Prev: Testing clients and servers,  Up: Setting up a realm

4.9 Slave servers, Incremental propagation, Testing clients and servers, Setting up a realm
===========================================================================================

It is desirable to have at least one backup (slave) server in case the
master server fails. It is possible to have any number of such slave
servers but more than three usually doesn't buy much more redundancy.

All Kerberos servers for a realm must have the same database so that
they present the same service to the users.  The `hprop' program,
running on the master, will propagate the database to the slaves,
running `hpropd' processes.

Every slave needs a database directory, the master key (if it was used
for the database) and a keytab with the principal `hprop/HOSTNAME'.
Add the principal with the `ktutil' command and start `hpropd', as
follows:

     slave# ktutil get -p foo/admin hprop/`hostname`
     slave# mkdir /var/heimdal
     slave# hpropd

The master will use the principal `kadmin/hprop' to authenticate to the
slaves.  This principal should be added when running `kadmin -l init'
but if you do not have it in your database for whatever reason, please
add it with `kadmin -l add'.

Then run `hprop' on the master:

     master# hprop slave

This was just an hands-on example to make sure that everything was
working properly.  Doing it manually is of course the wrong way, and to
automate this you will want to start `hpropd' from `inetd' on the
slave(s) and regularly run `hprop' on the master to regularly propagate
the database.  Starting the propagation once an hour from `cron' is
probably a good idea.


File: heimdal.info,  Node: Incremental propagation,  Next: Encryption types and salting,  Prev: Slave Servers,  Up: Setting up a realm

4.10 Incremental propagation
============================

There is also a newer mechanism for doing incremental propagation in
Heimdal.  Instead of sending the whole database regularly, it sends the
changes as they happen on the master to the slaves.  The master keeps
track of all the changes by assigning a version number to every change
to the database.  The slaves know which was the latest version they saw
and in this way it can be determined if they are in sync or not.  A log
of all the changes is kept on the master, and when a slave is at an
older version than the oldest one in the log, the whole database has to
be sent.

Protocol-wise, all the slaves connect to the master and as a greeting
tell it the latest version that they have (`IHAVE' message).  The
master then responds by sending all the changes between that version and
the current version at the master (a series of `FORYOU' messages) or
the whole database in a `TELLYOUEVERYTHING' message.  There is also a
keep-alive protocol that makes sure all slaves are up and running.

In addition on listening on the network to get connection from new
slaves, the ipropd-master also listens on a status unix socket. kadmind
and kpasswdd both open that socket when a transation is done and
written a notification to the socket. That cause ipropd-master to check
for new version in the log file. As a fallback in case a notification
is lost by the unix socket, the log file is checked after 30 seconds of
no event.

4.10.1 Configuring incremental propagation
------------------------------------------

The program that runs on the master is `ipropd-master' and all clients
run `ipropd-slave'.

Create the file `/var/heimdal/slaves' on the master containing all the
slaves that the database should be propagated to.  Each line contains
the full name of the principal (for example
`iprop/hemligare.foo.se@FOO.SE').

You should already have `iprop/tcp' defined as 2121, in your
`/etc/services'.  Otherwise, or if you need to use a different port for
some peculiar reason, you can use the `--port' option.  This is useful
when you have multiple realms to distribute from one server.

Then you need to create those principals that you added in the
configuration file.  Create one `iprop/hostname' for the master and for
every slave.

     master# /usr/heimdal/sbin/ktutil get iprop/`hostname`

     slave# /usr/heimdal/sbin/ktutil get iprop/`hostname`

The next step is to start the `ipropd-master' process on the master
server.  The `ipropd-master' listens on the UNIX domain socket
`/var/heimdal/signal' to know when changes have been made to the
database so they can be propagated to the slaves.  There is also a
safety feature of testing the version number regularly (every 30
seconds) to see if it has been modified by some means that do not raise
this signal.  Then, start `ipropd-slave' on all the slaves:

     master# /usr/heimdal/libexec/ipropd-master &
     slave#  /usr/heimdal/libexec/ipropd-slave master &

To manage the iprop log file you should use the `iprop-log' command.
With it you can dump, truncate and replay the logfile.

4.10.2 Status of iprop master and slave
---------------------------------------

Both the master and slave provides status of the world as they see it.

The master write outs the current status of the slaves, last seen and
their version number in `/var/heimdal/slaves-stats'.

The slave write out the current status in
`/var/heimdal/ipropd-slave-status'.

These locations can be changed with command line options, and in the
case of `ipropd_master', the configuration file.


File: heimdal.info,  Node: Encryption types and salting,  Next: Credential cache server - KCM,  Prev: Incremental propagation,  Up: Setting up a realm

4.11 Encryption types and salting
=================================

The encryption types that the KDC is going to assign by default is
possible to change. Since the keys used for user authentication is
salted the encryption types are described together with the salt
strings.

Salting is used to make it harder to pre-calculate all possible keys.
Using a salt increases the search space to make it almost impossible to
pre-calculate all keys. Salting is the process of mixing a public
string (the salt) with the password, then sending it through an
encryption type specific string-to-key function that will output the
fixed size encryption key.

In Kerberos 5 the salt is determined by the encryption type, except in
some special cases.

In `des' there is the Kerberos 4 salt (none at all) or the afs-salt
(using the cell (realm in AFS lingo)).

In `arcfour' (the encryption type that Microsoft Windows 2000 uses)
there is no salt. This is to be compatible with NTLM keys in Windows NT
4.

`[kadmin]default_keys' in `krb5.conf' controls what salting to use.

The syntax of `[kadmin]default_keys' is
`[etype:]salt-type[:salt-string]'. `etype' is the encryption type
(des-cbc-crc, arcfour-hmac-md5, aes256-cts-hmac-sha1-96), `salt-type'
is the type of salt (pw-salt or afs3-salt), and the salt-string is the
string that will be used as salt (remember that if the salt is
appended/prepended, the empty salt "" is the same thing as no salt at
all).

Common types of salting include

   * `v4' (or `des:pw-salt:')

     The Kerberos 4 salting is using no salt at all. Reason there is
     colon at the end of the salt string is that it makes the salt the
     empty string (same as no salt).

   * `v5' (or `pw-salt')

     `pw-salt' uses the default salt for each encryption type is
     specified for. If the encryption type `etype' isn't given, all
     default encryption will be used.

   * `afs3-salt'

     `afs3-salt' is the salt that is used with Transarc kaserver. It's
     the cell name appended to the password.



File: heimdal.info,  Node: Credential cache server - KCM,  Next: Cross realm,  Prev: Encryption types and salting,  Up: Setting up a realm

4.12 Credential cache server - KCM
==================================

When KCM running is easy for users to switch between different kerberos
principals using `kswitch' or built in support in application, like
OpenSSH's GSSAPIClientIdentity.

Other advantages are that there is the long term credentials are not
written to disk and on reboot the credential is removed when kcm
process stopps running.

Configure the system startup script to start the kcm process,
`/usr/heimdal/libexec/kcm' and then configure the system to use kcm in
`krb5.conf'.

     [libdefaults]
     	default_cc_type = KCM

Now when you run `kinit' it doesn't overwrite your existing credentials
but rather just add them to the set of credentials. `klist -l' lists
the credentials and the star marks the default credential.

     $ kinit lha@KTH.SE
     lha@KTH.SE's Password:
     $ klist -l
       Name         Cache name               Expires
     lha@KTH.SE   0                        Nov 22 23:09:40   *
     lha@SU.SE    Initial default ccache   Nov 22 14:14:24

When switching between credentials you can use `kswitch'.

     $ kswitch -i
          Principal
     1    lha@KTH.SE
     2    lha@SU.SE
     Select number: 2

After switching, a new set of credentials are used as default.

     $ klist -l
       Name         Cache name               Expires
     lha@SU.SE    Initial default ccache   Nov 22 14:14:24   *
     lha@KTH.SE   0                        Nov 22 23:09:40

Som applications, like openssh with Simon Wilkinsons patch applied,
support specifiying that credential to use.  The example below will
login to the host computer.kth.se using lha@KTH.SE (not the current
default credential).

     $ ssh \
        -o GSSAPIAuthentication=yes \
        -o GSSAPIKeyExchange=yes \
        -o GSSAPIClientIdentity=lha@KTH.SE \
        computer.kth.se


File: heimdal.info,  Node: Cross realm,  Next: Transit policy,  Prev: Credential cache server - KCM,  Up: Setting up a realm

4.13 Cross realm
================

Suppose you reside in the realm `MY.REALM', how do you authenticate to
a server in `OTHER.REALM'? Having valid tickets in `MY.REALM' allows
you to communicate with Kerberised services in that realm. However, the
computer in the other realm does not have a secret key shared with the
Kerberos server in your realm.

It is possible to share keys between two realms that trust each other.
When a client program, such as `telnet' or `ssh', finds that the other
computer is in a different realm, it will try to get a ticket granting
ticket for that other realm, but from the local Kerberos server. With
that ticket granting ticket, it will then obtain service tickets from
the Kerberos server in the other realm.

For a two way trust between `MY.REALM' and `OTHER.REALM' add the
following principals to each realm. The principals should be
`krbtgt/OTHER.REALM@MY.REALM' and `krbtgt/MY.REALM@OTHER.REALM' in
`MY.REALM', and `krbtgt/MY.REALM@OTHER.REALM' and
`krbtgt/OTHER.REALM@MY.REALM'in `OTHER.REALM'.

In Kerberos 5 the trust can be configured to be one way. So that users
from `MY.REALM' can authenticate to services in `OTHER.REALM', but not
the opposite. In the example above, the `krbtgt/MY.REALM@OTHER.REALM'
then should be removed.

The two principals must have the same key, key version number, and the
same set of encryption types. Remember to transfer the two keys in a
safe manner.

     vr$ klist
     Credentials cache: FILE:/tmp/krb5cc_913.console
             Principal: lha@E.KTH.SE

       Issued           Expires          Principal
     May  3 13:55:52  May  3 23:55:54  krbtgt/E.KTH.SE@E.KTH.SE

     vr$ telnet -l lha hummel.it.su.se
     Trying 2001:6b0:5:1095:250:fcff:fe24:dbf...
     Connected to hummel.it.su.se.
     Escape character is '^]'.
     Waiting for encryption to be negotiated...
     [ Trying mutual KERBEROS5 (host/hummel.it.su.se@SU.SE)... ]
     [ Kerberos V5 accepts you as ``lha@E.KTH.SE'' ]
     Encryption negotiated.
     Last login: Sat May  3 14:11:47 from vr.l.nxs.se
     hummel$ exit

     vr$ klist
     Credentials cache: FILE:/tmp/krb5cc_913.console
             Principal: lha@E.KTH.SE

       Issued           Expires          Principal
     May  3 13:55:52  May  3 23:55:54  krbtgt/E.KTH.SE@E.KTH.SE
     May  3 13:55:56  May  3 23:55:54  krbtgt/SU.SE@E.KTH.SE
     May  3 14:10:54  May  3 23:55:54  host/hummel.it.su.se@SU.SE


File: heimdal.info,  Node: Transit policy,  Next: Setting up DNS,  Prev: Cross realm,  Up: Setting up a realm

4.14 Transit policy
===================

Under some circumstances, you may not wish to set up direct cross-realm
trust with every realm to which you wish to authenticate or from which
you wish to accept authentications. Kerberos supports multi-hop
cross-realm trust where a client principal in realm A authenticates to
a service in realm C through a realm B with which both A and C have
cross-realm trust relationships. In this situation, A and C need not
set up cross-realm principals between each other.

If you want to use cross-realm authentication through an intermediate
realm, it must be explicitly allowed by either the KDCs for the realm
to which the client is authenticating (in this case, realm C), or the
server receiving the request. This is done in `krb5.conf' in the
`[capaths]' section.

In addition, the client in realm A need to be configured to know how to
reach realm C via realm B. This can be done either on the client or via
KDC configuration in the KDC for realm A.

4.14.1 Allowing cross-realm transits
------------------------------------

When the ticket transits through a realm to another realm, the
destination realm adds its peer to the "transited-realms" field in the
ticket. The field is unordered, since there is no way to know if know
if one of the transited-realms changed the order of the list. For the
authentication to be accepted by the final destination realm, all of
the transited realms must be listed as trusted in the `[capaths]'
configuration, either in the KDC for the destination realm or on the
server receiving the authentication.

The syntax for `[capaths]' section is:

     [capaths]
             CLIENT-REALM = {
                     SERVER-REALM = PERMITTED-CROSS-REALMS ...
             }

In the following example, the realm `STACKEN.KTH.SE' only has direct
cross-realm set up with `KTH.SE'.  `KTH.SE' has direct cross-realm set
up with `STACKEN.KTH.SE' and `SU.SE'.  `DSV.SU.SE' only has direct
cross-realm set up with `SU.SE'.  The goal is to allow principals in
the `DSV.SU.SE' or `SU.SE' realms to authenticate to services in
`STACKEN.KTH.SE'.  This is done with the following `[capaths]' entry on
either the server accepting authentication or on the KDC for
`STACKEN.KTH.SE'.

     [capaths]
     	SU.SE = {
                         STACKEN.KTH.SE = KTH.SE
     	}
     	DSV.SU.SE = {
                         STACKEN.KTH.SE = SU.SE KTH.SE
     	}

The first entry allows cross-realm authentication from clients in
`SU.SE' transiting through `KTH.SE' to `STACKEN.KTH.SE'.  The second
entry allows cross-realm authentication from clients in `DSV.SU.SE'
transiting through both `SU.SE' and `KTH.SE' to `STACKEN.KTH.SE'.

Be careful of which realm goes where; it's easy to put realms in the
wrong place.  The block is tagged with the client realm (the realm of
the principal authenticating), and the realm before the equal sign is
the final destination realm: the realm to which the client is
authenticating.  After the equal sign go all the realms that the client
transits through.

The order of the `PERMITTED-CROSS-REALMS' is not important when doing
transit cross realm verification.

4.14.2 Configuring client cross-realm transits
----------------------------------------------

The `[capaths]' section is also used for another purpose: to tell
clients which realm to transit through to reach a realm with which
their local realm does not have cross-realm trust.  This can be done by
either putting a `[capaths]' entry in the configuration of the client
or by putting the entry in the configuration of the KDC for the
client's local realm.  In the latter case, the KDC will then hand back
a referral to the client when the client requests a cross-realm ticket
to the destination realm, telling the client to try to go through an
intermediate realm.

For client configuration, the order of `PERMITTED-CROSS-REALMS' is
significant, since only the first realm in this section (after the
equal sign) is used by the client.

For example, again consider the `[capaths]' entry above for the case of
a client in the `SU.SE' realm, and assume that the client or the
`SU.SE' KDC has that `[capaths]' entry.  If the client attempts to
authenticate to a service in the `STACKEN.KTH.SE' realm, that entry
says to first authenticate cross-realm to the `KTH.SE' realm (the first
realm listed in the `PERMITTED-CROSS-REALMS' section), and then from
there to `STACKEN.KTH.SE'.

Each entry in `[capaths]' can only give the next hop, since only the
first realm in `PERMITTED-CROSS-REALMS' is used.  If, for instance, a
client in `DSV.SU.SE' had a `[capaths]' configuration as above but
without the first block for `SU.SE', they would not be able to reach
`STACKEN.KTH.SE'.  They would get as far as `SU.SE' based on the
`DSV.SU.SE' entry in `[capaths]' and then attempt to go directly from
there to `STACKEN.KTH.SE' and get stuck (unless, of course, the `SU.SE'
KDC had the additional entry required to tell the client to go through
`KTH.SE').

4.14.3 Active Directory forest example
--------------------------------------

One common place where a `[capaths]' configuration is desirable is with
Windows Active Directory forests.  One common Active Directory
configuration is to have one top-level Active Directory realm but then
divide systems, services, and users into child realms (perhaps based on
organizational unit).  One generally establishes cross-realm trust only
with the top-level realm, and then uses transit policy to permit
authentications to and from the child realms.

For example, suppose an organization has a Heimdal realm `EXAMPLE.COM',
a Windows Active Directory realm `WIN.EXAMPLE.COM', and then child
Active Directory realms `ENGR.WIN.EXAMPLE.COM' and
`SALES.WIN.EXAMPLE.COM'.  The goal is to allow users in any of these
realms to authenticate to services in any of these realms.  The
`EXAMPLE.COM' KDC (and possibly client) configuration should therefore
contain a `[capaths]' section as follows:

     [capaths]
     	ENGR.WIN.EXAMPLE.COM = {
     		EXAMPLE.COM = WIN.EXAMPLE.COM
     	}
     	SALES.WIN.EXAMPLE.COM = {
     		EXAMPLE.COM = WIN.EXAMPLE.COM
     	}
     	EXAMPLE.COM = {
     		ENGR.WIN.EXAMPLE.COM = WIN.EXAMPLE.COM
     		SALES.WIN.EXAMPLE.COM = WIN.EXAMPLE.COM
     	}

The first two blocks allow clients in the `ENGR.WIN.EXAMPLE.COM' and
`SALES.WIN.EXAMPLE.COM' realms to authenticate to services in the
`EXAMPLE.COM' realm.  The third block tells the client (or tells the
KDC to tell the client via referrals) to transit through
`WIN.EXAMPLE.COM' to reach these realms.  Both sides of the
configuration are needed for bi-directional transited cross-realm
authentication.


File: heimdal.info,  Node: Setting up DNS,  Next: Using LDAP to store the database,  Prev: Transit policy,  Up: Setting up a realm

4.15 Setting up DNS
===================

4.15.1 Using DNS to find KDC
----------------------------

If there is information about where to find the KDC or kadmind for a
realm in the `krb5.conf' for a realm, that information will be
preferred, and DNS will not be queried.

Heimdal will try to use DNS to find the KDCs for a realm. First it will
try to find a `SRV' resource record (RR) for the realm. If no SRV RRs
are found, it will fall back to looking for an `A' RR for a machine
named kerberos.REALM, and then kerberos-1.REALM, etc

Adding this information to DNS minimises the client configuration (in
the common case, resulting in no configuration needed) and allows the
system administrator to change the number of KDCs and on what machines
they are running without caring about clients.

The downside of using DNS is that the client might be fooled to use the
wrong server if someone fakes DNS replies/data, but storing the IP
addresses of the KDC on all the clients makes it very hard to change
the infrastructure.

An example of the configuration for the realm `EXAMPLE.COM':


     $ORIGIN example.com.
     _kerberos._tcp          SRV     10 1 88 kerberos.example.com.
     _kerberos._udp          SRV     10 1 88 kerberos.example.com.
     _kerberos._tcp          SRV     10 1 88 kerberos-1.example.com.
     _kerberos._udp          SRV     10 1 88 kerberos-1.example.com.
     _kpasswd._udp           SRV     10 1 464 kerberos.example.com.
     _kerberos-adm._tcp	SRV	10 1 749 kerberos.example.com.

More information about DNS SRV resource records can be found in
RFC-2782 (A DNS RR for specifying the location of services (DNS SRV)).

4.15.2 Using DNS to map hostname to Kerberos realm
--------------------------------------------------

Heimdal also supports a way to lookup a realm from a hostname. This to
minimise configuration needed on clients. Using this has the drawback
that clients can be redirected by an attacker to realms within the same
cross realm trust and made to believe they are talking to the right
server (since Kerberos authentication will succeed).

An example configuration that informs clients that for the realms
it.example.com and srv.example.com, they should use the realm
EXAMPLE.COM:


     $ORIGIN example.com.
     _kerberos.it		TXT     "EXAMPLE.COM"
     _kerberos.srv		TXT     "EXAMPLE.COM"


File: heimdal.info,  Node: Using LDAP to store the database,  Next: Providing Kerberos credentials to servers and programs,  Prev: Setting up DNS,  Up: Setting up a realm

4.16 Using LDAP to store the database
=====================================

This document describes how to install the LDAP backend for Heimdal.
Note that before attempting to configure such an installation, you
should be aware of the implications of storing private information
(such as users' keys) in a directory service primarily designed for
public information. Nonetheless, with a suitable authorisation policy,
it is possible to set this up in a secure fashion. A knowledge of LDAP,
Kerberos, and C is necessary to install this backend. The HDB schema
was devised by Leif Johansson.

This assumes, OpenLDAP 2.3 or later.

Requirements:

   * A current release of Heimdal, configured with
     `--with-openldap=/usr/local' (adjust according to where you have
     installed OpenLDAP).

     You can verify that you manage to configure LDAP support by running
     `kdc --builtin-hdb', and checking that `ldap:' is one entry in the
     list.

     Its also possible to configure the ldap backend as a shared module,
     see option -hdb-openldap-module to configure.

   * Optionally configure OpenLDAP with `--enable-local' to enable the
     local transport.

   * Add the hdb schema to the LDAP server, it's included in the
     source-tree in `lib/hdb/hdb.schema'. Example from slapd.conf:

          include /usr/local/etc/openldap/schema/hdb.schema

   * Configure the LDAP server ACLs to accept writes from clients. For
     example:

          access to *
                  by dn.exact="uid=heimdal,dc=services,dc=example,dc=com" write
                  ...

          authz-regexp "gidNumber=.*\\\+uidNumber=0,cn=peercred,cn=external,cn=auth''
          	"uid=heimdal,dc=services,dc=example,dc=com"

     The sasl-regexp is for mapping between the SASL/EXTERNAL and a
     user in a tree.  The user that the key is mapped to should be have
     a krb5Principal aux object with krb5PrincipalName set so that the
     "creator" and "modifier" is right in `kadmin'.

     Another option is to create an admins group and add the dn to that
     group.

     If a non-local LDAP connection is used, the authz-regexp is not
     needed as Heimdal will bind to LDAP over the network using
     provided credentials.

     Since Heimdal talks to the LDAP server over a UNIX domain socket
     when configured for ldapi:///, and uses external sasl
     authentication, it's not possible to require security layer
     quality (ssf in cyrus-sasl lingo).  So that requirement has to be
     turned off in OpenLDAP `slapd' configuration file `slapd.conf'.

          sasl-secprops minssf=0

   *  Start `slapd' with the local listener (as well as the default
     TCP/IP listener on port 389) as follows:

              slapd -h "ldapi:/// ldap:///"

     Note: These is a bug in `slapd' where it appears to corrupt the
     krb5Key binary attribute on shutdown. This may be related to our
     use of the V3 schema definition syntax instead of the old
     UMich-style, V2 syntax.

   * You should specify the distinguished name under which your
     principals will be stored in `krb5.conf'. Also you need to enter
     the path to the kadmin acl file:

          [kdc]
          	# Optional configuration
          	hdb-ldap-structural-object = inetOrgPerson
          	hdb-ldap-url = ldapi:/// (default), ldap://hostname or ldaps://hostname
          	hdb-ldap-secret-file = /path/to/file/containing/ldap/credentials
          	hdb-ldap-start-tls = false

                  database = {
                          dbname = ldap:ou=KerberosPrincipals,dc=example,dc=com
                          acl_file = /path/to/kadmind.acl
                          mkey_file = /path/to/mkey
                  }

     `mkey_file' can be excluded if you feel that you trust your ldap
     directory to have the raw keys inside it.  The
     hdb-ldap-structural-object is not necessary if you do not need
     Samba comatibility.

     If connecting to a server over a non-local transport, the
     `hdb-ldap-url' and `hdb-ldap-secret-file' options must be
     provided. The `hdb-ldap-secret-file' must contain the bind
     credentials:

          [kdc]
          	hdb-ldap-bind-dn = uid=heimdal,dc=services,dc=example,dc=com
          	hdb-ldap-bind-password = secretBindPassword

     The `hdb-ldap-secret-file' and should be protected with appropriate
     file permissions

   * Once you have built Heimdal and started the LDAP server, run kadmin
     (as usual) to initialise the database. Note that the instructions
     for stashing a master key are as per any Heimdal installation.

          kdc# kadmin -l
          kadmin> init EXAMPLE.COM
          Realm max ticket life [unlimited]:
          Realm max renewable ticket life [unlimited]:
          kadmin> add lukeh
          Max ticket life [1 day]:
          Max renewable life [1 week]:
          Principal expiration time [never]:
          Password expiration time [never]:
          Attributes []:
          lukeh@EXAMPLE.COM's Password:
          Verifying password - lukeh@EXAMPLE.COM's Password:
          kadmin> exit

     Verify that the principal database has indeed been stored in the
     directory with the following command:

          kdc# ldapsearch -L -h localhost -D cn=manager \
           -w secret -b ou=KerberosPrincipals,dc=example,dc=com \
           'objectclass=krb5KDCEntry'

   * Now consider adding indexes to the database to speed up the
     access, at least theses should be added to slapd.conf.

          index	objectClass		eq
          index	cn			eq,sub,pres
          index	uid			eq,sub,pres
          index	displayName		eq,sub,pres
          index	krb5PrincipalName	eq


4.16.1 smbk5pwd overlay
-----------------------

The smbk5pwd overlay, updates the krb5Key and krb5KeyVersionNumber
appropriately when it receives an LDAP Password change Extended
Operation:

`http://www.openldap.org/devel/cvsweb.cgi/contrib/slapd-modules/smbk5pwd/README?hideattic=1&sortbydate=0'

4.16.2 Troubleshooting guide
----------------------------

`https://sec.miljovern.no/bin/view/Info/TroubleshootingGuide'

4.16.3 Using Samba LDAP password database
-----------------------------------------

The Samba domain and the Kerberos realm can have different names since
arcfour's string to key functions principal/realm independent.  So now
will be your first and only chance name your Kerberos realm without
needing to deal with old configuration files.

First, you should set up Samba and get that working with LDAP backend.

Now you can proceed as in *Note Using LDAP to store the database::.
Heimdal will pick up the Samba LDAP entries if they are in the same
search space as the Kerberos entries.


File: heimdal.info,  Node: Providing Kerberos credentials to servers and programs,  Next: Setting up PK-INIT,  Prev: Using LDAP to store the database,  Up: Setting up a realm

4.17 Providing Kerberos credentials to servers and programs
===========================================================

Some services require Kerberos credentials when they start to make
connections to other services or need to use them when they have
started.

The easiest way to get tickets for a service is to store the key in a
keytab. Both ktutil get and kadmin ext can be used to get a keytab.
ktutil get is better in that way it changes the key/password for the
user. This is also the problem with ktutil. If ktutil is used for the
same service principal on several hosts, they keytab will only be
useful on the last host. In that case, run the extract command on one
host and then securely copy the keytab around to all other hosts that
need it.

     host# ktutil -k /etc/krb5-service.keytab \
           get -p lha/admin@EXAMPLE.ORG service-principal@EXAMPLE.ORG
     lha/admin@EXAMPLE.ORG's Password:

To get a Kerberos credential file for the service, use kinit in the
`--keytab' mode. This will not ask for a password but instead fetch the
key from the keytab.

     service@host$ kinit --cache=/var/run/service_krb5_cache \
                    --keytab=/etc/krb5-service.keytab \
            service-principal@EXAMPLE.ORG

Long running services might need credentials longer then the expiration
time of the tickets. kinit can run in a mode that refreshes the tickets
before they expire. This is useful for services that write into AFS and
other distributed file systems using Kerberos. To run the long running
script, just append the program and arguments (if any) after the
principal. kinit will stop refreshing credentials and remove the
credentials when the script-to-start-service exits.

     service@host$ kinit --cache=/var/run/service_krb5_cache \
            --keytab=/etc/krb5-service.keytab \
            service-principal@EXAMPLE.ORG \
            script-to-start-service argument1 argument2


File: heimdal.info,  Node: Setting up PK-INIT,  Next: Debugging Kerberos problems,  Prev: Providing Kerberos credentials to servers and programs,  Up: Setting up a realm

4.18 Setting up PK-INIT
=======================

PK-INIT leverages an existing PKI (public key infrastructure), using
certificates to get the initial ticket (usually the krbtgt
ticket-granting ticket).

To use PK-INIT you must first have a PKI. If you don't have one, it is
time to create it. You should first read the whole current chapter of
the document to see the requirements imposed on the CA software.

A mapping between the PKI certificate and what principals that
certificate is allowed to use must exist. There are several ways to do
this. The administrator can use a configuration file, store the
principal in the SubjectAltName extension of the certificate, or store
the mapping in the principals entry in the kerberos database.

4.19 Certificates
=================

This and following subsection documents the requirements on the KDC and
client certificates and the format used in the id-pkinit-san OtherName
extension.

On how to create certificates, you should read *Note Use OpenSSL to
create certificates::.

4.19.1 KDC certificate
----------------------

The certificate for the KDC has several requirements.

First, the certificate should have an Extended Key Usage (EKU)
id-pkkdcekuoid (1.3.6.1.5.2.3.5) set. Second, there must be a
subjectAltName otherName using OID id-pkinit-san (1.3.6.1.5.2.2) in the
type field and a DER encoded KRB5PrincipalName that matches the name of
the TGS of the target realm.  Also, if the certificate has a
nameConstraints extension with a Generalname with dNSName or iPAdress,
it must match the hostname or adress of the KDC.

The client is not required by the standard to check the server
certificate for this information if the client has external information
confirming which certificate the KDC is supposed to be using. However,
adding this information to the KDC certificate removes the need to
specially configure the client to recognize the KDC certificate.

Remember that if the client would accept any certificate as the KDC's
certificate, the client could be fooled into trusting something that
isn't a KDC and thus expose the user to giving away information (like a
password or other private information) that it is supposed to keep
secret.

4.19.2 Client certificate
-------------------------

The client certificate may need to have a EKU id-pkekuoid
(1.3.6.1.5.2.3.4) set depending on the configuration on the KDC.

It possible to store the principal (if allowed by the KDC) in the
certificate and thus delegate responsibility to do the mapping between
certificates and principals to the CA.

This behavior is controlled by KDC configuration option:

     [kdc]
     	pkinit_principal_in_certificate = yes

4.19.2.1 Using KRB5PrincipalName in id-pkinit-san
.................................................

The OtherName extension in the GeneralName is used to do the mapping
between certificate and principal.  For the KDC certificate, this
stores the krbtgt principal name for that KDC.  For the client
certificate, this stores the principal for which that certificate is
allowed to get tickets.

The principal is stored in a SubjectAltName in the certificate using
OtherName. The OID in the type is id-pkinit-san.

     id-pkinit-san OBJECT IDENTIFIER ::= { iso (1) org (3) dod (6)
     internet (1) security (5) kerberosv5 (2) 2 }

The data part of the OtherName is filled with the following DER encoded
ASN.1 structure:

     KRB5PrincipalName ::= SEQUENCE {
     	realm [0] Realm,
     	principalName [1] PrincipalName
     }

where Realm and PrincipalName is defined by the Kerberos ASN.1
specification.

4.20 Naming certificate using hx509
===================================

hx509 is the X.509 software used in Heimdal to handle certificates.
hx509 supports several different syntaxes for specifying certificate
files or formats. Several formats may be used:  PEM, certificates
embedded in PKCS#12 files, certificates embedded in PKCS#11 devices,
and raw DER encoded certificates.

Those formats may be specified as follows:

DIR:
     DIR specifies a directory which contains certificates in the DER or
     PEM format.

     The main feature of DIR is that the directory is read on demand
     when iterating over certificates. This allows applications, in some
     situations, to avoid having to store all certificates in memory.
     It's very useful for tests that iterate over large numbers of
     certificates.

     The syntax is:

          DIR:/path/to/der/files

FILE:
     FILE: specifies a file that contains a certificate or private key.
     The file can be either a PEM (openssl) file or a raw DER encoded
     certificate. If it's a PEM file, it can contain several keys and
     certificates and the code will try to match the private key and
     certificate together. Multiple files may be specified, separated by
     commas.

     It's useful to have one PEM file that contains all the trust
     anchors.

     The syntax is:

          FILE:certificate.pem,private-key.key,other-cert.pem,....

PKCS11:
     PKCS11: is used to handle smartcards via PKCS#11 drivers, such as
     soft-token, opensc, or muscle. The argument specifies a shared
     object that implements the PKCS#11 API. The default is to use all
     slots on the device/token.

     The syntax is:

          PKCS11:shared-object.so

PKCS12:
     PKCS12: is used to handle PKCS#12 files. PKCS#12 files commonly
     have the extension pfx or p12.

     The syntax is:

          PKCS12:/path/to/file.pfx


4.21 Configure the Kerberos software
====================================

First configure the client's trust anchors and what parameters to
verify. See the subsections below for how to do that. Then, you can use
kinit to get yourself tickets. For example:

     $ kinit -C FILE:$HOME/.certs/lha.crt,$HOME/.certs/lha.key lha@EXAMPLE.ORG
     Enter your private key passphrase:
     : lha@nutcracker ; klist
     Credentials cache: FILE:/tmp/krb5cc_19100a
             Principal: lha@EXAMPLE.ORG

       Issued           Expires          Principal
     Apr 20 02:08:08  Apr 20 12:08:08  krbtgt/EXAMPLE.ORG@EXAMPLE.ORG

Using PKCS#11 it can look like this instead:

     $ kinit -C PKCS11:/usr/heimdal/lib/hx509.so lha@EXAMPLE.ORG
     PIN code for SoftToken (slot):
     $ klist
     Credentials cache: API:4
             Principal: lha@EXAMPLE.ORG

       Issued           Expires          Principal
     Mar 26 23:40:10  Mar 27 09:40:10  krbtgt/EXAMPLE.ORG@EXAMPLE.ORG

4.22 Configure the client
=========================

     [appdefaults]
     	pkinit_anchors = FILE:/path/to/trust-anchors.pem

     [realms]
             EXAMPLE.COM = {
     		pkinit_require_eku = true
     		pkinit_require_krbtgt_otherName = true
     		pkinit_win2k = no
     		pkinit_win2k_require_binding = yes
     	}

4.23 Configure the KDC
======================

Configuration options for the KDC.

enable-pkinit = bool
     Enable PKINIT for this KDC.

pkinit_identity = string
     Identity that the KDC will use when talking to clients. Mandatory.

pkinit_anchors = string
     Trust anchors that the KDC will use when evaluating the trust of
     the client certificate. Mandatory.

pkinit_pool = strings ...
     Extra certificate the KDC will use when building trust chains if it
     can't find enough certificates in the request from the client.

pkinit_allow_proxy_certificate = bool
     Allow clients to use proxy certificates. The root certificate of
     the client's End Entity certificate is used for authorisation.

pkinit_win2k_require_binding = bool
     Require windows clients up be upgrade to not allow cut and paste
     attack on encrypted data, applies to Windows XP and windows 2000
     servers.

pkinit_principal_in_certificate = bool
     Enable the KDC to use id-pkinit-san to determine to determine the
     mapping between a certificate and principal.


     [kdc]
     	enable-pkinit = yes
     	pkinit_identity = FILE:/secure/kdc.crt,/secure/kdc.key
     	pkinit_anchors = FILE:/path/to/trust-anchors.pem
     	pkinit_pool = PKCS12:/path/to/useful-intermediate-certs.pfx
     	pkinit_pool = FILE:/path/to/other-useful-intermediate-certs.pem
     	pkinit_allow_proxy_certificate = no
     	pkinit_win2k_require_binding = yes
     	pkinit_principal_in_certificate = no

4.23.1 Using pki-mapping file
-----------------------------

Note that the file contents are space sensitive.

     # cat /var/heimdal/pki-mapping
     # comments starts with #
     lha@EXAMPLE.ORG:C=SE,O=Stockholm universitet,CN=Love,UID=lha
     lha@EXAMPLE.ORG:CN=Love,UID=lha

4.23.2 Using the Kerberos database
----------------------------------

You can also store the subject of the certificate in the principal
entry in the kerberos database.

     kadmin modify --pkinit-acl="CN=baz,DC=test,DC=h5l,DC=se" user@REALM

4.24 Use hxtool to create certificates
======================================

4.24.1 Generate certificates
----------------------------

First, you need to generate a CA certificate. This example creates a CA
certificate that will be valid for 10 years.

You need to change -subject in the command below to something
appropriate for your site.

     hxtool issue-certificate \
         --self-signed \
         --issue-ca \
         --generate-key=rsa \
         --subject="CN=CA,DC=test,DC=h5l,DC=se" \
         --lifetime=10years \
         --certificate="FILE:ca.pem"

The KDC needs to have a certificate, so generate a certificate of the
type "pkinit-kdc" and set the PK-INIT specifial SubjectAltName to the
name of the krbtgt of the realm.

You need to change -subject and -pk-init-principal in the command below
to something appropriate for your site.

     hxtool issue-certificate \
         --ca-certificate=FILE:ca.pem \
         --generate-key=rsa \
         --type="pkinit-kdc" \
         --pk-init-principal="krbtgt/TEST.H5L.SE@TEST.H5L.SE" \
         --subject="uid=kdc,DC=test,DC=h5l,DC=se" \
         --certificate="FILE:kdc.pem"

The users also needs to have certificates. For your first client,
generate a certificate of type "pkinit-client". The client doesn't need
to have the PK-INIT SubjectAltName set; you can have the Subject DN in
the ACL file (pki-mapping) instead.

You need to change -subject and -pk-init-principal in the command below
to something appropriate for your site. You can omit -pk-init-principal
if you're going to use the ACL file instead.

     hxtool issue-certificate \
         --ca-certificate=FILE:ca.pem \
         --generate-key=rsa \
         --type="pkinit-client" \
         --pk-init-principal="lha@TEST.H5L.SE" \
         --subject="uid=lha,DC=test,DC=h5l,DC=se" \
         --certificate="FILE:user.pem"

4.24.2 Validate the certificate
-------------------------------

hxtool also contains a tool that will validate certificates according
to rules from the PKIX document. These checks are not complete, but
they provide a good test of whether you got all of the basic bits right
in your certificates.

     hxtool validate FILE:user.pem

4.25 Use OpenSSL to create certificates
=======================================

This section tries to give the CA owners hints how to create
certificates using OpenSSL (or CA software based on OpenSSL).

4.25.1 Using OpenSSL to create certificates with krb5PrincipalName
------------------------------------------------------------------

To make OpenSSL create certificates with krb5PrincipalName, use an
`openssl.cnf' as described below. To see a complete example of creating
client and KDC certificates, see the test-data generation script
`lib/hx509/data/gen-req.sh' in the source-tree. The certicates it
creates are used to test the PK-INIT functionality in
`tests/kdc/check-kdc.in'.

To use this example you have to use OpenSSL 0.9.8a or later.


     [user_certificate]
     subjectAltName=otherName:1.3.6.1.5.2.2;SEQUENCE:princ_name

     [princ_name]
     realm = EXP:0, GeneralString:MY.REALM
     principal_name = EXP:1, SEQUENCE:principal_seq

     [principal_seq]
     name_type = EXP:0, INTEGER:1
     name_string = EXP:1, SEQUENCE:principals

     [principals]
     princ1 = GeneralString:userid

Command usage:

     openssl x509 -extensions user_certificate
     openssl ca -extensions user_certificate

4.26 Using PK-INIT with Windows
===============================

4.26.1 Client configration
--------------------------

Clients using a Windows KDC with PK-INIT need configuration since
windows uses pre-standard format and this can't be autodetected.

The pkinit_win2k_require_binding option requires the reply for the KDC
to be of the new, secure, type that binds the request to reply. Before,
clients could fake the reply from the KDC. To use this option you have
to apply a fix from Microsoft.

     [realms]
             MY.MS.REALM = {
                     pkinit_win2k = yes
                     pkinit_win2k_require_binding = no
     	}

4.26.2 Certificates
-------------------

The client certificates need to have the extended keyusage "Microsoft
Smartcardlogin" (openssl has the OID shortname msSmartcardLogin).

See Microsoft Knowledge Base Article - 281245 "Guidelines for Enabling
Smart Card Logon with Third-Party Certification Authorities" for a more
extensive description of how set setup an external CA so that it
includes all the information required to make a Windows KDC happy.

4.26.3 Configure Windows 2000 CA
--------------------------------

To enable Microsoft Smartcardlogin for certificates in your Windows
2000 CA, you want to look at Microsoft Knowledge Base Article - 313274
"HOW TO: Configure a Certification Authority to Issue Smart Card
Certificates in Windows".


File: heimdal.info,  Node: Debugging Kerberos problems,  Prev: Setting up PK-INIT,  Up: Setting up a realm

4.27 Debugging Kerberos problems
================================

To debug Kerberos client and server problems you can enable debug
traceing by adding the following to `/etc/krb5,conf'. Note that the
trace logging is sparse at the moment, but will continue to improve.

     [logging]
             libkrb5 = 0-/SYSLOG:


File: heimdal.info,  Node: Applications,  Next: Things in search for a better place,  Prev: Setting up a realm,  Up: Top

5 Applications
**************

* Menu:

* Authentication modules::
* AFS::


File: heimdal.info,  Node: Authentication modules,  Next: AFS,  Prev: Applications,  Up: Applications

5.1 Authentication modules
==========================

The problem of having different authentication mechanisms has been
recognised by several vendors, and several solutions have appeared. In
most cases these solutions involve some kind of shared modules that are
loaded at run-time.  Modules for some of these systems can be found in
`lib/auth'.  Presently there are modules for Digital's SIA, and IRIX'
`login' and `xdm' (in `lib/auth/afskauthlib').

* Menu:

* Digital SIA::
* IRIX::


File: heimdal.info,  Node: Digital SIA,  Next: IRIX,  Prev: Authentication modules,  Up: Authentication modules

5.1.1 Digital SIA
-----------------

How to install the SIA module depends on which OS version you're
running. Tru64 5.0 has a new command, `siacfg', which makes this
process quite simple. If you have this program, you should just be able
to run:
     siacfg -a KRB5 /usr/athena/lib/libsia_krb5.so

On older versions, or if you want to do it by hand, you have to do the
following (not tested by us on Tru64 5.0):

   * Make sure `libsia_krb5.so' is available in `/usr/athena/lib'. If
     `/usr/athena' is not on local disk, you might want to put it in
     `/usr/shlib' or someplace else. If you do, you'll have to edit
     `krb5_matrix.conf' to reflect the new location (you will also have
     to do this if you installed in some other directory than
     `/usr/athena'). If you built with shared libraries, you will have
     to copy the shared `libkrb.so', `libdes.so', `libkadm.so', and
     `libkafs.so' to a place where the loader can find them (such as
     `/usr/shlib').

   * Copy (your possibly edited) `krb5_matrix.conf' to `/etc/sia'.

   * Apply `security.patch' to `/sbin/init.d/security'.

   * Turn on KRB5 security by issuing `rcmgr set SECURITY KRB5' and
     `rcmgr set KRB5_MATRIX_CONF krb5_matrix.conf'.

   * Digital thinks you should reboot your machine, but that really
     shouldn't be necessary.  It's usually sufficient just to run
     `/sbin/init.d/security start' (and restart any applications that
     use SIA, like `xdm'.)

Users with local passwords (like `root') should be able to login safely.

When using Digital's xdm the `KRB5CCNAME' environment variable isn't
passed along as it should (since xdm zaps the environment). Instead you
have to set `KRB5CCNAME' to the correct value in
`/usr/lib/X11/xdm/Xsession'. Add a line similar to
     KRB5CCNAME=FILE:/tmp/krb5cc`id -u`_`ps -o ppid= -p $$`; export KRB5CCNAME
If you use CDE, `dtlogin' allows you to specify which additional
environment variables it should export. To add `KRB5CCNAME' to this
list, edit `/usr/dt/config/Xconfig', and look for the definition of
`exportList'. You want to add something like:
     Dtlogin.exportList:     KRB5CCNAME

Notes to users with Enhanced security
.....................................

Digital's `ENHANCED' (C2) security, and Kerberos solve two different
problems. C2 deals with local security, adds better control of who can
do what, auditing, and similar things. Kerberos deals with network
security.

To make C2 security work with Kerberos you will have to do the
following.

   * Replace all occurrences of `krb5_matrix.conf' with
     `krb5+c2_matrix.conf' in the directions above.

   * You must enable "vouching" in the `default' database.  This will
     make the OSFC2 module trust other SIA modules, so you can login
     without giving your C2 password. To do this use `edauth' to edit
     the default entry `/usr/tcb/bin/edauth -dd default', and add a
     `d_accept_alternate_vouching' capability, if not already present.

   * For each user who does _not_ have a local C2 password, you should
     set the password expiration field to zero. You can do this for each
     user, or in the `default' table. To do this use `edauth' to set
     (or change) the `u_exp' capability to `u_exp#0'.

   * You also need to be aware that the shipped `login', `rcp', and
     `rshd', don't do any particular C2 magic (such as checking for
     various forms of disabled accounts), so if you rely on those
     features, you shouldn't use those programs. If you configure with
     `--enable-osfc2', these programs will, however, set the login UID.
     Still: use at your own risk.

At present `su' does not accept the vouching flag, so it will not work
as expected.

Also, kerberised ftp will not work with C2 passwords. You can solve this
by using both Digital's ftpd and our on different ports.

*Remember*, if you do these changes you will get a system that most
certainly does _not_ fulfil the requirements of a C2 system. If C2 is
what you want, for instance if someone else is forcing you to use it,
you're out of luck.  If you use enhanced security because you want a
system that is more secure than it would otherwise be, you probably got
an even more secure system. Passwords will not be sent in the clear,
for instance.


File: heimdal.info,  Node: IRIX,  Prev: Digital SIA,  Up: Authentication modules

5.1.2 IRIX
----------

The IRIX support is a module that is compatible with Transarc's
`afskauthlib.so'.  It should work with all programs that use this
library. This should include `login' and `xdm'.

The interface is not very documented but it seems that you have to copy
`libkafs.so', `libkrb.so', and `libdes.so' to `/usr/lib', or build your
`afskauthlib.so' statically.

The `afskauthlib.so' itself is able to reside in `/usr/vice/etc',
`/usr/afsws/lib', or the current directory (wherever that is).

IRIX 6.4 and newer seem to have all programs (including `xdm' and
`login') in the N32 object format, whereas in older versions they were
O32. For it to work, the `afskauthlib.so' library has to be in the same
object format as the program that tries to load it. This might require
that you have to configure and build for O32 in addition to the default
N32.

Apart from this it should "just work"; there are no configuration files.

Note that recent Irix 6.5 versions (at least 6.5.22) have PAM,
including a `pam_krb5.so' module.  Not all relevant programs use PAM,
though, e.g. `ssh'. In particular, for console graphical login you need
to turn off `visuallogin' and turn on `xdm' with `chkconfig'.


File: heimdal.info,  Node: AFS,  Prev: Authentication modules,  Up: Applications

5.2 AFS
=======

AFS is a distributed filesystem that uses Kerberos for authentication.

For more information about AFS see OpenAFS `http://www.openafs.org/'
and Arla `http://www.stacken.kth.se/projekt/arla/'.

5.2.1 kafs and afslog
---------------------

`afslog(1)' will obtains AFS tokens for a number of cells. What cells
to get tokens for can either be specified as an explicit list, as file
paths to get tokens for, or be left unspecified, in which case will use
whatever magic `kafs(3)' decides upon.

If not told what cell to get credentials for, `kafs(3)' will search for
the files ThisCell and TheseCells in the locations specified in
`kafs(3)' and try to get tokens for these cells and the cells specified
in $HOME/.TheseCells.

More usefully it will look at and ~/.TheseCells in your home directory
and for each line which is a cell get afs token for these cells.

The TheseCells file defines the the cells to which applications on the
local client machine should try to aquire tokens for. It must reside in
the directories searched by `kafs(3)' on every AFS client machine.

The file is in ASCII format and contains one character string, the cell
name, per line. Cell names are case sensitive, but most cell names are
lower case.

See manpage for `kafs(3)' for search locations of ThisCell and
TheseCells.

5.2.2 How to get a KeyFile
--------------------------

`ktutil -k AFSKEYFILE:KeyFile get afs@MY.REALM'

or you can extract it with kadmin

     kadmin> ext -k AFSKEYFILE:/usr/afs/etc/KeyFile afs@My.CELL.NAME

You have to make sure you have a `des-cbc-md5' encryption type since
that is the enctype that will be converted.

5.2.3 How to convert a srvtab to a KeyFile
------------------------------------------

You need a `/usr/vice/etc/ThisCell' containing the cellname of your
AFS-cell.

`ktutil copy krb4:/root/afs-srvtab AFSKEYFILE:/usr/afs/etc/KeyFile'.

If keyfile already exists, this will add the new key in afs-srvtab to
KeyFile.

5.3 Using 2b tokens with AFS
============================

5.3.1 What is 2b ?
------------------

2b is the name of the proposal that was implemented to give basic
Kerberos 5 support to AFS in rxkad. It's not real Kerberos 5 support
since it still uses fcrypt for data encryption and not Kerberos
encryption types.

Its only possible (in all cases) to do this for DES encryption types
because only then the token (the AFS equivalent of a ticket) will be
smaller than the maximum size that can fit in the token cache in the
OpenAFS/Transarc client. It is a so tight fit that some extra wrapping
on the ASN1/DER encoding is removed from the Kerberos ticket.

2b uses a Kerberos 5 EncTicketPart instead of a Kerberos 4 ditto for
the part of the ticket that is encrypted with the service's key. The
client doesn't know what's inside the encrypted data so to the client
it doesn't matter.

To  differentiate between Kerberos 4 tickets and Kerberos 5 tickets, 2b
uses a special kvno, 213 for 2b tokens and 255 for Kerberos 5 tokens.

Its a requirement that all AFS servers that support 2b also support
native Kerberos 5 in rxkad.

5.3.2 Configuring a Heimdal kdc to use 2b tokens
------------------------------------------------

Support for 2b tokens in the kdc are turned on for specific principals
by adding them to the string list option `[kdc]use_2b' in the kdc's
`krb5.conf' file.

     [kdc]
     	use_2b = {
     		afs@SU.SE = yes
     		afs/it.su.se@SU.SE = yes
     	}

5.3.3 Configuring AFS clients for 2b support
--------------------------------------------

There is no need to configure AFS clients for 2b support. The only
software that needs to be installed/upgrade is a Kerberos 5 enabled
`afslog'.


File: heimdal.info,  Node: Things in search for a better place,  Next: Kerberos 4 issues,  Prev: Applications,  Up: Top

6 Things in search for a better place
*************************************

6.1 Making things work on Ciscos
================================

Modern versions of Cisco IOS has some support for authenticating via
Kerberos 5. This can be used both by having the router get a ticket when
you login (boring), and by using Kerberos authenticated telnet to access
your router (less boring). The following has been tested on IOS
11.2(12), things might be different with other versions. Old versions
are known to have bugs.

To make this work, you will first have to configure your router to use
Kerberos (this is explained in the documentation). A sample
configuration looks like the following:

     aaa new-model
     aaa authentication login default krb5-telnet krb5 enable
     aaa authorization exec krb5-instance
     kerberos local-realm FOO.SE
     kerberos srvtab entry host/router.foo.se 0 891725446 4 1 8 012345678901234567
     kerberos server FOO.SE 10.0.0.1
     kerberos instance map admin 15

This tells you (among other things) that when logging in, the router
should try to authenticate with kerberised telnet, and if that fails try
to verify a plain text password via a Kerberos ticket exchange (as
opposed to a local database, RADIUS or something similar), and if that
fails try the local enable password. If you're not careful when you
specify the `login default' authentication mechanism, you might not be
able to login at all. The `instance map' and `authorization exec' lines
says that people with `admin' instances should be given `enabled' shells
when logging in.

The numbers after the principal on the `srvtab' line are principal type,
time stamp (in seconds since 1970), key version number (4), keytype (1
== des), key length (always 8 with des), and then the key.

To make the Heimdal KDC produce tickets that the Cisco can decode you
might have to turn on the `encode_as_rep_as_tgs_rep' flag in the KDC.
You will also have to specify that the router can't handle anything but
`des-cbc-crc'. This can be done with the `del_enctype' command of
`kadmin'.

This all fine and so, but unless you have an IOS version with encryption
(available only in the U.S) it doesn't really solve any problems. Sure
you don't have to send your password over the wire, but since the telnet
connection isn't protected it's still possible for someone to steal your
session. This won't be fixed until someone adds integrity to the telnet
protocol.

A working solution would be to hook up a machine with a real operating
system to the console of the Cisco and then use it as a backwards
terminal server.


File: heimdal.info,  Node: Kerberos 4 issues,  Next: Windows compatibility,  Prev: Things in search for a better place,  Up: Top

7 Kerberos 4 issues
*******************

Kerberos 4 KDC and KA server have been moved.

For more about AFS, see the section *Note AFS::.

* Menu:

* Principal conversion issues::
* Converting a version 4 database::


File: heimdal.info,  Node: Principal conversion issues,  Next: Converting a version 4 database,  Prev: Kerberos 4 issues,  Up: Kerberos 4 issues

7.1 Principal conversion issues
===============================

First, Kerberos 4 and Kerberos 5 principals are different. A version 4
principal consists of a name, an instance, and a realm. A version 5
principal has one or more components, and a realm (the terms "name" and
"instance" are still used, for the first and second component,
respectively).    Also, in some cases the name of a version 4 principal
differs from the first component of the corresponding version 5
principal. One notable example is the "host" type principals, where the
version 4 name is `rcmd' (for "remote command"), and the version 5 name
is `host'. For the class of principals that has a hostname as instance,
there is an other major difference, Kerberos 4 uses only the first
component of the hostname, whereas Kerberos 5 uses the fully qualified
hostname.

Because of this it can be hard or impossible to correctly convert a
version 4 principal to a version 5 principal (1). The biggest problem is
to know if the conversion resulted in a valid principal. To give an
example, suppose you want to convert the principal `rcmd.foo'.

The `rcmd' name suggests that the instance is a hostname (even if there
are exceptions to this rule). To correctly convert the instance `foo'
to a hostname, you have to know which host it is referring to. You can
to this by either guessing (from the realm) which domain name to
append, or you have to have a list of possible hostnames. In the
simplest cases you can cover most principals with the first rule. If you
have several domains sharing a single realm this will not usually work.
If the exceptions are few you can probably come by with a lookup table
for the exceptions.

In a complex scenario you will need some kind of host lookup mechanism.
Using DNS for this is tempting, but DNS is error prone, slow and unsafe
(2).

Fortunately, the KDC has a trump on hand: it can easily tell if a
principal exists in the database. The KDC will use
`krb5_425_conv_principal_ext' to convert principals when handling to
version 4 requests.

---------- Footnotes ----------

(1) the other way is not always trivial either, but usually easier

(2) at least until secure DNS is commonly available


File: heimdal.info,  Node: Converting a version 4 database,  Prev: Principal conversion issues,  Up: Kerberos 4 issues

7.2 Converting a version 4 database
===================================

If you want to convert an existing version 4 database, the principal
conversion issue arises too.

If you decide to convert your database once and for all, you will only
have to do this conversion once. It is also possible to run a version 5
KDC as a slave to a version 4 KDC. In this case this conversion will
happen every time the database is propagated.  When doing this
conversion, there are a few things to look out for. If you have stale
entries in the database, these entries will not be converted. This might
be because these principals are not used anymore, or it might be just
because the principal couldn't be converted.

You might also see problems with a many-to-one mapping of principals.
For instance, if you are using DNS lookups and you have two principals
`rcmd.foo' and `rcmd.bar', where `foo' is a CNAME for `bar', the
resulting principals will be the same. Since the conversion function
can't tell which is correct, these conflicts will have to be resolved
manually.

7.2.1 Conversion example
------------------------

Given the following set of hosts and services:

     foo.se          rcmd
     mail.foo.se     rcmd, pop
     ftp.bar.se      rcmd, ftp

you have a database that consists of the following principals:

`rcmd.foo', `rcmd.mail', `pop.mail', `rcmd.ftp', and `ftp.ftp'.

lets say you also got these extra principals: `rcmd.gone',
`rcmd.old-mail', where `gone.foo.se' was a machine that has now passed
away, and `old-mail.foo.se' was an old mail machine that is now a CNAME
for `mail.foo.se'.

When you convert this database you want the following conversions to be
done:
     rcmd.foo         host/foo.se
     rcmd.mail        host/mail.foo.se
     pop.mail         pop/mail.foo.se
     rcmd.ftp         host/ftp.bar.se
     ftp.ftp          ftp/ftp.bar.se
     rcmd.gone        removed
     rcmd.old-mail    removed

A `krb5.conf' that does this looks like:

     [realms]
             FOO.SE = {
                     v4_name_convert = {
                             host = {
                                     ftp = ftp
                                     pop = pop
                                     rcmd = host
                             }
                     }
                     v4_instance_convert = {
                             foo = foo.se
                             ftp = ftp.bar.se
                     }
                     default_domain = foo.se
             }

The `v4_name_convert' section says which names should be considered
having an instance consisting of a hostname, and it also says how the
names should be converted (for instance `rcmd' should be converted to
`host'). The `v4_instance_convert' section says how a hostname should
be qualified (this is just a hosts-file in disguise). Host-instances
that aren't covered by `v4_instance_convert' are qualified by appending
the contents of the `default_domain'.

Actually, this example doesn't work. Or rather, it works to well. Since
it has no way of knowing which hostnames are valid and which are not, it
will happily convert `rcmd.gone' to `host/gone.foo.se'. This isn't a
big problem, but if you have run your kerberos realm for a few years,
chances are big that you have quite a few `junk' principals.

If you don't want this you can remove the `default_domain' statement,
but then you will have to add entries for _all_ your hosts in the
`v4_instance_convert' section.

Instead of doing this you can use DNS to convert instances. This is not
a solution without problems, but it is probably easier than adding lots
of static host entries.

To enable DNS lookup you should turn on `v4_instance_resolve' in the
`[libdefaults]' section.

7.2.2 Converting a database
---------------------------

The database conversion is done with `hprop'. You can run this command
to propagate the database to the machine called `slave-server' (which
should be running a `hpropd').

     hprop --source=krb4-db --master-key=/.m slave-server

This command can also be to use for converting the v4 database on the
server:

     hprop -n --source=krb4-db -d /var/kerberos/principal --master-key=/.m | hpropd -n


File: heimdal.info,  Node: Windows compatibility,  Next: Programming with Kerberos,  Prev: Kerberos 4 issues,  Up: Top

8 Windows compatibility
***********************

Microsoft Windows, starting from version 2000 (formerly known as
Windows NT 5), implements Kerberos 5. Their implementation, however,
has some quirks, peculiarities, and bugs. This chapter is a short
summary of the compatibility issues between Heimdal and various Windows
versions.

The big problem with the Kerberos implementation in Windows is that the
available documentation is more focused on getting things to work
rather than how they work, and not that useful in figuring out how
things really work. It's of course subject to change all the time and
mostly consists of our not so inspired guesses.  Hopefully it's still
somewhat useful.

* Menu:

* Configuring Windows to use a Heimdal KDC::
* Inter-Realm keys (trust) between Windows and a Heimdal KDC::
* Create account mappings::
* Encryption types::
* Authorisation data::
* Quirks of Windows 2000 KDC::
* Useful links when reading about the Windows::


File: heimdal.info,  Node: Configuring Windows to use a Heimdal KDC,  Next: Inter-Realm keys (trust) between Windows and a Heimdal KDC,  Prev: Windows compatibility,  Up: Windows compatibility

8.1 Configuring Windows to use a Heimdal KDC
============================================

You need the command line program called `ksetup.exe'. This program
comes with the Windows Support Tools, available from either the
installation CD-ROM (`SUPPORT/TOOLS/SUPPORT.CAB'), or from Microsoft
web site. Starting from Windows 2008, it is already installed. This
program is used to configure the Kerberos settings on a Workstation.

`Ksetup' store the domain information under the registry key:
`HKEY_LOCAL_MACHINE\System\CurrentControlSet\Control\LSA\Kerberos\Domains'.

Use the `kadmin' program in Heimdal to create a host principal in the
Kerberos realm.

     unix% kadmin
     kadmin> ank --password=password host/datan.example.com

The name `datan.example.com' should be replaced with DNS name of the
workstation.

You must configure the workstation as a member of a workgroup, as
opposed to a member in an NT domain, and specify the KDC server of the
realm as follows:
     C:> ksetup /setdomain EXAMPLE.COM
     C:> ksetup /addkdc EXAMPLE.COM kdc.example.com

Set the machine password, i.e. create the local keytab:
     C:> ksetup /SetComputerPassword password

The password used in `ksetup /setmachpassword' must be the same as the
password used in the `kadmin ank' command.

The workstation must now be rebooted.

A mapping between local NT users and Kerberos principals must be
specified.  You have two choices. First:

     C:> ksetup /mapuser user@MY.REALM nt_user

This will map a user to a specific principal; this allows you to have
other usernames in the realm than in your NT user database. (Don't ask
me why on earth you would want that....)

You can also say:
     C:> ksetup /mapuser * *
The Windows machine will now map any user to the corresponding
principal, for example `nisse' to the principal `nisse@MY.REALM'.
(This is most likely what you want.)


File: heimdal.info,  Node: Inter-Realm keys (trust) between Windows and a Heimdal KDC,  Next: Create account mappings,  Prev: Configuring Windows to use a Heimdal KDC,  Up: Windows compatibility

8.2 Inter-Realm keys (trust) between Windows and a Heimdal KDC
==============================================================

See also the Step-by-Step guide from Microsoft, referenced below.

Install Windows, and create a new controller (Active Directory Server)
for the domain.

By default the trust will be non-transitive. This means that only users
directly from the trusted domain may authenticate. This can be changed
to transitive by using the `netdom.exe' tool. `netdom.exe' can also be
used to add the trust between two realms.

You need to tell Windows on what hosts to find the KDCs for the
non-Windows realm with `ksetup', see *Note Configuring Windows to use a
Heimdal KDC::.

This needs to be done on all computers that want enable cross-realm
login with `Mapped Names'.  Then you need to add the inter-realm keys
on the Windows KDC. Start the Domain Tree Management tool (found in
Programs, Administrative tools, Active Directory Domains and Trusts).

Right click on Properties of your domain, select the Trust tab.  Press
Add on the appropriate trust windows and enter domain name and
password. When prompted if this is a non-Windows Kerberos realm, press
OK.

Do not forget to add trusts in both directions (if that's what you
want).

If you want to use `netdom.exe' instead of the Domain Tree Management
tool, you do it like this:

     netdom trust NT.REALM.EXAMPLE.COM /Domain:EXAMPLE.COM /add /realm /passwordt:TrustPassword

You also need to add the inter-realm keys to the Heimdal KDC. But take
care to the encryption types and salting used for those keys. There
should be no encryption type stronger than the one configured on
Windows side for this relationship, itself limited to the ones
supported by this specific version of Windows, nor any Kerberos 4
salted hashes, as Windows does not seem to understand them. Otherwise,
the trust will not works.

Here are the version-specific needed information:
  1. Windows 2000: maximum encryption type is DES

  2. Windows 2003: maximum encryption type is DES

  3. Windows 2003RC2: maximum encryption type is RC4, relationship
     defaults to DES

  4. Windows 2008: maximum encryption type is AES, relationship
     defaults to RC4

For Windows 2003RC2, to change the trust encryption type, you have to
use the `ktpass', from the Windows 2003 Resource kit *service pack2*,
available from Microsoft web site.

     C:> ktpass /MITRealmName UNIX.EXAMPLE.COM /TrustEncryp RC4

For Windows 2008, the same operation can be done with the `ksetup',
installed by default.

     C:> ksetup /SetEncTypeAttre EXAMPLE.COM AES256-SHA1

Once the relationship is correctly configured, you can add the required
inter-realm keys, using heimdal default encryption types:

     kadmin add krbtgt/NT.REALM.EXAMPLE.COM@EXAMPLE.COM
     kadmin add krbtgt/REALM.EXAMPLE.COM@NT.EXAMPLE.COM

Use the same passwords for both keys.

And if needed, to remove unsupported encryptions, such as the following
ones for a Windows 2003RC2 server.

     kadmin del_enctype krbtgt/REALM.EXAMPLE.COM@NT.EXAMPLE.COM aes256-cts-hmac-sha1-96
     kadmin del_enctype krbtgt/REALM.EXAMPLE.COM@NT.EXAMPLE.COM des3-cbc-sha1
     kadmin del_enctype krbtgt/NT.EXAMPLE.COM@EXAMPLE.COM aes256-cts-hmac-sha1-96
     kadmin del_enctype krbtgt/NT.EXAMPLE.COM@EXAMPLE.COM des3-cbc-sha1

Do not forget to reboot before trying the new realm-trust (after
running `ksetup'). It looks like it might work, but packets are never
sent to the non-Windows KDC.


File: heimdal.info,  Node: Create account mappings,  Next: Encryption types,  Prev: Inter-Realm keys (trust) between Windows and a Heimdal KDC,  Up: Windows compatibility

8.3 Create account mappings
===========================

Start the `Active Directory Users and Computers' tool. Select the View
menu, that is in the left corner just below the real menu (or press
Alt-V), and select Advanced Features. Right click on the user that you
are going to do a name mapping for and choose Name mapping.

Click on the Kerberos Names tab and add a new principal from the
non-Windows domain.

This adds `authorizationNames' entry to the users LDAP entry to the
Active Directory LDAP catalog. When you create users by script you can
add this entry instead.


File: heimdal.info,  Node: Encryption types,  Next: Authorisation data,  Prev: Create account mappings,  Up: Windows compatibility

8.4 Encryption types
====================

Windows 2000 supports both the standard DES encryptions (`des-cbc-crc'
and `des-cbc-md5') and its own proprietary encryption that is based on
MD4 and RC4 that is documented in and is supposed to be described in
`draft-brezak-win2k-krb-rc4-hmac-03.txt'.  New users will get both MD4
and DES keys.  Users that are converted from a NT4 database, will only
have MD4 passwords and will need a password change to get a DES key.


File: heimdal.info,  Node: Authorisation data,  Next: Quirks of Windows 2000 KDC,  Prev: Encryption types,  Up: Windows compatibility

8.5 Authorisation data
======================

The Windows 2000 KDC also adds extra authorisation data in tickets.  It
is at this point unclear what triggers it to do this.  The format of
this data is only available under a "secret" license from Microsoft,
which prohibits you implementing it.

A simple way of getting hold of the data to be able to understand it
better is described here.

  1. Find the client example on using the SSPI in the SDK documentation.

  2. Change "AuthSamp" in the source code to lowercase.

  3. Build the program.

  4. Add the "authsamp" principal with a known password to the
     database.  Make sure it has a DES key.

  5. Run `ktutil add' to add the key for that principal to a keytab.

  6. Run `appl/test/nt_gss_server -p 2000 -s authsamp --dump-auth=FILE'
     where FILE is an appropriate file.

  7. It should authenticate and dump for you the authorisation data in
     the file.

  8. The tool `lib/asn1/asn1_print' is somewhat useful for analysing
     the data.


File: heimdal.info,  Node: Quirks of Windows 2000 KDC,  Next: Useful links when reading about the Windows,  Prev: Authorisation data,  Up: Windows compatibility

8.6 Quirks of Windows 2000 KDC
==============================

There are some issues with salts and Windows 2000.  Using an empty
salt--which is the only one that Kerberos 4 supported, and is therefore
known as a Kerberos 4 compatible salt--does not work, as far as we can
tell from out experiments and users' reports.  Therefore, you have to
make sure you keep around keys with all the different types of salts
that are required.  Microsoft have fixed this issue post Windows 2003.

Microsoft seems also to have forgotten to implement the checksum
algorithms `rsa-md4-des' and `rsa-md5-des'. This can make Name mapping
(*note Create account mappings::) fail if a `des-cbc-md5' key is used.
To make the KDC return only `des-cbc-crc' you must delete the
`des-cbc-md5' key from the kdc using the `kadmin del_enctype' command.

     kadmin del_enctype lha des-cbc-md5

You should also add the following entries to the `krb5.conf' file:

     [libdefaults]
     	default_etypes = des-cbc-crc
     	default_etypes_des = des-cbc-crc

These configuration options will make sure that no checksums of the
unsupported types are generated.


File: heimdal.info,  Node: Useful links when reading about the Windows,  Prev: Quirks of Windows 2000 KDC,  Up: Windows compatibility

8.7 Useful links when reading about the Windows
===============================================

See also our paper presented at the 2001 Usenix Annual Technical
Conference, available in the proceedings or at
`http://www.usenix.org/publications/library/proceedings/usenix01/freenix01/westerlund.html'.

There are lots of texts about Kerberos on Microsoft's web site, here is
a short list of the interesting documents that we have managed to find.

   * Step-by-Step Guide to Kerberos 5 (krb5 1.0) Interoperability:
     `http://www.microsoft.com/technet/prodtechnol/windows2000serv/howto/kerbstep.mspx'.
     Kerberos GSS-API (in Windows-eze SSPI), Windows as a client in a
     non-Windows KDC realm, adding unix clients to a Windows 2000 KDC,
     and adding cross-realm trust (*note Inter-Realm keys (trust)
     between Windows and a Heimdal KDC::).

   * Windows 2000 Kerberos Authentication:
     `www.microsoft.com/technet/prodtechnol/windows2000serv/deploy/confeat/kerberos.mspx'.
     White paper that describes how Kerberos is used in Windows 2000.

   * Overview of Kerberos:
     `http://support.microsoft.com/support/kb/articles/Q248/7/58.ASP'.
     Links to useful other links.

   * Event logging for Kerberos:
     `http://support.microsoft.com/support/kb/articles/Q262/1/77.ASP'.
     Basically it say that you can add a registry key
     `HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Lsa\Kerberos\Parameters\LogLevel'
     with value DWORD equal to 1, and then you'll get logging in the
     Event Logger.


Other useful programs include these:

   * pwdump2
     `http://www.bindview.com/Support/RAZOR/Utilities/Windows/pwdump2_readme.cfm'


File: heimdal.info,  Node: Programming with Kerberos,  Next: Migration,  Prev: Windows compatibility,  Up: Top

9 Programming with Kerberos
***************************

See the Kerberos 5 API introduction and documentation on the Heimdal
webpage.


File: heimdal.info,  Node: Migration,  Next: Acknowledgments,  Prev: Programming with Kerberos,  Up: Top

10 Migration
************

10.1 Migration from MIT Kerberos to Heimdal
===========================================

hpropd can read MIT Kerberos dump in "kdb5_util load_dump version 5" or
version 6 format.  Simply run: `kdb5_util dump'.

To load the MIT Kerberos dump file, use the following command:

`/usr/heimdal/libexec/hprop --database=dump-file
--master-key=/var/db/krb5kdc/mit_stash --source=mit-dump --decrypt
--stdout | /usr/heimdal/libexec/hpropd --stdin'

kadmin can dump in MIT Kerberos format.  Simply run: `kadmin -l dump -f
MIT'.

The Heimdal KDC and kadmind, as well as kadmin -l and the libkadm5srv
library can read and write MIT KDBs, and can read MIT stash files.  To
build with KDB support requires having a standalone libdb from MIT
Kerberos and associated headers, then you can configure Heildal as
follows:

`./configure ... CPPFLAGS=-I/path-to-mit-db-headers
LDFLAGS="-L/path-to-mit-db-object -Wl,-rpath
-Wl,/path-to-mit-db-object" LDLIBS=-ldb'

At this time support for MIT Kerberos KDB dump/load format and direct
KDB access does not include support for PKINIT, or K/M key history,
constrained delegation, and other advanced features.

Heimdal supports using multiple HDBs at once, with all write going to
just one HDB.  This allows for entries to be moved to a native HDB from
an MIT KDB over time as those entries are changed.  Or you can use hprop
and hpropd.

10.2 General issues
===================

When migrating from a Kerberos 4 KDC.

10.3 Order in what to do things:
================================

   * Convert the database, check all principals that hprop complains
     about.

     `hprop -n --source=<NNN>| hpropd -n'

     Replace <NNN> with whatever source you have, like krb4-db or
     krb4-dump.

   * Run a Kerberos 5 slave for a while.

   * Figure out if it does everything you want it to.

     Make sure that all things that you use works for you.

   * Let a small number of controlled users use Kerberos 5 tools.

     Find a sample population of your users and check what programs
     they use, you can also check the kdc-log to check what ticket are
     checked out.

   * Burn the bridge and change the master.

   * Let all users use the Kerberos 5 tools by default.

   * Turn off services that do not need Kerberos 4 authentication.

     Things that might be hard to get away is old programs with support
     for Kerberos 4. Example applications are old Eudora installations
     using KPOP, and Zephyr. Eudora can use the Kerberos 4 kerberos in
     the Heimdal kdc.



File: heimdal.info,  Node: Acknowledgments,  Next: Copyrights and Licenses,  Prev: Migration,  Up: Top

Appendix A Acknowledgments
**************************

Eric Young wrote "libdes". Heimdal used to use libdes, without it
kth-krb would never have existed. Since there are no longer any Eric
Young code left in the library, we renamed it to libhcrypto.

All functions in libhcrypto have been re-implemented or used available
public domain code. The core AES function where written by Vincent
Rijmen, Antoon Bosselaers and Paulo Barreto.  The core DES SBOX
transformation was written by Richard Outerbridge. `imath' that is used
for public key crypto support is written by Michael J. Fromberger.

The University of California at Berkeley initially wrote `telnet', and
`telnetd'.  The authentication and encryption code of `telnet' and
`telnetd' was added by David Borman (then of Cray Research, Inc).  The
encryption code was removed when this was exported and then added back
by Juha Eskelinen.

The `popper' was also a Berkeley program initially.

Some of the functions in `libroken' also come from Berkeley by way of
NetBSD/FreeBSD.

`editline' was written by Simmule Turner and Rich Salz. Heimdal
contains a modifed copy.

The `getifaddrs' implementation for Linux was written by Hideaki
YOSHIFUJI for the Usagi project.

The `pkcs11.h' headerfile was written by the Scute project.

Bugfixes, documentation, encouragement, and code has been contributed
by:
Alexander Boström

Allan McRae

Andrew Bartlett

Andrew Cobaugh

Andrew Tridge

Anton Lundin

Asanka Herath

Björn Grönvall

Björn Sandell

Björn Schlögl

Brandon S. Allbery KF8NH

Brian A May

Buck Huppmann

Cacdric Schieli

Chaskiel M Grundman

Christos Zoulas

Cizzi Storm

Daniel Kouril

David Love

David Markey

David R Boldt

Derrick J Brashear

Donald Norwood

Douglas E Engert

Frank van der Linden

Gabor Gombas

Guido Günther

Guillaume Rousse

Harald Barth

Ingo Schwarze

Jacques A. Vidrine

Jaideep Padhye

Jan Rekorajski

Jason McIntyre

Jeffrey Altman

Jelmer Vernooij

Joerg Pulz

Johan Danielsson

Johan Gadsjö

Johan Ihrén

John Center

Julian Ospald

Jun-ichiro itojun Hagino

KAMADA Ken'ichi

Kamen Mazdrashki

Karolin Seeger

Ken Hornstein

Love Hörnquist Åstrand

Luke Howard

Magnus Ahltorp

Magnus Holmberg

Marc Horowitz

Mario Strasser

Mark Eichin

Martin von Gagern

Matthias Dieter Wallnöfer

Matthieu Patou

Mattias Amnefelt

Michael B Allen

Michael Fromberger

Michal Vocu

Milosz Kmieciak

Miroslav Ruda

Mustafa A. Hashmi

Nicolas Williams

Patrik Lundin

Petr Holub

Phil Fisher

Rafal Malinowski

Ragnar Sundblad

Rainer Toebbicke

Richard Nyberg

Roland C. Dowdeswell

Roman Divacky

Russ Allbery

Sho Hosoda, 細田 将

Simon Wilkinson

Stefan Metzmacher

Ted Percival

Timothy Pearson

Tom Payerle

Victor Guerra

Zeqing Xia

Åke Sandgren

and we hope that those not mentioned here will forgive us.

All bugs were introduced by ourselves.


File: heimdal.info,  Node: Copyrights and Licenses,  Prev: Acknowledgments,  Up: Top

Appendix B Copyrights and Licenses
**********************************

Kungliga Tekniska Högskolan
============================



Copyright (c) 1997-2011 Kungliga Tekniska Högskolan
(Royal Institute of Technology, Stockholm, Sweden).
All rights reserved.

Portions Copyright (c) 2009 Apple Inc. All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

3. Neither the name of the Institute nor the names of its contributors
   may be used to endorse or promote products derived from this software
   without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

Massachusetts Institute of Technology
=====================================

The parts of the libtelnet that handle Kerberos.



Copyright (C) 1990 by the Massachusetts Institute of Technology

Export of this software from the United States of America may
require a specific license from the United States Government.
It is the responsibility of any person or organization contemplating
export to obtain such a license before exporting.

WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
distribute this software and its documentation for any purpose and
without fee is hereby granted, provided that the above copyright
notice appear in all copies and that both that copyright notice and
this permission notice appear in supporting documentation, and that
the name of M.I.T. not be used in advertising or publicity pertaining
to distribution of the software without specific, written prior
permission.  M.I.T. makes no representations about the suitability of
this software for any purpose.  It is provided "as is" without express
or implied warranty.

The Regents of the University of California
===========================================

The parts of the libroken, most of libtelnet, telnet, ftp, and popper.



Copyright (c) 1988, 1990, 1993
     The Regents of the University of California.  All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

3. Neither the name of the University nor the names of its contributors
   may be used to endorse or promote products derived from this software
   without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

The Regents of the University of California.
============================================

libedit



Copyright (c) 1992, 1993
 The Regents of the University of California.  All rights reserved.

This code is derived from software contributed to Berkeley by
Christos Zoulas of Cornell University.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.
3. Neither the name of the University nor the names of its contributors
   may be used to endorse or promote products derived from this software
   without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

TomsFastMath / LibTomMath
=========================

Tom's fast math (bignum support) and LibTomMath



LibTomMath is hereby released into the Public Domain.

Doug Rabson
===========

GSS-API mechglue layer.



Copyright (c) 2005 Doug Rabson
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

PADL Software Pty Ltd
=====================

GSS-API CFX, SPNEGO, naming extensions, API extensions.

KCM credential cache.

HDB LDAP backend.



Copyright (c) 2003-2011, PADL Software Pty Ltd.
Copyright (c) 2004, Andrew Bartlett.
Copyright (c) 2003 - 2008, Kungliga Tekniska Högskolan
Copyright (c) 2015, Timothy Pearson.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.

2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

3. Neither the name of PADL Software nor the names of its contributors
   may be used to endorse or promote products derived from this software
   without specific prior written permission.

THIS SOFTWARE IS PROVIDED BY PADL SOFTWARE AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.  IN NO EVENT SHALL PADL SOFTWARE OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

Marko Kreen
===========

Fortuna in libhcrypto



Copyright (c) 2005 Marko Kreen
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
       notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
       notice, this list of conditions and the following disclaimer in the
       documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.	IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.

NTT (Nippon Telegraph and Telephone Corporation)
================================================

Camellia in libhcrypto



Copyright (c) 2006,2007
NTT (Nippon Telegraph and Telephone Corporation) . All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer as
  the first lines of this file unmodified.
2. Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in the
  documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY NTT ``AS IS'' AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
IN NO EVENT SHALL NTT BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

The NetBSD Foundation, Inc.
===========================

vis.c in libroken



Copyright (c) 1999, 2005 The NetBSD Foundation, Inc.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
   notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
   notice, this list of conditions and the following disclaimer in the
   documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.

Vincent Rijmen, Antoon Bosselaers, Paulo Barreto
================================================

AES in libhcrypto



rijndael-alg-fst.c

@version 3.0 (December 2000)

Optimised ANSI C code for the Rijndael cipher (now AES)

@author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
@author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
@author Paulo Barreto <paulo.barreto@terra.com.br>

This code is hereby placed in the public domain.

THIS SOFTWARE IS PROVIDED BY THE AUTHORS ''AS IS'' AND ANY EXPRESS
OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

Apple, Inc
==========

kdc/announce.c



Copyright (c) 2008 Apple Inc.  All Rights Reserved.

Export of this software from the United States of America may require
a specific license from the United States Government.  It is the
responsibility of any person or organization contemplating export to
obtain such a license before exporting.

WITHIN THAT CONSTRAINT, permission to use, copy, modify, and
distribute this software and its documentation for any purpose and
without fee is hereby granted, provided that the above copyright
notice appear in all copies and that both that copyright notice and
this permission notice appear in supporting documentation, and that
the name of Apple Inc. not be used in advertising or publicity pertaining
to distribution of the software without specific, written prior
permission.  Apple Inc. makes no representations about the suitability of
this software for any purpose.  It is provided "as is" without express
or implied warranty.

THIS SOFTWARE 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.

Richard Outerbridge
===================

DES core in libhcrypto



D3DES (V5.09) -

A portable, public domain, version of the Data Encryption Standard.

Written with Symantec's THINK (Lightspeed) C by Richard Outerbridge.
Thanks to: Dan Hoey for his excellent Initial and Inverse permutation
code;  Jim Gillogly & Phil Karn for the DES key schedule code; Dennis
Ferguson, Eric Young and Dana How for comparing notes; and Ray Lau,
for humouring me on.

Copyright (c) 1988,1989,1990,1991,1992 by Richard Outerbridge.
(GEnie : OUTER; CIS : [71755,204]) Graven Imagery, 1992.

Secure Endpoints Inc
====================

Windows support



Copyright (c) 2009-2015, Secure Endpoints Inc.
All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:

- Redistributions of source code must retain the above copyright
  notice, this list of conditions and the following disclaimer.

- Redistributions in binary form must reproduce the above copyright
  notice, this list of conditions and the following disclaimer in
  the documentation and/or other materials provided with the
  distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.

Novell, Inc
===========

lib/hcrypto/test_dh.c



Copyright (c) 2007, Novell, Inc.
Author: Matthias Koenig <mkoenig@suse.de>

All rights reserved.

Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:

* Redistributions of source code must retain the above copyright notice, this
  list of conditions and the following disclaimer.

* Redistributions in binary form must reproduce the above copyright notice,
  this list of conditions and the following disclaimer in the documentation
  and/or other materials provided with the distribution.

* Neither the name of the Novell nor the names of its contributors may be used
  to endorse or promote products derived from this software without specific
  prior written permission.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.



Tag Table:
Node: Top136
Node: Introduction1615
Node: What is Kerberos?4361
Node: Building and Installing9474
Node: Setting up a realm9801
Node: Configuration file10753
Node: Creating the database13822
Node: Modifying the database17475
Node: Checking the setup19068
Node: keytabs19923
Node: Remote administration20781
Node: Password changing22687
Node: Testing clients and servers26875
Node: Slave Servers27203
Node: Incremental propagation28956
Node: Encryption types and salting32675
Node: Credential cache server - KCM34852
Node: Cross realm36836
Node: Transit policy39382
Node: Setting up DNS46159
Node: Using LDAP to store the database48634
Node: Providing Kerberos credentials to servers and programs55485
Node: Setting up PK-INIT57583
Ref: Use OpenSSL to create certificates68816
Node: Debugging Kerberos problems71354
Node: Applications71785
Node: Authentication modules71985
Node: Digital SIA72579
Node: IRIX76963
Node: AFS78253
Node: Things in search for a better place82007
Node: Kerberos 4 issues84736
Node: Principal conversion issues85084
Ref: Principal conversion issues-Footnote-187315
Ref: Principal conversion issues-Footnote-287383
Node: Converting a version 4 database87436
Node: Windows compatibility91749
Node: Configuring Windows to use a Heimdal KDC92835
Node: Inter-Realm keys (trust) between Windows and a Heimdal KDC94905
Node: Create account mappings98576
Node: Encryption types99328
Node: Authorisation data99928
Node: Quirks of Windows 2000 KDC101075
Node: Useful links when reading about the Windows102369
Node: Programming with Kerberos104173
Node: Migration104423
Node: Acknowledgments107066
Node: Copyrights and Licenses110024

End Tag Table
