This is heimdal.info, produced by makeinfo version 4.0 from
heimdal.texi.

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


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

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,  Prev: Providing Kerberos credentials to servers and programs,  Up: Setting up a realm

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

PK-INIT is levering the existing PKI infrastructure to use certificates
to get the initial ticket, that is usually the krbtgt.

To use PK-INIT you must first have a PKI, so if you don't have one, now
its time to create it. Note that you should read the whole chapter of
the document to see the requirements on the CA sortware.

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

Certificates
============

This section document the requirements on the KDC and client
certificates and the format used in the id-pkinit-san OtherName
extention.

KDC certificate
---------------

The certificate for the KDC have serveral requirements.

First the certificate should have a 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 and DER encoded KRB5PrincipalName that matches the name
of the TGS of the target realm.

Both of these two requirements are not required by the standard to be
checked by the client if it have external information what the
certificate the KDC is supposed to be used. So its in the interst of
minium amount of configuration on the clients they should be included.

Remember that if 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
password or other private information) that it is supposed to secret.

Also, if the extension certificate have a nameConstraints extention
with a Generalname with dNSName or iPAdress it must match the hostname
or adress of the KDC.

Client certificate
------------------

The client certificate may need to have a EKU id-pkekuoid
(1.3.6.1.5.2.3.4) depending on set on the certifiate 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.

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

OtherName extenetion in the GeneralName is used is used to do the
mapping between certifiate and principal in the certifiate or storing
the krbtgt principal in the KDC certificate.

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 }

In 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 Kerberos ASN.1
specification.

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

hx509 is the X.509 software used in Heimdal to handle certificates.
hx509 use diffrent syntaxs to specify the diffrent format the
certificate is stored and in what format they exist in.

There are several format that can be used, PEM, embeded into PKCS12
files, embeded into PKCS11 devices and raw DER encoded certificates.
Below is a list of types to use.

DIR:
     DIR is reading all certificates in a directory that is DER or PEM
     formated.

     The main feature of DIR is that the directory is read on demand
     when iterating over certificates, that way appliction can for some
     cases avoid storeing all certificates in memory. Its very useful
     for tests that iterates over larger amount of certificates.

     Syntax is:

          DIR:/path/to/der/files

FILE:
     FILE: is used to have the lib pick up a certificate chain and a
     private key. The fil can be either a PEM (openssl) file or a raw
     DER encoded certificate. If its a PEM file it can contain several
     keys and certificates and the code will try to match the private
     key and certificate togehter.

     Its useful to have one PEM file that contains all the trust
     anchors.

     Syntax is:

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

PKCS11:
     PKCS11: is used handle smartcards via PKCS11 drivers, for example
     soft-token opensc, or muscle. Default is to use all slots on the
     device/token.

     Syntax is:

          PKCS11:shared-object.so

PKCS12:
     PKCS12: is used handle PKCS12 files. PKCS12 files commonly have the
     extension pfx or p12.

     Syntax is:

          PKCS12:/path/to/file.pfx

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

First configure the client's trust anchors and what parameters to
verify, see subsection below how to do that. Now you can use kinit to
get yourself tickets. One example how that can look it like this:

     $ 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 PKCS11 it can look like this instead:

     $ kinit -C PKCS11:/tmp/pkcs11/lib/soft-pkcs11.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

Write about the kdc.

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

     [appdefaults]
     	pkinit-anchors = FILE:/path/to/trust-anchors.pem
     
     [realms]
             EXAMPLE.COM = {
     		pkinit_require_eku = true
     		pkinit_require_krbtgt_otherName = true
     		win2k_pkinit = no
     		win2k_pkinit_require_binding = yes
     	}

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

     [kdc]
     	enable-pkinit = yes
     	pki-identity = FILE:/secure/kdc.crt,/secure/kdc.key
     	pki-anchors = FILE:/path/to/trust-anchors.pem
     	pki-pool = PKCS12:/path/to/useful-intermediate-certs.pfx
     	pki-pool = FILE:/path/to/other-useful-intermediate-certs.pem
     	pki-allow-proxy-certificate = false

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

Note that the file this is 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

Using Kerberos database
-----------------------

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).

Using OpenSSL to create certificate with krb5PrincipalName
----------------------------------------------------------

