Fix multiple vulnerabilities of ntp. [SA-17:03]

[FreeBSD/releng/10.3.git] / contrib / ntp / ntpd / ntp_crypto.c

/*
 * ntp_crypto.c - NTP version 4 public key routines
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#ifdef AUTOKEY
#include <stdio.h>
#include <stdlib.h>     /* strtoul */
#include <sys/types.h>
#include <sys/param.h>
#include <unistd.h>
#include <fcntl.h>

#include "ntpd.h"
#include "ntp_stdlib.h"
#include "ntp_unixtime.h"
#include "ntp_string.h"
#include "ntp_random.h"
#include "ntp_assert.h"
#include "ntp_calendar.h"
#include "ntp_leapsec.h"

#include "openssl/asn1.h"
#include "openssl/bn.h"
#include "openssl/crypto.h"
#include "openssl/err.h"
#include "openssl/evp.h"
#include "openssl/opensslv.h"
#include "openssl/pem.h"
#include "openssl/rand.h"
#include "openssl/x509.h"
#include "openssl/x509v3.h"
#include "libssl_compat.h"

#ifdef KERNEL_PLL
#include "ntp_syscall.h"
#endif /* KERNEL_PLL */

/*
 * calcomp - compare two calendar structures, ignoring yearday and weekday; like strcmp
 * No, it's not a plotter.  If you don't understand that, you're too young.
 */
static int calcomp(struct calendar *pjd1, struct calendar *pjd2)
{
        int32_t diff;   /* large enough to hold the signed difference between two uint16_t values */

        diff = pjd1->year - pjd2->year;
        if (diff < 0) return -1; else if (diff > 0) return 1;
        /* same year; compare months */
        diff = pjd1->month - pjd2->month;
        if (diff < 0) return -1; else if (diff > 0) return 1;
        /* same year and month; compare monthday */
        diff = pjd1->monthday - pjd2->monthday;
        if (diff < 0) return -1; else if (diff > 0) return 1;
        /* same year and month and monthday; compare time */
        diff = pjd1->hour - pjd2->hour;
        if (diff < 0) return -1; else if (diff > 0) return 1;
        diff = pjd1->minute - pjd2->minute;
        if (diff < 0) return -1; else if (diff > 0) return 1;
        diff = pjd1->second - pjd2->second;
        if (diff < 0) return -1; else if (diff > 0) return 1;
        /* identical */
        return 0;
}

/*
 * Extension field message format
 *
 * These are always signed and saved before sending in network byte
 * order. They must be converted to and from host byte order for
 * processing.
 *
 * +-------+-------+
 * |   op  |  len  | <- extension pointer
 * +-------+-------+
 * |    associd    |
 * +---------------+
 * |   timestamp   | <- value pointer
 * +---------------+
 * |   filestamp   |
 * +---------------+
 * |   value len   |
 * +---------------+
 * |               |
 * =     value     =
 * |               |
 * +---------------+
 * | signature len |
 * +---------------+
 * |               |
 * =   signature   =
 * |               |
 * +---------------+
 *
 * The CRYPTO_RESP bit is set to 0 for requests, 1 for responses.
 * Requests carry the association ID of the receiver; responses carry
 * the association ID of the sender. Some messages include only the
 * operation/length and association ID words and so have length 8
 * octets. Ohers include the value structure and associated value and
 * signature fields. These messages include the timestamp, filestamp,
 * value and signature words and so have length at least 24 octets. The
 * signature and/or value fields can be empty, in which case the
 * respective length words are zero. An empty value with nonempty
 * signature is syntactically valid, but semantically questionable.
 *
 * The filestamp represents the time when a cryptographic data file such
 * as a public/private key pair is created. It follows every reference
 * depending on that file and serves as a means to obsolete earlier data
 * of the same type. The timestamp represents the time when the
 * cryptographic data of the message were last signed. Creation of a
 * cryptographic data file or signing a message can occur only when the
 * creator or signor is synchronized to an authoritative source and
 * proventicated to a trusted authority.
 *
 * Note there are several conditions required for server trust. First,
 * the public key on the server certificate must be verified, which can
 * involve a hike along the certificate trail to a trusted host. Next,
 * the server trust must be confirmed by one of several identity
 * schemes. Valid cryptographic values are signed with attached
 * timestamp and filestamp. Individual packet trust is confirmed
 * relative to these values by a message digest with keys generated by a
 * reverse-order pseudorandom hash.
 *
 * State decomposition. These flags are lit in the order given. They are
 * dim only when the association is demobilized.
 *
 * CRYPTO_FLAG_ENAB     Lit upon acceptance of a CRYPTO_ASSOC message
 * CRYPTO_FLAG_CERT     Lit when a self-digned trusted certificate is
 *                      accepted.
 * CRYPTO_FLAG_VRFY     Lit when identity is confirmed.
 * CRYPTO_FLAG_PROV     Lit when the first signature is verified.
 * CRYPTO_FLAG_COOK     Lit when a valid cookie is accepted.
 * CRYPTO_FLAG_AUTO     Lit when valid autokey values are accepted.
 * CRYPTO_FLAG_SIGN     Lit when the server signed certificate is
 *                      accepted.
 * CRYPTO_FLAG_LEAP     Lit when the leapsecond values are accepted.
 */
/*
 * Cryptodefines
 */
#define TAI_1972        10      /* initial TAI offset (s) */
#define MAX_LEAP        100     /* max UTC leapseconds (s) */
#define VALUE_LEN       (6 * 4) /* min response field length */
#define MAX_VALLEN      (65535 - VALUE_LEN)
#define YEAR            (60 * 60 * 24 * 365) /* seconds in year */

/*
 * Global cryptodata in host byte order
 */
u_int32 crypto_flags = 0x0;     /* status word */
int     crypto_nid = KEY_TYPE_MD5; /* digest nid */
char    *sys_hostname = NULL;
char    *sys_groupname = NULL;
static char *host_filename = NULL;      /* host file name */
static char *ident_filename = NULL;     /* group file name */

/*
 * Global cryptodata in network byte order
 */
struct cert_info *cinfo = NULL; /* certificate info/value cache */
struct cert_info *cert_host = NULL; /* host certificate */
struct pkey_info *pkinfo = NULL; /* key info/value cache */
struct value hostval;           /* host value */
struct value pubkey;            /* public key */
struct value tai_leap;          /* leapseconds values */
struct pkey_info *iffkey_info = NULL; /* IFF keys */
struct pkey_info *gqkey_info = NULL; /* GQ keys */
struct pkey_info *mvkey_info = NULL; /* MV keys */

/*
 * Private cryptodata in host byte order
 */
static char *passwd = NULL;     /* private key password */
static EVP_PKEY *host_pkey = NULL; /* host key */
static EVP_PKEY *sign_pkey = NULL; /* sign key */
static const EVP_MD *sign_digest = NULL; /* sign digest */
static u_int sign_siglen;       /* sign key length */
static char *rand_file = NULL;  /* random seed file */

/*
 * Cryptotypes
 */
static  int     crypto_verify   (struct exten *, struct value *,
                                    struct peer *);
static  int     crypto_encrypt  (const u_char *, u_int, keyid_t *,
                                    struct value *);
static  int     crypto_alice    (struct peer *, struct value *);
static  int     crypto_alice2   (struct peer *, struct value *);
static  int     crypto_alice3   (struct peer *, struct value *);
static  int     crypto_bob      (struct exten *, struct value *);
static  int     crypto_bob2     (struct exten *, struct value *);
static  int     crypto_bob3     (struct exten *, struct value *);
static  int     crypto_iff      (struct exten *, struct peer *);
static  int     crypto_gq       (struct exten *, struct peer *);
static  int     crypto_mv       (struct exten *, struct peer *);
static  int     crypto_send     (struct exten *, struct value *, int);
static  tstamp_t crypto_time    (void);
static  void    asn_to_calendar         (const ASN1_TIME *, struct calendar*);
static  struct cert_info *cert_parse (const u_char *, long, tstamp_t);
static  int     cert_sign       (struct exten *, struct value *);
static  struct cert_info *cert_install (struct exten *, struct peer *);
static  int     cert_hike       (struct peer *, struct cert_info *);
static  void    cert_free       (struct cert_info *);
static  struct pkey_info *crypto_key (char *, char *, sockaddr_u *);
static  void    bighash         (BIGNUM *, BIGNUM *);
static  struct cert_info *crypto_cert (char *);
static  u_int   exten_payload_size(const struct exten *);

#ifdef SYS_WINNT
int
readlink(char * link, char * file, int len) {
        return (-1);
}
#endif

/*
 * session_key - generate session key
 *
 * This routine generates a session key from the source address,
 * destination address, key ID and private value. The value of the
 * session key is the MD5 hash of these values, while the next key ID is
 * the first four octets of the hash.
 *
 * Returns the next key ID or 0 if there is no destination address.
 */
keyid_t
session_key(
        sockaddr_u *srcadr,     /* source address */
        sockaddr_u *dstadr,     /* destination address */
        keyid_t keyno,          /* key ID */
        keyid_t private,        /* private value */
        u_long  lifetime        /* key lifetime */
        )
{
        EVP_MD_CTX *ctx;        /* message digest context */
        u_char dgst[EVP_MAX_MD_SIZE]; /* message digest */
        keyid_t keyid;          /* key identifer */
        u_int32 header[10];     /* data in network byte order */
        u_int   hdlen, len;

        if (!dstadr)
                return 0;
        
        /*
         * Generate the session key and key ID. If the lifetime is
         * greater than zero, install the key and call it trusted.
         */
        hdlen = 0;
        switch(AF(srcadr)) {
        case AF_INET:
                header[0] = NSRCADR(srcadr);
                header[1] = NSRCADR(dstadr);
                header[2] = htonl(keyno);
                header[3] = htonl(private);
                hdlen = 4 * sizeof(u_int32);
                break;

        case AF_INET6:
                memcpy(&header[0], PSOCK_ADDR6(srcadr),
                    sizeof(struct in6_addr));
                memcpy(&header[4], PSOCK_ADDR6(dstadr),
                    sizeof(struct in6_addr));
                header[8] = htonl(keyno);
                header[9] = htonl(private);
                hdlen = 10 * sizeof(u_int32);
                break;
        }
        ctx = EVP_MD_CTX_new();
        EVP_DigestInit(ctx, EVP_get_digestbynid(crypto_nid));
        EVP_DigestUpdate(ctx, (u_char *)header, hdlen);
        EVP_DigestFinal(ctx, dgst, &len);
        EVP_MD_CTX_free(ctx);
        memcpy(&keyid, dgst, 4);
        keyid = ntohl(keyid);
        if (lifetime != 0) {
                MD5auth_setkey(keyno, crypto_nid, dgst, len, NULL);
                authtrust(keyno, lifetime);
        }
        DPRINTF(2, ("session_key: %s > %s %08x %08x hash %08x life %lu\n",
                    stoa(srcadr), stoa(dstadr), keyno,
                    private, keyid, lifetime));

        return (keyid);
}


/*
 * make_keylist - generate key list
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 *
 * This routine constructs a pseudo-random sequence by repeatedly
 * hashing the session key starting from a given source address,
 * destination address, private value and the next key ID of the
 * preceeding session key. The last entry on the list is saved along
 * with its sequence number and public signature.
 */
int
make_keylist(
        struct peer *peer,      /* peer structure pointer */
        struct interface *dstadr /* interface */
        )
{
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;        /* NTP timestamp */
        struct autokey *ap;     /* autokey pointer */
        struct value *vp;       /* value pointer */
        keyid_t keyid = 0;      /* next key ID */
        keyid_t cookie;         /* private value */
        long    lifetime;
        u_int   len, mpoll;
        int     i;

        if (!dstadr)
                return XEVNT_ERR;
        
        /*
         * Allocate the key list if necessary.
         */
        tstamp = crypto_time();
        if (peer->keylist == NULL)
                peer->keylist = eallocarray(NTP_MAXSESSION,
                                            sizeof(keyid_t));

        /*
         * Generate an initial key ID which is unique and greater than
         * NTP_MAXKEY.
         */
        while (1) {
                keyid = ntp_random() & 0xffffffff;
                if (keyid <= NTP_MAXKEY)
                        continue;

                if (authhavekey(keyid))
                        continue;
                break;
        }

        /*
         * Generate up to NTP_MAXSESSION session keys. Stop if the
         * next one would not be unique or not a session key ID or if
         * it would expire before the next poll. The private value
         * included in the hash is zero if broadcast mode, the peer
         * cookie if client mode or the host cookie if symmetric modes.
         */
        mpoll = 1 << min(peer->ppoll, peer->hpoll);
        lifetime = min(1U << sys_automax, NTP_MAXSESSION * mpoll);
        if (peer->hmode == MODE_BROADCAST)
                cookie = 0;
        else
                cookie = peer->pcookie;
        for (i = 0; i < NTP_MAXSESSION; i++) {
                peer->keylist[i] = keyid;
                peer->keynumber = i;
                keyid = session_key(&dstadr->sin, &peer->srcadr, keyid,
                    cookie, lifetime + mpoll);
                lifetime -= mpoll;
                if (auth_havekey(keyid) || keyid <= NTP_MAXKEY ||
                    lifetime < 0 || tstamp == 0)
                        break;
        }

        /*
         * Save the last session key ID, sequence number and timestamp,
         * then sign these values for later retrieval by the clients. Be
         * careful not to use invalid key media. Use the public values
         * timestamp as filestamp. 
         */
        vp = &peer->sndval;
        if (vp->ptr == NULL)
                vp->ptr = emalloc(sizeof(struct autokey));
        ap = (struct autokey *)vp->ptr;
        ap->seq = htonl(peer->keynumber);
        ap->key = htonl(keyid);
        vp->tstamp = htonl(tstamp);
        vp->fstamp = hostval.tstamp;
        vp->vallen = htonl(sizeof(struct autokey));
        vp->siglen = 0;
        if (tstamp != 0) {
                if (vp->sig == NULL)
                        vp->sig = emalloc(sign_siglen);
                ctx = EVP_MD_CTX_new();
                EVP_SignInit(ctx, sign_digest);
                EVP_SignUpdate(ctx, (u_char *)vp, 12);
                EVP_SignUpdate(ctx, vp->ptr, sizeof(struct autokey));
                if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                        INSIST(len <= sign_siglen);
                        vp->siglen = htonl(len);
                        peer->flags |= FLAG_ASSOC;
                }
                EVP_MD_CTX_free(ctx);
        }
        DPRINTF(1, ("make_keys: %d %08x %08x ts %u fs %u poll %d\n",
                    peer->keynumber, keyid, cookie, ntohl(vp->tstamp),
                    ntohl(vp->fstamp), peer->hpoll));
        return (XEVNT_OK);
}


/*
 * crypto_recv - parse extension fields
 *
 * This routine is called when the packet has been matched to an
 * association and passed sanity, format and MAC checks. We believe the
 * extension field values only if the field has proper format and
 * length, the timestamp and filestamp are valid and the signature has
 * valid length and is verified. There are a few cases where some values
 * are believed even if the signature fails, but only if the proventic
 * bit is not set.
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 * XEVNT_LEN    bad field format or length
 */
int
crypto_recv(
        struct peer *peer,      /* peer structure pointer */
        struct recvbuf *rbufp   /* packet buffer pointer */
        )
{
        const EVP_MD *dp;       /* message digest algorithm */
        u_int32 *pkt;           /* receive packet pointer */
        struct autokey *ap, *bp; /* autokey pointer */
        struct exten *ep, *fp;  /* extension pointers */
        struct cert_info *xinfo; /* certificate info pointer */
        int     macbytes;       /* length of MAC field, signed by intention */
        int     authlen;        /* offset of MAC field */
        associd_t associd;      /* association ID */
        tstamp_t fstamp = 0;    /* filestamp */
        u_int   len;            /* extension field length */
        u_int   code;           /* extension field opcode */
        u_int   vallen = 0;     /* value length */
        X509    *cert;          /* X509 certificate */
        char    statstr[NTP_MAXSTRLEN]; /* statistics for filegen */
        keyid_t cookie;         /* crumbles */
        int     hismode;        /* packet mode */
        int     rval = XEVNT_OK;
        const u_char *puch;
        u_int32 temp32;

        /*
         * Initialize. Note that the packet has already been checked for
         * valid format and extension field lengths. First extract the
         * field length, command code and association ID in host byte
         * order. These are used with all commands and modes. Then check
         * the version number, which must be 2, and length, which must
         * be at least 8 for requests and VALUE_LEN (24) for responses.
         * Packets that fail either test sink without a trace. The
         * association ID is saved only if nonzero.
         */
        authlen = LEN_PKT_NOMAC;
        hismode = (int)PKT_MODE((&rbufp->recv_pkt)->li_vn_mode);
        while ((macbytes = rbufp->recv_length - authlen) > (int)MAX_MAC_LEN) {
                /* We can be reasonably sure that we can read at least
                 * the opcode and the size field here. More stringent
                 * checks follow up shortly.
                 */
                pkt = (u_int32 *)&rbufp->recv_pkt + authlen / 4;
                ep = (struct exten *)pkt;
                code = ntohl(ep->opcode) & 0xffff0000;
                len = ntohl(ep->opcode) & 0x0000ffff;
                // HMS: Why pkt[1] instead of ep->associd ?
                associd = (associd_t)ntohl(pkt[1]);
                rval = XEVNT_OK;
                DPRINTF(1, ("crypto_recv: flags 0x%x ext offset %d len %u code 0x%x associd %d\n",
                            peer->crypto, authlen, len, code >> 16,
                            associd));

                /*
                 * Check version number and field length. If bad,
                 * quietly ignore the packet.
                 */
                if (((code >> 24) & 0x3f) != CRYPTO_VN || len < 8) {
                        sys_badlength++;
                        code |= CRYPTO_ERROR;
                }

                /* Check if the declared size fits into the remaining
                 * buffer. We *know* 'macbytes' > 0 here!
                 */
                if (len > (u_int)macbytes) {
                        DPRINTF(1, ("crypto_recv: possible attack detected, associd %d\n",
                                    associd));
                        return XEVNT_LEN;
                }

                /* Check if the paylod of the extension fits into the
                 * declared frame.
                 */
                if (len >= VALUE_LEN) {
                        fstamp = ntohl(ep->fstamp);
                        vallen = ntohl(ep->vallen);
                        /*
                         * Bug 2761: I hope this isn't too early...
                         */
                        if (   vallen == 0
                            || len - VALUE_LEN < vallen)
                                return XEVNT_LEN;
                }
                switch (code) {

                /*
                 * Install status word, host name, signature scheme and
                 * association ID. In OpenSSL the signature algorithm is
                 * bound to the digest algorithm, so the NID completely
                 * defines the signature scheme. Note the request and
                 * response are identical, but neither is validated by
                 * signature. The request is processed here only in
                 * symmetric modes. The server name field might be
                 * useful to implement access controls in future.
                 */
                case CRYPTO_ASSOC:

                        /*
                         * If our state machine is running when this
                         * message arrives, the other fellow might have
                         * restarted. However, this could be an
                         * intruder, so just clamp the poll interval and
                         * find out for ourselves. Otherwise, pass the
                         * extension field to the transmit side.
                         */
                        if (peer->crypto & CRYPTO_FLAG_CERT) {
                                rval = XEVNT_ERR;
                                break;
                        }
                        if (peer->cmmd) {
                                if (peer->assoc != associd) {
                                        rval = XEVNT_ERR;
                                        break;
                                }
                                free(peer->cmmd); /* will be set again! */
                        }
                        fp = emalloc(len);
                        memcpy(fp, ep, len);
                        fp->associd = htonl(peer->associd);
                        peer->cmmd = fp;
                        /* fall through */

                case CRYPTO_ASSOC | CRYPTO_RESP:

                        /*
                         * Discard the message if it has already been
                         * stored or the message has been amputated.
                         */
                        if (peer->crypto) {
                                if (peer->assoc != associd)
                                        rval = XEVNT_ERR;
                                break;
                        }
                        INSIST(len >= VALUE_LEN);
                        if (vallen == 0 || vallen > MAXHOSTNAME ||
                            len - VALUE_LEN < vallen) {
                                rval = XEVNT_LEN;
                                break;
                        }
                        DPRINTF(1, ("crypto_recv: ident host 0x%x %d server 0x%x %d\n",
                                    crypto_flags, peer->associd, fstamp,
                                    peer->assoc));
                        temp32 = crypto_flags & CRYPTO_FLAG_MASK;

                        /*
                         * If the client scheme is PC, the server scheme
                         * must be PC. The public key and identity are
                         * presumed valid, so we skip the certificate
                         * and identity exchanges and move immediately
                         * to the cookie exchange which confirms the
                         * server signature.
                         */
                        if (crypto_flags & CRYPTO_FLAG_PRIV) {
                                if (!(fstamp & CRYPTO_FLAG_PRIV)) {
                                        rval = XEVNT_KEY;
                                        break;
                                }
                                fstamp |= CRYPTO_FLAG_CERT |
                                    CRYPTO_FLAG_VRFY | CRYPTO_FLAG_SIGN;

                        /*
                         * It is an error if either peer supports
                         * identity, but the other does not.
                         */
                        } else if (hismode == MODE_ACTIVE || hismode ==
                            MODE_PASSIVE) {
                                if ((temp32 && !(fstamp &
                                    CRYPTO_FLAG_MASK)) ||
                                    (!temp32 && (fstamp &
                                    CRYPTO_FLAG_MASK))) {
                                        rval = XEVNT_KEY;
                                        break;
                                }
                        }

                        /*
                         * Discard the message if the signature digest
                         * NID is not supported.
                         */
                        temp32 = (fstamp >> 16) & 0xffff;
                        dp =
                            (const EVP_MD *)EVP_get_digestbynid(temp32);
                        if (dp == NULL) {
                                rval = XEVNT_MD;
                                break;
                        }

                        /*
                         * Save status word, host name and message
                         * digest/signature type. If this is from a
                         * broadcast and the association ID has changed,
                         * request the autokey values.
                         */
                        peer->assoc = associd;
                        if (hismode == MODE_SERVER)
                                fstamp |= CRYPTO_FLAG_AUTO;
                        if (!(fstamp & CRYPTO_FLAG_TAI))
                                fstamp |= CRYPTO_FLAG_LEAP;
                        RAND_bytes((u_char *)&peer->hcookie, 4);
                        peer->crypto = fstamp;
                        peer->digest = dp;
                        if (peer->subject != NULL)
                                free(peer->subject);
                        peer->subject = emalloc(vallen + 1);
                        memcpy(peer->subject, ep->pkt, vallen);
                        peer->subject[vallen] = '\0';
                        if (peer->issuer != NULL)
                                free(peer->issuer);
                        peer->issuer = estrdup(peer->subject);
                        snprintf(statstr, sizeof(statstr),
                            "assoc %d %d host %s %s", peer->associd,
                            peer->assoc, peer->subject,
                            OBJ_nid2ln(temp32));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * Decode X509 certificate in ASN.1 format and extract
                 * the data containing, among other things, subject
                 * name and public key. In the default identification
                 * scheme, the certificate trail is followed to a self
                 * signed trusted certificate.
                 */
                case CRYPTO_CERT | CRYPTO_RESP:

                        /*
                         * Discard the message if empty or invalid.
                         */
                        if (len < VALUE_LEN)
                                break;

                        if ((rval = crypto_verify(ep, NULL, peer)) !=
                            XEVNT_OK)
                                break;

                        /*
                         * Scan the certificate list to delete old
                         * versions and link the newest version first on
                         * the list. Then, verify the signature. If the
                         * certificate is bad or missing, just ignore
                         * it.
                         */
                        if ((xinfo = cert_install(ep, peer)) == NULL) {
                                rval = XEVNT_CRT;
                                break;
                        }
                        if ((rval = cert_hike(peer, xinfo)) != XEVNT_OK)
                                break;

                        /*
                         * We plug in the public key and lifetime from
                         * the first certificate received. However, note
                         * that this certificate might not be signed by
                         * the server, so we can't check the
                         * signature/digest NID.
                         */
                        if (peer->pkey == NULL) {
                                puch = xinfo->cert.ptr;
                                cert = d2i_X509(NULL, &puch,
                                    ntohl(xinfo->cert.vallen));
                                peer->pkey = X509_get_pubkey(cert);
                                X509_free(cert);
                        }
                        peer->flash &= ~TEST8;
                        temp32 = xinfo->nid;
                        snprintf(statstr, sizeof(statstr),
                            "cert %s %s 0x%x %s (%u) fs %u",
                            xinfo->subject, xinfo->issuer, xinfo->flags,
                            OBJ_nid2ln(temp32), temp32,
                            ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * Schnorr (IFF) identity scheme. This scheme is
                 * designed for use with shared secret server group keys
                 * and where the certificate may be generated by a third
                 * party. The client sends a challenge to the server,
                 * which performs a calculation and returns the result.
                 * A positive result is possible only if both client and
                 * server contain the same secret group key.
                 */
                case CRYPTO_IFF | CRYPTO_RESP:

                        /*
                         * Discard the message if invalid.
                         */
                        if ((rval = crypto_verify(ep, NULL, peer)) !=
                            XEVNT_OK)
                                break;

                        /*
                         * If the challenge matches the response, the
                         * server public key, signature and identity are
                         * all verified at the same time. The server is
                         * declared trusted, so we skip further
                         * certificate exchanges and move immediately to
                         * the cookie exchange.
                         */
                        if ((rval = crypto_iff(ep, peer)) != XEVNT_OK)
                                break;

                        peer->crypto |= CRYPTO_FLAG_VRFY;
                        peer->flash &= ~TEST8;
                        snprintf(statstr, sizeof(statstr), "iff %s fs %u",
                            peer->issuer, ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * Guillou-Quisquater (GQ) identity scheme. This scheme
                 * is designed for use with public certificates carrying
                 * the GQ public key in an extension field. The client
                 * sends a challenge to the server, which performs a
                 * calculation and returns the result. A positive result
                 * is possible only if both client and server contain
                 * the same group key and the server has the matching GQ
                 * private key.
                 */
                case CRYPTO_GQ | CRYPTO_RESP:

                        /*
                         * Discard the message if invalid
                         */
                        if ((rval = crypto_verify(ep, NULL, peer)) !=
                            XEVNT_OK)
                                break;

                        /*
                         * If the challenge matches the response, the
                         * server public key, signature and identity are
                         * all verified at the same time. The server is
                         * declared trusted, so we skip further
                         * certificate exchanges and move immediately to
                         * the cookie exchange.
                         */
                        if ((rval = crypto_gq(ep, peer)) != XEVNT_OK)
                                break;

                        peer->crypto |= CRYPTO_FLAG_VRFY;
                        peer->flash &= ~TEST8;
                        snprintf(statstr, sizeof(statstr), "gq %s fs %u",
                            peer->issuer, ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * Mu-Varadharajan (MV) identity scheme. This scheme is
                 * designed for use with three levels of trust, trusted
                 * host, server and client. The trusted host key is
                 * opaque to servers and clients; the server keys are
                 * opaque to clients and each client key is different.
                 * Client keys can be revoked without requiring new key
                 * generations.
                 */
                case CRYPTO_MV | CRYPTO_RESP:

                        /*
                         * Discard the message if invalid.
                         */
                        if ((rval = crypto_verify(ep, NULL, peer)) !=
                            XEVNT_OK)
                                break;

                        /*
                         * If the challenge matches the response, the
                         * server public key, signature and identity are
                         * all verified at the same time. The server is
                         * declared trusted, so we skip further
                         * certificate exchanges and move immediately to
                         * the cookie exchange.
                         */
                        if ((rval = crypto_mv(ep, peer)) != XEVNT_OK)
                                break;

                        peer->crypto |= CRYPTO_FLAG_VRFY;
                        peer->flash &= ~TEST8;
                        snprintf(statstr, sizeof(statstr), "mv %s fs %u",
                            peer->issuer, ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;


                /*
                 * Cookie response in client and symmetric modes. If the
                 * cookie bit is set, the working cookie is the EXOR of
                 * the current and new values.
                 */
                case CRYPTO_COOK | CRYPTO_RESP:

                        /*
                         * Discard the message if invalid or signature
                         * not verified with respect to the cookie
                         * values.
                         */
                        if ((rval = crypto_verify(ep, &peer->cookval,
                            peer)) != XEVNT_OK)
                                break;

                        /*
                         * Decrypt the cookie, hunting all the time for
                         * errors.
                         */
                        if (vallen == (u_int)EVP_PKEY_size(host_pkey)) {
                                RSA *rsa = EVP_PKEY_get0_RSA(host_pkey);
                                u_int32 *cookiebuf = malloc(RSA_size(rsa));
                                if (!cookiebuf) {
                                        rval = XEVNT_CKY;
                                        break;
                                }

                                if (RSA_private_decrypt(vallen,
                                    (u_char *)ep->pkt,
                                    (u_char *)cookiebuf,
                                    rsa,
                                    RSA_PKCS1_OAEP_PADDING) != 4) {
                                        rval = XEVNT_CKY;
                                        free(cookiebuf);
                                        break;
                                } else {
                                        cookie = ntohl(*cookiebuf);
                                        free(cookiebuf);
                                }
                        } else {
                                rval = XEVNT_CKY;
                                break;
                        }

                        /*
                         * Install cookie values and light the cookie
                         * bit. If this is not broadcast client mode, we
                         * are done here.
                         */
                        key_expire(peer);
                        if (hismode == MODE_ACTIVE || hismode ==
                            MODE_PASSIVE)
                                peer->pcookie = peer->hcookie ^ cookie;
                        else
                                peer->pcookie = cookie;
                        peer->crypto |= CRYPTO_FLAG_COOK;
                        peer->flash &= ~TEST8;
                        snprintf(statstr, sizeof(statstr),
                            "cook %x ts %u fs %u", peer->pcookie,
                            ntohl(ep->tstamp), ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * Install autokey values in broadcast client and
                 * symmetric modes. We have to do this every time the
                 * sever/peer cookie changes or a new keylist is
                 * rolled. Ordinarily, this is automatic as this message
                 * is piggybacked on the first NTP packet sent upon
                 * either of these events. Note that a broadcast client
                 * or symmetric peer can receive this response without a
                 * matching request.
                 */
                case CRYPTO_AUTO | CRYPTO_RESP:

                        /*
                         * Discard the message if invalid or signature
                         * not verified with respect to the receive
                         * autokey values.
                         */
                        if ((rval = crypto_verify(ep, &peer->recval,
                            peer)) != XEVNT_OK) 
                                break;

                        /*
                         * Discard the message if a broadcast client and
                         * the association ID does not match. This might
                         * happen if a broacast server restarts the
                         * protocol. A protocol restart will occur at
                         * the next ASSOC message.
                         */
                        if ((peer->cast_flags & MDF_BCLNT) &&
                            peer->assoc != associd)
                                break;

                        /*
                         * Install autokey values and light the
                         * autokey bit. This is not hard.
                         */
                        if (ep->tstamp == 0)
                                break;

                        if (peer->recval.ptr == NULL)
                                peer->recval.ptr =
                                    emalloc(sizeof(struct autokey));
                        bp = (struct autokey *)peer->recval.ptr;
                        peer->recval.tstamp = ep->tstamp;
                        peer->recval.fstamp = ep->fstamp;
                        ap = (struct autokey *)ep->pkt;
                        bp->seq = ntohl(ap->seq);
                        bp->key = ntohl(ap->key);
                        peer->pkeyid = bp->key;
                        peer->crypto |= CRYPTO_FLAG_AUTO;
                        peer->flash &= ~TEST8;
                        snprintf(statstr, sizeof(statstr), 
                            "auto seq %d key %x ts %u fs %u", bp->seq,
                            bp->key, ntohl(ep->tstamp),
                            ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;
        
                /*
                 * X509 certificate sign response. Validate the
                 * certificate signed by the server and install. Later
                 * this can be provided to clients of this server in
                 * lieu of the self signed certificate in order to
                 * validate the public key.
                 */
                case CRYPTO_SIGN | CRYPTO_RESP:

                        /*
                         * Discard the message if invalid.
                         */
                        if ((rval = crypto_verify(ep, NULL, peer)) !=
                            XEVNT_OK)
                                break;

                        /*
                         * Scan the certificate list to delete old
                         * versions and link the newest version first on
                         * the list.
                         */
                        if ((xinfo = cert_install(ep, peer)) == NULL) {
                                rval = XEVNT_CRT;
                                break;
                        }
                        peer->crypto |= CRYPTO_FLAG_SIGN;
                        peer->flash &= ~TEST8;
                        temp32 = xinfo->nid;
                        snprintf(statstr, sizeof(statstr),
                            "sign %s %s 0x%x %s (%u) fs %u",
                            xinfo->subject, xinfo->issuer, xinfo->flags,
                            OBJ_nid2ln(temp32), temp32,
                            ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * Install leapseconds values. While the leapsecond
                 * values epoch, TAI offset and values expiration epoch
                 * are retained, only the current TAI offset is provided
                 * via the kernel to other applications.
                 */
                case CRYPTO_LEAP | CRYPTO_RESP:
                        /*
                         * Discard the message if invalid. We can't
                         * compare the value timestamps here, as they
                         * can be updated by different servers.
                         */
                        rval = crypto_verify(ep, NULL, peer);
                        if ((rval   != XEVNT_OK          ) ||
                            (vallen != 3*sizeof(uint32_t))  )
                                break;

                        /* Check if we can update the basic TAI offset
                         * for our current leap frame. This is a hack
                         * and ignores the time stamps in the autokey
                         * message.
                         */
                        if (sys_leap != LEAP_NOTINSYNC)
                                leapsec_autokey_tai(ntohl(ep->pkt[0]),
                                                    rbufp->recv_time.l_ui, NULL);
                        tai_leap.tstamp = ep->tstamp;
                        tai_leap.fstamp = ep->fstamp;
                        crypto_update();
                        mprintf_event(EVNT_TAI, peer,
                                      "%d seconds", ntohl(ep->pkt[0]));
                        peer->crypto |= CRYPTO_FLAG_LEAP;
                        peer->flash &= ~TEST8;
                        snprintf(statstr, sizeof(statstr),
                                 "leap TAI offset %d at %u expire %u fs %u",
                                 ntohl(ep->pkt[0]), ntohl(ep->pkt[1]),
                                 ntohl(ep->pkt[2]), ntohl(ep->fstamp));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        break;

                /*
                 * We come here in symmetric modes for miscellaneous
                 * commands that have value fields but are processed on
                 * the transmit side. All we need do here is check for
                 * valid field length. Note that ASSOC is handled
                 * separately.
                 */
                case CRYPTO_CERT:
                case CRYPTO_IFF:
                case CRYPTO_GQ:
                case CRYPTO_MV:
                case CRYPTO_COOK:
                case CRYPTO_SIGN:
                        if (len < VALUE_LEN) {
                                rval = XEVNT_LEN;
                                break;
                        }
                        /* fall through */

                /*
                 * We come here in symmetric modes for requests
                 * requiring a response (above plus AUTO and LEAP) and
                 * for responses. If a request, save the extension field
                 * for later; invalid requests will be caught on the
                 * transmit side. If an error or invalid response,
                 * declare a protocol error.
                 */
                default:
                        if (code & (CRYPTO_RESP | CRYPTO_ERROR)) {
                                rval = XEVNT_ERR;
                        } else if (peer->cmmd == NULL) {
                                fp = emalloc(len);
                                memcpy(fp, ep, len);
                                peer->cmmd = fp;
                        }
                }

                /*
                 * The first error found terminates the extension field
                 * scan and we return the laundry to the caller.
                 */
                if (rval != XEVNT_OK) {
                        snprintf(statstr, sizeof(statstr),
                            "%04x %d %02x %s", htonl(ep->opcode),
                            associd, rval, eventstr(rval));
                        record_crypto_stats(&peer->srcadr, statstr);
                        DPRINTF(1, ("crypto_recv: %s\n", statstr));
                        return (rval);
                }
                authlen += (len + 3) / 4 * 4;
        }
        return (rval);
}


/*
 * crypto_xmit - construct extension fields
 *
 * This routine is called both when an association is configured and
 * when one is not. The only case where this matters is to retrieve the
 * autokey information, in which case the caller has to provide the
 * association ID to match the association.
 *
 * Side effect: update the packet offset.
 *
 * Errors
 * XEVNT_OK     success
 * XEVNT_CRT    bad or missing certificate
 * XEVNT_ERR    protocol error
 * XEVNT_LEN    bad field format or length
 * XEVNT_PER    host certificate expired
 */
int
crypto_xmit(
        struct peer *peer,      /* peer structure pointer */
        struct pkt *xpkt,       /* transmit packet pointer */
        struct recvbuf *rbufp,  /* receive buffer pointer */
        int     start,          /* offset to extension field */
        struct exten *ep,       /* extension pointer */
        keyid_t cookie          /* session cookie */
        )
{
        struct exten *fp;       /* extension pointers */
        struct cert_info *cp, *xp, *yp; /* cert info/value pointer */
        sockaddr_u *srcadr_sin; /* source address */
        u_int32 *pkt;           /* packet pointer */
        u_int   opcode;         /* extension field opcode */
        char    certname[MAXHOSTNAME + 1]; /* subject name buffer */
        char    statstr[NTP_MAXSTRLEN]; /* statistics for filegen */
        tstamp_t tstamp;
        struct calendar tscal;
        u_int   vallen;
        struct value vtemp;
        associd_t associd;
        int     rval;
        int     len;
        keyid_t tcookie;

        /*
         * Generate the requested extension field request code, length
         * and association ID. If this is a response and the host is not
         * synchronized, light the error bit and go home.
         */
        pkt = (u_int32 *)xpkt + start / 4;
        fp = (struct exten *)pkt;
        opcode = ntohl(ep->opcode);
        if (peer != NULL) {
                srcadr_sin = &peer->srcadr;
                if (!(opcode & CRYPTO_RESP))
                        peer->opcode = ep->opcode;
        } else {
                srcadr_sin = &rbufp->recv_srcadr;
        }
        associd = (associd_t) ntohl(ep->associd);
        len = 8;
        fp->opcode = htonl((opcode & 0xffff0000) | len);
        fp->associd = ep->associd;
        rval = XEVNT_OK;
        tstamp = crypto_time();
        switch (opcode & 0xffff0000) {

        /*
         * Send association request and response with status word and
         * host name. Note, this message is not signed and the filestamp
         * contains only the status word.
         */
        case CRYPTO_ASSOC:
        case CRYPTO_ASSOC | CRYPTO_RESP:
                len = crypto_send(fp, &hostval, start);
                fp->fstamp = htonl(crypto_flags);
                break;

        /*
         * Send certificate request. Use the values from the extension
         * field.
         */
        case CRYPTO_CERT:
                memset(&vtemp, 0, sizeof(vtemp));
                vtemp.tstamp = ep->tstamp;
                vtemp.fstamp = ep->fstamp;
                vtemp.vallen = ep->vallen;
                vtemp.ptr = (u_char *)ep->pkt;
                len = crypto_send(fp, &vtemp, start);
                break;

        /*
         * Send sign request. Use the host certificate, which is self-
         * signed and may or may not be trusted.
         */
        case CRYPTO_SIGN:
                (void)ntpcal_ntp_to_date(&tscal, tstamp, NULL);
                if ((calcomp(&tscal, &(cert_host->first)) < 0)
                || (calcomp(&tscal, &(cert_host->last)) > 0))
                        rval = XEVNT_PER;
                else
                        len = crypto_send(fp, &cert_host->cert, start);
                break;

        /*
         * Send certificate response. Use the name in the extension
         * field to find the certificate in the cache. If the request
         * contains no subject name, assume the name of this host. This
         * is for backwards compatibility. Private certificates are
         * never sent.
         *
         * There may be several certificates matching the request. First
         * choice is a self-signed trusted certificate; second choice is
         * any certificate signed by another host. There is no third
         * choice. 
         */
        case CRYPTO_CERT | CRYPTO_RESP:
                vallen = exten_payload_size(ep); /* Must be <64k */
                if (vallen == 0 || vallen >= sizeof(certname) ) {
                        rval = XEVNT_LEN;
                        break;
                }

                /*
                 * Find all public valid certificates with matching
                 * subject. If a self-signed, trusted certificate is
                 * found, use that certificate. If not, use the last non
                 * self-signed certificate.
                 */
                memcpy(certname, ep->pkt, vallen);
                certname[vallen] = '\0';
                xp = yp = NULL;
                for (cp = cinfo; cp != NULL; cp = cp->link) {
                        if (cp->flags & (CERT_PRIV | CERT_ERROR))
                                continue;

                        if (strcmp(certname, cp->subject) != 0)
                                continue;

                        if (strcmp(certname, cp->issuer) != 0)
                                yp = cp;
                        else if (cp ->flags & CERT_TRUST)
                                xp = cp;
                        continue;
                }

                /*
                 * Be careful who you trust. If the certificate is not
                 * found, return an empty response. Note that we dont
                 * enforce lifetimes here.
                 *
                 * The timestamp and filestamp are taken from the
                 * certificate value structure. For all certificates the
                 * timestamp is the latest signature update time. For
                 * host and imported certificates the filestamp is the
                 * creation epoch. For signed certificates the filestamp
                 * is the creation epoch of the trusted certificate at
                 * the root of the certificate trail. In principle, this
                 * allows strong checking for signature masquerade.
                 */
                if (xp == NULL)
                        xp = yp;
                if (xp == NULL)
                        break;

                if (tstamp == 0)
                        break;

                len = crypto_send(fp, &xp->cert, start);
                break;

        /*
         * Send challenge in Schnorr (IFF) identity scheme.
         */
        case CRYPTO_IFF:
                if (peer == NULL)
                        break;          /* hack attack */

                if ((rval = crypto_alice(peer, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send response in Schnorr (IFF) identity scheme.
         */
        case CRYPTO_IFF | CRYPTO_RESP:
                if ((rval = crypto_bob(ep, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send challenge in Guillou-Quisquater (GQ) identity scheme.
         */
        case CRYPTO_GQ:
                if (peer == NULL)
                        break;          /* hack attack */

                if ((rval = crypto_alice2(peer, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send response in Guillou-Quisquater (GQ) identity scheme.
         */
        case CRYPTO_GQ | CRYPTO_RESP:
                if ((rval = crypto_bob2(ep, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send challenge in MV identity scheme.
         */
        case CRYPTO_MV:
                if (peer == NULL)
                        break;          /* hack attack */

                if ((rval = crypto_alice3(peer, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send response in MV identity scheme.
         */
        case CRYPTO_MV | CRYPTO_RESP:
                if ((rval = crypto_bob3(ep, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send certificate sign response. The integrity of the request
         * certificate has already been verified on the receive side.
         * Sign the response using the local server key. Use the
         * filestamp from the request and use the timestamp as the
         * current time. Light the error bit if the certificate is
         * invalid or contains an unverified signature.
         */
        case CRYPTO_SIGN | CRYPTO_RESP:
                if ((rval = cert_sign(ep, &vtemp)) == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Send public key and signature. Use the values from the public
         * key.
         */
        case CRYPTO_COOK:
                len = crypto_send(fp, &pubkey, start);
                break;

        /*
         * Encrypt and send cookie and signature. Light the error bit if
         * anything goes wrong.
         */
        case CRYPTO_COOK | CRYPTO_RESP:
                vallen = ntohl(ep->vallen);     /* Must be <64k */
                if (   vallen == 0
                    || (vallen >= MAX_VALLEN)
                    || (opcode & 0x0000ffff)  < VALUE_LEN + vallen) {
                        rval = XEVNT_LEN;
                        break;
                }
                if (peer == NULL)
                        tcookie = cookie;
                else
                        tcookie = peer->hcookie;
                if ((rval = crypto_encrypt((const u_char *)ep->pkt, vallen, &tcookie, &vtemp))
                    == XEVNT_OK) {
                        len = crypto_send(fp, &vtemp, start);
                        value_free(&vtemp);
                }
                break;

        /*
         * Find peer and send autokey data and signature in broadcast
         * server and symmetric modes. Use the values in the autokey
         * structure. If no association is found, either the server has
         * restarted with new associations or some perp has replayed an
         * old message, in which case light the error bit.
         */
        case CRYPTO_AUTO | CRYPTO_RESP:
                if (peer == NULL) {
                        if ((peer = findpeerbyassoc(associd)) == NULL) {
                                rval = XEVNT_ERR;
                                break;
                        }
                }
                peer->flags &= ~FLAG_ASSOC;
                len = crypto_send(fp, &peer->sndval, start);
                break;

        /*
         * Send leapseconds values and signature. Use the values from
         * the tai structure. If no table has been loaded, just send an
         * empty request.
         */
        case CRYPTO_LEAP | CRYPTO_RESP:
                len = crypto_send(fp, &tai_leap, start);
                break;

        /*
         * Default - Send a valid command for unknown requests; send
         * an error response for unknown resonses.
         */
        default:
                if (opcode & CRYPTO_RESP)
                        rval = XEVNT_ERR;
        }

        /*
         * In case of error, flame the log. If a request, toss the
         * puppy; if a response, return so the sender can flame, too.
         */
        if (rval != XEVNT_OK) {
                u_int32 uint32;

                uint32 = CRYPTO_ERROR;
                opcode |= uint32;
                fp->opcode |= htonl(uint32);
                snprintf(statstr, sizeof(statstr),
                    "%04x %d %02x %s", opcode, associd, rval,
                    eventstr(rval));
                record_crypto_stats(srcadr_sin, statstr);
                DPRINTF(1, ("crypto_xmit: %s\n", statstr));
                if (!(opcode & CRYPTO_RESP))
                        return (0);
        }
        DPRINTF(1, ("crypto_xmit: flags 0x%x offset %d len %d code 0x%x associd %d\n",
                    crypto_flags, start, len, opcode >> 16, associd));
        return (len);
}


/*
 * crypto_verify - verify the extension field value and signature
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 * XEVNT_FSP    bad filestamp
 * XEVNT_LEN    bad field format or length
 * XEVNT_PUB    bad or missing public key
 * XEVNT_SGL    bad signature length
 * XEVNT_SIG    signature not verified
 * XEVNT_TSP    bad timestamp
 */
static int
crypto_verify(
        struct exten *ep,       /* extension pointer */
        struct value *vp,       /* value pointer */
        struct peer *peer       /* peer structure pointer */
        )
{
        EVP_PKEY *pkey;         /* server public key */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp, tstamp1 = 0; /* timestamp */
        tstamp_t fstamp, fstamp1 = 0; /* filestamp */
        u_int   vallen;         /* value length */
        u_int   siglen;         /* signature length */
        u_int   opcode, len;
        int     i;

        /*
         * We are extremely parannoyed. We require valid opcode, length,
         * association ID, timestamp, filestamp, public key, digest,
         * signature length and signature, where relevant. Note that
         * preliminary length checks are done in the main loop.
         */
        len = ntohl(ep->opcode) & 0x0000ffff;
        opcode = ntohl(ep->opcode) & 0xffff0000;

        /*
         * Check for valid value header, association ID and extension
         * field length. Remember, it is not an error to receive an
         * unsolicited response; however, the response ID must match
         * the association ID.
         */
        if (opcode & CRYPTO_ERROR)
                return (XEVNT_ERR);

        if (len < VALUE_LEN)
                return (XEVNT_LEN);

        if (opcode == (CRYPTO_AUTO | CRYPTO_RESP) && (peer->pmode ==
            MODE_BROADCAST || (peer->cast_flags & MDF_BCLNT))) {
                if (ntohl(ep->associd) != peer->assoc)
                        return (XEVNT_ERR);
        } else {
                if (ntohl(ep->associd) != peer->associd)
                        return (XEVNT_ERR);
        }

        /*
         * We have a valid value header. Check for valid value and
         * signature field lengths. The extension field length must be
         * long enough to contain the value header, value and signature.
         * Note both the value and signature field lengths are rounded
         * up to the next word (4 octets).
         */
        vallen = ntohl(ep->vallen);
        if (   vallen == 0
            || vallen > MAX_VALLEN)
                return (XEVNT_LEN);

        i = (vallen + 3) / 4;
        siglen = ntohl(ep->pkt[i++]);
        if (   siglen > MAX_VALLEN
            || len - VALUE_LEN < ((vallen + 3) / 4) * 4
            || len - VALUE_LEN - ((vallen + 3) / 4) * 4
              < ((siglen + 3) / 4) * 4)
                return (XEVNT_LEN);

        /*
         * Check for valid timestamp and filestamp. If the timestamp is
         * zero, the sender is not synchronized and signatures are
         * not possible. If nonzero the timestamp must not precede the
         * filestamp. The timestamp and filestamp must not precede the
         * corresponding values in the value structure, if present.
         */
        tstamp = ntohl(ep->tstamp);
        fstamp = ntohl(ep->fstamp);
        if (tstamp == 0)
                return (XEVNT_TSP);

        if (tstamp < fstamp)
                return (XEVNT_TSP);

        if (vp != NULL) {
                tstamp1 = ntohl(vp->tstamp);
                fstamp1 = ntohl(vp->fstamp);
                if (tstamp1 != 0 && fstamp1 != 0) {
                        if (tstamp < tstamp1)
                                return (XEVNT_TSP);

                        if ((tstamp < fstamp1 || fstamp < fstamp1))
                                return (XEVNT_FSP);
                }
        }

        /*
         * At the time the certificate message is validated, the public
         * key in the message is not available. Thus, don't try to
         * verify the signature.
         */
        if (opcode == (CRYPTO_CERT | CRYPTO_RESP))
                return (XEVNT_OK);

        /*
         * Check for valid signature length, public key and digest
         * algorithm.
         */
        if (crypto_flags & peer->crypto & CRYPTO_FLAG_PRIV)
                pkey = sign_pkey;
        else
                pkey = peer->pkey;
        if (siglen == 0 || pkey == NULL || peer->digest == NULL)
                return (XEVNT_ERR);

        if (siglen != (u_int)EVP_PKEY_size(pkey))
                return (XEVNT_SGL);

        /*
         * Darn, I thought we would never get here. Verify the
         * signature. If the identity exchange is verified, light the
         * proventic bit. What a relief.
         */
        ctx = EVP_MD_CTX_new();
        EVP_VerifyInit(ctx, peer->digest);
        /* XXX: the "+ 12" needs to be at least documented... */
        EVP_VerifyUpdate(ctx, (u_char *)&ep->tstamp, vallen + 12);
        if (EVP_VerifyFinal(ctx, (u_char *)&ep->pkt[i], siglen,
            pkey) <= 0) {
                EVP_MD_CTX_free(ctx);
                return (XEVNT_SIG);
        }
        EVP_MD_CTX_free(ctx);

        if (peer->crypto & CRYPTO_FLAG_VRFY)
                peer->crypto |= CRYPTO_FLAG_PROV;
        return (XEVNT_OK);
}


/*
 * crypto_encrypt - construct vp (encrypted cookie and signature) from
 * the public key and cookie.
 *
 * Returns:
 * XEVNT_OK     success
 * XEVNT_CKY    bad or missing cookie
 * XEVNT_PUB    bad or missing public key
 */
static int
crypto_encrypt(
        const u_char *ptr,      /* Public Key */
        u_int   vallen,         /* Length of Public Key */
        keyid_t *cookie,        /* server cookie */
        struct value *vp        /* value pointer */
        )
{
        EVP_PKEY *pkey;         /* public key */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;        /* NTP timestamp */
        u_int32 temp32;
        u_char *puch;

        /*
         * Extract the public key from the request.
         */
        pkey = d2i_PublicKey(EVP_PKEY_RSA, NULL, &ptr, vallen);
        if (pkey == NULL) {
                msyslog(LOG_ERR, "crypto_encrypt: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_PUB);
        }

        /*
         * Encrypt the cookie, encode in ASN.1 and sign.
         */
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = hostval.tstamp;
        vallen = EVP_PKEY_size(pkey);
        vp->vallen = htonl(vallen);
        vp->ptr = emalloc(vallen);
        puch = vp->ptr;
        temp32 = htonl(*cookie);
        if (RSA_public_encrypt(4, (u_char *)&temp32, puch,
            EVP_PKEY_get0_RSA(pkey), RSA_PKCS1_OAEP_PADDING) <= 0) {
                msyslog(LOG_ERR, "crypto_encrypt: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                free(vp->ptr);
                EVP_PKEY_free(pkey);
                return (XEVNT_CKY);
        }
        EVP_PKEY_free(pkey);
        if (tstamp == 0)
                return (XEVNT_OK);

        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, vallen);
        if (EVP_SignFinal(ctx, vp->sig, &vallen, sign_pkey)) {
                INSIST(vallen <= sign_siglen);
                vp->siglen = htonl(vallen);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_ident - construct extension field for identity scheme
 *
 * This routine determines which identity scheme is in use and
 * constructs an extension field for that scheme.
 *
 * Returns
 * CRYTPO_IFF   IFF scheme
 * CRYPTO_GQ    GQ scheme
 * CRYPTO_MV    MV scheme
 * CRYPTO_NULL  no available scheme
 */
u_int
crypto_ident(
        struct peer *peer       /* peer structure pointer */
        )
{
        char            filename[MAXFILENAME];
        const char *    scheme_name;
        u_int           scheme_id;

        /*
         * We come here after the group trusted host has been found; its
         * name defines the group name. Search the key cache for all
         * keys matching the same group name in order IFF, GQ and MV.
         * Use the first one available.
         */
        scheme_name = NULL;
        if (peer->crypto & CRYPTO_FLAG_IFF) {
                scheme_name = "iff";
                scheme_id = CRYPTO_IFF;
        } else if (peer->crypto & CRYPTO_FLAG_GQ) {
                scheme_name = "gq";
                scheme_id = CRYPTO_GQ;
        } else if (peer->crypto & CRYPTO_FLAG_MV) {
                scheme_name = "mv";
                scheme_id = CRYPTO_MV;
        }

        if (scheme_name != NULL) {
                snprintf(filename, sizeof(filename), "ntpkey_%spar_%s",
                    scheme_name, peer->ident);
                peer->ident_pkey = crypto_key(filename, NULL,
                    &peer->srcadr);
                if (peer->ident_pkey != NULL)
                        return scheme_id;
        }

        msyslog(LOG_NOTICE,
            "crypto_ident: no identity parameters found for group %s",
            peer->ident);

        return CRYPTO_NULL;
}


/*
 * crypto_args - construct extension field from arguments
 *
 * This routine creates an extension field with current timestamps and
 * specified opcode, association ID and optional string. Note that the
 * extension field is created here, but freed after the crypto_xmit()
 * call in the protocol module.
 *
 * Returns extension field pointer (no errors)
 *
 * XXX: opcode and len should really be 32-bit quantities and
 * we should make sure that str is not too big.
 */
struct exten *
crypto_args(
        struct peer *peer,      /* peer structure pointer */
        u_int   opcode,         /* operation code */
        associd_t associd,      /* association ID */
        char    *str            /* argument string */
        )
{
        tstamp_t tstamp;        /* NTP timestamp */
        struct exten *ep;       /* extension field pointer */
        u_int   len;            /* extension field length */
        size_t  slen = 0;

        tstamp = crypto_time();
        len = sizeof(struct exten);
        if (str != NULL) {
                slen = strlen(str);
                INSIST(slen < MAX_VALLEN);
                len += slen;
        }
        ep = emalloc_zero(len);
        if (opcode == 0)
                return (ep);

        REQUIRE(0 == (len    & ~0x0000ffff));
        REQUIRE(0 == (opcode & ~0xffff0000));

        ep->opcode = htonl(opcode + len);
        ep->associd = htonl(associd);
        ep->tstamp = htonl(tstamp);
        ep->fstamp = hostval.tstamp;
        ep->vallen = 0;
        if (str != NULL) {
                ep->vallen = htonl(slen);
                memcpy((char *)ep->pkt, str, slen);
        }
        return (ep);
}


/*
 * crypto_send - construct extension field from value components
 *
 * The value and signature fields are zero-padded to a word boundary.
 * Note: it is not polite to send a nonempty signature with zero
 * timestamp or a nonzero timestamp with an empty signature, but those
 * rules are not enforced here.
 *
 * XXX This code won't work on a box with 16-bit ints.
 */
int
crypto_send(
        struct exten *ep,       /* extension field pointer */
        struct value *vp,       /* value pointer */
        int     start           /* buffer offset */
        )
{
        u_int   len, vallen, siglen, opcode;
        u_int   i, j;

        /*
         * Calculate extension field length and check for buffer
         * overflow. Leave room for the MAC.
         */
        len = 16;                               /* XXX Document! */
        vallen = ntohl(vp->vallen);
        INSIST(vallen <= MAX_VALLEN);
        len += ((vallen + 3) / 4 + 1) * 4; 
        siglen = ntohl(vp->siglen);
        len += ((siglen + 3) / 4 + 1) * 4; 
        if (start + len > sizeof(struct pkt) - MAX_MAC_LEN)
                return (0);

        /*
         * Copy timestamps.
         */
        ep->tstamp = vp->tstamp;
        ep->fstamp = vp->fstamp;
        ep->vallen = vp->vallen;

        /*
         * Copy value. If the data field is empty or zero length,
         * encode an empty value with length zero.
         */
        i = 0;
        if (vallen > 0 && vp->ptr != NULL) {
                j = vallen / 4;
                if (j * 4 < vallen)
                        ep->pkt[i + j++] = 0;
                memcpy(&ep->pkt[i], vp->ptr, vallen);
                i += j;
        }

        /*
         * Copy signature. If the signature field is empty or zero
         * length, encode an empty signature with length zero.
         */
        ep->pkt[i++] = vp->siglen;
        if (siglen > 0 && vp->sig != NULL) {
                j = siglen / 4;
                if (j * 4 < siglen)
                        ep->pkt[i + j++] = 0;
                memcpy(&ep->pkt[i], vp->sig, siglen);
                /* i += j; */   /* We don't use i after this */
        }
        opcode = ntohl(ep->opcode);
        ep->opcode = htonl((opcode & 0xffff0000) | len); 
        ENSURE(len <= MAX_VALLEN);
        return (len);
}


/*
 * crypto_update - compute new public value and sign extension fields
 *
 * This routine runs periodically, like once a day, and when something
 * changes. It updates the timestamps on three value structures and one
 * value structure list, then signs all the structures:
 *
 * hostval      host name (not signed)
 * pubkey       public key
 * cinfo        certificate info/value list
 * tai_leap     leap values
 *
 * Filestamps are proventic data, so this routine runs only when the
 * host is synchronized to a proventicated source. Thus, the timestamp
 * is proventic and can be used to deflect clogging attacks.
 *
 * Returns void (no errors)
 */
void
crypto_update(void)
{
        EVP_MD_CTX *ctx;        /* message digest context */
        struct cert_info *cp;   /* certificate info/value */
        char    statstr[NTP_MAXSTRLEN]; /* statistics for filegen */
        u_int32 *ptr;
        u_int   len;
        leap_result_t leap_data;

        hostval.tstamp = htonl(crypto_time());
        if (hostval.tstamp == 0)
                return;

        ctx = EVP_MD_CTX_new();

        /*
         * Sign public key and timestamps. The filestamp is derived from
         * the host key file extension from wherever the file was
         * generated. 
         */
        if (pubkey.vallen != 0) {
                pubkey.tstamp = hostval.tstamp;
                pubkey.siglen = 0;
                if (pubkey.sig == NULL)
                        pubkey.sig = emalloc(sign_siglen);
                EVP_SignInit(ctx, sign_digest);
                EVP_SignUpdate(ctx, (u_char *)&pubkey, 12);
                EVP_SignUpdate(ctx, pubkey.ptr, ntohl(pubkey.vallen));
                if (EVP_SignFinal(ctx, pubkey.sig, &len, sign_pkey)) {
                        INSIST(len <= sign_siglen);
                        pubkey.siglen = htonl(len);
                }
        }

        /*
         * Sign certificates and timestamps. The filestamp is derived
         * from the certificate file extension from wherever the file
         * was generated. Note we do not throw expired certificates
         * away; they may have signed younger ones.
         */
        for (cp = cinfo; cp != NULL; cp = cp->link) {
                cp->cert.tstamp = hostval.tstamp;
                cp->cert.siglen = 0;
                if (cp->cert.sig == NULL)
                        cp->cert.sig = emalloc(sign_siglen);
                EVP_SignInit(ctx, sign_digest);
                EVP_SignUpdate(ctx, (u_char *)&cp->cert, 12);
                EVP_SignUpdate(ctx, cp->cert.ptr,
                    ntohl(cp->cert.vallen));
                if (EVP_SignFinal(ctx, cp->cert.sig, &len, sign_pkey)) {
                        INSIST(len <= sign_siglen);
                        cp->cert.siglen = htonl(len);
                }
        }

        /*
         * Sign leapseconds values and timestamps. Note it is not an
         * error to return null values.
         */
        tai_leap.tstamp = hostval.tstamp;
        tai_leap.fstamp = hostval.fstamp;

        /* Get the leap second era. We might need a full lookup early
         * after start, when the cache is not yet loaded.
         */
        leapsec_frame(&leap_data);
        if ( ! memcmp(&leap_data.ebase, &leap_data.ttime, sizeof(vint64))) {
                time_t   now    = time(NULL);
                uint32_t nowntp = (uint32_t)now + JAN_1970;
                leapsec_query(&leap_data, nowntp, &now);
        }

        /* Create the data block. The protocol does not work without. */
        len = 3 * sizeof(u_int32);
        if (tai_leap.ptr == NULL || ntohl(tai_leap.vallen) != len) {
                free(tai_leap.ptr);
                tai_leap.ptr = emalloc(len);
                tai_leap.vallen = htonl(len);
        }
        ptr = (u_int32 *)tai_leap.ptr;
        if (leap_data.tai_offs > 10) {
                /* create a TAI / leap era block. The end time is a
                 * fake -- maybe we can do better.
                 */
                ptr[0] = htonl(leap_data.tai_offs);
                ptr[1] = htonl(leap_data.ebase.d_s.lo);
                if (leap_data.ttime.d_s.hi >= 0)
                        ptr[2] = htonl(leap_data.ttime.D_s.lo +  7*86400);
                else
                        ptr[2] = htonl(leap_data.ebase.D_s.lo + 25*86400);
        } else {
                /* no leap era available */
                memset(ptr, 0, len);
        }
        if (tai_leap.sig == NULL)
                tai_leap.sig = emalloc(sign_siglen);
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&tai_leap, 12);
        EVP_SignUpdate(ctx, tai_leap.ptr, len);
        if (EVP_SignFinal(ctx, tai_leap.sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                tai_leap.siglen = htonl(len);
        }
        crypto_flags |= CRYPTO_FLAG_TAI;

        snprintf(statstr, sizeof(statstr), "signature update ts %u",
            ntohl(hostval.tstamp)); 
        record_crypto_stats(NULL, statstr);
        DPRINTF(1, ("crypto_update: %s\n", statstr));
        EVP_MD_CTX_free(ctx);
}

/*
 * crypto_update_taichange - eventually trigger crypto_update
 *
 * This is called when a change in 'sys_tai' is detected. This will
 * happen shortly after a leap second is detected, but unhappily also
 * early after system start; also, the crypto stuff might be unused and
 * an unguarded call to crypto_update() causes a crash.
 *
 * This function makes sure that there already *is* a valid crypto block
 * for the use with autokey, and only calls 'crypto_update()' if it can
 * succeed.
 *
 * Returns void (no errors)
 */
void
crypto_update_taichange(void)
{
        static const u_int len = 3 * sizeof(u_int32);

        /* check if the signing digest algo is available */
        if (sign_digest == NULL || sign_pkey == NULL)
                return;

        /* check size of TAI extension block */
        if (tai_leap.ptr == NULL || ntohl(tai_leap.vallen) != len)
                return;

        /* crypto_update should at least not crash here! */
        crypto_update();
}

/*
 * value_free - free value structure components.
 *
 * Returns void (no errors)
 */
void
value_free(
        struct value *vp        /* value structure */
        )
{
        if (vp->ptr != NULL)
                free(vp->ptr);
        if (vp->sig != NULL)
                free(vp->sig);
        memset(vp, 0, sizeof(struct value));
}


/*
 * crypto_time - returns current NTP time.
 *
 * Returns NTP seconds if in synch, 0 otherwise
 */
tstamp_t
crypto_time()
{
        l_fp    tstamp;         /* NTP time */

        L_CLR(&tstamp);
        if (sys_leap != LEAP_NOTINSYNC)
                get_systime(&tstamp);
        return (tstamp.l_ui);
}


/*
 * asn_to_calendar - convert ASN1_TIME time structure to struct calendar.
 *
 */
static
void
asn_to_calendar (
        const ASN1_TIME *asn1time,      /* pointer to ASN1_TIME structure */
        struct calendar *pjd    /* pointer to result */
        )
{
        size_t  len;            /* length of ASN1_TIME string */
        char    v[24];          /* writable copy of ASN1_TIME string */
        unsigned long   temp;   /* result from strtoul */

        /*
         * Extract time string YYMMDDHHMMSSZ from ASN1 time structure.
         * Or YYYYMMDDHHMMSSZ.
         * Note that the YY, MM, DD fields start with one, the HH, MM,
         * SS fields start with zero and the Z character is ignored.
         * Also note that two-digit years less than 50 map to years greater than
         * 100. Dontcha love ASN.1? Better than MIL-188.
         */
        len = asn1time->length;
        REQUIRE(len < sizeof(v));
        (void)strncpy(v, (char *)(asn1time->data), len);
        REQUIRE(len >= 13);
        temp = strtoul(v+len-3, NULL, 10);
        pjd->second = temp;
        v[len-3] = '\0';

        temp = strtoul(v+len-5, NULL, 10);
        pjd->minute = temp;
        v[len-5] = '\0';

        temp = strtoul(v+len-7, NULL, 10);
        pjd->hour = temp;
        v[len-7] = '\0';

        temp = strtoul(v+len-9, NULL, 10);
        pjd->monthday = temp;
        v[len-9] = '\0';

        temp = strtoul(v+len-11, NULL, 10);
        pjd->month = temp;
        v[len-11] = '\0';

        temp = strtoul(v, NULL, 10);
        /* handle two-digit years */
        if (temp < 50UL)
            temp += 100UL;
        if (temp < 150UL)
            temp += 1900UL;
        pjd->year = temp;

        pjd->yearday = pjd->weekday = 0;
        return;
}


/*
 * bigdig() - compute a BIGNUM MD5 hash of a BIGNUM number.
 *
 * Returns void (no errors)
 */
static void
bighash(
        BIGNUM  *bn,            /* BIGNUM * from */
        BIGNUM  *bk             /* BIGNUM * to */
        )
{
        EVP_MD_CTX *ctx;        /* message digest context */
        u_char dgst[EVP_MAX_MD_SIZE]; /* message digest */
        u_char  *ptr;           /* a BIGNUM as binary string */
        u_int   len;

        len = BN_num_bytes(bn);
        ptr = emalloc(len);
        BN_bn2bin(bn, ptr);
        ctx = EVP_MD_CTX_new();
        EVP_DigestInit(ctx, EVP_md5());
        EVP_DigestUpdate(ctx, ptr, len);
        EVP_DigestFinal(ctx, dgst, &len);
        EVP_MD_CTX_free(ctx);
        BN_bin2bn(dgst, len, bk);
        free(ptr);
}


/*
 ***********************************************************************
 *                                                                     *
 * The following routines implement the Schnorr (IFF) identity scheme  *
 *                                                                     *
 ***********************************************************************
 *
 * The Schnorr (IFF) identity scheme is intended for use when
 * certificates are generated by some other trusted certificate
 * authority and the certificate cannot be used to convey public
 * parameters. There are two kinds of files: encrypted server files that
 * contain private and public values and nonencrypted client files that
 * contain only public values. New generations of server files must be
 * securely transmitted to all servers of the group; client files can be
 * distributed by any means. The scheme is self contained and
 * independent of new generations of host keys, sign keys and
 * certificates.
 *
 * The IFF values hide in a DSA cuckoo structure which uses the same
 * parameters. The values are used by an identity scheme based on DSA
 * cryptography and described in Stimson p. 285. The p is a 512-bit
 * prime, g a generator of Zp* and q a 160-bit prime that divides p - 1
 * and is a qth root of 1 mod p; that is, g^q = 1 mod p. The TA rolls a
 * private random group key b (0 < b < q) and public key v = g^b, then
 * sends (p, q, g, b) to the servers and (p, q, g, v) to the clients.
 * Alice challenges Bob to confirm identity using the protocol described
 * below.
 *
 * How it works
 *
 * The scheme goes like this. Both Alice and Bob have the public primes
 * p, q and generator g. The TA gives private key b to Bob and public
 * key v to Alice.
 *
 * Alice rolls new random challenge r (o < r < q) and sends to Bob in
 * the IFF request message. Bob rolls new random k (0 < k < q), then
 * computes y = k + b r mod q and x = g^k mod p and sends (y, hash(x))
 * to Alice in the response message. Besides making the response
 * shorter, the hash makes it effectivey impossible for an intruder to
 * solve for b by observing a number of these messages.
 * 
 * Alice receives the response and computes g^y v^r mod p. After a bit
 * of algebra, this simplifies to g^k. If the hash of this result
 * matches hash(x), Alice knows that Bob has the group key b. The signed
 * response binds this knowledge to Bob's private key and the public key
 * previously received in his certificate.
 *
 * crypto_alice - construct Alice's challenge in IFF scheme
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ID     bad or missing group key
 * XEVNT_PUB    bad or missing public key
 */
static int
crypto_alice(
        struct peer *peer,      /* peer pointer */
        struct value *vp        /* value pointer */
        )
{
        DSA     *dsa;           /* IFF parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;
        u_int   len;
        const BIGNUM *q;

        /*
         * The identity parameters must have correct format and content.
         */
        if (peer->ident_pkey == NULL) {
                msyslog(LOG_NOTICE, "crypto_alice: scheme unavailable");
                return (XEVNT_ID);
        }

        if ((dsa = EVP_PKEY_get0_DSA(peer->ident_pkey->pkey)) == NULL) {
                msyslog(LOG_NOTICE, "crypto_alice: defective key");
                return (XEVNT_PUB);
        }

        /*
         * Roll new random r (0 < r < q).
         */
        if (peer->iffval != NULL)
                BN_free(peer->iffval);
        peer->iffval = BN_new();
        DSA_get0_pqg(dsa, NULL, &q, NULL);
        len = BN_num_bytes(q);
        BN_rand(peer->iffval, len * 8, -1, 1);  /* r mod q*/
        bctx = BN_CTX_new();
        BN_mod(peer->iffval, peer->iffval, q, bctx);
        BN_CTX_free(bctx);

        /*
         * Sign and send to Bob. The filestamp is from the local file.
         */
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = htonl(peer->ident_pkey->fstamp);
        vp->vallen = htonl(len);
        vp->ptr = emalloc(len);
        BN_bn2bin(peer->iffval, vp->ptr);
        if (tstamp == 0)
                return (XEVNT_OK);

        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, len);
        if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                vp->siglen = htonl(len);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_bob - construct Bob's response to Alice's challenge
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 * XEVNT_ID     bad or missing group key
 */
static int
crypto_bob(
        struct exten *ep,       /* extension pointer */
        struct value *vp        /* value pointer */
        )
{
        DSA     *dsa;           /* IFF parameters */
        DSA_SIG *sdsa;          /* DSA signature context fake */
        BN_CTX  *bctx;          /* BIGNUM context */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;        /* NTP timestamp */
        BIGNUM  *bn, *bk, *r;
        u_char  *ptr;
        u_int   len;            /* extension field value length */
        const BIGNUM *p, *q, *g;
        const BIGNUM *priv_key;

        /*
         * If the IFF parameters are not valid, something awful
         * happened or we are being tormented.
         */
        if (iffkey_info == NULL) {
                msyslog(LOG_NOTICE, "crypto_bob: scheme unavailable");
                return (XEVNT_ID);
        }
        dsa = EVP_PKEY_get0_DSA(iffkey_info->pkey);
        DSA_get0_pqg(dsa, &p, &q, &g);
        DSA_get0_key(dsa, NULL, &priv_key);

        /*
         * Extract r from the challenge.
         */
        len = exten_payload_size(ep);
        if (len == 0 || len > MAX_VALLEN)
                return (XEVNT_LEN);
        if ((r = BN_bin2bn((u_char *)ep->pkt, len, NULL)) == NULL) {
                msyslog(LOG_ERR, "crypto_bob: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_ERR);
        }

        /*
         * Bob rolls random k (0 < k < q), computes y = k + b r mod q
         * and x = g^k mod p, then sends (y, hash(x)) to Alice.
         */
        bctx = BN_CTX_new(); bk = BN_new(); bn = BN_new();
        sdsa = DSA_SIG_new();
        BN_rand(bk, len * 8, -1, 1);            /* k */
        BN_mod_mul(bn, priv_key, r, q, bctx); /* b r mod q */
        BN_add(bn, bn, bk);
        BN_mod(bn, bn, q, bctx);                /* k + b r mod q */
        BN_mod_exp(bk, g, bk, p, bctx); /* g^k mod p */
        bighash(bk, bk);
        DSA_SIG_set0(sdsa, bn, bk);
        BN_CTX_free(bctx);
        BN_free(r);
#ifdef DEBUG
        if (debug > 1)
                DSA_print_fp(stdout, dsa, 0);
#endif

        /*
         * Encode the values in ASN.1 and sign. The filestamp is from
         * the local file.
         */
        len = i2d_DSA_SIG(sdsa, NULL);
        if (len == 0) {
                msyslog(LOG_ERR, "crypto_bob: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                DSA_SIG_free(sdsa);
                return (XEVNT_ERR);
        }
        if (len > MAX_VALLEN) {
                msyslog(LOG_ERR, "crypto_bob: signature is too big: %u",
                    len);
                DSA_SIG_free(sdsa);
                return (XEVNT_LEN);
        }
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = htonl(iffkey_info->fstamp);
        vp->vallen = htonl(len);
        ptr = emalloc(len);
        vp->ptr = ptr;
        i2d_DSA_SIG(sdsa, &ptr);
        DSA_SIG_free(sdsa);
        if (tstamp == 0)
                return (XEVNT_OK);

        /* XXX: more validation to make sure the sign fits... */
        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, len);
        if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                vp->siglen = htonl(len);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_iff - verify Bob's response to Alice's challenge
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_FSP    bad filestamp
 * XEVNT_ID     bad or missing group key
 * XEVNT_PUB    bad or missing public key
 */
int
crypto_iff(
        struct exten *ep,       /* extension pointer */
        struct peer *peer       /* peer structure pointer */
        )
{
        DSA     *dsa;           /* IFF parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        DSA_SIG *sdsa;          /* DSA parameters */
        BIGNUM  *bn, *bk;
        u_int   len;
        const u_char *ptr;
        int     temp;
        const BIGNUM *p, *g;
        const BIGNUM *r, *s;
        const BIGNUM *pub_key;

        /*
         * If the IFF parameters are not valid or no challenge was sent,
         * something awful happened or we are being tormented.
         */
        if (peer->ident_pkey == NULL) {
                msyslog(LOG_NOTICE, "crypto_iff: scheme unavailable");
                return (XEVNT_ID);
        }
        if (ntohl(ep->fstamp) != peer->ident_pkey->fstamp) {
                msyslog(LOG_NOTICE, "crypto_iff: invalid filestamp %u",
                    ntohl(ep->fstamp));
                return (XEVNT_FSP);
        }
        if ((dsa = EVP_PKEY_get0_DSA(peer->ident_pkey->pkey)) == NULL) {
                msyslog(LOG_NOTICE, "crypto_iff: defective key");
                return (XEVNT_PUB);
        }
        if (peer->iffval == NULL) {
                msyslog(LOG_NOTICE, "crypto_iff: missing challenge");
                return (XEVNT_ID);
        }

        /*
         * Extract the k + b r and g^k values from the response.
         */
        bctx = BN_CTX_new(); bk = BN_new(); bn = BN_new();
        len = ntohl(ep->vallen);
        ptr = (u_char *)ep->pkt;
        if ((sdsa = d2i_DSA_SIG(NULL, &ptr, len)) == NULL) {
                BN_free(bn); BN_free(bk); BN_CTX_free(bctx);
                msyslog(LOG_ERR, "crypto_iff: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_ERR);
        }

        /*
         * Compute g^(k + b r) g^(q - b)r mod p.
         */
        DSA_get0_key(dsa, &pub_key, NULL);
        DSA_get0_pqg(dsa, &p, NULL, &g);
        DSA_SIG_get0(sdsa, &r, &s);
        BN_mod_exp(bn, pub_key, peer->iffval, p, bctx);
        BN_mod_exp(bk, g, r, p, bctx);
        BN_mod_mul(bn, bn, bk, p, bctx);

        /*
         * Verify the hash of the result matches hash(x).
         */
        bighash(bn, bn);
        temp = BN_cmp(bn, s);
        BN_free(bn); BN_free(bk); BN_CTX_free(bctx);
        BN_free(peer->iffval);
        peer->iffval = NULL;
        DSA_SIG_free(sdsa);
        if (temp == 0)
                return (XEVNT_OK);

        msyslog(LOG_NOTICE, "crypto_iff: identity not verified");
        return (XEVNT_ID);
}


/*
 ***********************************************************************
 *                                                                     *
 * The following routines implement the Guillou-Quisquater (GQ)        *
 * identity scheme                                                     *
 *                                                                     *
 ***********************************************************************
 *
 * The Guillou-Quisquater (GQ) identity scheme is intended for use when
 * the certificate can be used to convey public parameters. The scheme
 * uses a X509v3 certificate extension field do convey the public key of
 * a private key known only to servers. There are two kinds of files:
 * encrypted server files that contain private and public values and
 * nonencrypted client files that contain only public values. New
 * generations of server files must be securely transmitted to all
 * servers of the group; client files can be distributed by any means.
 * The scheme is self contained and independent of new generations of
 * host keys and sign keys. The scheme is self contained and independent
 * of new generations of host keys and sign keys.
 *
 * The GQ parameters hide in a RSA cuckoo structure which uses the same
 * parameters. The values are used by an identity scheme based on RSA
 * cryptography and described in Stimson p. 300 (with errors). The 512-
 * bit public modulus is n = p q, where p and q are secret large primes.
 * The TA rolls private random group key b as RSA exponent. These values
 * are known to all group members.
 *
 * When rolling new certificates, a server recomputes the private and
 * public keys. The private key u is a random roll, while the public key
 * is the inverse obscured by the group key v = (u^-1)^b. These values
 * replace the private and public keys normally generated by the RSA
 * scheme. Alice challenges Bob to confirm identity using the protocol
 * described below.
 *
 * How it works
 *
 * The scheme goes like this. Both Alice and Bob have the same modulus n
 * and some random b as the group key. These values are computed and
 * distributed in advance via secret means, although only the group key
 * b is truly secret. Each has a private random private key u and public
 * key (u^-1)^b, although not necessarily the same ones. Bob and Alice
 * can regenerate the key pair from time to time without affecting
 * operations. The public key is conveyed on the certificate in an
 * extension field; the private key is never revealed.
 *
 * Alice rolls new random challenge r and sends to Bob in the GQ
 * request message. Bob rolls new random k, then computes y = k u^r mod
 * n and x = k^b mod n and sends (y, hash(x)) to Alice in the response
 * message. Besides making the response shorter, the hash makes it
 * effectivey impossible for an intruder to solve for b by observing
 * a number of these messages.
 * 
 * Alice receives the response and computes y^b v^r mod n. After a bit
 * of algebra, this simplifies to k^b. If the hash of this result
 * matches hash(x), Alice knows that Bob has the group key b. The signed
 * response binds this knowledge to Bob's private key and the public key
 * previously received in his certificate.
 *
 * crypto_alice2 - construct Alice's challenge in GQ scheme
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ID     bad or missing group key
 * XEVNT_PUB    bad or missing public key
 */
static int
crypto_alice2(
        struct peer *peer,      /* peer pointer */
        struct value *vp        /* value pointer */
        )
{
        RSA     *rsa;           /* GQ parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;
        u_int   len;
        const BIGNUM *n;

        /*
         * The identity parameters must have correct format and content.
         */
        if (peer->ident_pkey == NULL)
                return (XEVNT_ID);

        if ((rsa = EVP_PKEY_get0_RSA(peer->ident_pkey->pkey)) == NULL) {
                msyslog(LOG_NOTICE, "crypto_alice2: defective key");
                return (XEVNT_PUB);
        }

        /*
         * Roll new random r (0 < r < n).
         */
        if (peer->iffval != NULL)
                BN_free(peer->iffval);
        peer->iffval = BN_new();
        RSA_get0_key(rsa, &n, NULL, NULL);
        len = BN_num_bytes(n);
        BN_rand(peer->iffval, len * 8, -1, 1);  /* r mod n */
        bctx = BN_CTX_new();
        BN_mod(peer->iffval, peer->iffval, n, bctx);
        BN_CTX_free(bctx);

        /*
         * Sign and send to Bob. The filestamp is from the local file.
         */
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = htonl(peer->ident_pkey->fstamp);
        vp->vallen = htonl(len);
        vp->ptr = emalloc(len);
        BN_bn2bin(peer->iffval, vp->ptr);
        if (tstamp == 0)
                return (XEVNT_OK);

        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, len);
        if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                vp->siglen = htonl(len);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_bob2 - construct Bob's response to Alice's challenge
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 * XEVNT_ID     bad or missing group key
 */
static int
crypto_bob2(
        struct exten *ep,       /* extension pointer */
        struct value *vp        /* value pointer */
        )
{
        RSA     *rsa;           /* GQ parameters */
        DSA_SIG *sdsa;          /* DSA parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;        /* NTP timestamp */
        BIGNUM  *r, *k, *g, *y;
        u_char  *ptr;
        u_int   len;
        int     s_len;
        const BIGNUM *n, *p, *e;

        /*
         * If the GQ parameters are not valid, something awful
         * happened or we are being tormented.
         */
        if (gqkey_info == NULL) {
                msyslog(LOG_NOTICE, "crypto_bob2: scheme unavailable");
                return (XEVNT_ID);
        }
        rsa = EVP_PKEY_get0_RSA(gqkey_info->pkey);
        RSA_get0_key(rsa, &n, &p, &e);

        /*
         * Extract r from the challenge.
         */
        len = exten_payload_size(ep);
        if (len == 0 || len > MAX_VALLEN)
                return (XEVNT_LEN);
        if ((r = BN_bin2bn((u_char *)ep->pkt, len, NULL)) == NULL) {
                msyslog(LOG_ERR, "crypto_bob2: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_ERR);
        }

        /*
         * Bob rolls random k (0 < k < n), computes y = k u^r mod n and
         * x = k^b mod n, then sends (y, hash(x)) to Alice. 
         */
        bctx = BN_CTX_new(); k = BN_new(); g = BN_new(); y = BN_new();
        sdsa = DSA_SIG_new();
        BN_rand(k, len * 8, -1, 1);             /* k */
        BN_mod(k, k, n, bctx);
        BN_mod_exp(y, p, r, n, bctx); /* u^r mod n */
        BN_mod_mul(y, k, y, n, bctx);   /* k u^r mod n */
        BN_mod_exp(g, k, e, n, bctx); /* k^b mod n */
        bighash(g, g);
        DSA_SIG_set0(sdsa, y, g);
        BN_CTX_free(bctx);
        BN_free(r); BN_free(k);
#ifdef DEBUG
        if (debug > 1)
                RSA_print_fp(stdout, rsa, 0);
#endif
 
        /*
         * Encode the values in ASN.1 and sign. The filestamp is from
         * the local file.
         */
        len = s_len = i2d_DSA_SIG(sdsa, NULL);
        if (s_len <= 0) {
                msyslog(LOG_ERR, "crypto_bob2: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                DSA_SIG_free(sdsa);
                return (XEVNT_ERR);
        }
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = htonl(gqkey_info->fstamp);
        vp->vallen = htonl(len);
        ptr = emalloc(len);
        vp->ptr = ptr;
        i2d_DSA_SIG(sdsa, &ptr);
        DSA_SIG_free(sdsa);
        if (tstamp == 0)
                return (XEVNT_OK);

        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, len);
        if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                vp->siglen = htonl(len);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_gq - verify Bob's response to Alice's challenge
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 * XEVNT_FSP    bad filestamp
 * XEVNT_ID     bad or missing group keys
 * XEVNT_PUB    bad or missing public key
 */
int
crypto_gq(
        struct exten *ep,       /* extension pointer */
        struct peer *peer       /* peer structure pointer */
        )
{
        RSA     *rsa;           /* GQ parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        DSA_SIG *sdsa;          /* RSA signature context fake */
        BIGNUM  *y, *v;
        const u_char *ptr;
        long    len;
        u_int   temp;
        const BIGNUM *n, *e;
        const BIGNUM *r, *s;

        /*
         * If the GQ parameters are not valid or no challenge was sent,
         * something awful happened or we are being tormented. Note that
         * the filestamp on the local key file can be greater than on
         * the remote parameter file if the keys have been refreshed.
         */
        if (peer->ident_pkey == NULL) {
                msyslog(LOG_NOTICE, "crypto_gq: scheme unavailable");
                return (XEVNT_ID);
        }
        if (ntohl(ep->fstamp) < peer->ident_pkey->fstamp) {
                msyslog(LOG_NOTICE, "crypto_gq: invalid filestamp %u",
                    ntohl(ep->fstamp));
                return (XEVNT_FSP);
        }
        if ((rsa = EVP_PKEY_get0_RSA(peer->ident_pkey->pkey)) == NULL) {
                msyslog(LOG_NOTICE, "crypto_gq: defective key");
                return (XEVNT_PUB);
        }
        RSA_get0_key(rsa, &n, NULL, &e);
        if (peer->iffval == NULL) {
                msyslog(LOG_NOTICE, "crypto_gq: missing challenge");
                return (XEVNT_ID);
        }

        /*
         * Extract the y = k u^r and hash(x = k^b) values from the
         * response.
         */
        bctx = BN_CTX_new(); y = BN_new(); v = BN_new();
        len = ntohl(ep->vallen);
        ptr = (u_char *)ep->pkt;
        if ((sdsa = d2i_DSA_SIG(NULL, &ptr, len)) == NULL) {
                BN_CTX_free(bctx); BN_free(y); BN_free(v);
                msyslog(LOG_ERR, "crypto_gq: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_ERR);
        }
        DSA_SIG_get0(sdsa, &r, &s);

        /*
         * Compute v^r y^b mod n.
         */
        if (peer->grpkey == NULL) {
                msyslog(LOG_NOTICE, "crypto_gq: missing group key");
                return (XEVNT_ID);
        }
        BN_mod_exp(v, peer->grpkey, peer->iffval, n, bctx);
                                                /* v^r mod n */
        BN_mod_exp(y, r, e, n, bctx); /* y^b mod n */
        BN_mod_mul(y, v, y, n, bctx);   /* v^r y^b mod n */

        /*
         * Verify the hash of the result matches hash(x).
         */
        bighash(y, y);
        temp = BN_cmp(y, s);
        BN_CTX_free(bctx); BN_free(y); BN_free(v);
        BN_free(peer->iffval);
        peer->iffval = NULL;
        DSA_SIG_free(sdsa);
        if (temp == 0)
                return (XEVNT_OK);

        msyslog(LOG_NOTICE, "crypto_gq: identity not verified");
        return (XEVNT_ID);
}


/*
 ***********************************************************************
 *                                                                     *
 * The following routines implement the Mu-Varadharajan (MV) identity  *
 * scheme                                                              *
 *                                                                     *
 ***********************************************************************
 *
 * The Mu-Varadharajan (MV) cryptosystem was originally intended when
 * servers broadcast messages to clients, but clients never send
 * messages to servers. There is one encryption key for the server and a
 * separate decryption key for each client. It operated something like a
 * pay-per-view satellite broadcasting system where the session key is
 * encrypted by the broadcaster and the decryption keys are held in a
 * tamperproof set-top box.
 *
 * The MV parameters and private encryption key hide in a DSA cuckoo
 * structure which uses the same parameters, but generated in a
 * different way. The values are used in an encryption scheme similar to
 * El Gamal cryptography and a polynomial formed from the expansion of
 * product terms (x - x[j]), as described in Mu, Y., and V.
 * Varadharajan: Robust and Secure Broadcasting, Proc. Indocrypt 2001,
 * 223-231. The paper has significant errors and serious omissions.
 *
 * Let q be the product of n distinct primes s1[j] (j = 1...n), where
 * each s1[j] has m significant bits. Let p be a prime p = 2 * q + 1, so
 * that q and each s1[j] divide p - 1 and p has M = n * m + 1
 * significant bits. Let g be a generator of Zp; that is, gcd(g, p - 1)
 * = 1 and g^q = 1 mod p. We do modular arithmetic over Zq and then
 * project into Zp* as exponents of g. Sometimes we have to compute an
 * inverse b^-1 of random b in Zq, but for that purpose we require
 * gcd(b, q) = 1. We expect M to be in the 500-bit range and n
 * relatively small, like 30. These are the parameters of the scheme and
 * they are expensive to compute.
 *
 * We set up an instance of the scheme as follows. A set of random
 * values x[j] mod q (j = 1...n), are generated as the zeros of a
 * polynomial of order n. The product terms (x - x[j]) are expanded to
 * form coefficients a[i] mod q (i = 0...n) in powers of x. These are
 * used as exponents of the generator g mod p to generate the private
 * encryption key A. The pair (gbar, ghat) of public server keys and the
 * pairs (xbar[j], xhat[j]) (j = 1...n) of private client keys are used
 * to construct the decryption keys. The devil is in the details.
 *
 * This routine generates a private server encryption file including the
 * private encryption key E and partial decryption keys gbar and ghat.
 * It then generates public client decryption files including the public
 * keys xbar[j] and xhat[j] for each client j. The partial decryption
 * files are used to compute the inverse of E. These values are suitably
 * blinded so secrets are not revealed.
 *
 * The distinguishing characteristic of this scheme is the capability to
 * revoke keys. Included in the calculation of E, gbar and ghat is the
 * product s = prod(s1[j]) (j = 1...n) above. If the factor s1[j] is
 * subsequently removed from the product and E, gbar and ghat
 * recomputed, the jth client will no longer be able to compute E^-1 and
 * thus unable to decrypt the messageblock.
 *
 * How it works
 *
 * The scheme goes like this. Bob has the server values (p, E, q, gbar,
 * ghat) and Alice has the client values (p, xbar, xhat).
 *
 * Alice rolls new random nonce r mod p and sends to Bob in the MV
 * request message. Bob rolls random nonce k mod q, encrypts y = r E^k
 * mod p and sends (y, gbar^k, ghat^k) to Alice.
 * 
 * Alice receives the response and computes the inverse (E^k)^-1 from
 * the partial decryption keys gbar^k, ghat^k, xbar and xhat. She then
 * decrypts y and verifies it matches the original r. The signed
 * response binds this knowledge to Bob's private key and the public key
 * previously received in his certificate.
 *
 * crypto_alice3 - construct Alice's challenge in MV scheme
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ID     bad or missing group key
 * XEVNT_PUB    bad or missing public key
 */
static int
crypto_alice3(
        struct peer *peer,      /* peer pointer */
        struct value *vp        /* value pointer */
        )
{
        DSA     *dsa;           /* MV parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;
        u_int   len;
        const BIGNUM *p;

        /*
         * The identity parameters must have correct format and content.
         */
        if (peer->ident_pkey == NULL)
                return (XEVNT_ID);

        if ((dsa = EVP_PKEY_get0_DSA(peer->ident_pkey->pkey)) == NULL) {
                msyslog(LOG_NOTICE, "crypto_alice3: defective key");
                return (XEVNT_PUB);
        }
        DSA_get0_pqg(dsa, &p, NULL, NULL);

        /*
         * Roll new random r (0 < r < q).
         */
        if (peer->iffval != NULL)
                BN_free(peer->iffval);
        peer->iffval = BN_new();
        len = BN_num_bytes(p);
        BN_rand(peer->iffval, len * 8, -1, 1);  /* r mod p */
        bctx = BN_CTX_new();
        BN_mod(peer->iffval, peer->iffval, p, bctx);
        BN_CTX_free(bctx);

        /*
         * Sign and send to Bob. The filestamp is from the local file.
         */
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = htonl(peer->ident_pkey->fstamp);
        vp->vallen = htonl(len);
        vp->ptr = emalloc(len);
        BN_bn2bin(peer->iffval, vp->ptr);
        if (tstamp == 0)
                return (XEVNT_OK);

        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, len);
        if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                vp->siglen = htonl(len);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_bob3 - construct Bob's response to Alice's challenge
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 */
static int
crypto_bob3(
        struct exten *ep,       /* extension pointer */
        struct value *vp        /* value pointer */
        )
{
        DSA     *dsa;           /* MV parameters */
        DSA     *sdsa;          /* DSA signature context fake */
        BN_CTX  *bctx;          /* BIGNUM context */
        EVP_MD_CTX *ctx;        /* signature context */
        tstamp_t tstamp;        /* NTP timestamp */
        BIGNUM  *r, *k, *u;
        u_char  *ptr;
        u_int   len;
        const BIGNUM *p, *q, *g;
        const BIGNUM *pub_key, *priv_key;
        BIGNUM *sp, *sq, *sg;

        /*
         * If the MV parameters are not valid, something awful
         * happened or we are being tormented.
         */
        if (mvkey_info == NULL) {
                msyslog(LOG_NOTICE, "crypto_bob3: scheme unavailable");
                return (XEVNT_ID);
        }
        dsa = EVP_PKEY_get0_DSA(mvkey_info->pkey);
        DSA_get0_pqg(dsa, &p, &q, &g);
        DSA_get0_key(dsa, &pub_key, &priv_key);

        /*
         * Extract r from the challenge.
         */
        len = exten_payload_size(ep);
        if (len == 0 || len > MAX_VALLEN)
                return (XEVNT_LEN);
        if ((r = BN_bin2bn((u_char *)ep->pkt, len, NULL)) == NULL) {
                msyslog(LOG_ERR, "crypto_bob3: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_ERR);
        }

        /*
         * Bob rolls random k (0 < k < q), making sure it is not a
         * factor of q. He then computes y = r A^k and sends (y, gbar^k,
         * and ghat^k) to Alice.
         */
        bctx = BN_CTX_new(); k = BN_new(); u = BN_new();
        sdsa = DSA_new();
        sp = BN_new(); sq = BN_new(); sg = BN_new();
        while (1) {
                BN_rand(k, BN_num_bits(q), 0, 0);
                BN_mod(k, k, q, bctx);
                BN_gcd(u, k, q, bctx);
                if (BN_is_one(u))
                        break;
        }
        BN_mod_exp(u, g, k, p, bctx); /* A^k r */
        BN_mod_mul(sp, u, r, p, bctx);
        BN_mod_exp(sq, priv_key, k, p, bctx); /* gbar */
        BN_mod_exp(sg, pub_key, k, p, bctx); /* ghat */
        DSA_set0_key(sdsa, BN_dup(pub_key), NULL);
        DSA_set0_pqg(sdsa, sp, sq, sg);
        BN_CTX_free(bctx); BN_free(k); BN_free(r); BN_free(u);
#ifdef DEBUG
        if (debug > 1)
                DSA_print_fp(stdout, sdsa, 0);
#endif

        /*
         * Encode the values in ASN.1 and sign. The filestamp is from
         * the local file.
         */
        memset(vp, 0, sizeof(struct value));
        tstamp = crypto_time();
        vp->tstamp = htonl(tstamp);
        vp->fstamp = htonl(mvkey_info->fstamp);
        len = i2d_DSAparams(sdsa, NULL);
        if (len == 0) {
                msyslog(LOG_ERR, "crypto_bob3: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                DSA_free(sdsa);
                return (XEVNT_ERR);
        }
        vp->vallen = htonl(len);
        ptr = emalloc(len);
        vp->ptr = ptr;
        i2d_DSAparams(sdsa, &ptr);
        DSA_free(sdsa);
        if (tstamp == 0)
                return (XEVNT_OK);

        vp->sig = emalloc(sign_siglen);
        ctx = EVP_MD_CTX_new();
        EVP_SignInit(ctx, sign_digest);
        EVP_SignUpdate(ctx, (u_char *)&vp->tstamp, 12);
        EVP_SignUpdate(ctx, vp->ptr, len);
        if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                INSIST(len <= sign_siglen);
                vp->siglen = htonl(len);
        }
        EVP_MD_CTX_free(ctx);
        return (XEVNT_OK);
}


/*
 * crypto_mv - verify Bob's response to Alice's challenge
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_ERR    protocol error
 * XEVNT_FSP    bad filestamp
 * XEVNT_ID     bad or missing group key
 * XEVNT_PUB    bad or missing public key
 */
int
crypto_mv(
        struct exten *ep,       /* extension pointer */
        struct peer *peer       /* peer structure pointer */
        )
{
        DSA     *dsa;           /* MV parameters */
        DSA     *sdsa;          /* DSA parameters */
        BN_CTX  *bctx;          /* BIGNUM context */
        BIGNUM  *k, *u, *v;
        u_int   len;
        const u_char *ptr;
        int     temp;
        const BIGNUM *p;
        const BIGNUM *pub_key, *priv_key;
        const BIGNUM *sp, *sq, *sg;

        /*
         * If the MV parameters are not valid or no challenge was sent,
         * something awful happened or we are being tormented.
         */
        if (peer->ident_pkey == NULL) {
                msyslog(LOG_NOTICE, "crypto_mv: scheme unavailable");
                return (XEVNT_ID);
        }
        if (ntohl(ep->fstamp) != peer->ident_pkey->fstamp) {
                msyslog(LOG_NOTICE, "crypto_mv: invalid filestamp %u",
                    ntohl(ep->fstamp));
                return (XEVNT_FSP);
        }
        if ((dsa = EVP_PKEY_get0_DSA(peer->ident_pkey->pkey)) == NULL) {
                msyslog(LOG_NOTICE, "crypto_mv: defective key");
                return (XEVNT_PUB);
        }
        DSA_get0_pqg(dsa, &p, NULL, NULL);
        DSA_get0_key(dsa, &pub_key, &priv_key);
        if (peer->iffval == NULL) {
                msyslog(LOG_NOTICE, "crypto_mv: missing challenge");
                return (XEVNT_ID);
        }

        /*
         * Extract the y, gbar and ghat values from the response.
         */
        bctx = BN_CTX_new(); k = BN_new(); u = BN_new(); v = BN_new();
        len = ntohl(ep->vallen);
        ptr = (u_char *)ep->pkt;
        if ((sdsa = d2i_DSAparams(NULL, &ptr, len)) == NULL) {
                msyslog(LOG_ERR, "crypto_mv: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_ERR);
        }
        DSA_get0_pqg(sdsa, &sp, &sq, &sg);

        /*
         * Compute (gbar^xhat ghat^xbar) mod p.
         */
        BN_mod_exp(u, sq, pub_key, p, bctx);
        BN_mod_exp(v, sg, priv_key, p, bctx);
        BN_mod_mul(u, u, v, p, bctx);
        BN_mod_mul(u, u, sp, p, bctx);

        /*
         * The result should match r.
         */
        temp = BN_cmp(u, peer->iffval);
        BN_CTX_free(bctx); BN_free(k); BN_free(u); BN_free(v);
        BN_free(peer->iffval);
        peer->iffval = NULL;
        DSA_free(sdsa);
        if (temp == 0)
                return (XEVNT_OK);

        msyslog(LOG_NOTICE, "crypto_mv: identity not verified");
        return (XEVNT_ID);
}


/*
 ***********************************************************************
 *                                                                     *
 * The following routines are used to manipulate certificates          *
 *                                                                     *
 ***********************************************************************
 */
/*
 * cert_sign - sign x509 certificate equest and update value structure.
 *
 * The certificate request includes a copy of the host certificate,
 * which includes the version number, subject name and public key of the
 * host. The resulting certificate includes these values plus the
 * serial number, issuer name and valid interval of the server. The
 * valid interval extends from the current time to the same time one
 * year hence. This may extend the life of the signed certificate beyond
 * that of the signer certificate.
 *
 * It is convenient to use the NTP seconds of the current time as the
 * serial number. In the value structure the timestamp is the current
 * time and the filestamp is taken from the extension field. Note this
 * routine is called only when the client clock is synchronized to a
 * proventic source, so timestamp comparisons are valid.
 *
 * The host certificate is valid from the time it was generated for a
 * period of one year. A signed certificate is valid from the time of
 * signature for a period of one year, but only the host certificate (or
 * sign certificate if used) is actually used to encrypt and decrypt
 * signatures. The signature trail is built from the client via the
 * intermediate servers to the trusted server. Each signature on the
 * trail must be valid at the time of signature, but it could happen
 * that a signer certificate expire before the signed certificate, which
 * remains valid until its expiration. 
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_CRT    bad or missing certificate
 * XEVNT_PER    host certificate expired
 * XEVNT_PUB    bad or missing public key
 * XEVNT_VFY    certificate not verified
 */
static int
cert_sign(
        struct exten *ep,       /* extension field pointer */
        struct value *vp        /* value pointer */
        )
{
        X509    *req;           /* X509 certificate request */
        X509    *cert;          /* X509 certificate */
        X509_EXTENSION *ext;    /* certificate extension */
        ASN1_INTEGER *serial;   /* serial number */
        X509_NAME *subj;        /* distinguished (common) name */
        EVP_PKEY *pkey;         /* public key */
        EVP_MD_CTX *ctx;        /* message digest context */
        tstamp_t tstamp;        /* NTP timestamp */
        struct calendar tscal;
        u_int   len;
        const u_char *cptr;
        u_char *ptr;
        int     i, temp;

        /*
         * Decode ASN.1 objects and construct certificate structure.
         * Make sure the system clock is synchronized to a proventic
         * source.
         */
        tstamp = crypto_time();
        if (tstamp == 0)
                return (XEVNT_TSP);

        len = exten_payload_size(ep);
        if (len == 0 || len > MAX_VALLEN)
                return (XEVNT_LEN);
        cptr = (void *)ep->pkt;
        if ((req = d2i_X509(NULL, &cptr, len)) == NULL) {
                msyslog(LOG_ERR, "cert_sign: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (XEVNT_CRT);
        }
        /*
         * Extract public key and check for errors.
         */
        if ((pkey = X509_get_pubkey(req)) == NULL) {
                msyslog(LOG_ERR, "cert_sign: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                X509_free(req);
                return (XEVNT_PUB);
        }

        /*
         * Generate X509 certificate signed by this server. If this is a
         * trusted host, the issuer name is the group name; otherwise,
         * it is the host name. Also copy any extensions that might be
         * present.
         */
        cert = X509_new();
        X509_set_version(cert, X509_get_version(req));
        serial = ASN1_INTEGER_new();
        ASN1_INTEGER_set(serial, tstamp);
        X509_set_serialNumber(cert, serial);
        X509_gmtime_adj(X509_getm_notBefore(cert), 0L);
        X509_gmtime_adj(X509_getm_notAfter(cert), YEAR);
        subj = X509_get_issuer_name(cert);
        X509_NAME_add_entry_by_txt(subj, "commonName", MBSTRING_ASC,
            hostval.ptr, strlen((const char *)hostval.ptr), -1, 0);
        subj = X509_get_subject_name(req);
        X509_set_subject_name(cert, subj);
        X509_set_pubkey(cert, pkey);
        temp = X509_get_ext_count(req);
        for (i = 0; i < temp; i++) {
                ext = X509_get_ext(req, i);
                INSIST(X509_add_ext(cert, ext, -1));
        }
        X509_free(req);

        /*
         * Sign and verify the client certificate, but only if the host
         * certificate has not expired.
         */
        (void)ntpcal_ntp_to_date(&tscal, tstamp, NULL);
        if ((calcomp(&tscal, &(cert_host->first)) < 0)
        || (calcomp(&tscal, &(cert_host->last)) > 0)) {
                X509_free(cert);
                return (XEVNT_PER);
        }
        X509_sign(cert, sign_pkey, sign_digest);
        if (X509_verify(cert, sign_pkey) <= 0) {
                msyslog(LOG_ERR, "cert_sign: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                X509_free(cert);
                return (XEVNT_VFY);
        }
        len = i2d_X509(cert, NULL);

        /*
         * Build and sign the value structure. We have to sign it here,
         * since the response has to be returned right away. This is a
         * clogging hazard.
         */
        memset(vp, 0, sizeof(struct value));
        vp->tstamp = htonl(tstamp);
        vp->fstamp = ep->fstamp;
        vp->vallen = htonl(len);
        vp->ptr = emalloc(len);
        ptr = vp->ptr;
        i2d_X509(cert, (unsigned char **)(intptr_t)&ptr);
        vp->siglen = 0;
        if (tstamp != 0) {
                vp->sig = emalloc(sign_siglen);
                ctx = EVP_MD_CTX_new();
                EVP_SignInit(ctx, sign_digest);
                EVP_SignUpdate(ctx, (u_char *)vp, 12);
                EVP_SignUpdate(ctx, vp->ptr, len);
                if (EVP_SignFinal(ctx, vp->sig, &len, sign_pkey)) {
                        INSIST(len <= sign_siglen);
                        vp->siglen = htonl(len);
                }
                EVP_MD_CTX_free(ctx);
        }
#ifdef DEBUG
        if (debug > 1)
                X509_print_fp(stdout, cert);
#endif
        X509_free(cert);
        return (XEVNT_OK);
}


/*
 * cert_install - install certificate in certificate cache
 *
 * This routine encodes an extension field into a certificate info/value
 * structure. It searches the certificate list for duplicates and
 * expunges whichever is older. Finally, it inserts this certificate
 * first on the list.
 *
 * Returns certificate info pointer if valid, NULL if not.
 */
struct cert_info *
cert_install(
        struct exten *ep,       /* cert info/value */
        struct peer *peer       /* peer structure */
        )
{
        struct cert_info *cp, *xp, **zp;

        /*
         * Parse and validate the signed certificate. If valid,
         * construct the info/value structure; otherwise, scamper home
         * empty handed.
         */
        if ((cp = cert_parse((u_char *)ep->pkt, (long)ntohl(ep->vallen),
            (tstamp_t)ntohl(ep->fstamp))) == NULL)
                return (NULL);

        /*
         * Scan certificate list looking for another certificate with
         * the same subject and issuer. If another is found with the
         * same or older filestamp, unlink it and return the goodies to
         * the heap. If another is found with a later filestamp, discard
         * the new one and leave the building with the old one.
         *
         * Make a note to study this issue again. An earlier certificate
         * with a long lifetime might be overtaken by a later
         * certificate with a short lifetime, thus invalidating the
         * earlier signature. However, we gotta find a way to leak old
         * stuff from the cache, so we do it anyway. 
         */
        zp = &cinfo;
        for (xp = cinfo; xp != NULL; xp = xp->link) {
                if (strcmp(cp->subject, xp->subject) == 0 &&
                    strcmp(cp->issuer, xp->issuer) == 0) {
                        if (ntohl(cp->cert.fstamp) <=
                            ntohl(xp->cert.fstamp)) {
                                cert_free(cp);
                                cp = xp;
                        } else {
                                *zp = xp->link;
                                cert_free(xp);
                                xp = NULL;
                        }
                        break;
                }
                zp = &xp->link;
        }
        if (xp == NULL) {
                cp->link = cinfo;
                cinfo = cp;
        }
        cp->flags |= CERT_VALID;
        crypto_update();
        return (cp);
}


/*
 * cert_hike - verify the signature using the issuer public key
 *
 * Returns
 * XEVNT_OK     success
 * XEVNT_CRT    bad or missing certificate
 * XEVNT_PER    host certificate expired
 * XEVNT_VFY    certificate not verified
 */
int
cert_hike(
        struct peer *peer,      /* peer structure pointer */
        struct cert_info *yp    /* issuer certificate */
        )
{
        struct cert_info *xp;   /* subject certificate */
        X509    *cert;          /* X509 certificate */
        const u_char *ptr;

        /*
         * Save the issuer on the new certificate, but remember the old
         * one.
         */
        if (peer->issuer != NULL)
                free(peer->issuer);
        peer->issuer = estrdup(yp->issuer);
        xp = peer->xinfo;
        peer->xinfo = yp;

        /*
         * If subject Y matches issuer Y, then the certificate trail is
         * complete. If Y is not trusted, the server certificate has yet
         * been signed, so keep trying. Otherwise, save the group key
         * and light the valid bit. If the host certificate is trusted,
         * do not execute a sign exchange. If no identity scheme is in
         * use, light the identity and proventic bits.
         */
        if (strcmp(yp->subject, yp->issuer) == 0) {
                if (!(yp->flags & CERT_TRUST))
                        return (XEVNT_OK);

                /*
                 * If the server has an an identity scheme, fetch the
                 * identity credentials. If not, the identity is
                 * verified only by the trusted certificate. The next
                 * signature will set the server proventic.
                 */
                peer->crypto |= CRYPTO_FLAG_CERT;
                peer->grpkey = yp->grpkey;
                if (peer->ident == NULL || !(peer->crypto &
                    CRYPTO_FLAG_MASK))
                        peer->crypto |= CRYPTO_FLAG_VRFY;
        }

        /*
         * If X exists, verify signature X using public key Y.
         */
        if (xp == NULL)
                return (XEVNT_OK);

        ptr = (u_char *)xp->cert.ptr;
        cert = d2i_X509(NULL, &ptr, ntohl(xp->cert.vallen));
        if (cert == NULL) {
                xp->flags |= CERT_ERROR;
                return (XEVNT_CRT);
        }
        if (X509_verify(cert, yp->pkey) <= 0) {
                X509_free(cert);
                xp->flags |= CERT_ERROR;
                return (XEVNT_VFY);
        }
        X509_free(cert);

        /*
         * Signature X is valid only if it begins during the
         * lifetime of Y. 
         */
        if ((calcomp(&(xp->first), &(yp->first)) < 0)
        || (calcomp(&(xp->first), &(yp->last)) > 0)) {
                xp->flags |= CERT_ERROR;
                return (XEVNT_PER);
        }
        xp->flags |= CERT_SIGN;
        return (XEVNT_OK);
}


/*
 * cert_parse - parse x509 certificate and create info/value structures.
 *
 * The server certificate includes the version number, issuer name,
 * subject name, public key and valid date interval. If the issuer name
 * is the same as the subject name, the certificate is self signed and
 * valid only if the server is configured as trustable. If the names are
 * different, another issuer has signed the server certificate and
 * vouched for it. In this case the server certificate is valid if
 * verified by the issuer public key.
 *
 * Returns certificate info/value pointer if valid, NULL if not.
 */
struct cert_info *              /* certificate information structure */
cert_parse(
        const u_char *asn1cert, /* X509 certificate */
        long    len,            /* certificate length */
        tstamp_t fstamp         /* filestamp */
        )
{
        X509    *cert;          /* X509 certificate */
        struct cert_info *ret;  /* certificate info/value */
        BIO     *bp;
        char    pathbuf[MAXFILENAME];
        const u_char *ptr;
        char    *pch;
        int     cnt, i;
        struct calendar fscal;

        /*
         * Decode ASN.1 objects and construct certificate structure.
         */
        ptr = asn1cert;
        if ((cert = d2i_X509(NULL, &ptr, len)) == NULL) {
                msyslog(LOG_ERR, "cert_parse: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                return (NULL);
        }
#ifdef DEBUG
        if (debug > 1)
                X509_print_fp(stdout, cert);
#endif

        /*
         * Extract version, subject name and public key.
         */
        ret = emalloc_zero(sizeof(*ret));
        if ((ret->pkey = X509_get_pubkey(cert)) == NULL) {
                msyslog(LOG_ERR, "cert_parse: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                cert_free(ret);
                X509_free(cert);
                return (NULL);
        }
        ret->version = X509_get_version(cert);
        X509_NAME_oneline(X509_get_subject_name(cert), pathbuf,
            sizeof(pathbuf));
        pch = strstr(pathbuf, "CN=");
        if (NULL == pch) {
                msyslog(LOG_NOTICE, "cert_parse: invalid subject %s",
                    pathbuf);
                cert_free(ret);
                X509_free(cert);
                return (NULL);
        }
        ret->subject = estrdup(pch + 3);

        /*
         * Extract remaining objects. Note that the NTP serial number is
         * the NTP seconds at the time of signing, but this might not be
         * the case for other authority. We don't bother to check the
         * objects at this time, since the real crunch can happen only
         * when the time is valid but not yet certificated.
         */
        ret->nid = X509_get_signature_nid(cert);
        ret->digest = (const EVP_MD *)EVP_get_digestbynid(ret->nid);
        ret->serial =
            (u_long)ASN1_INTEGER_get(X509_get_serialNumber(cert));
        X509_NAME_oneline(X509_get_issuer_name(cert), pathbuf,
            sizeof(pathbuf));
        if ((pch = strstr(pathbuf, "CN=")) == NULL) {
                msyslog(LOG_NOTICE, "cert_parse: invalid issuer %s",
                    pathbuf);
                cert_free(ret);
                X509_free(cert);
                return (NULL);
        }
        ret->issuer = estrdup(pch + 3);
        asn_to_calendar(X509_get0_notBefore(cert), &(ret->first));
        asn_to_calendar(X509_get0_notAfter(cert), &(ret->last));

        /*
         * Extract extension fields. These are ad hoc ripoffs of
         * currently assigned functions and will certainly be changed
         * before prime time.
         */
        cnt = X509_get_ext_count(cert);
        for (i = 0; i < cnt; i++) {
                X509_EXTENSION *ext;
                ASN1_OBJECT *obj;
                int nid;
                ASN1_OCTET_STRING *data;

                ext = X509_get_ext(cert, i);
                obj = X509_EXTENSION_get_object(ext);
                nid = OBJ_obj2nid(obj);

                switch (nid) {

                /*
                 * If a key_usage field is present, we decode whether
                 * this is a trusted or private certificate. This is
                 * dorky; all we want is to compare NIDs, but OpenSSL
                 * insists on BIO text strings.
                 */
                case NID_ext_key_usage:
                        bp = BIO_new(BIO_s_mem());
                        X509V3_EXT_print(bp, ext, 0, 0);
                        BIO_gets(bp, pathbuf, sizeof(pathbuf));
                        BIO_free(bp);
                        if (strcmp(pathbuf, "Trust Root") == 0)
                                ret->flags |= CERT_TRUST;
                        else if (strcmp(pathbuf, "Private") == 0)
                                ret->flags |= CERT_PRIV;
                        DPRINTF(1, ("cert_parse: %s: %s\n",
                                    OBJ_nid2ln(nid), pathbuf));
                        break;

                /*
                 * If a NID_subject_key_identifier field is present, it
                 * contains the GQ public key.
                 */
                case NID_subject_key_identifier:
                        data = X509_EXTENSION_get_data(ext);
                        ret->grpkey = BN_bin2bn(&data->data[2],
                            data->length - 2, NULL);
                        /* fall through */
                default:
                        DPRINTF(1, ("cert_parse: %s\n",
                                    OBJ_nid2ln(nid)));
                        break;
                }
        }
        if (strcmp(ret->subject, ret->issuer) == 0) {

                /*
                 * If certificate is self signed, verify signature.
                 */
                if (X509_verify(cert, ret->pkey) <= 0) {
                        msyslog(LOG_NOTICE,
                            "cert_parse: signature not verified %s",
                            ret->subject);
                        cert_free(ret);
                        X509_free(cert);
                        return (NULL);
                }
        } else {

                /*
                 * Check for a certificate loop.
                 */
                if (strcmp((const char *)hostval.ptr, ret->issuer) == 0) {
                        msyslog(LOG_NOTICE,
                            "cert_parse: certificate trail loop %s",
                            ret->subject);
                        cert_free(ret);
                        X509_free(cert);
                        return (NULL);
                }
        }

        /*
         * Verify certificate valid times. Note that certificates cannot
         * be retroactive.
         */
        (void)ntpcal_ntp_to_date(&fscal, fstamp, NULL);
        if ((calcomp(&(ret->first), &(ret->last)) > 0)
        || (calcomp(&(ret->first), &fscal) < 0)) {
                msyslog(LOG_NOTICE,
                    "cert_parse: invalid times %s first %u-%02u-%02uT%02u:%02u:%02u last %u-%02u-%02uT%02u:%02u:%02u fstamp %u-%02u-%02uT%02u:%02u:%02u",
                    ret->subject,
                    ret->first.year, ret->first.month, ret->first.monthday,
                    ret->first.hour, ret->first.minute, ret->first.second,
                    ret->last.year, ret->last.month, ret->last.monthday,
                    ret->last.hour, ret->last.minute, ret->last.second,
                    fscal.year, fscal.month, fscal.monthday,
                    fscal.hour, fscal.minute, fscal.second);
                cert_free(ret);
                X509_free(cert);
                return (NULL);
        }

        /*
         * Build the value structure to sign and send later.
         */
        ret->cert.fstamp = htonl(fstamp);
        ret->cert.vallen = htonl(len);
        ret->cert.ptr = emalloc(len);
        memcpy(ret->cert.ptr, asn1cert, len);
        X509_free(cert);
        return (ret);
}


/*
 * cert_free - free certificate information structure
 */
void
cert_free(
        struct cert_info *cinf  /* certificate info/value structure */ 
        )
{
        if (cinf->pkey != NULL)
                EVP_PKEY_free(cinf->pkey);
        if (cinf->subject != NULL)
                free(cinf->subject);
        if (cinf->issuer != NULL)
                free(cinf->issuer);
        if (cinf->grpkey != NULL)
                BN_free(cinf->grpkey);
        value_free(&cinf->cert);
        free(cinf);
}


/*
 * crypto_key - load cryptographic parameters and keys
 *
 * This routine searches the key cache for matching name in the form
 * ntpkey_<key>_<name>, where <key> is one of host, sign, iff, gq, mv,
 * and <name> is the host/group name. If not found, it tries to load a
 * PEM-encoded file of the same name and extracts the filestamp from
 * the first line of the file name. It returns the key pointer if valid,
 * NULL if not.
 */
static struct pkey_info *
crypto_key(
        char    *cp,            /* file name */
        char    *passwd1,       /* password */
        sockaddr_u *addr        /* IP address */
        )
{
        FILE    *str;           /* file handle */
        struct pkey_info *pkp;  /* generic key */
        EVP_PKEY *pkey = NULL;  /* public/private key */
        tstamp_t fstamp;
        char    filename[MAXFILENAME]; /* name of key file */
        char    linkname[MAXFILENAME]; /* filestamp buffer) */
        char    statstr[NTP_MAXSTRLEN]; /* statistics for filegen */
        char    *ptr;

        /*
         * Search the key cache for matching key and name.
         */
        for (pkp = pkinfo; pkp != NULL; pkp = pkp->link) {
                if (strcmp(cp, pkp->name) == 0)
                        return (pkp);
        }  

        /*
         * Open the key file. If the first character of the file name is
         * not '/', prepend the keys directory string. If something goes
         * wrong, abandon ship.
         */
        if (*cp == '/')
                strlcpy(filename, cp, sizeof(filename));
        else
                snprintf(filename, sizeof(filename), "%s/%s", keysdir,
                    cp);
        str = fopen(filename, "r");
        if (str == NULL)
                return (NULL);

        /*
         * Read the filestamp, which is contained in the first line.
         */
        if ((ptr = fgets(linkname, sizeof(linkname), str)) == NULL) {
                msyslog(LOG_ERR, "crypto_key: empty file %s",
                    filename);
                fclose(str);
                return (NULL);
        }
        if ((ptr = strrchr(ptr, '.')) == NULL) {
                msyslog(LOG_ERR, "crypto_key: no filestamp %s",
                    filename);
                fclose(str);
                return (NULL);
        }
        if (sscanf(++ptr, "%u", &fstamp) != 1) {
                msyslog(LOG_ERR, "crypto_key: invalid filestamp %s",
                    filename);
                fclose(str);
                return (NULL);
        }

        /*
         * Read and decrypt PEM-encoded private key. If it fails to
         * decrypt, game over.
         */
        pkey = PEM_read_PrivateKey(str, NULL, NULL, passwd1);
        fclose(str);
        if (pkey == NULL) {
                msyslog(LOG_ERR, "crypto_key: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                exit (-1);
        }

        /*
         * Make a new entry in the key cache.
         */
        pkp = emalloc(sizeof(struct pkey_info));
        pkp->link = pkinfo;
        pkinfo = pkp;
        pkp->pkey = pkey;
        pkp->name = estrdup(cp);
        pkp->fstamp = fstamp;

        /*
         * Leave tracks in the cryptostats.
         */
        if ((ptr = strrchr(linkname, '\n')) != NULL)
                *ptr = '\0'; 
        snprintf(statstr, sizeof(statstr), "%s mod %d", &linkname[2],
            EVP_PKEY_size(pkey) * 8);
        record_crypto_stats(addr, statstr);
        
        DPRINTF(1, ("crypto_key: %s\n", statstr));
#ifdef DEBUG
        if (debug > 1) {
                if (EVP_PKEY_base_id(pkey) == EVP_PKEY_DSA)
                        DSA_print_fp(stdout, EVP_PKEY_get0_DSA(pkey), 0);
                else if (EVP_PKEY_base_id(pkey) == EVP_PKEY_RSA)
                        RSA_print_fp(stdout, EVP_PKEY_get0_RSA(pkey), 0);
        }
#endif
        return (pkp);
}


/*
 ***********************************************************************
 *                                                                     *
 * The following routines are used only at initialization time         *
 *                                                                     *
 ***********************************************************************
 */
/*
 * crypto_cert - load certificate from file
 *
 * This routine loads an X.509 RSA or DSA certificate from a file and
 * constructs a info/cert value structure for this machine. The
 * structure includes a filestamp extracted from the file name. Later
 * the certificate can be sent to another machine on request.
 *
 * Returns certificate info/value pointer if valid, NULL if not.
 */
static struct cert_info *       /* certificate information */
crypto_cert(
        char    *cp             /* file name */
        )
{
        struct cert_info *ret; /* certificate information */
        FILE    *str;           /* file handle */
        char    filename[MAXFILENAME]; /* name of certificate file */
        char    linkname[MAXFILENAME]; /* filestamp buffer */
        char    statstr[NTP_MAXSTRLEN]; /* statistics for filegen */
        tstamp_t fstamp;        /* filestamp */
        long    len;
        char    *ptr;
        char    *name, *header;
        u_char  *data;

        /*
         * Open the certificate file. If the first character of the file
         * name is not '/', prepend the keys directory string. If
         * something goes wrong, abandon ship.
         */
        if (*cp == '/')
                strlcpy(filename, cp, sizeof(filename));
        else
                snprintf(filename, sizeof(filename), "%s/%s", keysdir,
                    cp);
        str = fopen(filename, "r");
        if (str == NULL)
                return (NULL);

        /*
         * Read the filestamp, which is contained in the first line.
         */
        if ((ptr = fgets(linkname, sizeof(linkname), str)) == NULL) {
                msyslog(LOG_ERR, "crypto_cert: empty file %s",
                    filename);
                fclose(str);
                return (NULL);
        }
        if ((ptr = strrchr(ptr, '.')) == NULL) {
                msyslog(LOG_ERR, "crypto_cert: no filestamp %s",
                    filename);
                fclose(str);
                return (NULL);
        }
        if (sscanf(++ptr, "%u", &fstamp) != 1) {
                msyslog(LOG_ERR, "crypto_cert: invalid filestamp %s",
                    filename);
                fclose(str);
                return (NULL);
        }

        /*
         * Read PEM-encoded certificate and install.
         */
        if (!PEM_read(str, &name, &header, &data, &len)) {
                msyslog(LOG_ERR, "crypto_cert: %s",
                    ERR_error_string(ERR_get_error(), NULL));
                fclose(str);
                return (NULL);
        }
        fclose(str);
        free(header);
        if (strcmp(name, "CERTIFICATE") != 0) {
                msyslog(LOG_NOTICE, "crypto_cert: wrong PEM type %s",
                    name);
                free(name);
                free(data);
                return (NULL);
        }
        free(name);

        /*
         * Parse certificate and generate info/value structure. The
         * pointer and copy nonsense is due something broken in Solaris.
         */
        ret = cert_parse(data, len, fstamp);
        free(data);
        if (ret == NULL)
                return (NULL);

        if ((ptr = strrchr(linkname, '\n')) != NULL)
                *ptr = '\0'; 
        snprintf(statstr, sizeof(statstr), "%s 0x%x len %lu",
            &linkname[2], ret->flags, len);
        record_crypto_stats(NULL, statstr);
        DPRINTF(1, ("crypto_cert: %s\n", statstr));
        return (ret);
}


/*
 * crypto_setup - load keys, certificate and identity parameters
 *
 * This routine loads the public/private host key and certificate. If
 * available, it loads the public/private sign key, which defaults to
 * the host key. The host key must be RSA, but the sign key can be
 * either RSA or DSA. If a trusted certificate, it loads the identity
 * parameters. In either case, the public key on the certificate must
 * agree with the sign key.
 *
 * Required but missing files and inconsistent data and errors are
 * fatal. Allowing configuration to continue would be hazardous and
 * require really messy error checks.
 */
void
crypto_setup(void)
{
        struct pkey_info *pinfo; /* private/public key */
        char    filename[MAXFILENAME]; /* file name buffer */
        char    hostname[MAXFILENAME]; /* host name buffer */
        char    *randfile;
        char    statstr[NTP_MAXSTRLEN]; /* statistics for filegen */
        l_fp    seed;           /* crypto PRNG seed as NTP timestamp */
        u_int   len;
        int     bytes;
        u_char  *ptr;

        /*
         * Check for correct OpenSSL version and avoid initialization in
         * the case of multiple crypto commands.
         */
        if (crypto_flags & CRYPTO_FLAG_ENAB) {
                msyslog(LOG_NOTICE,
                    "crypto_setup: spurious crypto command");
                return;
        }
        ssl_check_version();

        /*
         * Load required random seed file and seed the random number
         * generator. Be default, it is found as .rnd in the user home
         * directory. The root home directory may be / or /root,
         * depending on the system. Wiggle the contents a bit and write
         * it back so the sequence does not repeat when we next restart.
         */
        if (!RAND_status()) {
                if (rand_file == NULL) {
                        RAND_file_name(filename, sizeof(filename));
                        randfile = filename;
                } else if (*rand_file != '/') {
                        snprintf(filename, sizeof(filename), "%s/%s",
                            keysdir, rand_file);
                        randfile = filename;
                } else
                        randfile = rand_file;

                if ((bytes = RAND_load_file(randfile, -1)) == 0) {
                        msyslog(LOG_ERR,
                            "crypto_setup: random seed file %s missing",
                            randfile);
                        exit (-1);
                }
                arc4random_buf(&seed, sizeof(l_fp));
                RAND_seed(&seed, sizeof(l_fp));
                RAND_write_file(randfile);
                DPRINTF(1, ("crypto_setup: OpenSSL version %lx random seed file %s bytes read %d\n",
                            OpenSSL_version_num(), randfile, bytes));

        }

        /*
         * Initialize structures.
         */
        gethostname(hostname, sizeof(hostname));
        if (host_filename != NULL)
                strlcpy(hostname, host_filename, sizeof(hostname));
        if (passwd == NULL)
                passwd = estrdup(hostname);
        memset(&hostval, 0, sizeof(hostval));
        memset(&pubkey, 0, sizeof(pubkey));
        memset(&tai_leap, 0, sizeof(tai_leap));

        /*
         * Load required host key from file "ntpkey_host_<hostname>". If
         * no host key file is not found or has invalid password, life
         * as we know it ends. The host key also becomes the default
         * sign key. 
         */
        snprintf(filename, sizeof(filename), "ntpkey_host_%s", hostname);
        pinfo = crypto_key(filename, passwd, NULL);
        if (pinfo == NULL) {
                msyslog(LOG_ERR,
                    "crypto_setup: host key file %s not found or corrupt",
                    filename);
                exit (-1);
        }
        if (EVP_PKEY_base_id(pinfo->pkey) != EVP_PKEY_RSA) {
                msyslog(LOG_ERR,
                    "crypto_setup: host key is not RSA key type");
                exit (-1);
        }
        host_pkey = pinfo->pkey;
        sign_pkey = host_pkey;
        hostval.fstamp = htonl(pinfo->fstamp);
        
        /*
         * Construct public key extension field for agreement scheme.
         */
        len = i2d_PublicKey(host_pkey, NULL);
        ptr = emalloc(len);
        pubkey.ptr = ptr;
        i2d_PublicKey(host_pkey, &ptr);
        pubkey.fstamp = hostval.fstamp;
        pubkey.vallen = htonl(len);

        /*
         * Load optional sign key from file "ntpkey_sign_<hostname>". If
         * available, it becomes the sign key.
         */
        snprintf(filename, sizeof(filename), "ntpkey_sign_%s", hostname);
        pinfo = crypto_key(filename, passwd, NULL);
        if (pinfo != NULL)
                sign_pkey = pinfo->pkey;

        /*
         * Load required certificate from file "ntpkey_cert_<hostname>".
         */
        snprintf(filename, sizeof(filename), "ntpkey_cert_%s", hostname);
        cinfo = crypto_cert(filename);
        if (cinfo == NULL) {
                msyslog(LOG_ERR,
                    "crypto_setup: certificate file %s not found or corrupt",
                    filename);
                exit (-1);
        }
        cert_host = cinfo;
        sign_digest = cinfo->digest;
        sign_siglen = EVP_PKEY_size(sign_pkey);
        if (cinfo->flags & CERT_PRIV)
                crypto_flags |= CRYPTO_FLAG_PRIV;

        /*
         * The certificate must be self-signed.
         */
        if (strcmp(cinfo->subject, cinfo->issuer) != 0) {
                msyslog(LOG_ERR,
                    "crypto_setup: certificate %s is not self-signed",
                    filename);
                exit (-1);
        }
        hostval.ptr = estrdup(cinfo->subject);
        hostval.vallen = htonl(strlen(cinfo->subject));
        sys_hostname = hostval.ptr;
        ptr = (u_char *)strchr(sys_hostname, '@');
        if (ptr != NULL)
                sys_groupname = estrdup((char *)++ptr);
        if (ident_filename != NULL)
                strlcpy(hostname, ident_filename, sizeof(hostname));

        /*
         * Load optional IFF parameters from file
         * "ntpkey_iffkey_<hostname>".
         */
        snprintf(filename, sizeof(filename), "ntpkey_iffkey_%s",
            hostname);
        iffkey_info = crypto_key(filename, passwd, NULL);
        if (iffkey_info != NULL)
                crypto_flags |= CRYPTO_FLAG_IFF;

        /*
         * Load optional GQ parameters from file
         * "ntpkey_gqkey_<hostname>".
         */
        snprintf(filename, sizeof(filename), "ntpkey_gqkey_%s",
            hostname);
        gqkey_info = crypto_key(filename, passwd, NULL);
        if (gqkey_info != NULL)
                crypto_flags |= CRYPTO_FLAG_GQ;

        /*
         * Load optional MV parameters from file
         * "ntpkey_mvkey_<hostname>".
         */
        snprintf(filename, sizeof(filename), "ntpkey_mvkey_%s",
            hostname);
        mvkey_info = crypto_key(filename, passwd, NULL);
        if (mvkey_info != NULL)
                crypto_flags |= CRYPTO_FLAG_MV;

        /*
         * We met the enemy and he is us. Now strike up the dance.
         */
        crypto_flags |= CRYPTO_FLAG_ENAB | (cinfo->nid << 16);
        snprintf(statstr, sizeof(statstr), "setup 0x%x host %s %s",
            crypto_flags, hostname, OBJ_nid2ln(cinfo->nid));
        record_crypto_stats(NULL, statstr);
        DPRINTF(1, ("crypto_setup: %s\n", statstr));
}


/*
 * crypto_config - configure data from the crypto command.
 */
void
crypto_config(
        int     item,           /* configuration item */
        char    *cp             /* item name */
        )
{
        int     nid;

        DPRINTF(1, ("crypto_config: item %d %s\n", item, cp));

        switch (item) {

        /*
         * Set host name (host).
         */
        case CRYPTO_CONF_PRIV:
                if (NULL != host_filename)
                        free(host_filename);
                host_filename = estrdup(cp);
                break;

        /*
         * Set group name (ident).
         */
        case CRYPTO_CONF_IDENT:
                if (NULL != ident_filename)
                        free(ident_filename);
                ident_filename = estrdup(cp);
                break;

        /*
         * Set private key password (pw).
         */
        case CRYPTO_CONF_PW:
                if (NULL != passwd)
                        free(passwd);
                passwd = estrdup(cp);
                break;

        /*
         * Set random seed file name (randfile).
         */
        case CRYPTO_CONF_RAND:
                if (NULL != rand_file)
                        free(rand_file);
                rand_file = estrdup(cp);
                break;

        /*
         * Set message digest NID.
         */
        case CRYPTO_CONF_NID:
                nid = OBJ_sn2nid(cp);
                if (nid == 0)
                        msyslog(LOG_ERR,
                            "crypto_config: invalid digest name %s", cp);
                else
                        crypto_nid = nid;
                break;
        }
}

/*
 * Get the  payload size (internal value length) of an extension packet.
 * If the inner value size does not match the outer packet size (that
 * is, the value would end behind the frame given by the opcode/size
 * field) the function will effectively return UINT_MAX. If the frame is
 * too short to hold a variable-sized value, the return value is zero.
 */
static u_int
exten_payload_size(
        const struct exten * ep)
{
        typedef const u_char *BPTR;
        
        size_t extn_size;
        size_t data_size;
        size_t head_size;

        data_size = 0;
        if (NULL != ep) {
                head_size = (BPTR)(&ep->vallen + 1) - (BPTR)ep;
                extn_size = (uint16_t)(ntohl(ep->opcode) & 0x0000ffff);
                if (extn_size >= head_size) {
                        data_size = (uint32_t)ntohl(ep->vallen);
                        if (data_size > extn_size - head_size)
                                data_size = ~(size_t)0u;
                }
        }
        return (u_int)data_size;
}
# else  /* !AUTOKEY follows */
int ntp_crypto_bs_pubkey;
# endif /* !AUTOKEY */