To make OpenSSL create certificate with krb5PrincipalName use
`openssl.cnf' as described below. To see an 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

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

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 win2k_pkinit_require_binding option requires the reply for the KDC
to be of the new, secure, type that binds the request to reply. Before
clients should fake the reply from the KDC. To use this option you have
to apply a fix from Microsoft.

     [realms]
             MY.MS.REALM = {
                     win2k_pkinit = yes
                     win2k_pkinit_require_binding = no
     	}

Certificates
------------

The client certificates needs to have the extended keyusage "Microsoft
Smartcardlogin" (openssl have 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 to it includes
all information that will make a Windows KDC happy.

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: Applications,  Next: Things in search for a better place,  Prev: Setting up a realm,  Up: Top

Applications
************

* Menu:

* Authentication modules::
* AFS::


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

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

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

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

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/>.

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.

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.

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

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

2b is the name of the proposal that was implemented to give basic
Kerberos 5 support to AFS in rxkad. Its 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.

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
     	}

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

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

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 2000 compatability,  Prev: Things in search for a better place,  Up: Top

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

The KDC has built-in version 4 support. It is not enabled by default,
see setup how to set it up.

The KDC will also have kaserver emulation and be able to handle
AFS-clients that use `klog'.

* Menu:

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


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

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,  Next: kaserver,  Prev: Principal conversion issues,  Up: Kerberos 4 issues

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.

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.

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

Version 4 Kadmin
================

`kadmind' can act as a version 4 kadmind, and you can do most
operations, but with some restrictions (since the version 4 kadmin
protocol is, lets say, very ad hoc.) One example is that it only passes
des keys when creating principals and changing passwords (modern kpasswd
clients do send the password, so it's possible to to password quality
checks). Because of this you can only create principals with des keys,
and you can't set any flags or do any other fancy stuff.

To get this to work, you have to add another entry to inetd (since
version 4 uses port 751, not 749).

_And then there are a many more things you can do; more on this in a
later version of this manual. Until then, UTSL._


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

kaserver
========

kaserver emulation
------------------

The Heimdal kdc can emulate a kaserver. The kaserver is a Kerberos 4
server with pre-authentication using Rx as the on-wire protocol. The kdc
contains a minimalistic Rx implementation.

There are three parts of the kaserver; KAA (Authentication), KAT (Ticket
Granting), and KAM (Maintenance). The KAA interface and KAT interface
both passes over DES encrypted data-blobs (just like the
Kerberos-protocol) and thus do not need any other protection.  The KAM
interface uses `rxkad' (Kerberos authentication layer for Rx) for
security and data protection, and is used for example for changing
passwords.  This part is not implemented in the kdc.

Another difference between the ka-protocol and the Kerberos 4 protocol
is that the pass-phrase is salted with the cellname in the `string to
key' function in the ka-protocol, while in the Kerberos 4 protocol there
is no salting of the password at all. To make sure AFS-compatible keys
are added to each principals when they are created or their password are
changed, `afs3-salt' should be added to `[kadmin]default_keys'.

Transarc AFS Windows client
---------------------------

The Transarc Windows client uses Kerberos 4 to obtain tokens, and thus
does not need a kaserver. The Windows client assumes that the Kerberos
server is on the same machine as the AFS-database server. If you do not
like to do that you can add a small program that runs on the database
servers that forward all kerberos requests to the real kerberos server.
A program that does this is `krb-forward'
(<ftp://ftp.stacken.kth.se/pub/projekts/krb-forward>).


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

Windows 2000 compatability
**************************

Windows 2000 (formerly known as Windows NT 5) from Microsoft implements
Kerberos 5.  Their implementation, however, has some quirks,
peculiarities, and bugs.  This chapter is a short summary of the things
that we have found out while trying to test Heimdal against Windows
2000.  Another big problem with the Kerberos implementation in Windows
2000 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.

This information should apply to Heimdal 0.8 and Windows 2000
Professional.  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 2000 to use a Heimdal KDC::
* Inter-Realm keys (trust) between Windows 2000 and a Heimdal KDC::
* Create account mappings::
* Encryption types::
* Authorisation data::
* Quirks of Windows 2000 KDC::
* Useful links when reading about the Windows 2000::


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

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

You need the command line program called `ksetup.exe' which is available
in the file `SUPPORT/TOOLS/SUPPORT.CAB' on the Windows 2000 Professional
CD-ROM. 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 /setmachpassword 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 2000 and a Heimdal KDC,  Next: Create account mappings,  Prev: Configuring Windows 2000 to use a Heimdal KDC,  Up: Windows 2000 compatability

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

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

Install Windows 2000, 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 2000 on what hosts to find the KDCs for the
non-Windows realm with `ksetup', see *Note Configuring Windows 2000 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. There are
some tweaks that you need to do to `krb5.conf' beforehand.

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

since otherwise checksum types that are not understood by Windows 2000
will be generated (*note Quirks of Windows 2000 KDC::).

Another issue is salting.  Since Windows 2000 does not seem to
understand Kerberos 4 salted hashes you might need to turn off anything
similar to the following if you have it, at least while adding the
principals that are going to share keys with Windows 2000.

     [kadmin]
             default_keys = v5 v4

So remove v4 from default keys.

What you probably want to use is this:

     [kadmin]
             default_keys = des-cbc-crc:pw-salt arcfour-hmac-md5:pw-salt

Note that before Windows 2003 SP1, arcfour-hmac-md5 wasn't supported
between Windows realms and Non Windows realms.

Once that is also done, you can add the required inter-realm keys:

     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.

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 2000 and a Heimdal KDC,  Up: Windows 2000 compatability

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 2000 compatability

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 2000 compatability

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 2000,  Prev: Authorisation data,  Up: Windows 2000 compatability

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 2000,  Prev: Quirks of Windows 2000 KDC,  Up: Windows 2000 compatability

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

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/windows2000/library/planning/security/kerbsteps.asp'.
     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 2000 and a Heimdal KDC::).

   * Windows 2000 Kerberos Authentication:
     `http://www.microsoft.com/TechNet/win2000/win2ksrv/technote/kerberos.asp'.
     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 2000 compatability,  Up: Top

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

First you need to know how the Kerberos model works, go read the
introduction text (*note What is Kerberos?::).

* Menu:

* Kerberos 5 API Overview::
* Walkthrough of a sample Kerberos 5 client::
* Validating a password in a server application::
* API differences to MIT Kerberos::
* File formats::


File: heimdal.info,  Node: Kerberos 5 API Overview,  Next: Walkthrough of a sample Kerberos 5 client,  Prev: Programming with Kerberos,  Up: Programming with Kerberos

Kerberos 5 API Overview
=======================

All functions are documented in manual pages.  This section tries to
give an overview of the major components used in Kerberos library, and
point to where to look for a specific function.

Kerberos context
----------------

A kerberos context (`krb5_context') holds all per thread state. All
global variables that are context specific are stored in this
structure, including default encryption types, credential cache (for
example, a ticket file), and default realms.

See the manual pages for `krb5_context(3)' and `krb5_init_context(3)'.

Kerberos authentication context
-------------------------------

Kerberos authentication context (`krb5_auth_context') holds all context
related to an authenticated connection, in a similar way to the
kerberos context that holds the context for the thread or process.

The `krb5_auth_context' is used by various functions that are directly
related to authentication between the server/client. Example of data
that this structure contains are various flags, addresses of client and
server, port numbers, keyblocks (and subkeys), sequence numbers, replay
cache, and checksum types.

See the manual page for `krb5_auth_context(3)'.

Kerberos principal
------------------

The Kerberos principal is the structure that identifies a user or
service in Kerberos. The structure that holds the principal is the
`krb5_principal'. There are function to extract the realm and elements
of the principal, but most applications have no reason to inspect the
content of the structure.

The are several ways to create a principal (with different degree of
portability), and one way to free it.

See manual page for `krb5_principal(3)' for more information about the
functions.

Credential cache
----------------

A credential cache holds the tickets for a user. A given user can have
several credential caches, one for each realm where the user have the
initial tickets (the first krbtgt).

The credential cache data can be stored internally in different way,
each of them for different proposes.  File credential (FILE) caches and
processes based (KCM) caches are for permanent storage. While memory
caches (MEMORY) are local caches to the local process.

Caches are opened with `krb5_cc_resolve(3)' or created with
`krb5_cc_gen_unique(3)'.

If the cache needs to be opened again (using `krb5_cc_resolve(3)')
`krb5_cc_close(3)' will close the handle, but not the remove the cache.
`krb5_cc_destroy(3)' will zero out the cache, remove the cache so it
can no longer be referenced.

See also manual page for `krb5_ccache(3)'

Kerberos errors
---------------

Kerberos errors are based on the com_err library.  All error codes are
32-bit signed numbers, the first 24 bits define what subsystem the
error originates from, and last 8 bits are 255 error codes within the
library.  Each error code have fixed string associated with it.  For
example, the error-code -1765328383 have the symbolic name
KRB5KDC_ERR_NAME_EXP, and associated error string "Client's entry in
database has expired".

This is a great improvement compared to just getting one of the unix
error-codes back.  However, Heimdal have an extention to pass back
customised errors messages.  Instead of getting "Key table entry not
found", the user might back "failed to find
host/host.example.com@EXAMLE.COM(kvno 3) in keytab /etc/krb5.keytab
(des-cbc-crc)".  This improves the chance that the user find the cause
of the error so you should use the customised error message whenever
its available.

See also manual page for `krb5_get_error_string(3)' and
`krb5_get_err_text(3)'.

Keytab management
-----------------

A keytab is a storage for locally stored keys. Heimdal includes keytab
support for Kerberos 5 keytabs, Kerberos 4 srvtab, AFS-KeyFile's, and
for storing keys in memory.

Keytabs are used for servers and long-running services.

See also manual page for `krb5_keytab(3)'

Kerberos crypto
---------------

Heimdal includes a implementation of the Kerberos crypto framework, all
crypto operations.

See also manual page for `krb5_crypto_init(3)', `krb5_keyblock(3)',
`krb5_create_checksum(3)', and `krb5_encrypt(3)'.

