xref: /titanic_44/usr/src/lib/sasl_plugins/digestmd5/digestmd5.c (revision 694c35faa87b858ecdadfe4fc592615f4eefbb07)

/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/* DIGEST-MD5 SASL plugin
 * Rob Siemborski
 * Tim Martin
 * Alexey Melnikov
 * $Id: digestmd5.c,v 1.153 2003/03/30 22:17:06 leg Exp $
 */
/*
 * Copyright (c) 1998-2003 Carnegie Mellon University.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *
 * 3. The name "Carnegie Mellon University" must not be used to
 *    endorse or promote products derived from this software without
 *    prior written permission. For permission or any other legal
 *    details, please contact
 *      Office of Technology Transfer
 *      Carnegie Mellon University
 *      5000 Forbes Avenue
 *      Pittsburgh, PA  15213-3890
 *      (412) 268-4387, fax: (412) 268-7395
 *      tech-transfer@andrew.cmu.edu
 *
 * 4. Redistributions of any form whatsoever must retain the following
 *    acknowledgment:
 *    "This product includes software developed by Computing Services
 *     at Carnegie Mellon University (http://www.cmu.edu/computing/)."
 *
 * CARNEGIE MELLON UNIVERSITY DISCLAIMS ALL WARRANTIES WITH REGARD TO
 * THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS, IN NO EVENT SHALL CARNEGIE MELLON UNIVERSITY BE LIABLE
 * FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
 * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <config.h>

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#ifndef macintosh
#include <sys/types.h>
#include <sys/stat.h>
#endif
#include <fcntl.h>
#include <ctype.h>

/* DES support */
#ifdef WITH_DES
# ifdef WITH_SSL_DES
#  include <openssl/des.h>
# else /* system DES library */
#  include <des.h>
# endif
#endif /* WITH_DES */

#ifdef WIN32
# include <winsock.h>
#else /* Unix */
# include <netinet/in.h>
#endif /* WIN32 */

#ifdef _SUN_SDK_
#include <unistd.h>
#endif /* _SUN_SDK_ */

#include <sasl.h>
#include <saslplug.h>

#include "plugin_common.h"

#if defined _SUN_SDK_  && defined USE_UEF
#include <security/cryptoki.h>
static int uef_init(const sasl_utils_t *utils);
#endif /* _SUN_SDK_ && USE_UEF */

#ifndef WIN32
extern int strcasecmp(const char *s1, const char *s2);
#endif /* end WIN32 */

#ifdef macintosh
#include <sasl_md5_plugin_decl.h>
#endif

/* external definitions */

#ifndef _SUN_SDK_
#ifdef sun
/* gotta define gethostname ourselves on suns */
extern int      gethostname(char *, int);
#endif
#endif /* !_SUN_SDK_ */

#define bool int

#ifndef TRUE
#define TRUE  (1)
#define FALSE (0)
#endif

#define DEFAULT_BUFSIZE 0xFFFF

/*****************************  Common Section  *****************************/

#ifndef _SUN_SDK_
static const char plugin_id[] = "$Id: digestmd5.c,v 1.153 2003/03/30 22:17:06 leg Exp $";
#endif /* !_SUN_SDK_ */

/* Definitions */
#define NONCE_SIZE (32)		/* arbitrary */

/* Layer Flags */
#define DIGEST_NOLAYER    (1)
#define DIGEST_INTEGRITY  (2)
#define DIGEST_PRIVACY    (4)

/* defines */
#define HASHLEN 16
typedef unsigned char HASH[HASHLEN + 1];
#define HASHHEXLEN 32
typedef unsigned char HASHHEX[HASHHEXLEN + 1];

#define MAC_SIZE 10
#define MAC_OFFS 2

const char *SEALING_CLIENT_SERVER="Digest H(A1) to client-to-server sealing key magic constant";
const char *SEALING_SERVER_CLIENT="Digest H(A1) to server-to-client sealing key magic constant";

const char *SIGNING_CLIENT_SERVER="Digest session key to client-to-server signing key magic constant";
const char *SIGNING_SERVER_CLIENT="Digest session key to server-to-client signing key magic constant";

#define HT	(9)
#define CR	(13)
#define LF	(10)
#define SP	(32)
#define DEL	(127)

struct context;

/* function definitions for cipher encode/decode */
typedef int cipher_function_t(struct context *,
			      const char *,
			      unsigned,
			      unsigned char[],
			      char *,
			      unsigned *);

#ifdef _SUN_SDK_
typedef int cipher_init_t(struct context *, char [16],
                                            char [16]);
#else
typedef int cipher_init_t(struct context *, unsigned char [16],
                                            unsigned char [16]);
#endif /* _SUN_SDK_ */

typedef void cipher_free_t(struct context *);

enum Context_type { SERVER = 0, CLIENT = 1 };

typedef struct cipher_context cipher_context_t;

/* cached auth info used for fast reauth */
typedef struct reauth_entry {
    char *authid;
    char *realm;
    unsigned char *nonce;
    unsigned int nonce_count;
    unsigned char *cnonce;

    union {
	struct {
	    time_t timestamp;
	} s; /* server stuff */

	struct {
	    char *serverFQDN;
	    int protection;
	    struct digest_cipher *cipher;
	    unsigned int server_maxbuf;
	} c; /* client stuff */
    } u;
} reauth_entry_t;

typedef struct reauth_cache {
    /* static stuff */
    enum Context_type i_am;	/* are we the client or server? */
    time_t timeout;
    void *mutex;
    size_t size;

    reauth_entry_t *e;		/* fixed-size hash table of entries */
} reauth_cache_t;

/* context that stores info */
typedef struct context {
    int state;			/* state in the authentication we are in */
    enum Context_type i_am;	/* are we the client or server? */

    reauth_cache_t *reauth;

    char *authid;
    char *realm;
    unsigned char *nonce;
    unsigned int nonce_count;
    unsigned char *cnonce;

    char *response_value;

    unsigned int seqnum;
    unsigned int rec_seqnum;	/* for checking integrity */

    HASH Ki_send;
    HASH Ki_receive;

    HASH HA1;		/* Kcc or Kcs */

    /* copy of utils from the params structures */
    const sasl_utils_t *utils;

    /* For general use */
    char *out_buf;
    unsigned out_buf_len;

    /* for encoding/decoding */
    buffer_info_t *enc_in_buf;
    char *encode_buf, *decode_buf, *decode_once_buf;
    unsigned encode_buf_len, decode_buf_len, decode_once_buf_len;
    char *decode_tmp_buf;
    unsigned decode_tmp_buf_len;
    char *MAC_buf;
    unsigned MAC_buf_len;

    char *buffer;
    char sizebuf[4];
    int cursize;

    /* Layer info */
    unsigned int size; /* Absolute size of buffer */
    unsigned int needsize; /* How much of the size of the buffer is left */

    /* Server MaxBuf for Client or Client MaxBuf For Server */
    /* INCOMING */
    unsigned int in_maxbuf;

    /* if privacy mode is used use these functions for encode and decode */
    cipher_function_t *cipher_enc;
    cipher_function_t *cipher_dec;
    cipher_init_t *cipher_init;
    cipher_free_t *cipher_free;
    struct cipher_context *cipher_enc_context;
    struct cipher_context *cipher_dec_context;
} context_t;

struct digest_cipher {
    char *name;
    sasl_ssf_t ssf;
    int n; /* bits to make privacy key */
    int flag; /* a bitmask to make things easier for us */

    cipher_function_t *cipher_enc;
    cipher_function_t *cipher_dec;
    cipher_init_t *cipher_init;
    cipher_free_t *cipher_free;
};

#ifdef _SUN_SDK_
static const unsigned char *COLON = (unsigned char *)":";
#else
static const unsigned char *COLON = ":";
#endif /* _SUN_SDK_ */

/* Hashes a string to produce an unsigned short */
static unsigned hash(const char *str)
{
    unsigned val = 0;
    int i;

    while (str && *str) {
	i = (int) *str;
	val ^= i;
	val <<= 1;
	str++;
    }

    return val;
}

static void CvtHex(HASH Bin, HASHHEX Hex)
{
    unsigned short  i;
    unsigned char   j;

    for (i = 0; i < HASHLEN; i++) {
	j = (Bin[i] >> 4) & 0xf;
	if (j <= 9)
	    Hex[i * 2] = (j + '0');
	else
	    Hex[i * 2] = (j + 'a' - 10);
	j = Bin[i] & 0xf;
	if (j <= 9)
	    Hex[i * 2 + 1] = (j + '0');
	else
	    Hex[i * 2 + 1] = (j + 'a' - 10);
    }
    Hex[HASHHEXLEN] = '\0';
}

/*
 * calculate request-digest/response-digest as per HTTP Digest spec
 */
void
DigestCalcResponse(const sasl_utils_t * utils,
		   HASHHEX HA1,	/* H(A1) */
		   unsigned char *pszNonce,	/* nonce from server */
		   unsigned int pszNonceCount,	/* 8 hex digits */
		   unsigned char *pszCNonce,	/* client nonce */
		   unsigned char *pszQop,	/* qop-value: "", "auth",
						 * "auth-int" */
		   unsigned char *pszDigestUri,	/* requested URL */
		   unsigned char *pszMethod,
		   HASHHEX HEntity,	/* H(entity body) if qop="auth-int" */
		   HASHHEX Response	/* request-digest or response-digest */
    )
{
    MD5_CTX         Md5Ctx;
    HASH            HA2;
    HASH            RespHash;
    HASHHEX         HA2Hex;
    char ncvalue[10];

    /* calculate H(A2) */
    utils->MD5Init(&Md5Ctx);

    if (pszMethod != NULL) {
	utils->MD5Update(&Md5Ctx, pszMethod, strlen((char *) pszMethod));
    }
    utils->MD5Update(&Md5Ctx, (unsigned char *) COLON, 1);

    /* utils->MD5Update(&Md5Ctx, (unsigned char *) "AUTHENTICATE:", 13); */
    utils->MD5Update(&Md5Ctx, pszDigestUri, strlen((char *) pszDigestUri));
    if (strcasecmp((char *) pszQop, "auth") != 0) {
	/* append ":00000000000000000000000000000000" */
	utils->MD5Update(&Md5Ctx, COLON, 1);
	utils->MD5Update(&Md5Ctx, HEntity, HASHHEXLEN);
    }
    utils->MD5Final(HA2, &Md5Ctx);
    CvtHex(HA2, HA2Hex);

    /* calculate response */
    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, HA1, HASHHEXLEN);
    utils->MD5Update(&Md5Ctx, COLON, 1);
    utils->MD5Update(&Md5Ctx, pszNonce, strlen((char *) pszNonce));
    utils->MD5Update(&Md5Ctx, COLON, 1);
    if (*pszQop) {
	sprintf(ncvalue, "%08x", pszNonceCount);
#ifdef _SUN_SDK_
	utils->MD5Update(&Md5Ctx, (unsigned char *)ncvalue, strlen(ncvalue));
#else
	utils->MD5Update(&Md5Ctx, ncvalue, strlen(ncvalue));
#endif /* _SUN_SDK_ */
	utils->MD5Update(&Md5Ctx, COLON, 1);
	utils->MD5Update(&Md5Ctx, pszCNonce, strlen((char *) pszCNonce));
	utils->MD5Update(&Md5Ctx, COLON, 1);
	utils->MD5Update(&Md5Ctx, pszQop, strlen((char *) pszQop));
	utils->MD5Update(&Md5Ctx, COLON, 1);
    }
    utils->MD5Update(&Md5Ctx, HA2Hex, HASHHEXLEN);
    utils->MD5Final(RespHash, &Md5Ctx);
    CvtHex(RespHash, Response);
}

static bool UTF8_In_8859_1(const unsigned char *base, int len)
{
    const unsigned char *scan, *end;

    end = base + len;
    for (scan = base; scan < end; ++scan) {
	if (*scan > 0xC3)
	    break;			/* abort if outside 8859-1 */
	if (*scan >= 0xC0 && *scan <= 0xC3) {
	    if (++scan == end || *scan < 0x80 || *scan > 0xBF)
		break;
	}
    }

    /* if scan >= end, then this is a 8859-1 string. */
    return (scan >= end);
}

/*
 * if the string is entirely in the 8859-1 subset of UTF-8, then translate to
 * 8859-1 prior to MD5
 */
void MD5_UTF8_8859_1(const sasl_utils_t * utils,
		     MD5_CTX * ctx,
		     bool In_ISO_8859_1,
		     const unsigned char *base,
		     int len)
{
    const unsigned char *scan, *end;
    unsigned char   cbuf;

    end = base + len;

    /* if we found a character outside 8859-1, don't alter string */
    if (!In_ISO_8859_1) {
	utils->MD5Update(ctx, base, len);
	return;
    }
    /* convert to 8859-1 prior to applying hash */
    do {
	for (scan = base; scan < end && *scan < 0xC0; ++scan);
	if (scan != base)
	    utils->MD5Update(ctx, base, scan - base);
	if (scan + 1 >= end)
	    break;
	cbuf = ((scan[0] & 0x3) << 6) | (scan[1] & 0x3f);
	utils->MD5Update(ctx, &cbuf, 1);
	base = scan + 2;
    }
    while (base < end);
}

static void DigestCalcSecret(const sasl_utils_t * utils,
			     unsigned char *pszUserName,
			     unsigned char *pszRealm,
			     unsigned char *Password,
			     int PasswordLen,
			     HASH HA1)
{
    bool            In_8859_1;

    MD5_CTX         Md5Ctx;

    /* Chris Newman clarified that the following text in DIGEST-MD5 spec
       is bogus: "if name and password are both in ISO 8859-1 charset"
       We shoud use code example instead */

    utils->MD5Init(&Md5Ctx);

    /* We have to convert UTF-8 to ISO-8859-1 if possible */
    In_8859_1 = UTF8_In_8859_1(pszUserName, strlen((char *) pszUserName));
    MD5_UTF8_8859_1(utils, &Md5Ctx, In_8859_1,
		    pszUserName, strlen((char *) pszUserName));

    utils->MD5Update(&Md5Ctx, COLON, 1);

    if (pszRealm != NULL && pszRealm[0] != '\0') {
	/* a NULL realm is equivalent to the empty string */
	utils->MD5Update(&Md5Ctx, pszRealm, strlen((char *) pszRealm));
    }

    utils->MD5Update(&Md5Ctx, COLON, 1);

    /* We have to convert UTF-8 to ISO-8859-1 if possible */
    In_8859_1 = UTF8_In_8859_1(Password, PasswordLen);
    MD5_UTF8_8859_1(utils, &Md5Ctx, In_8859_1,
		    Password, PasswordLen);

    utils->MD5Final(HA1, &Md5Ctx);
}

static unsigned char *create_nonce(const sasl_utils_t * utils)
{
    unsigned char  *base64buf;
    int             base64len;

    char           *ret = (char *) utils->malloc(NONCE_SIZE);
    if (ret == NULL)
	return NULL;

#if defined _DEV_URANDOM && defined _SUN_SDK_
    {
	int fd = open(_DEV_URANDOM, O_RDONLY);
	int nread = 0;

  	if (fd != -1) {
		nread = read(fd, ret, NONCE_SIZE);
		close(fd);
	}
	if (nread != NONCE_SIZE)
	    utils->rand(utils->rpool, (char *) ret, NONCE_SIZE);
    }
#else
    utils->rand(utils->rpool, (char *) ret, NONCE_SIZE);
#endif /* _DEV_URANDOM && _SUN_SDK_ */

    /* base 64 encode it so it has valid chars */
    base64len = (NONCE_SIZE * 4 / 3) + (NONCE_SIZE % 3 ? 4 : 0);

    base64buf = (unsigned char *) utils->malloc(base64len + 1);
    if (base64buf == NULL) {
#ifdef _SUN_SDK_
	utils->log(utils->conn, SASL_LOG_ERR,
		   "Unable to allocate final buffer");
#else
	utils->seterror(utils->conn, 0, "Unable to allocate final buffer");
#endif /* _SUN_SDK_ */
	return NULL;
    }

    /*
     * Returns SASL_OK on success, SASL_BUFOVER if result won't fit
     */
    if (utils->encode64(ret, NONCE_SIZE,
			(char *) base64buf, base64len, NULL) != SASL_OK) {
	utils->free(ret);
	return NULL;
    }
    utils->free(ret);

    return base64buf;
}

static int add_to_challenge(const sasl_utils_t *utils,
			    char **str, unsigned *buflen, unsigned *curlen,
			    char *name,
			    unsigned char *value,
			    bool need_quotes)
{
    int             namesize = strlen(name);
    int             valuesize = strlen((char *) value);
    int             ret;

    ret = _plug_buf_alloc(utils, str, buflen,
			  *curlen + 1 + namesize + 2 + valuesize + 2);
    if(ret != SASL_OK) return ret;

    *curlen = *curlen + 1 + namesize + 2 + valuesize + 2;

    strcat(*str, ",");
    strcat(*str, name);

    if (need_quotes) {
	strcat(*str, "=\"");
	strcat(*str, (char *) value);	/* XXX. What about quoting??? */
	strcat(*str, "\"");
    } else {
	strcat(*str, "=");
	strcat(*str, (char *) value);
    }

    return SASL_OK;
}

static char *skip_lws (char *s)
{
    if(!s) return NULL;

    /* skipping spaces: */
    while (s[0] == ' ' || s[0] == HT || s[0] == CR || s[0] == LF) {
	if (s[0]=='\0') break;
	s++;
    }

    return s;
}

#ifdef __SUN_SDK_
static char *skip_token (char *s, int caseinsensitive  __attribute__((unused)))
#else
static char *skip_token (char *s, int caseinsensitive)
#endif /* _SUN_SDK_ */
{
    if(!s) return NULL;

#ifdef __SUN_SDK_
    while (((unsigned char *)s)[0]>SP) {
#else
    while (s[0]>SP) {
#endif /* _SUN_SDK_ */
	if (s[0]==DEL || s[0]=='(' || s[0]==')' || s[0]=='<' || s[0]=='>' ||
	    s[0]=='@' || s[0]==',' || s[0]==';' || s[0]==':' || s[0]=='\\' ||
	    s[0]=='\'' || s[0]=='/' || s[0]=='[' || s[0]==']' || s[0]== '?' ||
	    s[0]=='=' || s[0]== '{' || s[0]== '}') {
#ifdef __SUN_SDK_
	    /* the above chars are never uppercase */
	    break;
#else
	    if (caseinsensitive == 1) {
		if (!isupper((unsigned char) s[0]))
		    break;
	    } else {
		break;
	    }
#endif /* _SUN_SDK_ */
	}
	s++;
    }
    return s;
}

/* NULL - error (unbalanced quotes),
   otherwise pointer to the first character after value */
static char *unquote (char *qstr)
{
    char *endvalue;
    int   escaped = 0;
    char *outptr;

    if(!qstr) return NULL;

    if (qstr[0] == '"') {
	qstr++;
	outptr = qstr;

	for (endvalue = qstr; endvalue[0] != '\0'; endvalue++, outptr++) {
	    if (escaped) {
		outptr[0] = endvalue[0];
		escaped = 0;
	    }
	    else if (endvalue[0] == '\\') {
		escaped = 1;
		outptr--; /* Will be incremented at the end of the loop */
	    }
	    else if (endvalue[0] == '"') {
		break;
	    }
	    else {
		outptr[0] = endvalue[0];
	    }
	}

	if (endvalue[0] != '"') {
	    return NULL;
	}

	while (outptr <= endvalue) {
	    outptr[0] = '\0';
	    outptr++;
	}
	endvalue++;
    }
    else { /* not qouted value (token) */
	endvalue = skip_token(qstr,0);
    };

    return endvalue;
}

static void get_pair(char **in, char **name, char **value)
{
    char  *endpair;
    /* int    inQuotes; */
    char  *curp = *in;
    *name = NULL;
    *value = NULL;

    if (curp == NULL) return;
    if (curp[0] == '\0') return;

    /* skipping spaces: */
    curp = skip_lws(curp);

    *name = curp;

    curp = skip_token(curp,1);

    /* strip wierd chars */
    if (curp[0] != '=' && curp[0] != '\0') {
	*curp++ = '\0';
    };

    curp = skip_lws(curp);

    if (curp[0] != '=') { /* No '=' sign */
	*name = NULL;
	return;
    }

    curp[0] = '\0';
    curp++;

    curp = skip_lws(curp);

    *value = (curp[0] == '"') ? curp+1 : curp;

    endpair = unquote (curp);
    if (endpair == NULL) { /* Unbalanced quotes */
	*name = NULL;
	return;
    }
    if (endpair[0] != ',') {
	if (endpair[0]!='\0') {
	    *endpair++ = '\0';
	}
    }

    endpair = skip_lws(endpair);

    /* syntax check: MUST be '\0' or ',' */
    if (endpair[0] == ',') {
	endpair[0] = '\0';
	endpair++; /* skipping <,> */
    } else if (endpair[0] != '\0') {
	*name = NULL;
	return;
    }

    *in = endpair;
}

#ifdef WITH_DES
struct des_context_s {
    des_key_schedule keysched;  /* key schedule for des initialization */
    des_cblock ivec;            /* initial vector for encoding */
    des_key_schedule keysched2; /* key schedule for 3des initialization */
};

typedef struct des_context_s des_context_t;

/* slide the first 7 bytes of 'inbuf' into the high seven bits of the
   first 8 bytes of 'keybuf'. 'keybuf' better be 8 bytes long or longer. */
static void slidebits(unsigned char *keybuf, unsigned char *inbuf)
{
    keybuf[0] = inbuf[0];
    keybuf[1] = (inbuf[0]<<7) | (inbuf[1]>>1);
    keybuf[2] = (inbuf[1]<<6) | (inbuf[2]>>2);
    keybuf[3] = (inbuf[2]<<5) | (inbuf[3]>>3);
    keybuf[4] = (inbuf[3]<<4) | (inbuf[4]>>4);
    keybuf[5] = (inbuf[4]<<3) | (inbuf[5]>>5);
    keybuf[6] = (inbuf[5]<<2) | (inbuf[6]>>6);
    keybuf[7] = (inbuf[6]<<1);
}

/******************************
 *
 * 3DES functions
 *
 *****************************/

static int dec_3des(context_t *text,
		    const char *input,
		    unsigned inputlen,
		    unsigned char digest[16],
		    char *output,
		    unsigned *outputlen)
{
    des_context_t *c = (des_context_t *) text->cipher_dec_context;
    int padding, p;

    des_ede2_cbc_encrypt((void *) input,
			 (void *) output,
			 inputlen,
			 c->keysched,
			 c->keysched2,
			 &c->ivec,
			 DES_DECRYPT);

    /* now chop off the padding */
    padding = output[inputlen - 11];
    if (padding < 1 || padding > 8) {
	/* invalid padding length */
	return SASL_FAIL;
    }
    /* verify all padding is correct */
    for (p = 1; p <= padding; p++) {
	if (output[inputlen - 10 - p] != padding) {
	    return SASL_FAIL;
	}
    }

    /* chop off the padding */
    *outputlen = inputlen - padding - 10;

    /* copy in the HMAC to digest */
    memcpy(digest, output + inputlen - 10, 10);

    return SASL_OK;
}

static int enc_3des(context_t *text,
		    const char *input,
		    unsigned inputlen,
		    unsigned char digest[16],
		    char *output,
		    unsigned *outputlen)
{
    des_context_t *c = (des_context_t *) text->cipher_enc_context;
    int len;
    int paddinglen;

    /* determine padding length */
    paddinglen = 8 - ((inputlen + 10) % 8);

    /* now construct the full stuff to be ciphered */
    memcpy(output, input, inputlen);                /* text */
    memset(output+inputlen, paddinglen, paddinglen);/* pad  */
    memcpy(output+inputlen+paddinglen, digest, 10); /* hmac */

    len=inputlen+paddinglen+10;

    des_ede2_cbc_encrypt((void *) output,
			 (void *) output,
			 len,
			 c->keysched,
			 c->keysched2,
			 &c->ivec,
			 DES_ENCRYPT);

    *outputlen=len;

    return SASL_OK;
}

static int init_3des(context_t *text,
		     unsigned char enckey[16],
		     unsigned char deckey[16])
{
    des_context_t *c;
    unsigned char keybuf[8];

    /* allocate enc & dec context */
    c = (des_context_t *) text->utils->malloc(2 * sizeof(des_context_t));
    if (c == NULL) return SASL_NOMEM;

    /* setup enc context */
    slidebits(keybuf, enckey);
    if (des_key_sched((des_cblock *) keybuf, c->keysched) < 0)
	return SASL_FAIL;

    slidebits(keybuf, enckey + 7);
    if (des_key_sched((des_cblock *) keybuf, c->keysched2) < 0)
	return SASL_FAIL;
    memcpy(c->ivec, ((char *) enckey) + 8, 8);

    text->cipher_enc_context = (cipher_context_t *) c;

    /* setup dec context */
    c++;
    slidebits(keybuf, deckey);
    if (des_key_sched((des_cblock *) keybuf, c->keysched) < 0)
	return SASL_FAIL;

    slidebits(keybuf, deckey + 7);
    if (des_key_sched((des_cblock *) keybuf, c->keysched2) < 0)
	return SASL_FAIL;

    memcpy(c->ivec, ((char *) deckey) + 8, 8);

    text->cipher_dec_context = (cipher_context_t *) c;

    return SASL_OK;
}


/******************************
 *
 * DES functions
 *
 *****************************/

static int dec_des(context_t *text,
		   const char *input,
		   unsigned inputlen,
		   unsigned char digest[16],
		   char *output,
		   unsigned *outputlen)
{
    des_context_t *c = (des_context_t *) text->cipher_dec_context;
    int p, padding = 0;

    des_cbc_encrypt((void *) input,
		    (void *) output,
		    inputlen,
		    c->keysched,
		    &c->ivec,
		    DES_DECRYPT);

    /* Update the ivec (des_cbc_encrypt implementations tend to be broken in
       this way) */
    memcpy(c->ivec, input + (inputlen - 8), 8);

    /* now chop off the padding */
    padding = output[inputlen - 11];
    if (padding < 1 || padding > 8) {
	/* invalid padding length */
	return SASL_FAIL;
    }
    /* verify all padding is correct */
    for (p = 1; p <= padding; p++) {
	if (output[inputlen - 10 - p] != padding) {
	    return SASL_FAIL;
	}
    }

    /* chop off the padding */
    *outputlen = inputlen - padding - 10;

    /* copy in the HMAC to digest */
    memcpy(digest, output + inputlen - 10, 10);

    return SASL_OK;
}

static int enc_des(context_t *text,
		   const char *input,
		   unsigned inputlen,
		   unsigned char digest[16],
		   char *output,
		   unsigned *outputlen)
{
    des_context_t *c = (des_context_t *) text->cipher_enc_context;
    int len;
    int paddinglen;

    /* determine padding length */
    paddinglen = 8 - ((inputlen+10) % 8);

    /* now construct the full stuff to be ciphered */
    memcpy(output, input, inputlen);                /* text */
    memset(output+inputlen, paddinglen, paddinglen);/* pad  */
    memcpy(output+inputlen+paddinglen, digest, 10); /* hmac */

    len = inputlen + paddinglen + 10;

    des_cbc_encrypt((void *) output,
                    (void *) output,
                    len,
                    c->keysched,
                    &c->ivec,
                    DES_ENCRYPT);

    /* Update the ivec (des_cbc_encrypt implementations tend to be broken in
       this way) */
    memcpy(c->ivec, output + (len - 8), 8);

    *outputlen = len;

    return SASL_OK;
}

static int init_des(context_t *text,
		    unsigned char enckey[16],
		    unsigned char deckey[16])
{
    des_context_t *c;
    unsigned char keybuf[8];

    /* allocate enc context */
    c = (des_context_t *) text->utils->malloc(2 * sizeof(des_context_t));
    if (c == NULL) return SASL_NOMEM;

    /* setup enc context */
    slidebits(keybuf, enckey);
    des_key_sched((des_cblock *) keybuf, c->keysched);

    memcpy(c->ivec, ((char *) enckey) + 8, 8);

    text->cipher_enc_context = (cipher_context_t *) c;

    /* setup dec context */
    c++;
    slidebits(keybuf, deckey);
    des_key_sched((des_cblock *) keybuf, c->keysched);

    memcpy(c->ivec, ((char *) deckey) + 8, 8);

    text->cipher_dec_context = (cipher_context_t *) c;

    return SASL_OK;
}

static void free_des(context_t *text)
{
    /* free des contextss. only cipher_enc_context needs to be free'd,
       since cipher_dec_context was allocated at the same time. */
    if (text->cipher_enc_context) text->utils->free(text->cipher_enc_context);
}

#endif /* WITH_DES */

#ifdef WITH_RC4
/* quick generic implementation of RC4 */
struct rc4_context_s {
    unsigned char sbox[256];
    int i, j;
};

typedef struct rc4_context_s rc4_context_t;

static void rc4_init(rc4_context_t *text,
		     const unsigned char *key,
		     unsigned keylen)
{
    int i, j;

    /* fill in linearly s0=0 s1=1... */
    for (i=0;i<256;i++)
	text->sbox[i]=i;

    j=0;
    for (i = 0; i < 256; i++) {
	unsigned char tmp;
	/* j = (j + Si + Ki) mod 256 */
	j = (j + text->sbox[i] + key[i % keylen]) % 256;

	/* swap Si and Sj */
	tmp = text->sbox[i];
	text->sbox[i] = text->sbox[j];
	text->sbox[j] = tmp;
    }

    /* counters initialized to 0 */
    text->i = 0;
    text->j = 0;
}

static void rc4_encrypt(rc4_context_t *text,
			const char *input,
			char *output,
			unsigned len)
{
    int tmp;
    int i = text->i;
    int j = text->j;
    int t;
    int K;
    const char *input_end = input + len;

    while (input < input_end) {
	i = (i + 1) % 256;

	j = (j + text->sbox[i]) % 256;

	/* swap Si and Sj */
	tmp = text->sbox[i];
	text->sbox[i] = text->sbox[j];
	text->sbox[j] = tmp;

	t = (text->sbox[i] + text->sbox[j]) % 256;

	K = text->sbox[t];

	/* byte K is Xor'ed with plaintext */
	*output++ = *input++ ^ K;
    }

    text->i = i;
    text->j = j;
}

static void rc4_decrypt(rc4_context_t *text,
			const char *input,
			char *output,
			unsigned len)
{
    int tmp;
    int i = text->i;
    int j = text->j;
    int t;
    int K;
    const char *input_end = input + len;

    while (input < input_end) {
	i = (i + 1) % 256;

	j = (j + text->sbox[i]) % 256;

	/* swap Si and Sj */
	tmp = text->sbox[i];
	text->sbox[i] = text->sbox[j];
	text->sbox[j] = tmp;

	t = (text->sbox[i] + text->sbox[j]) % 256;

	K = text->sbox[t];

	/* byte K is Xor'ed with plaintext */
	*output++ = *input++ ^ K;
    }

    text->i = i;
    text->j = j;
}

static void free_rc4(context_t *text)
{
    /* free rc4 context structures */

    if(text->cipher_enc_context) text->utils->free(text->cipher_enc_context);
    if(text->cipher_dec_context) text->utils->free(text->cipher_dec_context);
#ifdef _SUN_SDK_
    text->cipher_enc_context = NULL;
    text->cipher_dec_context = NULL;
#endif /* _SUN_SDK_ */
}

static int init_rc4(context_t *text,
#ifdef _SUN_SDK_
		    char enckey[16],
		    char deckey[16])
#else
		    unsigned char enckey[16],
		    unsigned char deckey[16])
#endif /* _SUN_SDK_ */
{
    /* allocate rc4 context structures */
    text->cipher_enc_context=
	(cipher_context_t *) text->utils->malloc(sizeof(rc4_context_t));
    if (text->cipher_enc_context == NULL) return SASL_NOMEM;

    text->cipher_dec_context=
	(cipher_context_t *) text->utils->malloc(sizeof(rc4_context_t));
#ifdef _SUN_SDK_
    if (text->cipher_dec_context == NULL) {
	text->utils->free(text->cipher_enc_context);
	text->cipher_enc_context = NULL;
	return SASL_NOMEM;
    }
#else
    if (text->cipher_dec_context == NULL) return SASL_NOMEM;
#endif /* _SUN_SDK_ */

    /* initialize them */
    rc4_init((rc4_context_t *) text->cipher_enc_context,
             (const unsigned char *) enckey, 16);
    rc4_init((rc4_context_t *) text->cipher_dec_context,
             (const unsigned char *) deckey, 16);

    return SASL_OK;
}

static int dec_rc4(context_t *text,
		   const char *input,
		   unsigned inputlen,
		   unsigned char digest[16],
		   char *output,
		   unsigned *outputlen)
{
    /* decrypt the text part */
    rc4_decrypt((rc4_context_t *) text->cipher_dec_context,
                input, output, inputlen-10);

    /* decrypt the HMAC part */
    rc4_decrypt((rc4_context_t *) text->cipher_dec_context,
		input+(inputlen-10), (char *) digest, 10);

    /* no padding so we just subtract the HMAC to get the text length */
    *outputlen = inputlen - 10;

    return SASL_OK;
}

static int enc_rc4(context_t *text,
		   const char *input,
		   unsigned inputlen,
		   unsigned char digest[16],
		   char *output,
		   unsigned *outputlen)
{
    /* pad is zero */
    *outputlen = inputlen+10;

    /* encrypt the text part */
    rc4_encrypt((rc4_context_t *) text->cipher_enc_context,
                input,
                output,
                inputlen);

    /* encrypt the HMAC part */
    rc4_encrypt((rc4_context_t *) text->cipher_enc_context,
                (const char *) digest,
		(output)+inputlen, 10);

    return SASL_OK;
}

#endif /* WITH_RC4 */

struct digest_cipher available_ciphers[] =
{
#ifdef WITH_RC4
    { "rc4-40", 40, 5, 0x01, &enc_rc4, &dec_rc4, &init_rc4, &free_rc4 },
    { "rc4-56", 56, 7, 0x02, &enc_rc4, &dec_rc4, &init_rc4, &free_rc4 },
    { "rc4", 128, 16, 0x04, &enc_rc4, &dec_rc4, &init_rc4, &free_rc4 },
#endif
#ifdef WITH_DES
    { "des", 55, 16, 0x08, &enc_des, &dec_des, &init_des, &free_des },
    { "3des", 112, 16, 0x10, &enc_3des, &dec_3des, &init_3des, &free_des },
#endif
    { NULL, 0, 0, 0, NULL, NULL, NULL, NULL }
};


#ifdef USE_UEF
DEFINE_STATIC_MUTEX(uef_init_mutex);
#define DES_CIPHER_INDEX	3
#define DES3_CIPHER_INDEX	4

static int got_uef_slot = FALSE;
static sasl_ssf_t uef_max_ssf = 0;
static CK_SLOT_ID rc4_slot_id;
static CK_SLOT_ID des_slot_id;
static CK_SLOT_ID des3_slot_id;

struct uef_context_s {
    CK_SESSION_HANDLE hSession;
    CK_OBJECT_HANDLE hKey;
};

typedef struct uef_context_s uef_context_t;

/*
 * slide the first 7 bytes of 'inbuf' into the high seven bits of the
 * first 8 bytes of 'keybuf'. 'inbuf' better be 8 bytes long or longer.
 *
 * This is used to compute the IV for "des" and "3des" as described in
 * draft-ietf-sasl-rfc2831bis-00.txt - The IV for "des"
 *  and "3des" is the last 8 bytes of Kcc or Kcs - the encryption keys.
 */

static void slidebits(unsigned char *keybuf, unsigned char *inbuf)
{
    keybuf[0] = inbuf[0];
    keybuf[1] = (inbuf[0]<<7) | (inbuf[1]>>1);
    keybuf[2] = (inbuf[1]<<6) | (inbuf[2]>>2);
    keybuf[3] = (inbuf[2]<<5) | (inbuf[3]>>3);
    keybuf[4] = (inbuf[3]<<4) | (inbuf[4]>>4);
    keybuf[5] = (inbuf[4]<<3) | (inbuf[5]>>5);
    keybuf[6] = (inbuf[5]<<2) | (inbuf[6]>>6);
    keybuf[7] = (inbuf[6]<<1);
}

/*
 * Create encryption and decryption session handle handles for later use.
 * Returns SASL_OK on success - any other return indicates failure.
 *
 * free_uef is called to release associated resources by
 *	digestmd5_common_mech_dispose
 */

static int init_uef(context_t *text,
		    CK_KEY_TYPE keyType,
		    CK_MECHANISM_TYPE mech_type,
		    CK_SLOT_ID slot_id,
		    char enckey[16],
		    char deckey[16])
{
    CK_RV		rv;
    uef_context_t	*enc_context;
    uef_context_t	*dec_context;
    CK_OBJECT_CLASS	class = CKO_SECRET_KEY;
    CK_BBOOL		true = TRUE;
    static CK_MECHANISM	mechanism = {CKM_RC4, NULL, 0};
    unsigned char 	keybuf[24];
    CK_ATTRIBUTE	template[] = {
				{CKA_CLASS, NULL, sizeof (class)},
				{CKA_KEY_TYPE, NULL, sizeof (keyType)},
				{CKA_ENCRYPT, NULL, sizeof (true)},
				{CKA_VALUE, NULL, 16}};

    template[0].pValue = &class;
    template[1].pValue = &keyType;
    template[2].pValue = &true;
    if (keyType == CKK_DES || keyType == CKK_DES3) {
	slidebits(keybuf, (unsigned char *)enckey);
	if (keyType == CKK_DES3) {
	    slidebits(keybuf + 8, (unsigned char *)enckey + 7);
	    (void) memcpy(keybuf + 16, keybuf, 8);
	    template[3].ulValueLen = 24;
	} else {
	    template[3].ulValueLen = 8;
	}
	template[3].pValue = keybuf;
	mechanism.pParameter = enckey + 8;
	mechanism.ulParameterLen = 8;
    } else {
	template[3].pValue = enckey;
    }
    mechanism.mechanism = mech_type;

    /* allocate rc4 context structures */
    enc_context = text->utils->malloc(sizeof (uef_context_t));
    if (enc_context == NULL)
	return SASL_NOMEM;

    rv = C_OpenSession(slot_id, CKF_SERIAL_SESSION, NULL_PTR, NULL_PTR,
		&enc_context->hSession);
    if (rv != CKR_OK) {
	text->utils->free(enc_context);
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
		"enc C_OpenSession Failed:0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }

    rv = C_CreateObject(enc_context->hSession, template,
		sizeof (template)/sizeof (template[0]), &enc_context->hKey);
    if (rv != CKR_OK) {
	text->utils->free(enc_context);
	(void) C_CloseSession(enc_context->hSession);
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "enc C_CreateObject: rv = 0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }

    text->cipher_enc_context = (cipher_context_t *)enc_context;

    /* Initialize the encryption operation in the session */
    rv = C_EncryptInit(enc_context->hSession, &mechanism, enc_context->hKey);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_EncryptInit: rv = 0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }

    dec_context = text->utils->malloc(sizeof(uef_context_t));
    if (dec_context == NULL)
	return SASL_NOMEM;

    rv = C_OpenSession(slot_id, CKF_SERIAL_SESSION, NULL_PTR, NULL_PTR,
		&dec_context->hSession);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
		"dec C_OpenSession Failed:0x%.8X\n", rv);
#endif
	text->utils->free(dec_context);
	return SASL_FAIL;
    }

    template[2].type = CKA_DECRYPT;
    if (keyType == CKK_DES || keyType == CKK_DES3) {
	slidebits(keybuf, (unsigned char *)deckey);
	if (keyType == CKK_DES3) {
	    slidebits(keybuf + 8, (unsigned char *)deckey + 7);
	    (void) memcpy(keybuf + 16, keybuf, 8);
	}
	mechanism.pParameter = deckey + 8;
    } else {
	template[3].pValue = deckey;
    }

    rv = C_CreateObject(dec_context->hSession, template,
		sizeof (template)/sizeof (template[0]), &dec_context->hKey);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
		"dec C_CreateObject: rv = 0x%.8X\n", rv);
#endif
	(void) C_CloseSession(dec_context->hSession);
	text->utils->free(dec_context);
	return SASL_FAIL;
    }
    text->cipher_dec_context = (cipher_context_t *)dec_context;

    /* Initialize the decryption operation in the session */
    rv = C_DecryptInit(dec_context->hSession, &mechanism, dec_context->hKey);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_DecryptInit: rv = 0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }

    return SASL_OK;
}

static int init_rc4_uef(context_t *text,
		    char enckey[16],
		    char deckey[16])
{
    return init_uef(text, CKK_RC4, CKM_RC4, rc4_slot_id, enckey, deckey);
}

static int init_des_uef(context_t *text,
		    char enckey[16],
		    char deckey[16])
{
    return init_uef(text, CKK_DES, CKM_DES_CBC, des_slot_id, enckey, deckey);
}

static int init_3des_uef(context_t *text,
		    char enckey[16],
		    char deckey[16])
{
    return init_uef(text, CKK_DES3, CKM_DES3_CBC, des3_slot_id, enckey, deckey);
}

static void
free_uef(context_t *text)
{
    uef_context_t	*enc_context =
		(uef_context_t *)text->cipher_enc_context;
    uef_context_t	*dec_context =
		(uef_context_t *)text->cipher_dec_context;
    CK_RV		rv;
    unsigned char 	buf[1];
    CK_ULONG		ulLen = 0;


    if (enc_context != NULL) {
	rv = C_EncryptFinal(enc_context->hSession, buf, &ulLen);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
	    		     "C_EncryptFinal failed:0x%.8X\n", rv);
#endif
	}
	rv = C_DestroyObject(enc_context->hSession, enc_context->hKey);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			     "C_DestroyObject failed:0x%.8X\n", rv);
#endif
	}
	rv = C_CloseSession(enc_context->hSession);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			     "C_CloseSession failed:0x%.8X\n", rv);
#endif
	}
	text->utils->free(enc_context);
    }
    if (dec_context != NULL) {
	rv = C_DecryptFinal(dec_context->hSession, buf, &ulLen);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			     "C_DecryptFinal failed:0x%.8X\n", rv);
#endif
	}
	rv = C_DestroyObject(dec_context->hSession, dec_context->hKey);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			     "C_DestroyObject failed:0x%.8X\n", rv);
#endif
	}

	rv = C_CloseSession(dec_context->hSession);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			     "C_CloseSession failed:0x%.8X\n", rv);
#endif
	}
	text->utils->free(dec_context);
    }
    text->cipher_enc_context = NULL;
    text->cipher_dec_context = NULL;
}

static int
dec_rc4_uef(context_t *text,
	    const char *input,
	    unsigned inputlen,
	    unsigned char digest[16],
	    char *output,
	    unsigned *outputlen)
{
    CK_RV		rv;
    uef_context_t	*dec_context =
		(uef_context_t *)text->cipher_dec_context;
    CK_ULONG		ulDataLen = *outputlen - MAC_SIZE;
    CK_ULONG		ulDigestLen = MAC_SIZE;

    rv = C_DecryptUpdate(dec_context->hSession, (CK_BYTE_PTR)input,
	inputlen - MAC_SIZE, (CK_BYTE_PTR)output, &ulDataLen);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_DecryptUpdate failed:0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }
    *outputlen = (unsigned)ulDataLen;

    rv = C_DecryptUpdate(dec_context->hSession,
	(CK_BYTE_PTR)input+(inputlen-MAC_SIZE), MAC_SIZE, (CK_BYTE_PTR)digest,
	&ulDigestLen);
    if (rv != CKR_OK || ulDigestLen != MAC_SIZE) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_DecryptUpdate:0x%.8X, digestLen:%d\n",
			 rv, ulDigestLen);
#endif
	return SASL_FAIL;
    }

    return SASL_OK;
}

static int
enc_rc4_uef(context_t *text,
	    const char *input,
	    unsigned inputlen,
	    unsigned char digest[16],
	    char *output,
	    unsigned *outputlen)
{
    CK_RV		rv;
    uef_context_t	*enc_context =
		(uef_context_t *)text->cipher_enc_context;
    CK_ULONG		ulDataLen = inputlen;
    CK_ULONG		ulDigestLen = MAC_SIZE;

    rv = C_EncryptUpdate(enc_context->hSession, (CK_BYTE_PTR)input, inputlen,
	(CK_BYTE_PTR)output, &ulDataLen);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_EncryptUpdate failed: 0x%.8X "
			  "inputlen:%d outputlen:%d\n",
			  rv, inputlen, ulDataLen);
#endif
	return SASL_FAIL;
    }
    rv = C_EncryptUpdate(enc_context->hSession, (CK_BYTE_PTR)digest, MAC_SIZE,
	(CK_BYTE_PTR)output + inputlen, &ulDigestLen);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_EncryptUpdate failed: 0x%.8X ulDigestLen:%d\n",
			 rv, ulDigestLen);
#endif
	return SASL_FAIL;
    }

    *outputlen = ulDataLen + ulDigestLen;

    return SASL_OK;
}

static int
dec_des_uef(context_t *text,
	    const char *input,
	    unsigned inputlen,
	    unsigned char digest[16],
	    char *output,
	    unsigned *outputlen)
{
    CK_RV		rv;
    uef_context_t	*dec_context =
		(uef_context_t *)text->cipher_dec_context;
    CK_ULONG		ulDataLen = inputlen;
    int			padding, p;

    rv = C_DecryptUpdate(dec_context->hSession, (CK_BYTE_PTR)input,
	inputlen, (CK_BYTE_PTR)output, &ulDataLen);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_DecryptUpdate failed:0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }
    if (ulDataLen != inputlen) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_DecryptUpdate unexpected data len:%d !=%d\n",
			 inputlen, ulDataLen);
#endif
	return SASL_BUFOVER;
    }

    /* now chop off the padding */
    padding = output[inputlen - 11];
    if (padding < 1 || padding > 8) {
	/* invalid padding length */
	return SASL_BADMAC;
    }
    /* verify all padding is correct */
    for (p = 1; p <= padding; p++) {
	if (output[inputlen - MAC_SIZE - p] != padding) {
	    return SASL_BADMAC;
	}
    }

    /* chop off the padding */
    *outputlen = inputlen - padding - MAC_SIZE;

    /* copy in the HMAC to digest */
    memcpy(digest, output + inputlen - MAC_SIZE, MAC_SIZE);

    return SASL_OK;
}

static int
enc_des_uef(context_t *text,
	    const char *input,
	    unsigned inputlen,
	    unsigned char digest[16],
	    char *output,
	    unsigned *outputlen)
{
    CK_RV		rv;
    uef_context_t	*enc_context =
		(uef_context_t *)text->cipher_enc_context;
    CK_ULONG		ulDataLen;
    int paddinglen;

    /* determine padding length */
    paddinglen = 8 - ((inputlen + MAC_SIZE) % 8);

    /* now construct the full stuff to be ciphered */
    memcpy(output, input, inputlen);                /* text */
    memset(output+inputlen, paddinglen, paddinglen);/* pad  */
    memcpy(output+inputlen+paddinglen, digest, MAC_SIZE); /* hmac */

    ulDataLen=inputlen+paddinglen+MAC_SIZE;

    rv = C_EncryptUpdate(enc_context->hSession, (CK_BYTE_PTR)output, ulDataLen,
	(CK_BYTE_PTR)output, &ulDataLen);
    if (rv != CKR_OK) {
#ifdef DEBUG
	text->utils->log(text->utils->conn, SASL_LOG_DEBUG,
			 "C_EncryptUpdate failed: 0x%.8X "
			 "inputlen:%d outputlen:%d\n",
			 rv, ulDataLen, ulDataLen);
#endif
	return SASL_FAIL;
    }
    *outputlen = (unsigned)ulDataLen;

    return SASL_OK;
}

struct digest_cipher uef_ciphers[] =
{
    { "rc4-40", 40, 5, 0x01, &enc_rc4_uef, &dec_rc4_uef, &init_rc4_uef,
	&free_uef },
    { "rc4-56", 56, 7, 0x02, &enc_rc4_uef, &dec_rc4_uef, &init_rc4_uef,
	&free_uef },
    { "rc4", 128, 16, 0x04, &enc_rc4_uef, &dec_rc4_uef, &init_rc4_uef,
	&free_uef },
    { "des", 55, 16, 0x08, &enc_des_uef, &dec_des_uef, &init_des_uef,
	&free_uef },
    { "3des", 112, 16, 0x10, &enc_des_uef, &dec_des_uef, &init_3des_uef,
	&free_uef },
    { NULL, 0, 0, 0, NULL, NULL, NULL, NULL }
};

struct digest_cipher *available_ciphers1 = uef_ciphers;
#endif /* USE_UEF */

static int create_layer_keys(context_t *text,
			     const sasl_utils_t *utils,
			     HASH key, int keylen,
			     char enckey[16], char deckey[16])
{
    MD5_CTX Md5Ctx;

    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, key, keylen);
    if (text->i_am == SERVER) {
	utils->MD5Update(&Md5Ctx, (const unsigned char *) SEALING_SERVER_CLIENT,
			 strlen(SEALING_SERVER_CLIENT));
    } else {
	utils->MD5Update(&Md5Ctx, (const unsigned char *) SEALING_CLIENT_SERVER,
			 strlen(SEALING_CLIENT_SERVER));
    }
    utils->MD5Final((unsigned char *) enckey, &Md5Ctx);

    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, key, keylen);
    if (text->i_am != SERVER) {
	utils->MD5Update(&Md5Ctx, (const unsigned char *)SEALING_SERVER_CLIENT,
			 strlen(SEALING_SERVER_CLIENT));
    } else {
	utils->MD5Update(&Md5Ctx, (const unsigned char *)SEALING_CLIENT_SERVER,
			 strlen(SEALING_CLIENT_SERVER));
    }
    utils->MD5Final((unsigned char *) deckey, &Md5Ctx);

    /* create integrity keys */
    /* sending */
    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, text->HA1, HASHLEN);
    if (text->i_am == SERVER) {
	utils->MD5Update(&Md5Ctx, (const unsigned char *)SIGNING_SERVER_CLIENT,
			 strlen(SIGNING_SERVER_CLIENT));
    } else {
	utils->MD5Update(&Md5Ctx, (const unsigned char *)SIGNING_CLIENT_SERVER,
			 strlen(SIGNING_CLIENT_SERVER));
    }
    utils->MD5Final(text->Ki_send, &Md5Ctx);

    /* receiving */
    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, text->HA1, HASHLEN);
    if (text->i_am != SERVER) {
	utils->MD5Update(&Md5Ctx, (const unsigned char *)SIGNING_SERVER_CLIENT,
			 strlen(SIGNING_SERVER_CLIENT));
    } else {
	utils->MD5Update(&Md5Ctx, (const unsigned char *)SIGNING_CLIENT_SERVER,
			 strlen(SIGNING_CLIENT_SERVER));
    }
    utils->MD5Final(text->Ki_receive, &Md5Ctx);

    return SASL_OK;
}

static const unsigned short version = 1;

/* len, CIPHER(Kc, {msg, pag, HMAC(ki, {SeqNum, msg})[0..9]}), x0001, SeqNum */

static int
digestmd5_privacy_encode(void *context,
			 const struct iovec *invec,
			 unsigned numiov,
			 const char **output,
			 unsigned *outputlen)
{
    context_t *text = (context_t *) context;
    int tmp;
    unsigned int tmpnum;
    unsigned short int tmpshort;
    int ret;
    char *out;
    unsigned char digest[16];
    struct buffer_info *inblob, bufinfo;

    if(!context || !invec || !numiov || !output || !outputlen) {
	PARAMERROR(text->utils);
	return SASL_BADPARAM;
    }

    if (numiov > 1) {
	ret = _plug_iovec_to_buf(text->utils, invec, numiov, &text->enc_in_buf);
	if (ret != SASL_OK) return ret;
	inblob = text->enc_in_buf;
    } else {
	/* avoid the data copy */
	bufinfo.data = invec[0].iov_base;
	bufinfo.curlen = invec[0].iov_len;
	inblob = &bufinfo;
    }

    /* make sure the output buffer is big enough for this blob */
    ret = _plug_buf_alloc(text->utils, &(text->encode_buf),
			  &(text->encode_buf_len),
			  (4 +                        /* for length */
			   inblob->curlen + /* for content */
			   10 +                       /* for MAC */
			   8 +                        /* maximum pad */
			   6 +                        /* for padding */
			   1));                       /* trailing null */
    if(ret != SASL_OK) return ret;

    /* skip by the length for now */
    out = (text->encode_buf)+4;

    /* construct (seqnum, msg) */
    /* We can just use the output buffer because it's big enough */
    tmpnum = htonl(text->seqnum);
    memcpy(text->encode_buf, &tmpnum, 4);
    memcpy(text->encode_buf + 4, inblob->data, inblob->curlen);

    /* HMAC(ki, (seqnum, msg) ) */
    text->utils->hmac_md5((const unsigned char *) text->encode_buf,
			  inblob->curlen + 4,
			  text->Ki_send, HASHLEN, digest);

    /* calculate the encrypted part */
    text->cipher_enc(text, inblob->data, inblob->curlen,
		     digest, out, outputlen);
    out+=(*outputlen);

    /* copy in version */
    tmpshort = htons(version);
    memcpy(out, &tmpshort, 2);	/* 2 bytes = version */

    out+=2;
    (*outputlen)+=2; /* for version */

    /* put in seqnum */
    tmpnum = htonl(text->seqnum);
    memcpy(out, &tmpnum, 4);	/* 4 bytes = seq # */

    (*outputlen)+=4; /* for seqnum */

    /* put the 1st 4 bytes in */
    tmp=htonl(*outputlen);
    memcpy(text->encode_buf, &tmp, 4);

    (*outputlen)+=4;

    *output = text->encode_buf;
    text->seqnum++;

    return SASL_OK;
}

static int
digestmd5_privacy_decode_once(void *context,
			      const char **input,
			      unsigned *inputlen,
			      char **output,
			      unsigned *outputlen)
{
    context_t *text = (context_t *) context;
    unsigned int tocopy;
    unsigned diff;
    int result;
    unsigned char digest[16];
    int tmpnum;
    int lup;

    if (text->needsize>0) /* 4 bytes for how long message is */
	{
	    /* if less than 4 bytes just copy those we have into text->size */
	    if (*inputlen<4)
		tocopy=*inputlen;
	    else
		tocopy=4;

	    if (tocopy>text->needsize)
		tocopy=text->needsize;

	    memcpy(text->sizebuf+4-text->needsize, *input, tocopy);
	    text->needsize-=tocopy;

	    *input+=tocopy;
	    *inputlen-=tocopy;

	    if (text->needsize==0) /* got all of size */
	    {
		memcpy(&(text->size), text->sizebuf, 4);
		text->cursize=0;
		text->size=ntohl(text->size);

		if (text->size > text->in_maxbuf) {
		    return SASL_FAIL; /* too big probably error */
		}

		if(!text->buffer)
		    text->buffer=text->utils->malloc(text->size+5);
		else
		    text->buffer=text->utils->realloc(text->buffer,
						      text->size+5);
		if (text->buffer == NULL) return SASL_NOMEM;
	    }

	    *outputlen=0;
	    *output=NULL;
	    if (*inputlen==0) /* have to wait until next time for data */
		return SASL_OK;

	    if (text->size==0)  /* should never happen */
		return SASL_FAIL;
	}

    diff=text->size - text->cursize; /* bytes need for full message */

    if (! text->buffer)
	return SASL_FAIL;

    if (*inputlen < diff) /* not enough for a decode */
    {
	memcpy(text->buffer+text->cursize, *input, *inputlen);
	text->cursize+=*inputlen;
	*inputlen=0;
	*outputlen=0;
	*output=NULL;
	return SASL_OK;
    } else {
	memcpy(text->buffer+text->cursize, *input, diff);
	*input+=diff;
	*inputlen-=diff;
    }

    {
	unsigned short ver;
	unsigned int seqnum;
	unsigned char checkdigest[16];

	result = _plug_buf_alloc(text->utils, &text->decode_once_buf,
				 &text->decode_once_buf_len,
				 text->size-6);
	if (result != SASL_OK)
	    return result;

	*output = text->decode_once_buf;
	*outputlen = *inputlen;

	result=text->cipher_dec(text,text->buffer,text->size-6,digest,
				*output, outputlen);

	if (result!=SASL_OK)
	    return result;

	{
	    int i;
	    for(i=10; i; i--) {
		memcpy(&ver, text->buffer+text->size-i,2);
		ver=ntohs(ver);
	    }
	}

	/* check the version number */
	memcpy(&ver, text->buffer+text->size-6, 2);
	ver=ntohs(ver);
	if (ver != version)
	{
#ifdef _INTEGRATED_SOLARIS_
	    text->utils->seterror(text->utils->conn, 0,
		gettext("Wrong Version"));
#else
	    text->utils->seterror(text->utils->conn, 0, "Wrong Version");
#endif /* _INTEGRATED_SOLARIS_ */
	    return SASL_FAIL;
	}

	/* check the CMAC */

	/* construct (seqnum, msg) */
	result = _plug_buf_alloc(text->utils, &text->decode_tmp_buf,
				 &text->decode_tmp_buf_len, *outputlen + 4);
	if(result != SASL_OK) return result;

	tmpnum = htonl(text->rec_seqnum);
	memcpy(text->decode_tmp_buf, &tmpnum, 4);
	memcpy(text->decode_tmp_buf + 4, *output, *outputlen);

	/* HMAC(ki, (seqnum, msg) ) */
	text->utils->hmac_md5((const unsigned char *) text->decode_tmp_buf,
			      (*outputlen) + 4,
			      text->Ki_receive, HASHLEN, checkdigest);

	/* now check it */
	for (lup=0;lup<10;lup++)
	    if (checkdigest[lup]!=digest[lup])
		{
#ifdef _SUN_SDK_
		    text->utils->log(text->utils->conn, SASL_LOG_ERR,
			"CMAC doesn't match at byte %d!", lup);
		    return SASL_BADMAC;
#else
		    text->utils->seterror(text->utils->conn, 0,
					  "CMAC doesn't match at byte %d!", lup);
		    return SASL_FAIL;
#endif /* _SUN_SDK_ */
		}

	/* check the sequence number */
	memcpy(&seqnum, text->buffer+text->size-4,4);
	seqnum=ntohl(seqnum);

	if (seqnum!=text->rec_seqnum)
	    {
#ifdef _SUN_SDK_
		text->utils->log(text->utils->conn, SASL_LOG_ERR,
				 "Incorrect Sequence Number");
#else
		text->utils->seterror(text->utils->conn, 0,
				      "Incorrect Sequence Number");
#endif /* _SUN_SDK_ */
		return SASL_FAIL;
	    }

	text->rec_seqnum++; /* now increment it */
    }

    text->needsize=4;

    return SASL_OK;
}

static int digestmd5_privacy_decode(void *context,
				    const char *input, unsigned inputlen,
				    const char **output, unsigned *outputlen)
{
    context_t *text = (context_t *) context;
    int ret;

    ret = _plug_decode(text->utils, context, input, inputlen,
		       &text->decode_buf, &text->decode_buf_len, outputlen,
		       digestmd5_privacy_decode_once);

    *output = text->decode_buf;

    return ret;
}

static int
digestmd5_integrity_encode(void *context,
			   const struct iovec *invec,
			   unsigned numiov,
			   const char **output,
			   unsigned *outputlen)
{
    context_t      *text = (context_t *) context;
    unsigned char   MAC[16];
    unsigned int    tmpnum;
    unsigned short int tmpshort;
    struct buffer_info *inblob, bufinfo;
    int ret;

    if(!context || !invec || !numiov || !output || !outputlen) {
	PARAMERROR( text->utils );
	return SASL_BADPARAM;
    }

    if (numiov > 1) {
	ret = _plug_iovec_to_buf(text->utils, invec, numiov,
				 &text->enc_in_buf);
	if (ret != SASL_OK) return ret;
	inblob = text->enc_in_buf;
    } else {
	/* avoid the data copy */
	bufinfo.data = invec[0].iov_base;
	bufinfo.curlen = invec[0].iov_len;
	inblob = &bufinfo;
    }

    /* construct output */
    *outputlen = 4 + inblob->curlen + 16;

    ret = _plug_buf_alloc(text->utils, &(text->encode_buf),
			  &(text->encode_buf_len), *outputlen);
    if(ret != SASL_OK) return ret;

    /* construct (seqnum, msg) */
    /* we can just use the output buffer */
    tmpnum = htonl(text->seqnum);
    memcpy(text->encode_buf, &tmpnum, 4);
    memcpy(text->encode_buf + 4, inblob->data, inblob->curlen);

    /* HMAC(ki, (seqnum, msg) ) */
#ifdef _SUN_SDK_
    text->utils->hmac_md5((unsigned char *)text->encode_buf,
			  inblob->curlen + 4,
			  text->Ki_send, HASHLEN, MAC);
#else
    text->utils->hmac_md5(text->encode_buf, inblob->curlen + 4,
			  text->Ki_send, HASHLEN, MAC);
#endif /* _SUN_SDK_ */

    /* create MAC */
    tmpshort = htons(version);
    memcpy(MAC + 10, &tmpshort, MAC_OFFS);	/* 2 bytes = version */

    tmpnum = htonl(text->seqnum);
    memcpy(MAC + 12, &tmpnum, 4);	/* 4 bytes = sequence number */

    /* copy into output */
    tmpnum = htonl((*outputlen) - 4);

    /* length of message in network byte order */
    memcpy(text->encode_buf, &tmpnum, 4);
    /* the message text */
    memcpy(text->encode_buf + 4, inblob->data, inblob->curlen);
    /* the MAC */
    memcpy(text->encode_buf + 4 + inblob->curlen, MAC, 16);

    text->seqnum++;		/* add one to sequence number */

    *output = text->encode_buf;

    return SASL_OK;
}

static int
create_MAC(context_t * text,
	   char *input,
	   int inputlen,
	   int seqnum,
	   unsigned char MAC[16])
{
    unsigned int    tmpnum;
    unsigned short int tmpshort;
    int ret;

    if (inputlen < 0)
	return SASL_FAIL;

    ret = _plug_buf_alloc(text->utils, &(text->MAC_buf),
			  &(text->MAC_buf_len), inputlen + 4);
    if(ret != SASL_OK) return ret;

    /* construct (seqnum, msg) */
    tmpnum = htonl(seqnum);
    memcpy(text->MAC_buf, &tmpnum, 4);
    memcpy(text->MAC_buf + 4, input, inputlen);

    /* HMAC(ki, (seqnum, msg) ) */
#ifdef _SUN_SDK_
    text->utils->hmac_md5((unsigned char *)text->MAC_buf, inputlen + 4,
			  text->Ki_receive, HASHLEN,
			  MAC);
#else
    text->utils->hmac_md5(text->MAC_buf, inputlen + 4,
			  text->Ki_receive, HASHLEN,
			  MAC);
#endif /* _SUN_SDK_ */

    /* create MAC */
    tmpshort = htons(version);
    memcpy(MAC + 10, &tmpshort, 2);	/* 2 bytes = version */

    tmpnum = htonl(seqnum);
    memcpy(MAC + 12, &tmpnum, 4);	/* 4 bytes = sequence number */

    return SASL_OK;
}

static int
check_integrity(context_t * text,
		char *buf, int bufsize,
		char **output, unsigned *outputlen)
{
    unsigned char MAC[16];
    int result;

    result = create_MAC(text, buf, bufsize - 16, text->rec_seqnum, MAC);
    if (result != SASL_OK)
	return result;

    /* make sure the MAC is right */
    if (strncmp((char *) MAC, buf + bufsize - 16, 16) != 0)
    {
#ifdef _SUN_SDK_
	text->utils->log(text->utils->conn, SASL_LOG_ERR,
			 "MAC doesn't match");
	return SASL_BADMAC;
#else
	text->utils->seterror(text->utils->conn, 0, "MAC doesn't match");
	return SASL_FAIL;
#endif /* _SUN_SDK_ */
    }

    text->rec_seqnum++;

    /* ok make output message */
    result = _plug_buf_alloc(text->utils, &text->decode_once_buf,
			     &text->decode_once_buf_len,
			     bufsize - 15);
    if (result != SASL_OK)
	return result;

    *output = text->decode_once_buf;
    memcpy(*output, buf, bufsize - 16);
    *outputlen = bufsize - 16;
    (*output)[*outputlen] = 0;

    return SASL_OK;
}

static int
digestmd5_integrity_decode_once(void *context,
				const char **input,
				unsigned *inputlen,
				char **output,
				unsigned *outputlen)
{
    context_t      *text = (context_t *) context;
    unsigned int    tocopy;
    unsigned        diff;
    int             result;

    if (text->needsize > 0) {	/* 4 bytes for how long message is */
	/*
	 * if less than 4 bytes just copy those we have into text->size
	 */
	if (*inputlen < 4)
	    tocopy = *inputlen;
	else
	    tocopy = 4;

	if (tocopy > text->needsize)
	    tocopy = text->needsize;

	memcpy(text->sizebuf + 4 - text->needsize, *input, tocopy);
	text->needsize -= tocopy;

	*input += tocopy;
	*inputlen -= tocopy;

	if (text->needsize == 0) {	/* got all of size */
	    memcpy(&(text->size), text->sizebuf, 4);
	    text->cursize = 0;
	    text->size = ntohl(text->size);

	    if (text->size > text->in_maxbuf)
		return SASL_FAIL;	/* too big probably error */

	    if(!text->buffer)
		text->buffer=text->utils->malloc(text->size+5);
	    else
		text->buffer=text->utils->realloc(text->buffer,text->size+5);
	    if (text->buffer == NULL) return SASL_NOMEM;
	}
	*outputlen = 0;
	*output = NULL;
	if (*inputlen == 0)		/* have to wait until next time for data */
	    return SASL_OK;

	if (text->size == 0)	/* should never happen */
	    return SASL_FAIL;
    }
    diff = text->size - text->cursize;	/* bytes need for full message */

    if(! text->buffer)
	return SASL_FAIL;

    if (*inputlen < diff) {	/* not enough for a decode */
	memcpy(text->buffer + text->cursize, *input, *inputlen);
	text->cursize += *inputlen;
	*inputlen = 0;
	*outputlen = 0;
	*output = NULL;
	return SASL_OK;
    } else {
	memcpy(text->buffer + text->cursize, *input, diff);
	*input += diff;
	*inputlen -= diff;
    }

    result = check_integrity(text, text->buffer, text->size,
			     output, outputlen);
    if (result != SASL_OK)
	return result;

    /* Reset State */
    text->needsize = 4;

    return SASL_OK;
}

static int digestmd5_integrity_decode(void *context,
				      const char *input, unsigned inputlen,
				      const char **output, unsigned *outputlen)
{
    context_t *text = (context_t *) context;
    int ret;

    ret = _plug_decode(text->utils, context, input, inputlen,
		       &text->decode_buf, &text->decode_buf_len, outputlen,
		       digestmd5_integrity_decode_once);

    *output = text->decode_buf;

    return ret;
}

static void
digestmd5_common_mech_dispose(void *conn_context, const sasl_utils_t *utils)
{
    context_t *text = (context_t *) conn_context;

    if (!text || !utils) return;

    if (text->authid) utils->free(text->authid);
    if (text->realm) utils->free(text->realm);
    if (text->nonce) utils->free(text->nonce);
    if (text->cnonce) utils->free(text->cnonce);

    if (text->cipher_free) text->cipher_free(text);

    /* free the stuff in the context */
    if (text->response_value) utils->free(text->response_value);

    if (text->buffer) utils->free(text->buffer);
    if (text->encode_buf) utils->free(text->encode_buf);
    if (text->decode_buf) utils->free(text->decode_buf);
    if (text->decode_once_buf) utils->free(text->decode_once_buf);
    if (text->decode_tmp_buf) utils->free(text->decode_tmp_buf);
    if (text->out_buf) utils->free(text->out_buf);
    if (text->MAC_buf) utils->free(text->MAC_buf);

    if (text->enc_in_buf) {
	if (text->enc_in_buf->data) utils->free(text->enc_in_buf->data);
	utils->free(text->enc_in_buf);
    }

    utils->free(conn_context);
}

static void
clear_reauth_entry(reauth_entry_t *reauth, enum Context_type type,
		   const sasl_utils_t *utils)
{
    if (!reauth) return;

    if (reauth->authid) utils->free(reauth->authid);
    if (reauth->realm) utils->free(reauth->realm);
    if (reauth->nonce) utils->free(reauth->nonce);
    if (reauth->cnonce) utils->free(reauth->cnonce);

    if (type == CLIENT) {
	if (reauth->u.c.serverFQDN) utils->free(reauth->u.c.serverFQDN);
    }

    memset(reauth, 0, sizeof(reauth_entry_t));
}

static void
digestmd5_common_mech_free(void *glob_context, const sasl_utils_t *utils)
{
    reauth_cache_t *reauth_cache = (reauth_cache_t *) glob_context;
    size_t n;

    if (!reauth_cache) return;

    for (n = 0; n < reauth_cache->size; n++)
	clear_reauth_entry(&reauth_cache->e[n], reauth_cache->i_am, utils);
    if (reauth_cache->e) utils->free(reauth_cache->e);

    if (reauth_cache->mutex) utils->mutex_free(reauth_cache->mutex);

    utils->free(reauth_cache);
}

/*****************************  Server Section  *****************************/

typedef struct server_context {
    context_t common;

    time_t timestamp;
    int stale;				/* last nonce is stale */
    sasl_ssf_t limitssf, requiressf;	/* application defined bounds */
} server_context_t;

static void
DigestCalcHA1FromSecret(context_t * text,
			const sasl_utils_t * utils,
			HASH HA1,
			unsigned char *authorization_id,
			unsigned char *pszNonce,
			unsigned char *pszCNonce,
			HASHHEX SessionKey)
{
    MD5_CTX Md5Ctx;

    /* calculate session key */
    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, HA1, HASHLEN);
    utils->MD5Update(&Md5Ctx, COLON, 1);
    utils->MD5Update(&Md5Ctx, pszNonce, strlen((char *) pszNonce));
    utils->MD5Update(&Md5Ctx, COLON, 1);
    utils->MD5Update(&Md5Ctx, pszCNonce, strlen((char *) pszCNonce));
    if (authorization_id != NULL) {
	utils->MD5Update(&Md5Ctx, COLON, 1);
	utils->MD5Update(&Md5Ctx, authorization_id, strlen((char *) authorization_id));
    }
    utils->MD5Final(HA1, &Md5Ctx);

    CvtHex(HA1, SessionKey);


    /* save HA1 because we need it to make the privacy and integrity keys */
    memcpy(text->HA1, HA1, sizeof(HASH));
}

static char *create_response(context_t * text,
			     const sasl_utils_t * utils,
			     unsigned char *nonce,
			     unsigned int ncvalue,
			     unsigned char *cnonce,
			     char *qop,
			     char *digesturi,
			     HASH Secret,
			     char *authorization_id,
			     char **response_value)
{
    HASHHEX         SessionKey;
    HASHHEX         HEntity = "00000000000000000000000000000000";
    HASHHEX         Response;
    char           *result;

    if (qop == NULL)
	qop = "auth";

    DigestCalcHA1FromSecret(text,
			    utils,
			    Secret,
			    (unsigned char *) authorization_id,
			    nonce,
			    cnonce,
			    SessionKey);

    DigestCalcResponse(utils,
		       SessionKey,/* H(A1) */
		       nonce,	/* nonce from server */
		       ncvalue,	/* 8 hex digits */
		       cnonce,	/* client nonce */
		       (unsigned char *) qop,	/* qop-value: "", "auth",
						 * "auth-int" */
		       (unsigned char *) digesturi,	/* requested URL */
		       (unsigned char *) "AUTHENTICATE",
		       HEntity,	/* H(entity body) if qop="auth-int" */
		       Response	/* request-digest or response-digest */
	);

    result = utils->malloc(HASHHEXLEN + 1);
#ifdef _SUN_SDK_
    if (result == NULL)
	return NULL;
#endif /* _SUN_SDK_ */
/* TODO */
    memcpy(result, Response, HASHHEXLEN);
    result[HASHHEXLEN] = 0;

    /* response_value (used for reauth i think */
    if (response_value != NULL) {
	DigestCalcResponse(utils,
			   SessionKey,	/* H(A1) */
			   nonce,	/* nonce from server */
			   ncvalue,	/* 8 hex digits */
			   cnonce,	/* client nonce */
			   (unsigned char *) qop,	/* qop-value: "", "auth",
							 * "auth-int" */
			   (unsigned char *) digesturi,	/* requested URL */
			   NULL,
			   HEntity,	/* H(entity body) if qop="auth-int" */
			   Response	/* request-digest or response-digest */
	    );

	*response_value = utils->malloc(HASHHEXLEN + 1);
	if (*response_value == NULL)
	    return NULL;
	memcpy(*response_value, Response, HASHHEXLEN);
	(*response_value)[HASHHEXLEN] = 0;
    }
    return result;
}

static int
get_server_realm(sasl_server_params_t * params,
		 char **realm)
{
    /* look at user realm first */
    if (params->user_realm != NULL) {
	if(params->user_realm[0] != '\0') {
	    *realm = (char *) params->user_realm;
	} else {
	    /* Catch improperly converted apps */
#ifdef _SUN_SDK_
	    params->utils->log(params->utils->conn, SASL_LOG_ERR,
			       "user_realm is an empty string!");
#else
	    params->utils->seterror(params->utils->conn, 0,
				    "user_realm is an empty string!");
#endif /* _SUN_SDK_ */
	    return SASL_BADPARAM;
	}
    } else if (params->serverFQDN != NULL) {
	*realm = (char *) params->serverFQDN;
    } else {
#ifdef _SUN_SDK_
	params->utils->log(params->utils->conn, SASL_LOG_ERR,
			   "no way to obtain domain");
#else
	params->utils->seterror(params->utils->conn, 0,
				"no way to obtain domain");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    return SASL_OK;
}

/*
 * Convert hex string to int
 */
static int htoi(unsigned char *hexin, unsigned int *res)
{
    int             lup, inlen;
    inlen = strlen((char *) hexin);

    *res = 0;
    for (lup = 0; lup < inlen; lup++) {
	switch (hexin[lup]) {
	case '0':
	case '1':
	case '2':
	case '3':
	case '4':
	case '5':
	case '6':
	case '7':
	case '8':
	case '9':
	    *res = (*res << 4) + (hexin[lup] - '0');
	    break;

	case 'a':
	case 'b':
	case 'c':
	case 'd':
	case 'e':
	case 'f':
	    *res = (*res << 4) + (hexin[lup] - 'a' + 10);
	    break;

	case 'A':
	case 'B':
	case 'C':
	case 'D':
	case 'E':
	case 'F':
	    *res = (*res << 4) + (hexin[lup] - 'A' + 10);
	    break;

	default:
	    return SASL_BADPARAM;
	}

    }

    return SASL_OK;
}

static int digestmd5_server_mech_new(void *glob_context,
				     sasl_server_params_t * sparams,
				     const char *challenge __attribute__((unused)),
				     unsigned challen __attribute__((unused)),
				     void **conn_context)
{
    context_t *text;

    /* holds state are in -- allocate server size */
    text = sparams->utils->malloc(sizeof(server_context_t));
    if (text == NULL)
	return SASL_NOMEM;
    memset(text, 0, sizeof(server_context_t));

    text->state = 1;
    text->i_am = SERVER;
    text->reauth = glob_context;

    *conn_context = text;
    return SASL_OK;
}

static int
digestmd5_server_mech_step1(server_context_t *stext,
			    sasl_server_params_t *sparams,
			    const char *clientin __attribute__((unused)),
			    unsigned clientinlen __attribute__((unused)),
			    const char **serverout,
			    unsigned *serveroutlen,
			    sasl_out_params_t * oparams __attribute__((unused)))
{
    context_t *text = (context_t *) stext;
    int             result;
    char           *realm;
    unsigned char  *nonce;
    char           *charset = "utf-8";
    char qop[1024], cipheropts[1024];
    struct digest_cipher *cipher;
    unsigned       resplen;
    int added_conf = 0;
    char maxbufstr[64];

    sparams->utils->log(sparams->utils->conn, SASL_LOG_DEBUG,
			"DIGEST-MD5 server step 1");

    /* get realm */
    result = get_server_realm(sparams, &realm);
    if(result != SASL_OK) return result;

    /* what options should we offer the client? */
    qop[0] = '\0';
    cipheropts[0] = '\0';
    if (stext->requiressf == 0) {
	if (*qop) strcat(qop, ",");
	strcat(qop, "auth");
    }
    if (stext->requiressf <= 1 && stext->limitssf >= 1) {
	if (*qop) strcat(qop, ",");
	strcat(qop, "auth-int");
    }

#ifdef USE_UEF_SERVER
    cipher = available_ciphers1;
#else
    cipher = available_ciphers;
#endif
    while (cipher->name) {
	/* do we allow this particular cipher? */
	if (stext->requiressf <= cipher->ssf &&
	    stext->limitssf >= cipher->ssf) {
	    if (!added_conf) {
		if (*qop) strcat(qop, ",");
		strcat(qop, "auth-conf");
		added_conf = 1;
	    }
#ifdef _SUN_SDK_
	    if(strlen(cipheropts) + strlen(cipher->name) + 1 >=
			sizeof (cipheropts)) {
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
		    "internal error: cipheropts too big");
		return SASL_FAIL;
	    }
#endif /* _SUN_SDK_ */
	    if (*cipheropts) strcat(cipheropts, ",");
	    strcat(cipheropts, cipher->name);
	}
	cipher++;
    }

    if (*qop == '\0') {
	/* we didn't allow anything?!? we'll return SASL_TOOWEAK, since
	   that's close enough */
	return SASL_TOOWEAK;
    }

    /*
     * digest-challenge  = 1#( realm | nonce | qop-options | stale | maxbuf |
     * charset | cipher-opts | auth-param )
     */

#ifndef _SUN_SDK_
    /* FIXME: get nonce XXX have to clean up after self if fail */
#endif /* !_SUN_SDK_ */
    nonce = create_nonce(sparams->utils);
    if (nonce == NULL) {
#ifdef _SUN_SDK_
	/* Note typo below */
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "internal error: failed creating a nonce");
#else
	SETERROR(sparams->utils, "internal erorr: failed creating a nonce");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

#ifdef _SUN_SDK_
    resplen = strlen((char *)nonce) + strlen("nonce") + 5;
#else
    resplen = strlen(nonce) + strlen("nonce") + 5;
#endif /* _SUN_SDK_ */
    result = _plug_buf_alloc(sparams->utils, &(text->out_buf),
			     &(text->out_buf_len), resplen);
#ifdef _SUN_SDK_
    if(result != SASL_OK) {
	sparams->utils->free(nonce);
	return result;
    }
#else
    if(result != SASL_OK) return result;
#endif /* _SUN_SDK_ */

    sprintf(text->out_buf, "nonce=\"%s\"", nonce);

    /* add to challenge; if we chose not to specify a realm, we won't
     * send one to the client */
    if (realm && add_to_challenge(sparams->utils,
				  &text->out_buf, &text->out_buf_len, &resplen,
				  "realm", (unsigned char *) realm,
				  TRUE) != SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "internal error: add_to_challenge failed");
	sparams->utils->free(nonce);
#else
	SETERROR(sparams->utils, "internal error: add_to_challenge failed");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }
    /*
     * qop-options A quoted string of one or more tokens indicating the
     * "quality of protection" values supported by the server.  The value
     * "auth" indicates authentication; the value "auth-int" indicates
     * authentication with integrity protection; the value "auth-conf"
     * indicates authentication with integrity protection and encryption.
     */

    /* add qop to challenge */
    if (add_to_challenge(sparams->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "qop",
			 (unsigned char *) qop, TRUE) != SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
		 "internal error: add_to_challenge 3 failed");
	sparams->utils->free(nonce);
#else
	SETERROR(sparams->utils, "internal error: add_to_challenge 3 failed");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    /*
     *  Cipheropts - list of ciphers server supports
     */
    /* add cipher-opts to challenge; only add if there are some */
    if (strcmp(cipheropts,"")!=0)
	{
	    if (add_to_challenge(sparams->utils,
				 &text->out_buf, &text->out_buf_len, &resplen,
				 "cipher", (unsigned char *) cipheropts,
				 TRUE) != SASL_OK) {
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			"internal error: add_to_challenge 4 failed");
		sparams->utils->free(nonce);
#else
		SETERROR(sparams->utils,
			 "internal error: add_to_challenge 4 failed");
#endif /* _SUN_SDK_ */
		return SASL_FAIL;
	    }
	}

    /* "stale" is true if a reauth failed because of a nonce timeout */
    if (stext->stale &&
	add_to_challenge(sparams->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
#ifdef _SUN_SDK_
			 "stale", (unsigned char *)"true", FALSE) != SASL_OK) {
	sparams->utils->free(nonce);
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "internal error: add_to_challenge failed");
#else
			 "stale", "true", FALSE) != SASL_OK) {
	SETERROR(sparams->utils, "internal error: add_to_challenge failed");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    /*
     * maxbuf A number indicating the size of the largest buffer the server
     * is able to receive when using "auth-int". If this directive is
     * missing, the default value is 65536. This directive may appear at most
     * once; if multiple instances are present, the client should abort the
     * authentication exchange.
     */
    if(sparams->props.maxbufsize) {
	snprintf(maxbufstr, sizeof(maxbufstr), "%d",
		 sparams->props.maxbufsize);
	if (add_to_challenge(sparams->utils,
			     &text->out_buf, &text->out_buf_len, &resplen,
			     "maxbuf",
			     (unsigned char *) maxbufstr, FALSE) != SASL_OK) {
#ifdef _SUN_SDK_
	    sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				"internal error: add_to_challenge 5 failed");
#else
	    SETERROR(sparams->utils,
		     "internal error: add_to_challenge 5 failed");
#endif /* _SUN_SDK_ */
	    return SASL_FAIL;
	}
    }


    if (add_to_challenge(sparams->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "charset",
			 (unsigned char *) charset, FALSE) != SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "internal error: add_to_challenge 6 failed");
	sparams->utils->free(nonce);
#else
	SETERROR(sparams->utils, "internal error: add_to_challenge 6 failed");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }


    /*
     * algorithm
     *  This directive is required for backwards compatibility with HTTP
     *  Digest., which supports other algorithms. . This directive is
     *  required and MUST appear exactly once; if not present, or if multiple
     *  instances are present, the client should abort the authentication
     *  exchange.
     *
     * algorithm         = "algorithm" "=" "md5-sess"
     */

    if (add_to_challenge(sparams->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "algorithm",
			 (unsigned char *) "md5-sess", FALSE)!=SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "internal error: add_to_challenge 7 failed");
	sparams->utils->free(nonce);
#else
	SETERROR(sparams->utils, "internal error: add_to_challenge 7 failed");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    /*
     * The size of a digest-challenge MUST be less than 2048 bytes!!!
     */
    if (*serveroutlen > 2048) {
#ifdef _SUN_SDK_
	sparams->utils->free(nonce);
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "internal error: challenge larger than 2048 bytes");
#else
	SETERROR(sparams->utils,
		 "internal error: challenge larger than 2048 bytes");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    text->authid = NULL;
    _plug_strdup(sparams->utils, realm, &text->realm, NULL);
    text->nonce = nonce;
    text->nonce_count = 1;
    text->cnonce = NULL;
    stext->timestamp = time(0);

    *serveroutlen = strlen(text->out_buf);
    *serverout = text->out_buf;

    text->state = 2;

    return SASL_CONTINUE;
}

static int
digestmd5_server_mech_step2(server_context_t *stext,
			    sasl_server_params_t *sparams,
			    const char *clientin,
			    unsigned clientinlen,
			    const char **serverout,
			    unsigned *serveroutlen,
			    sasl_out_params_t * oparams)
{
    context_t *text = (context_t *) stext;
    /* verify digest */
    sasl_secret_t  *sec = NULL;
    int             result;
    char           *serverresponse = NULL;
    char           *username = NULL;
    char           *authorization_id = NULL;
    char           *realm = NULL;
    unsigned char  *nonce = NULL, *cnonce = NULL;
    unsigned int   noncecount = 0;
    char           *qop = NULL;
    char           *digesturi = NULL;
    char           *response = NULL;

    /* setting the default value (65536) */
    unsigned int    client_maxbuf = 65536;
    int             maxbuf_count = 0;  /* How many maxbuf instaces was found */

    char           *charset = NULL;
    char           *cipher = NULL;
    unsigned int   n=0;

    HASH            A1;

    /* password prop_request */
    const char *password_request[] = { SASL_AUX_PASSWORD,
				       "*cmusaslsecretDIGEST-MD5",
				       NULL };
    unsigned len;
    struct propval auxprop_values[2];

    /* can we mess with clientin? copy it to be safe */
    char           *in_start = NULL;
    char           *in = NULL;

    sparams->utils->log(sparams->utils->conn, SASL_LOG_DEBUG,
			"DIGEST-MD5 server step 2");

    in = sparams->utils->malloc(clientinlen + 1);
#ifdef _SUN_SDK_
    if (!in) return SASL_NOMEM;
#endif /* _SUN_SDK_ */

    memcpy(in, clientin, clientinlen);
    in[clientinlen] = 0;

    in_start = in;


    /* parse what we got */
    while (in[0] != '\0') {
	char           *name = NULL, *value = NULL;
	get_pair(&in, &name, &value);

	if (name == NULL)
	    break;

	/* Extracting parameters */

	/*
	 * digest-response  = 1#( username | realm | nonce | cnonce |
	 * nonce-count | qop | digest-uri | response | maxbuf | charset |
	 * cipher | auth-param )
	 */

	if (strcasecmp(name, "username") == 0) {
	    _plug_strdup(sparams->utils, value, &username, NULL);
	} else if (strcasecmp(name, "authzid") == 0) {
	    _plug_strdup(sparams->utils, value, &authorization_id, NULL);
	} else if (strcasecmp(name, "cnonce") == 0) {
	    _plug_strdup(sparams->utils, value, (char **) &cnonce, NULL);
	} else if (strcasecmp(name, "nc") == 0) {
	    if (htoi((unsigned char *) value, &noncecount) != SASL_OK) {
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			 "error converting hex to int");
#else
		SETERROR(sparams->utils,
			 "error converting hex to int");
#endif /* _SUN_SDK_ */
		result = SASL_BADAUTH;
		goto FreeAllMem;
	    }
	} else if (strcasecmp(name, "realm") == 0) {
	    if (realm) {
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				    "duplicate realm: authentication aborted");
#else
		SETERROR(sparams->utils,
			 "duplicate realm: authentication aborted");
#endif /* _SUN_SDK_ */
		result = SASL_FAIL;
		goto FreeAllMem;
	    }
	    _plug_strdup(sparams->utils, value, &realm, NULL);
	} else if (strcasecmp(name, "nonce") == 0) {
	    _plug_strdup(sparams->utils, value, (char **) &nonce, NULL);
	} else if (strcasecmp(name, "qop") == 0) {
	    _plug_strdup(sparams->utils, value, &qop, NULL);
	} else if (strcasecmp(name, "digest-uri") == 0) {
            size_t service_len;

	    /*
	     * digest-uri-value  = serv-type "/" host [ "/" serv-name ]
	     */

	    _plug_strdup(sparams->utils, value, &digesturi, NULL);

	    /* verify digest-uri format */

            /* make sure it's the service that we're expecting */
            service_len = strlen(sparams->service);
            if (strncasecmp(digesturi, sparams->service, service_len) ||
                digesturi[service_len] != '/') {
                result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				    "bad digest-uri: doesn't match service");
#else
                SETERROR(sparams->utils,
                         "bad digest-uri: doesn't match service");
#endif /* _SUN_SDK_ */
                goto FreeAllMem;
            }

            /* xxx we don't verify the hostname component */

	} else if (strcasecmp(name, "response") == 0) {
	    _plug_strdup(sparams->utils, value, &response, NULL);
	} else if (strcasecmp(name, "cipher") == 0) {
	    _plug_strdup(sparams->utils, value, &cipher, NULL);
	} else if (strcasecmp(name, "maxbuf") == 0) {
	    maxbuf_count++;
	    if (maxbuf_count != 1) {
		result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				    "duplicate maxbuf: authentication aborted");
#else
		SETERROR(sparams->utils,
			 "duplicate maxbuf: authentication aborted");
#endif /* _SUN_SDK_ */
		goto FreeAllMem;
	    } else if (sscanf(value, "%u", &client_maxbuf) != 1) {
		result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			"invalid maxbuf parameter");
#else
		SETERROR(sparams->utils, "invalid maxbuf parameter");
#endif /* _SUN_SDK_ */
		goto FreeAllMem;
	    } else {
		if (client_maxbuf <= 16) {
		    result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		    sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
					"maxbuf parameter too small");
#else
		    SETERROR(sparams->utils,
			     "maxbuf parameter too small");
#endif /* _SUN_SDK_ */
		    goto FreeAllMem;
		}
	    }
	} else if (strcasecmp(name, "charset") == 0) {
	    if (strcasecmp(value, "utf-8") != 0) {
#ifdef _SUN_SDK_
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				    "client doesn't support UTF-8");
#else
		SETERROR(sparams->utils, "client doesn't support UTF-8");
#endif /* _SUN_SDK_ */
		result = SASL_FAIL;
		goto FreeAllMem;
	    }
	    _plug_strdup(sparams->utils, value, &charset, NULL);
	} else {
	    sparams->utils->log(sparams->utils->conn, SASL_LOG_DEBUG,
				"DIGEST-MD5 unrecognized pair %s/%s: ignoring",
				name, value);
	}
    }

    /*
     * username         = "username" "=" <"> username-value <">
     * username-value   = qdstr-val cnonce           = "cnonce" "=" <">
     * cnonce-value <"> cnonce-value     = qdstr-val nonce-count      = "nc"
     * "=" nc-value nc-value         = 8LHEX qop              = "qop" "="
     * qop-value digest-uri = "digest-uri" "=" digest-uri-value
     * digest-uri-value  = serv-type "/" host [ "/" serv-name ] serv-type
     * = 1*ALPHA host             = 1*( ALPHA | DIGIT | "-" | "." ) service
     * = host response         = "response" "=" <"> response-value <">
     * response-value   = 32LHEX LHEX = "0" | "1" | "2" | "3" | "4" | "5" |
     * "6" | "7" | "8" | "9" | "a" | "b" | "c" | "d" | "e" | "f" cipher =
     * "cipher" "=" cipher-value
     */
    /* Verifing that all parameters was defined */
    if ((username == NULL) ||
	(nonce == NULL) ||
	(noncecount == 0) ||
	(cnonce == NULL) ||
	(digesturi == NULL) ||
	(response == NULL)) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
		"required parameters missing");
#else
	SETERROR(sparams->utils, "required parameters missing");
#endif /* _SUN_SDK_ */
	result = SASL_BADAUTH;
	goto FreeAllMem;
    }

    if (text->state == 1) {
	unsigned val = hash(username) % text->reauth->size;

	/* reauth attempt, see if we have any info for this user */
	if (sparams->utils->mutex_lock(text->reauth->mutex) == SASL_OK) { /* LOCK */
	    if (text->reauth->e[val].authid &&
		!strcmp(username, text->reauth->e[val].authid)) {

		_plug_strdup(sparams->utils, text->reauth->e[val].realm,
			     &text->realm, NULL);
#ifdef _SUN_SDK_
		_plug_strdup(sparams->utils, (char *)text->reauth->e[val].nonce,
			     (char **) &text->nonce, NULL);
#else
		_plug_strdup(sparams->utils, text->reauth->e[val].nonce,
			     (char **) &text->nonce, NULL);
#endif /* _SUN_SDK_ */
		text->nonce_count = ++text->reauth->e[val].nonce_count;
#ifdef _SUN_SDK_
		_plug_strdup(sparams->utils, (char *)text->reauth->e[val].cnonce,
			     (char **) &text->cnonce, NULL);
#else
		_plug_strdup(sparams->utils, text->reauth->e[val].cnonce,
			     (char **) &text->cnonce, NULL);
#endif /* _SUN_SDK_ */
		stext->timestamp = text->reauth->e[val].u.s.timestamp;
	    }
	    sparams->utils->mutex_unlock(text->reauth->mutex); /* UNLOCK */
	}

	if (!text->nonce) {
	    /* we don't have any reauth info, so bail */
	    result = SASL_FAIL;
	    goto FreeAllMem;
	}
    }

    /* Sanity check the parameters */
#ifdef _SUN_SDK_
    if ((realm != NULL && text->realm != NULL &&
		strcmp(realm, text->realm) != 0) ||
	    (realm == NULL && text->realm != NULL) ||
	    (realm != NULL && text->realm == NULL)) {
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "realm changed: authentication aborted");
#else
    if (strcmp(realm, text->realm) != 0) {
	SETERROR(sparams->utils,
		 "realm changed: authentication aborted");
#endif /* _SUN_SDK_ */
	result = SASL_BADAUTH;
	goto FreeAllMem;
    }
#ifdef _SUN_SDK_
    if (strcmp((char *)nonce, (char *) text->nonce) != 0) {
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "nonce changed: authentication aborted");
#else
    if (strcmp(nonce, (char *) text->nonce) != 0) {
	SETERROR(sparams->utils,
		 "nonce changed: authentication aborted");
#endif /* _SUN_SKD_ */
	result = SASL_BADAUTH;
	goto FreeAllMem;
    }
    if (noncecount != text->nonce_count) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "incorrect nonce-count: authentication aborted");
#else
	SETERROR(sparams->utils,
		 "incorrect nonce-count: authentication aborted");
#endif /* _SUN_SDK_ */
	result = SASL_BADAUTH;
	goto FreeAllMem;
    }
#ifdef _SUN_SDK_
    if (text->cnonce && strcmp((char *)cnonce, (char *)text->cnonce) != 0) {
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "cnonce changed: authentication aborted");
#else
    if (text->cnonce && strcmp(cnonce, text->cnonce) != 0) {
	SETERROR(sparams->utils,
		 "cnonce changed: authentication aborted");
#endif /* _SUN_SDK_ */
	result = SASL_BADAUTH;
	goto FreeAllMem;
    }

    result = sparams->utils->prop_request(sparams->propctx, password_request);
    if(result != SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "unable to request user password");
#else
	SETERROR(sparams->utils, "unable to resquest user password");
#endif /* _SUN_SDK_ */
	goto FreeAllMem;
    }

    /* this will trigger the getting of the aux properties */
    /* Note that if we don't have an authorization id, we don't use it... */
    result = sparams->canon_user(sparams->utils->conn,
				 username, 0, SASL_CU_AUTHID, oparams);
    if (result != SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "unable canonify user and get auxprops");
#else
	SETERROR(sparams->utils, "unable canonify user and get auxprops");
#endif /* _SUN_SDK_ */
	goto FreeAllMem;
    }

    if (!authorization_id || !*authorization_id) {
	result = sparams->canon_user(sparams->utils->conn,
				     username, 0, SASL_CU_AUTHZID, oparams);
    } else {
	result = sparams->canon_user(sparams->utils->conn,
				     authorization_id, 0, SASL_CU_AUTHZID,
				     oparams);
    }

    if (result != SASL_OK) {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "unable to canonicalize authorization ID");
#else
	SETERROR(sparams->utils, "unable authorization ID");
#endif /* _SUN_SDK_ */
	goto FreeAllMem;
    }

    result = sparams->utils->prop_getnames(sparams->propctx, password_request,
					   auxprop_values);
    if (result < 0 ||
       ((!auxprop_values[0].name || !auxprop_values[0].values) &&
	(!auxprop_values[1].name || !auxprop_values[1].values))) {
	/* We didn't find this username */
#ifdef _INTEGRATED_SOLARIS_
	sparams->utils->seterror(sparams->utils->conn, 0,
			gettext("no secret in database"));
#else
	sparams->utils->seterror(sparams->utils->conn, 0,
				 "no secret in database");
#endif /* _INTEGRATED_SOLARIS_ */
	result = SASL_NOUSER;
	goto FreeAllMem;
    }

    if (auxprop_values[0].name && auxprop_values[0].values) {
	len = strlen(auxprop_values[0].values[0]);
	if (len == 0) {
#ifdef _INTEGRATED_SOLARIS_
	    sparams->utils->seterror(sparams->utils->conn,0,
			gettext("empty secret"));
#else
	    sparams->utils->seterror(sparams->utils->conn,0,
				     "empty secret");
#endif /* _INTEGRATED_SOLARIS_ */
	    result = SASL_FAIL;
	    goto FreeAllMem;
	}

	sec = sparams->utils->malloc(sizeof(sasl_secret_t) + len);
	if (!sec) {
#ifdef _SUN_SDK_
	    sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				"unable to allocate secret");
#else
	    SETERROR(sparams->utils, "unable to allocate secret");
#endif /* _SUN_SDK_ */
	    result = SASL_FAIL;
	    goto FreeAllMem;
	}

	sec->len = len;
#ifdef _SUN_SDK_
	strncpy((char *)sec->data, auxprop_values[0].values[0], len + 1);
#else
	strncpy(sec->data, auxprop_values[0].values[0], len + 1);
#endif /* _SUN_SDK_ */

	/*
	 * Verifying response obtained from client
	 *
	 * H_URP = H({ username-value,":",realm-value,":",passwd}) sec->data
	 * contains H_URP
	 */

	/* Calculate the secret from the plaintext password */
	{
	    HASH HA1;

#ifdef _SUN_SDK_
	    DigestCalcSecret(sparams->utils, (unsigned char *)username,
			     (unsigned char *)text->realm, sec->data,
			     sec->len, HA1);
#else
	    DigestCalcSecret(sparams->utils, username,
			     text->realm, sec->data, sec->len, HA1);
#endif /* _SUN_SDK_ */

	    /*
	     * A1 = { H( { username-value, ":", realm-value, ":", passwd } ),
	     * ":", nonce-value, ":", cnonce-value }
	     */

	    memcpy(A1, HA1, HASHLEN);
	    A1[HASHLEN] = '\0';
	}

	/* We're done with sec now. Let's get rid of it */
	_plug_free_secret(sparams->utils, &sec);
    } else if (auxprop_values[1].name && auxprop_values[1].values) {
	memcpy(A1, auxprop_values[1].values[0], HASHLEN);
	A1[HASHLEN] = '\0';
    } else {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "Have neither type of secret");
#else
	sparams->utils->seterror(sparams->utils->conn, 0,
				 "Have neither type of secret");
#endif /* _SUN_SDK_ */
#ifdef _SUN_SDK_
	result = SASL_FAIL;
	goto FreeAllMem;
#else
	return SASL_FAIL;
#endif /* _SUN_SDK_ */
    }

    /* defaulting qop to "auth" if not specified */
    if (qop == NULL) {
	_plug_strdup(sparams->utils, "auth", &qop, NULL);
    }

    /* check which layer/cipher to use */
    if ((!strcasecmp(qop, "auth-conf")) && (cipher != NULL)) {
	/* see what cipher was requested */
	struct digest_cipher *cptr;

#ifdef USE_UEF_SERVER
	cptr = available_ciphers1;
#else
	cptr = available_ciphers;
#endif
	while (cptr->name) {
	    /* find the cipher requested & make sure it's one we're happy
	       with by policy */
	    if (!strcasecmp(cipher, cptr->name) &&
		stext->requiressf <= cptr->ssf &&
		stext->limitssf >= cptr->ssf) {
		/* found it! */
		break;
	    }
	    cptr++;
	}

	if (cptr->name) {
	    text->cipher_enc = cptr->cipher_enc;
	    text->cipher_dec = cptr->cipher_dec;
	    text->cipher_init = cptr->cipher_init;
	    text->cipher_free = cptr->cipher_free;
	    oparams->mech_ssf = cptr->ssf;
	    n = cptr->n;
	} else {
	    /* erg? client requested something we didn't advertise! */
	    sparams->utils->log(sparams->utils->conn, SASL_LOG_WARN,
				"protocol violation: client requested invalid cipher");
#ifndef _SUN_SDK_
	    SETERROR(sparams->utils, "client requested invalid cipher");
#endif /* !_SUN_SDK_ */
	    /* Mark that we attempted security layer negotiation */
	    oparams->mech_ssf = 2;
	    result = SASL_FAIL;
	    goto FreeAllMem;
	}

	oparams->encode=&digestmd5_privacy_encode;
	oparams->decode=&digestmd5_privacy_decode;
    } else if (!strcasecmp(qop, "auth-int") &&
	       stext->requiressf <= 1 && stext->limitssf >= 1) {
	oparams->encode = &digestmd5_integrity_encode;
	oparams->decode = &digestmd5_integrity_decode;
	oparams->mech_ssf = 1;
    } else if (!strcasecmp(qop, "auth") && stext->requiressf == 0) {
	oparams->encode = NULL;
	oparams->decode = NULL;
	oparams->mech_ssf = 0;
    } else {
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "protocol violation: client requested invalid qop");
#else
	SETERROR(sparams->utils,
		 "protocol violation: client requested invalid qop");
#endif /* _SUN_SDK_ */
	result = SASL_FAIL;
	goto FreeAllMem;
    }

    serverresponse = create_response(text,
				     sparams->utils,
				     text->nonce,
				     text->nonce_count,
				     cnonce,
				     qop,
				     digesturi,
				     A1,
				     authorization_id,
				     &text->response_value);

    if (serverresponse == NULL) {
#ifndef _SUN_SDK_
	SETERROR(sparams->utils, "internal error: unable to create response");
#endif /* !_SUN_SDK_ */
	result = SASL_NOMEM;
	goto FreeAllMem;
    }

    /* if ok verified */
    if (strcmp(serverresponse, response) != 0) {
#ifdef _INTEGRATED_SOLARIS_
	SETERROR(sparams->utils,
		 gettext("client response doesn't match what we generated"));
#else
	SETERROR(sparams->utils,
		 "client response doesn't match what we generated");
#endif /* _INTEGRATED_SOLARIS_ */
	result = SASL_BADAUTH;

	goto FreeAllMem;
    }

    /* see if our nonce expired */
    if (text->reauth->timeout &&
	time(0) - stext->timestamp > text->reauth->timeout) {
#ifdef _INTEGRATED_SOLARIS_
	SETERROR(sparams->utils, gettext("server nonce expired"));
#else
	SETERROR(sparams->utils, "server nonce expired");
#endif /* _INTEGRATED_SOLARIS_ */
	stext->stale = 1;
	result = SASL_BADAUTH;

	goto FreeAllMem;
     }

    /*
     * nothing more to do; authenticated set oparams information
     */
    oparams->doneflag = 1;
    oparams->maxoutbuf = client_maxbuf - 4;
    if (oparams->mech_ssf > 1) {
#ifdef _SUN_SDK_
	if (oparams->maxoutbuf <= 25) {
	     result = SASL_BADPARAM;
	     goto FreeAllMem;
	}
#endif
	/* MAC block (privacy) */
	oparams->maxoutbuf -= 25;
    } else if(oparams->mech_ssf == 1) {
#ifdef _SUN_SDK_
	if (oparams->maxoutbuf <= 16) {
	     result = SASL_BADPARAM;
	     goto FreeAllMem;
	}
#endif
	/* MAC block (integrity) */
	oparams->maxoutbuf -= 16;
    }

    oparams->param_version = 0;

    text->seqnum = 0;		/* for integrity/privacy */
    text->rec_seqnum = 0;	/* for integrity/privacy */
    text->in_maxbuf =
       sparams->props.maxbufsize ? sparams->props.maxbufsize : DEFAULT_BUFSIZE;
    text->utils = sparams->utils;

    /* used by layers */
    text->needsize = 4;
    text->buffer = NULL;

    if (oparams->mech_ssf > 0) {
	char enckey[16];
	char deckey[16];

	create_layer_keys(text, sparams->utils,text->HA1,n,enckey,deckey);

	/* initialize cipher if need be */
#ifdef _SUN_SDK_
	if (text->cipher_init) {
	    if (text->cipher_free)
		text->cipher_free(text);
	    if ((result = text->cipher_init(text, enckey, deckey)) != SASL_OK) {
		sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
				"couldn't init cipher");
		goto FreeAllMem;
	    }
	}
#else
	if (text->cipher_init)
	    if (text->cipher_init(text, enckey, deckey) != SASL_OK) {
		sparams->utils->seterror(sparams->utils->conn, 0,
					 "couldn't init cipher");
	    }
#endif /* _SUN_SDK_ */
    }

    /*
     * The server receives and validates the "digest-response". The server
     * checks that the nonce-count is "00000001". If it supports subsequent
     * authentication, it saves the value of the nonce and the nonce-count.
     */

    /*
     * The "username-value", "realm-value" and "passwd" are encoded according
     * to the value of the "charset" directive. If "charset=UTF-8" is
     * present, and all the characters of either "username-value" or "passwd"
     * are in the ISO 8859-1 character set, then it must be converted to
     * UTF-8 before being hashed. A sample implementation of this conversion
     * is in section 8.
     */

    /* add to challenge */
    {
	unsigned resplen =
	    strlen(text->response_value) + strlen("rspauth") + 3;

	result = _plug_buf_alloc(sparams->utils, &(text->out_buf),
				 &(text->out_buf_len), resplen);
	if(result != SASL_OK) {
	    goto FreeAllMem;
	}

	sprintf(text->out_buf, "rspauth=%s", text->response_value);

	/* self check */
	if (strlen(text->out_buf) > 2048) {
	    result = SASL_FAIL;
	    goto FreeAllMem;
	}
    }

    *serveroutlen = strlen(text->out_buf);
    *serverout = text->out_buf;

    result = SASL_OK;

  FreeAllMem:
    if (text->reauth->timeout &&
	sparams->utils->mutex_lock(text->reauth->mutex) == SASL_OK) { /* LOCK */
	unsigned val = hash(username) % text->reauth->size;

	switch (result) {
	case SASL_OK:
	    /* successful auth, setup for future reauth */
	    if (text->nonce_count == 1) {
		/* successful initial auth, create new entry */
		clear_reauth_entry(&text->reauth->e[val], SERVER, sparams->utils);
		text->reauth->e[val].authid = username; username = NULL;
		text->reauth->e[val].realm = text->realm; text->realm = NULL;
		text->reauth->e[val].nonce = text->nonce; text->nonce = NULL;
		text->reauth->e[val].cnonce = cnonce; cnonce = NULL;
	    }
	    if (text->nonce_count <= text->reauth->e[val].nonce_count) {
		/* paranoia.  prevent replay attacks */
		clear_reauth_entry(&text->reauth->e[val], SERVER, sparams->utils);
	    }
	    else {
		text->reauth->e[val].nonce_count = text->nonce_count;
		text->reauth->e[val].u.s.timestamp = time(0);
	    }
	    break;
	default:
	    if (text->nonce_count > 1) {
		/* failed reauth, clear entry */
		clear_reauth_entry(&text->reauth->e[val], SERVER, sparams->utils);
	    }
	    else {
		/* failed initial auth, leave existing cache */
	    }
	}
	sparams->utils->mutex_unlock(text->reauth->mutex); /* UNLOCK */
    }

    /* free everything */
    if (in_start) sparams->utils->free (in_start);

    if (username != NULL)
	sparams->utils->free (username);
#ifdef _SUN_SDK_
    if (authorization_id != NULL)
	sparams->utils->free (authorization_id);
#endif /* _SUN_SDK_ */
    if (realm != NULL)
	sparams->utils->free (realm);
    if (nonce != NULL)
	sparams->utils->free (nonce);
    if (cnonce != NULL)
	sparams->utils->free (cnonce);
    if (response != NULL)
	sparams->utils->free (response);
    if (cipher != NULL)
	sparams->utils->free (cipher);
    if (serverresponse != NULL)
	sparams->utils->free(serverresponse);
    if (charset != NULL)
	sparams->utils->free (charset);
    if (digesturi != NULL)
	sparams->utils->free (digesturi);
    if (qop!=NULL)
	sparams->utils->free (qop);
    if (sec)
	_plug_free_secret(sparams->utils, &sec);

    return result;
}

static int
digestmd5_server_mech_step(void *conn_context,
			   sasl_server_params_t *sparams,
			   const char *clientin,
			   unsigned clientinlen,
			   const char **serverout,
			   unsigned *serveroutlen,
			   sasl_out_params_t *oparams)
{
    context_t *text = (context_t *) conn_context;
    server_context_t *stext = (server_context_t *) conn_context;

    if (clientinlen > 4096) return SASL_BADPROT;

    *serverout = NULL;
    *serveroutlen = 0;

    switch (text->state) {

    case 1:
	/* setup SSF limits */
	if (!sparams->props.maxbufsize) {
	    stext->limitssf = 0;
	    stext->requiressf = 0;
	} else {
	    if (sparams->props.max_ssf < sparams->external_ssf) {
		stext->limitssf = 0;
	    } else {
		stext->limitssf =
		    sparams->props.max_ssf - sparams->external_ssf;
	    }
	    if (sparams->props.min_ssf < sparams->external_ssf) {
		stext->requiressf = 0;
	    } else {
		stext->requiressf =
		    sparams->props.min_ssf - sparams->external_ssf;
	    }
	}

        if (clientin && text->reauth->timeout) {
	    /* here's where we attempt fast reauth if possible */
	    if (digestmd5_server_mech_step2(stext, sparams,
					    clientin, clientinlen,
					    serverout, serveroutlen,
					    oparams) == SASL_OK) {
		return SASL_OK;
	    }

#ifdef _SUN_SDK_
	    sparams->utils->log(sparams->utils->conn, SASL_LOG_WARN,
				"DIGEST-MD5 reauth failed");
#else
	    sparams->utils->log(NULL, SASL_LOG_WARN,
				"DIGEST-MD5 reauth failed\n");
#endif /* _SUN_SDK_ */

	    /* re-initialize everything for a fresh start */
	    memset(oparams, 0, sizeof(sasl_out_params_t));

	    /* fall through and issue challenge */
	}

	return digestmd5_server_mech_step1(stext, sparams,
					   clientin, clientinlen,
					   serverout, serveroutlen, oparams);

    case 2:
	return digestmd5_server_mech_step2(stext, sparams,
					   clientin, clientinlen,
					   serverout, serveroutlen, oparams);

    default:
#ifdef _SUN_SDK_
	sparams->utils->log(sparams->utils->conn, SASL_LOG_ERR,
			    "Invalid DIGEST-MD5 server step %d", text->state);
#else
	sparams->utils->log(NULL, SASL_LOG_ERR,
			    "Invalid DIGEST-MD5 server step %d\n", text->state);
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

#ifndef _SUN_SDK_
    return SASL_FAIL; /* should never get here */
#endif /* !_SUN_SDK_ */
}

static void
digestmd5_server_mech_dispose(void *conn_context, const sasl_utils_t *utils)
{
    server_context_t *stext = (server_context_t *) conn_context;

    if (!stext || !utils) return;

    digestmd5_common_mech_dispose(conn_context, utils);
}

static sasl_server_plug_t digestmd5_server_plugins[] =
{
    {
	"DIGEST-MD5",			/* mech_name */
#ifdef WITH_RC4
	128,				/* max_ssf */
#elif WITH_DES
	112,
#else
	0,
#endif
	SASL_SEC_NOPLAINTEXT
	| SASL_SEC_NOANONYMOUS
	| SASL_SEC_MUTUAL_AUTH,		/* security_flags */
	SASL_FEAT_ALLOWS_PROXY,		/* features */
	NULL,				/* glob_context */
	&digestmd5_server_mech_new,	/* mech_new */
	&digestmd5_server_mech_step,	/* mech_step */
	&digestmd5_server_mech_dispose,	/* mech_dispose */
	&digestmd5_common_mech_free,	/* mech_free */
	NULL,				/* setpass */
	NULL,				/* user_query */
	NULL,				/* idle */
	NULL,				/* mech avail */
	NULL				/* spare */
    }
};

int digestmd5_server_plug_init(sasl_utils_t *utils,
			       int maxversion,
			       int *out_version,
			       sasl_server_plug_t **pluglist,
			       int *plugcount)
{
    reauth_cache_t *reauth_cache;
    const char *timeout = NULL;
    unsigned int len;
#if defined _SUN_SDK_  && defined USE_UEF
    int ret;
#endif /* _SUN_SDK_ && USE_UEF */

    if (maxversion < SASL_SERVER_PLUG_VERSION)
	return SASL_BADVERS;

#if defined _SUN_SDK_  && defined USE_UEF
    if ((ret = uef_init(utils)) != SASL_OK)
	return ret;
#endif /* _SUN_SDK_ && USE_UEF */

    /* reauth cache */
    reauth_cache = utils->malloc(sizeof(reauth_cache_t));
    if (reauth_cache == NULL)
	return SASL_NOMEM;
    memset(reauth_cache, 0, sizeof(reauth_cache_t));
    reauth_cache->i_am = SERVER;

    /* fetch and canonify the reauth_timeout */
    utils->getopt(utils->getopt_context, "DIGEST-MD5", "reauth_timeout",
		  &timeout, &len);
    if (timeout)
	reauth_cache->timeout = (time_t) 60 * strtol(timeout, NULL, 10);
#ifdef _SUN_SDK_
    else
	reauth_cache->timeout = 0;
#endif /* _SUN_SDK_ */
    if (reauth_cache->timeout < 0)
	reauth_cache->timeout = 0;

    if (reauth_cache->timeout) {
	/* mutex */
	reauth_cache->mutex = utils->mutex_alloc();
	if (!reauth_cache->mutex)
	    return SASL_FAIL;

	/* entries */
	reauth_cache->size = 100;
	reauth_cache->e = utils->malloc(reauth_cache->size *
					sizeof(reauth_entry_t));
	if (reauth_cache->e == NULL)
	    return SASL_NOMEM;
	memset(reauth_cache->e, 0, reauth_cache->size * sizeof(reauth_entry_t));
    }

    digestmd5_server_plugins[0].glob_context = reauth_cache;

#ifdef _SUN_SDK_
#ifdef USE_UEF_CLIENT
    digestmd5_server_plugins[0].max_ssf = uef_max_ssf;
#endif /* USE_UEF_CLIENT */
#endif /* _SUN_SDK_ */

#ifdef _INTEGRATED_SOLARIS_
    /*
     * Let libsasl know that we are a "Sun" plugin so that privacy
     * and integrity will be allowed.
     */
    REG_PLUG("DIGEST-MD5", digestmd5_server_plugins);
#endif /* _INTEGRATED_SOLARIS_ */

    *out_version = SASL_SERVER_PLUG_VERSION;
    *pluglist = digestmd5_server_plugins;
    *plugcount = 1;

    return SASL_OK;
}

/*****************************  Client Section  *****************************/

typedef struct client_context {
    context_t common;

    sasl_secret_t *password;	/* user password */
    unsigned int free_password; /* set if we need to free password */

    int protection;
    struct digest_cipher *cipher;
    unsigned int server_maxbuf;
#ifdef _INTEGRATED_SOLARIS_
    void *h;
#endif /* _INTEGRATED_SOLARIS_ */
} client_context_t;

/* calculate H(A1) as per spec */
static void
DigestCalcHA1(context_t * text,
	      const sasl_utils_t * utils,
	      unsigned char *pszUserName,
	      unsigned char *pszRealm,
	      sasl_secret_t * pszPassword,
	      unsigned char *pszAuthorization_id,
	      unsigned char *pszNonce,
	      unsigned char *pszCNonce,
	      HASHHEX SessionKey)
{
    MD5_CTX         Md5Ctx;
    HASH            HA1;

    DigestCalcSecret(utils,
		     pszUserName,
		     pszRealm,
		     (unsigned char *) pszPassword->data,
		     pszPassword->len,
		     HA1);

    /* calculate the session key */
    utils->MD5Init(&Md5Ctx);
    utils->MD5Update(&Md5Ctx, HA1, HASHLEN);
    utils->MD5Update(&Md5Ctx, COLON, 1);
    utils->MD5Update(&Md5Ctx, pszNonce, strlen((char *) pszNonce));
    utils->MD5Update(&Md5Ctx, COLON, 1);
    utils->MD5Update(&Md5Ctx, pszCNonce, strlen((char *) pszCNonce));
    if (pszAuthorization_id != NULL) {
	utils->MD5Update(&Md5Ctx, COLON, 1);
	utils->MD5Update(&Md5Ctx, pszAuthorization_id,
			 strlen((char *) pszAuthorization_id));
    }
    utils->MD5Final(HA1, &Md5Ctx);

    CvtHex(HA1, SessionKey);

    /* xxx rc-* use different n */

    /* save HA1 because we'll need it for the privacy and integrity keys */
    memcpy(text->HA1, HA1, sizeof(HASH));

}

static char *calculate_response(context_t * text,
				const sasl_utils_t * utils,
				unsigned char *username,
				unsigned char *realm,
				unsigned char *nonce,
				unsigned int ncvalue,
				unsigned char *cnonce,
				char *qop,
				unsigned char *digesturi,
				sasl_secret_t * passwd,
				unsigned char *authorization_id,
				char **response_value)
{
    HASHHEX         SessionKey;
    HASHHEX         HEntity = "00000000000000000000000000000000";
    HASHHEX         Response;
    char           *result;

    /* Verifing that all parameters was defined */
    if(!username || !cnonce || !nonce || !ncvalue || !digesturi || !passwd) {
	PARAMERROR( utils );
	return NULL;
    }

    if (realm == NULL) {
	/* a NULL realm is equivalent to the empty string */
	realm = (unsigned char *) "";
    }

    if (qop == NULL) {
	/* default to a qop of just authentication */
	qop = "auth";
    }

    DigestCalcHA1(text,
		  utils,
		  username,
		  realm,
		  passwd,
		  authorization_id,
		  nonce,
		  cnonce,
		  SessionKey);

    DigestCalcResponse(utils,
		       SessionKey,/* H(A1) */
		       nonce,	/* nonce from server */
		       ncvalue,	/* 8 hex digits */
		       cnonce,	/* client nonce */
		       (unsigned char *) qop,	/* qop-value: "", "auth",
						 * "auth-int" */
		       digesturi,	/* requested URL */
		       (unsigned char *) "AUTHENTICATE",
		       HEntity,	/* H(entity body) if qop="auth-int" */
		       Response	/* request-digest or response-digest */
	);

    result = utils->malloc(HASHHEXLEN + 1);
#ifdef _SUN_SDK_
    if (result == NULL)
	return NULL;
#endif /* _SUN_SDK_ */
    memcpy(result, Response, HASHHEXLEN);
    result[HASHHEXLEN] = 0;

    if (response_value != NULL) {
	DigestCalcResponse(utils,
			   SessionKey,	/* H(A1) */
			   nonce,	/* nonce from server */
			   ncvalue,	/* 8 hex digits */
			   cnonce,	/* client nonce */
			   (unsigned char *) qop,	/* qop-value: "", "auth",
							 * "auth-int" */
			   (unsigned char *) digesturi,	/* requested URL */
			   NULL,
			   HEntity,	/* H(entity body) if qop="auth-int" */
			   Response	/* request-digest or response-digest */
	    );

#ifdef _SUN_SDK_
	if (*response_value != NULL)
	    utils->free(*response_value);
#endif /* _SUN_SDK_ */
	*response_value = utils->malloc(HASHHEXLEN + 1);
	if (*response_value == NULL)
	    return NULL;

	memcpy(*response_value, Response, HASHHEXLEN);
	(*response_value)[HASHHEXLEN] = 0;

    }

    return result;
}

static int
make_client_response(context_t *text,
		     sasl_client_params_t *params,
		     sasl_out_params_t *oparams)
{
    client_context_t *ctext = (client_context_t *) text;
    char *qop = NULL;
    unsigned nbits = 0;
    unsigned char  *digesturi = NULL;
    bool            IsUTF8 = FALSE;
    char           ncvalue[10];
    char           maxbufstr[64];
    char           *response = NULL;
    unsigned        resplen = 0;
    int result;

    switch (ctext->protection) {
    case DIGEST_PRIVACY:
	qop = "auth-conf";
	oparams->encode = &digestmd5_privacy_encode;
	oparams->decode = &digestmd5_privacy_decode;
	oparams->mech_ssf = ctext->cipher->ssf;

	nbits = ctext->cipher->n;
	text->cipher_enc = ctext->cipher->cipher_enc;
	text->cipher_dec = ctext->cipher->cipher_dec;
	text->cipher_free = ctext->cipher->cipher_free;
	text->cipher_init = ctext->cipher->cipher_init;
	break;
    case DIGEST_INTEGRITY:
	qop = "auth-int";
	oparams->encode = &digestmd5_integrity_encode;
	oparams->decode = &digestmd5_integrity_decode;
	oparams->mech_ssf = 1;
	break;
    case DIGEST_NOLAYER:
    default:
	qop = "auth";
	oparams->encode = NULL;
	oparams->decode = NULL;
	oparams->mech_ssf = 0;
    }

    digesturi = params->utils->malloc(strlen(params->service) + 1 +
				      strlen(params->serverFQDN) + 1 +
				      1);
    if (digesturi == NULL) {
	result = SASL_NOMEM;
	goto FreeAllocatedMem;
    };

    /* allocated exactly this. safe */
    strcpy((char *) digesturi, params->service);
    strcat((char *) digesturi, "/");
    strcat((char *) digesturi, params->serverFQDN);
    /*
     * strcat (digesturi, "/"); strcat (digesturi, params->serverFQDN);
     */

    /* response */
    response =
	calculate_response(text,
			   params->utils,
#ifdef _SUN_SDK_
			   (unsigned char *) oparams->authid,
#else
			   (char *) oparams->authid,
#endif /* _SUN_SDK_ */
			   (unsigned char *) text->realm,
			   text->nonce,
			   text->nonce_count,
			   text->cnonce,
			   qop,
			   digesturi,
			   ctext->password,
			   strcmp(oparams->user, oparams->authid) ?
#ifdef _SUN_SDK_
			   (unsigned char *) oparams->user : NULL,
#else
			   (char *) oparams->user : NULL,
#endif /* _SUN_SDK_ */
			   &text->response_value);

#ifdef _SUN_SDK_
    if (response == NULL) {
	result = SASL_NOMEM;
	goto FreeAllocatedMem;
    }
#endif /* _SUN_SDK_ */

    resplen = strlen(oparams->authid) + strlen("username") + 5;
    result =_plug_buf_alloc(params->utils, &(text->out_buf),
			    &(text->out_buf_len),
			    resplen);
    if (result != SASL_OK) goto FreeAllocatedMem;

    sprintf(text->out_buf, "username=\"%s\"", oparams->authid);

    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "realm", (unsigned char *) text->realm,
			 TRUE) != SASL_OK) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }
    if (strcmp(oparams->user, oparams->authid)) {
	if (add_to_challenge(params->utils,
			     &text->out_buf, &text->out_buf_len, &resplen,
#ifdef _SUN_SDK_
			     "authzid", (unsigned char *) oparams->user,
			     TRUE) != SASL_OK) {
#else
			     "authzid", (char *) oparams->user, TRUE) != SASL_OK) {
#endif /* _SUN_SDK_ */
	    result = SASL_FAIL;
	    goto FreeAllocatedMem;
	}
    }
    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "nonce", text->nonce, TRUE) != SASL_OK) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }
    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "cnonce", text->cnonce, TRUE) != SASL_OK) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }
    snprintf(ncvalue, sizeof(ncvalue), "%08x", text->nonce_count);
    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "nc", (unsigned char *) ncvalue, FALSE) != SASL_OK) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }
    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "qop", (unsigned char *) qop, FALSE) != SASL_OK) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }
    if (ctext->cipher != NULL) {
	if (add_to_challenge(params->utils,
			     &text->out_buf, &text->out_buf_len, &resplen,
			     "cipher",
			     (unsigned char *) ctext->cipher->name,
			     TRUE) != SASL_OK) {
	    result = SASL_FAIL;
	    goto FreeAllocatedMem;
	}
    }

    if (params->props.maxbufsize) {
	snprintf(maxbufstr, sizeof(maxbufstr), "%d", params->props.maxbufsize);
	if (add_to_challenge(params->utils,
			     &text->out_buf, &text->out_buf_len, &resplen,
			     "maxbuf", (unsigned char *) maxbufstr,
			     FALSE) != SASL_OK) {
#ifdef _SUN_SDK_
	    params->utils->log(params->utils->conn, SASL_LOG_ERR,
		     "internal error: add_to_challenge maxbuf failed");
#else
	    SETERROR(params->utils,
		     "internal error: add_to_challenge maxbuf failed");
#endif /* _SUN_SDK_ */
	    goto FreeAllocatedMem;
	}
    }

    if (IsUTF8) {
	if (add_to_challenge(params->utils,
			     &text->out_buf, &text->out_buf_len, &resplen,
			     "charset", (unsigned char *) "utf-8",
			     FALSE) != SASL_OK) {
	    result = SASL_FAIL;
	    goto FreeAllocatedMem;
	}
    }
    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "digest-uri", digesturi, TRUE) != SASL_OK) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }
    if (add_to_challenge(params->utils,
			 &text->out_buf, &text->out_buf_len, &resplen,
			 "response", (unsigned char *) response,
			 FALSE) != SASL_OK) {

	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }

    /* self check */
    if (strlen(text->out_buf) > 2048) {
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }

    /* set oparams */
#ifdef _SUN_SDK_
    oparams->maxoutbuf = ctext->server_maxbuf - 4;
#else
    oparams->maxoutbuf = ctext->server_maxbuf;
#endif /* _SUN_SDK_ */
    if(oparams->mech_ssf > 1) {
#ifdef _SUN_SDK_
	if (oparams->maxoutbuf <= 25)
	     return (SASL_BADPARAM);
#endif
	/* MAC block (privacy) */
	oparams->maxoutbuf -= 25;
    } else if(oparams->mech_ssf == 1) {
#ifdef _SUN_SDK_
	if (oparams->maxoutbuf <= 16)
	     return (SASL_BADPARAM);
#endif
	/* MAC block (integrity) */
	oparams->maxoutbuf -= 16;
    }

    text->seqnum = 0;	/* for integrity/privacy */
    text->rec_seqnum = 0;	/* for integrity/privacy */
    text->utils = params->utils;

    text->in_maxbuf =
	params->props.maxbufsize ? params->props.maxbufsize : DEFAULT_BUFSIZE;

    /* used by layers */
    text->needsize = 4;
    text->buffer = NULL;

    if (oparams->mech_ssf > 0) {
	char enckey[16];
	char deckey[16];

	create_layer_keys(text, params->utils, text->HA1, nbits,
			  enckey, deckey);

	/* initialize cipher if need be */
#ifdef _SUN_SDK_
	if (text->cipher_init) {
	    if (text->cipher_free)
		text->cipher_free(text);
	    if((result = text->cipher_init(text, enckey, deckey)) != SASL_OK) {
		params->utils->log(params->utils->conn, SASL_LOG_ERR,
					"couldn't init cipher");
		goto FreeAllocatedMem;
	    }
	}
#else
	if (text->cipher_init)
	    text->cipher_init(text, enckey, deckey);
#endif /* _SUN_SDK_ */
    }

    result = SASL_OK;

  FreeAllocatedMem:
    if (digesturi) params->utils->free(digesturi);
    if (response) params->utils->free(response);

    return result;
}

static int parse_server_challenge(client_context_t *ctext,
				  sasl_client_params_t *params,
				  const char *serverin, unsigned serverinlen,
				  char ***outrealms, int *noutrealm)
{
    context_t *text = (context_t *) ctext;
    int result = SASL_OK;
    char *in_start = NULL;
    char *in = NULL;
    char **realms = NULL;
    int nrealm = 0;
    sasl_ssf_t limit, musthave = 0;
    sasl_ssf_t external;
    int protection = 0;
    int ciphers = 0;
    int maxbuf_count = 0;
#ifndef _SUN_SDK_
    bool IsUTF8 = FALSE;
#endif /* !_SUN_SDK_ */
    int algorithm_count = 0;

    if (!serverin || !serverinlen) {
#ifndef _SUN_SDK_
	params->utils->log(params->utils->conn, SASL_LOG_ERR,
				"no server challenge");
#else
	params->utils->seterror(params->utils->conn, 0,
				"no server challenge");
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    in_start = in = params->utils->malloc(serverinlen + 1);
    if (in == NULL) return SASL_NOMEM;

    memcpy(in, serverin, serverinlen);
    in[serverinlen] = 0;

    ctext->server_maxbuf = 65536; /* Default value for maxbuf */

    /* create a new cnonce */
    text->cnonce = create_nonce(params->utils);
    if (text->cnonce == NULL) {
#ifdef _SUN_SDK_
	params->utils->log(params->utils->conn, SASL_LOG_ERR,
			   "failed to create cnonce");
#else
	params->utils->seterror(params->utils->conn, 0,
				"failed to create cnonce");
#endif /* _SUN_SDK_ */
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }

    /* parse the challenge */
    while (in[0] != '\0') {
	char *name, *value;

	get_pair(&in, &name, &value);

	/* if parse error */
	if (name == NULL) {
#ifdef _SUN_SDK_
	    params->utils->log(params->utils->conn, SASL_LOG_ERR,
			       "Parse error");
#else
	    params->utils->seterror(params->utils->conn, 0, "Parse error");
#endif /* _SUN_SDK_ */
	    result = SASL_FAIL;
	    goto FreeAllocatedMem;
	}

	if (strcasecmp(name, "realm") == 0) {
	    nrealm++;

	    if(!realms)
		realms = params->utils->malloc(sizeof(char *) * (nrealm + 1));
	    else
		realms = params->utils->realloc(realms,
						sizeof(char *) * (nrealm + 1));

	    if (realms == NULL) {
		result = SASL_NOMEM;
		goto FreeAllocatedMem;
	    }

	    _plug_strdup(params->utils, value, &realms[nrealm-1], NULL);
	    realms[nrealm] = NULL;
	} else if (strcasecmp(name, "nonce") == 0) {
	    _plug_strdup(params->utils, value, (char **) &text->nonce,
			 NULL);
	    text->nonce_count = 1;
	} else if (strcasecmp(name, "qop") == 0) {
	    while (value && *value) {
		char *comma = strchr(value, ',');
		if (comma != NULL) {
		    *comma++ = '\0';
		}

		if (strcasecmp(value, "auth-conf") == 0) {
		    protection |= DIGEST_PRIVACY;
		} else if (strcasecmp(value, "auth-int") == 0) {
		    protection |= DIGEST_INTEGRITY;
		} else if (strcasecmp(value, "auth") == 0) {
		    protection |= DIGEST_NOLAYER;
		} else {
		    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
				       "Server supports unknown layer: %s\n",
				       value);
		}

		value = comma;
	    }

	    if (protection == 0) {
		result = SASL_BADAUTH;
#ifdef _INTEGRATED_SOLARIS_
		params->utils->seterror(params->utils->conn, 0,
			gettext("Server doesn't support known qop level"));
#else
		params->utils->seterror(params->utils->conn, 0,
					"Server doesn't support known qop level");
#endif /* _INTEGRATED_SOLARIS_ */
		goto FreeAllocatedMem;
	    }
	} else if (strcasecmp(name, "cipher") == 0) {
	    while (value && *value) {
		char *comma = strchr(value, ',');
#ifdef USE_UEF_CLIENT
		struct digest_cipher *cipher = available_ciphers1;
#else
		struct digest_cipher *cipher = available_ciphers;
#endif

		if (comma != NULL) {
		    *comma++ = '\0';
		}

		/* do we support this cipher? */
		while (cipher->name) {
		    if (!strcasecmp(value, cipher->name)) break;
		    cipher++;
		}
		if (cipher->name) {
		    ciphers |= cipher->flag;
		} else {
		    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
				       "Server supports unknown cipher: %s\n",
				       value);
		}

		value = comma;
	    }
	} else if (strcasecmp(name, "stale") == 0 && ctext->password) {
	    /* clear any cached password */
	    if (ctext->free_password)
		_plug_free_secret(params->utils, &ctext->password);
	    ctext->password = NULL;
	} else if (strcasecmp(name, "maxbuf") == 0) {
	    /* maxbuf A number indicating the size of the largest
	     * buffer the server is able to receive when using
	     * "auth-int". If this directive is missing, the default
	     * value is 65536. This directive may appear at most once;
	     * if multiple instances are present, the client should
	     * abort the authentication exchange.
	     */
	    maxbuf_count++;

	    if (maxbuf_count != 1) {
		result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		params->utils->log(params->utils->conn, SASL_LOG_ERR,
				   "At least two maxbuf directives found."
				   " Authentication aborted");
#else
		params->utils->seterror(params->utils->conn, 0,
					"At least two maxbuf directives found. Authentication aborted");
#endif /* _SUN_SDK_ */
		goto FreeAllocatedMem;
	    } else if (sscanf(value, "%u", &ctext->server_maxbuf) != 1) {
		result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		params->utils->log(params->utils->conn, SASL_LOG_ERR,
			"Invalid maxbuf parameter received from server");
#else
		params->utils->seterror(params->utils->conn, 0,
					"Invalid maxbuf parameter received from server");
#endif /* _SUN_SDK_ */
		goto FreeAllocatedMem;
	    } else {
		if (ctext->server_maxbuf<=16) {
		    result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		    params->utils->log(params->utils->conn, SASL_LOG_ERR,
			"Invalid maxbuf parameter received from server"
			" (too small: %s)", value);
#else
		    params->utils->seterror(params->utils->conn, 0,
					    "Invalid maxbuf parameter received from server (too small: %s)", value);
#endif /* _SUN_SDK_ */
		    goto FreeAllocatedMem;
		}
	    }
	} else if (strcasecmp(name, "charset") == 0) {
	    if (strcasecmp(value, "utf-8") != 0) {
		result = SASL_BADAUTH;
#ifdef _SUN_SDK_
		params->utils->log(params->utils->conn, SASL_LOG_ERR,
				   "Charset must be UTF-8");
#else
		params->utils->seterror(params->utils->conn, 0,
					"Charset must be UTF-8");
#endif /* _SUN_SDK_ */
		goto FreeAllocatedMem;
	    } else {
#ifndef _SUN_SDK_
		IsUTF8 = TRUE;
#endif /* !_SUN_SDK_ */
	    }
	} else if (strcasecmp(name,"algorithm")==0) {
	    if (strcasecmp(value, "md5-sess") != 0)
		{
#ifdef _SUN_SDK_
		    params->utils->log(params->utils->conn, SASL_LOG_ERR,
				"'algorithm' isn't 'md5-sess'");
#else
		    params->utils->seterror(params->utils->conn, 0,
					    "'algorithm' isn't 'md5-sess'");
#endif /* _SUN_SDK_ */
		    result = SASL_FAIL;
		    goto FreeAllocatedMem;
		}

	    algorithm_count++;
	    if (algorithm_count > 1)
		{
#ifdef _SUN_SDK_
		    params->utils->log(params->utils->conn, SASL_LOG_ERR,
				       "Must see 'algorithm' only once");
#else
		    params->utils->seterror(params->utils->conn, 0,
					    "Must see 'algorithm' only once");
#endif /* _SUN_SDK_ */
		    result = SASL_FAIL;
		    goto FreeAllocatedMem;
		}
	} else {
	    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
			       "DIGEST-MD5 unrecognized pair %s/%s: ignoring",
			       name, value);
	}
    }

    if (algorithm_count != 1) {
#ifdef _SUN_SDK_
	params->utils->log(params->utils->conn, SASL_LOG_ERR,
		"Must see 'algorithm' once. Didn't see at all");
#else
	params->utils->seterror(params->utils->conn, 0,
				"Must see 'algorithm' once. Didn't see at all");
#endif /* _SUN_SDK_ */
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }

    /* make sure we have everything we require */
    if (text->nonce == NULL) {
#ifdef _SUN_SDK_
	params->utils->log(params->utils->conn, SASL_LOG_ERR,
			   "Don't have nonce.");
#else
	params->utils->seterror(params->utils->conn, 0,
				"Don't have nonce.");
#endif /* _SUN_SDK_ */
	result = SASL_FAIL;
	goto FreeAllocatedMem;
    }

    /* get requested ssf */
    external = params->external_ssf;

    /* what do we _need_?  how much is too much? */
    if (params->props.maxbufsize == 0) {
	musthave = 0;
	limit = 0;
    } else {
	if (params->props.max_ssf > external) {
	    limit = params->props.max_ssf - external;
	} else {
	    limit = 0;
	}
	if (params->props.min_ssf > external) {
	    musthave = params->props.min_ssf - external;
	} else {
	    musthave = 0;
	}
    }

    /* we now go searching for an option that gives us at least "musthave"
       and at most "limit" bits of ssf. */
    if ((limit > 1) && (protection & DIGEST_PRIVACY)) {
	struct digest_cipher *cipher;

	/* let's find an encryption scheme that we like */
#ifdef USE_UEF_CLIENT
	cipher = available_ciphers1;
#else
	cipher = available_ciphers;
#endif
	while (cipher->name) {
	    /* examine each cipher we support, see if it meets our security
	       requirements, and see if the server supports it.
	       choose the best one of these */
	    if ((limit >= cipher->ssf) && (musthave <= cipher->ssf) &&
		(ciphers & cipher->flag) &&
		(!ctext->cipher || (cipher->ssf > ctext->cipher->ssf))) {
		ctext->cipher = cipher;
	    }
	    cipher++;
	}

	if (ctext->cipher) {
	    /* we found a cipher we like */
	    ctext->protection = DIGEST_PRIVACY;
	} else {
	    /* we didn't find any ciphers we like */
#ifdef _INTEGRATED_SOLARIS_
	    params->utils->seterror(params->utils->conn, 0,
				    gettext("No good privacy layers"));
#else
	    params->utils->seterror(params->utils->conn, 0,
				    "No good privacy layers");
#endif /* _INTEGRATED_SOLARIS_ */
	}
    }

    if (ctext->cipher == NULL) {
	/* we failed to find an encryption layer we liked;
	   can we use integrity or nothing? */

	if ((limit >= 1) && (musthave <= 1)
	    && (protection & DIGEST_INTEGRITY)) {
	    /* integrity */
	    ctext->protection = DIGEST_INTEGRITY;
#ifdef _SUN_SDK_
	} else if (musthave == 0) {
#else
	} else if (musthave <= 0) {
#endif /* _SUN_SDK_ */
	    /* no layer */
	    ctext->protection = DIGEST_NOLAYER;

	    /* See if server supports not having a layer */
	    if ((protection & DIGEST_NOLAYER) != DIGEST_NOLAYER) {
#ifdef _INTEGRATED_SOLARIS_
		params->utils->seterror(params->utils->conn, 0,
			gettext("Server doesn't support \"no layer\""));
#else
		params->utils->seterror(params->utils->conn, 0,
					"Server doesn't support \"no layer\"");
#endif /* _INTEGRATED_SOLARIS_ */
		result = SASL_FAIL;
		goto FreeAllocatedMem;
	    }
	} else {
#ifdef _INTEGRATED_SOLARIS_
	    params->utils->seterror(params->utils->conn, 0,
				    gettext("Can't find an acceptable layer"));
#else
	    params->utils->seterror(params->utils->conn, 0,
				    "Can't find an acceptable layer");
#endif /* _INTEGRATED_SOLARIS_ */
	    result = SASL_TOOWEAK;
	    goto FreeAllocatedMem;
	}
    }

    *outrealms = realms;
    *noutrealm = nrealm;

  FreeAllocatedMem:
    if (in_start) params->utils->free(in_start);

    if (result != SASL_OK && realms) {
	int lup;

	/* need to free all the realms */
	for (lup = 0;lup < nrealm; lup++)
	    params->utils->free(realms[lup]);

	params->utils->free(realms);
    }

    return result;
}

static int ask_user_info(client_context_t *ctext,
			 sasl_client_params_t *params,
			 char **realms, int nrealm,
			 sasl_interact_t **prompt_need,
			 sasl_out_params_t *oparams)
{
    context_t *text = (context_t *) ctext;
    int result = SASL_OK;
    const char *authid = NULL, *userid = NULL, *realm = NULL;
    char *realm_chal = NULL;
    int user_result = SASL_OK;
    int auth_result = SASL_OK;
    int pass_result = SASL_OK;
    int realm_result = SASL_FAIL;

    /* try to get the authid */
    if (oparams->authid == NULL) {
	auth_result = _plug_get_authid(params->utils, &authid, prompt_need);

	if ((auth_result != SASL_OK) && (auth_result != SASL_INTERACT)) {
	    return auth_result;
	}
    }

    /* try to get the userid */
    if (oparams->user == NULL) {
	user_result = _plug_get_userid(params->utils, &userid, prompt_need);

	if ((user_result != SASL_OK) && (user_result != SASL_INTERACT)) {
	    return user_result;
	}
    }

    /* try to get the password */
    if (ctext->password == NULL) {
	pass_result = _plug_get_password(params->utils, &ctext->password,
					 &ctext->free_password, prompt_need);
	if ((pass_result != SASL_OK) && (pass_result != SASL_INTERACT)) {
	    return pass_result;
	}
    }

    /* try to get the realm */
    if (text->realm == NULL) {
	if (realms) {
	    if(nrealm == 1) {
		/* only one choice */
		realm = realms[0];
		realm_result = SASL_OK;
	    } else {
		/* ask the user */
		realm_result = _plug_get_realm(params->utils,
					       (const char **) realms,
					       (const char **) &realm,
					       prompt_need);
	    }
	}

	/* fake the realm if we must */
	if ((realm_result != SASL_OK) && (realm_result != SASL_INTERACT)) {
	    if (params->serverFQDN) {
		realm = params->serverFQDN;
	    } else {
		return realm_result;
	    }
	}
    }

    /* free prompts we got */
    if (prompt_need && *prompt_need) {
	params->utils->free(*prompt_need);
	*prompt_need = NULL;
    }

    /* if there are prompts not filled in */
    if ((user_result == SASL_INTERACT) || (auth_result == SASL_INTERACT) ||
	(pass_result == SASL_INTERACT) || (realm_result == SASL_INTERACT)) {

	/* make our default realm */
	if ((realm_result == SASL_INTERACT) && params->serverFQDN) {
	    realm_chal = params->utils->malloc(3+strlen(params->serverFQDN));
	    if (realm_chal) {
		sprintf(realm_chal, "{%s}", params->serverFQDN);
	    } else {
		return SASL_NOMEM;
	    }
	}

	/* make the prompt list */
	result =
#if defined _INTEGRATED_SOLARIS_
	    _plug_make_prompts(params->utils, &ctext->h, prompt_need,
			       user_result == SASL_INTERACT ?
			       convert_prompt(params->utils, &ctext->h,
			       gettext("Please enter your authorization name"))
					: NULL,
			       NULL,
			       auth_result == SASL_INTERACT ?
			       convert_prompt(params->utils, &ctext->h,
			gettext("Please enter your authentication name"))
					: NULL,
			       NULL,
			       pass_result == SASL_INTERACT ?
			       convert_prompt(params->utils, &ctext->h,
					gettext("Please enter your password"))
					: NULL, NULL,
			       NULL, NULL, NULL,
			       realm_chal ? realm_chal : "{}",
			       realm_result == SASL_INTERACT ?
			       convert_prompt(params->utils, &ctext->h,
				    gettext("Please enter your realm")) : NULL,
			       params->serverFQDN ? params->serverFQDN : NULL);
#else
	    _plug_make_prompts(params->utils, prompt_need,
			       user_result == SASL_INTERACT ?
			       "Please enter your authorization name" : NULL,
			       NULL,
			       auth_result == SASL_INTERACT ?
			       "Please enter your authentication name" : NULL,
			       NULL,
			       pass_result == SASL_INTERACT ?
			       "Please enter your password" : NULL, NULL,
			       NULL, NULL, NULL,
			       realm_chal ? realm_chal : "{}",
			       realm_result == SASL_INTERACT ?
			       "Please enter your realm" : NULL,
			       params->serverFQDN ? params->serverFQDN : NULL);
#endif /* _INTEGRATED_SOLARIS_ */

	if (result == SASL_OK) return SASL_INTERACT;

	return result;
    }

    if (oparams->authid == NULL) {
	if (!userid || !*userid) {
	    result = params->canon_user(params->utils->conn, authid, 0,
					SASL_CU_AUTHID | SASL_CU_AUTHZID,
					oparams);
	}
	else {
	    result = params->canon_user(params->utils->conn,
					authid, 0, SASL_CU_AUTHID, oparams);
	    if (result != SASL_OK) return result;

	    result = params->canon_user(params->utils->conn,
					userid, 0, SASL_CU_AUTHZID, oparams);
	}
	if (result != SASL_OK) return result;
    }

    /* Get an allocated version of the realm into the structure */
    if (realm && text->realm == NULL) {
	_plug_strdup(params->utils, realm, (char **) &text->realm, NULL);
    }

    return result;
}

static int
digestmd5_client_mech_new(void *glob_context,
			  sasl_client_params_t * params,
			  void **conn_context)
{
    context_t *text;

    /* holds state are in -- allocate client size */
    text = params->utils->malloc(sizeof(client_context_t));
    if (text == NULL)
	return SASL_NOMEM;
    memset(text, 0, sizeof(client_context_t));

    text->state = 1;
    text->i_am = CLIENT;
    text->reauth = glob_context;

    *conn_context = text;

    return SASL_OK;
}

static int
digestmd5_client_mech_step1(client_context_t *ctext,
			    sasl_client_params_t *params,
			    const char *serverin __attribute__((unused)),
			    unsigned serverinlen __attribute__((unused)),
			    sasl_interact_t **prompt_need,
			    const char **clientout,
			    unsigned *clientoutlen,
			    sasl_out_params_t *oparams)
{
    context_t *text = (context_t *) ctext;
    int result = SASL_FAIL;
    unsigned val;

    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
		       "DIGEST-MD5 client step 1");

    result = ask_user_info(ctext, params, NULL, 0, prompt_need, oparams);
    if (result != SASL_OK) return result;

    /* check if we have cached info for this user on this server */
    val = hash(params->serverFQDN) % text->reauth->size;
    if (params->utils->mutex_lock(text->reauth->mutex) == SASL_OK) { /* LOCK */
	if (text->reauth->e[val].u.c.serverFQDN &&
	    !strcasecmp(text->reauth->e[val].u.c.serverFQDN,
			params->serverFQDN) &&
	    !strcmp(text->reauth->e[val].authid, oparams->authid)) {

#ifdef _SUN_SDK_
	    if (text->realm) params->utils->free(text->realm);
	    if (text->nonce) params->utils->free(text->nonce);
	    if (text->cnonce) params->utils->free(text->cnonce);
#endif /* _SUN_SDK_ */
	    /* we have info, so use it */
	    _plug_strdup(params->utils, text->reauth->e[val].realm,
			 &text->realm, NULL);
#ifdef _SUN_SDK_
	    _plug_strdup(params->utils, (char *)text->reauth->e[val].nonce,
			 (char **) &text->nonce, NULL);
#else
	    _plug_strdup(params->utils, text->reauth->e[val].nonce,
			 (char **) &text->nonce, NULL);
#endif /* _SUN_SDK_ */
	    text->nonce_count = ++text->reauth->e[val].nonce_count;
#ifdef _SUN_SDK_
	    _plug_strdup(params->utils, (char *)text->reauth->e[val].cnonce,
			 (char **) &text->cnonce, NULL);
#else
	    _plug_strdup(params->utils, text->reauth->e[val].cnonce,
			 (char **) &text->cnonce, NULL);
#endif /* _SUN_SDK_ */
	    ctext->protection = text->reauth->e[val].u.c.protection;
	    ctext->cipher = text->reauth->e[val].u.c.cipher;
	    ctext->server_maxbuf = text->reauth->e[val].u.c.server_maxbuf;
	}
	params->utils->mutex_unlock(text->reauth->mutex); /* UNLOCK */
    }

    if (!text->nonce) {
	/* we don't have any reauth info, so just return
	 * that there is no initial client send */
	text->state = 2;
	return SASL_CONTINUE;
    }

    /*
     * (username | realm | nonce | cnonce | nonce-count | qop digest-uri |
     * response | maxbuf | charset | auth-param )
     */

    result = make_client_response(text, params, oparams);
    if (result != SASL_OK) return result;

    *clientoutlen = strlen(text->out_buf);
    *clientout = text->out_buf;

    text->state = 3;
    return SASL_CONTINUE;
}

static int
digestmd5_client_mech_step2(client_context_t *ctext,
			    sasl_client_params_t *params,
			    const char *serverin,
			    unsigned serverinlen,
			    sasl_interact_t **prompt_need,
			    const char **clientout,
			    unsigned *clientoutlen,
			    sasl_out_params_t *oparams)
{
    context_t *text = (context_t *) ctext;
    int result = SASL_FAIL;
    char **realms = NULL;
    int nrealm = 0;

    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
		       "DIGEST-MD5 client step 2");

    if (params->props.min_ssf > params->props.max_ssf) {
	return SASL_BADPARAM;
    }

    /* don't bother parsing the challenge more than once */
    if (text->nonce == NULL) {
	result = parse_server_challenge(ctext, params, serverin, serverinlen,
					&realms, &nrealm);
	if (result != SASL_OK) goto FreeAllocatedMem;

	if (nrealm == 1) {
	    /* only one choice! */
	    text->realm = realms[0];

	    /* free realms */
	    params->utils->free(realms);
	    realms = NULL;
	}
    }

    result = ask_user_info(ctext, params, realms, nrealm,
			   prompt_need, oparams);
    if (result != SASL_OK) goto FreeAllocatedMem;

    /*
     * (username | realm | nonce | cnonce | nonce-count | qop digest-uri |
     * response | maxbuf | charset | auth-param )
     */

    result = make_client_response(text, params, oparams);
    if (result != SASL_OK) goto FreeAllocatedMem;

    *clientoutlen = strlen(text->out_buf);
    *clientout = text->out_buf;

    text->state = 3;

    result = SASL_CONTINUE;

  FreeAllocatedMem:
    if (realms) {
	int lup;

	/* need to free all the realms */
	for (lup = 0;lup < nrealm; lup++)
	    params->utils->free(realms[lup]);

	params->utils->free(realms);
    }

    return result;
}

static int
digestmd5_client_mech_step3(client_context_t *ctext,
			    sasl_client_params_t *params,
			    const char *serverin,
			    unsigned serverinlen,
			    sasl_interact_t **prompt_need __attribute__((unused)),
			    const char **clientout __attribute__((unused)),
			    unsigned *clientoutlen __attribute__((unused)),
			    sasl_out_params_t *oparams)
{
    context_t *text = (context_t *) ctext;
    char           *in = NULL;
    char           *in_start;
    int result = SASL_FAIL;

    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
		       "DIGEST-MD5 client step 3");

    /* Verify that server is really what he claims to be */
    in_start = in = params->utils->malloc(serverinlen + 1);
    if (in == NULL) return SASL_NOMEM;

    memcpy(in, serverin, serverinlen);
    in[serverinlen] = 0;

    /* parse the response */
    while (in[0] != '\0') {
	char *name, *value;
	get_pair(&in, &name, &value);

	if (name == NULL) {
#ifdef _SUN_SDK_
	    params->utils->log(params->utils->conn, SASL_LOG_ERR,
			       "DIGEST-MD5 Received Garbage");
#else
	    params->utils->seterror(params->utils->conn, 0,
				    "DIGEST-MD5 Received Garbage");
#endif /* _SUN_SDK_ */
	    break;
	}

	if (strcasecmp(name, "rspauth") == 0) {

	    if (strcmp(text->response_value, value) != 0) {
#ifdef _INTEGRATED_SOLARIS_
		params->utils->seterror(params->utils->conn, 0,
			gettext("Server authentication failed"));
#else
		params->utils->seterror(params->utils->conn, 0,
					"DIGEST-MD5: This server wants us to believe that he knows shared secret");
#endif /* _INTEGRATED_SOLARIS_ */
		result = SASL_FAIL;
	    } else {
		oparams->doneflag = 1;
		oparams->param_version = 0;

		result = SASL_OK;
	    }
	    break;
	} else {
	    params->utils->log(params->utils->conn, SASL_LOG_DEBUG,
			       "DIGEST-MD5 unrecognized pair %s/%s: ignoring",
			       name, value);
	}
    }

    params->utils->free(in_start);

    if (params->utils->mutex_lock(text->reauth->mutex) == SASL_OK) { /* LOCK */
	unsigned val = hash(params->serverFQDN) % text->reauth->size;
	switch (result) {
	case SASL_OK:
	    if (text->nonce_count == 1) {
		/* successful initial auth, setup for future reauth */
		clear_reauth_entry(&text->reauth->e[val], CLIENT, params->utils);
		_plug_strdup(params->utils, oparams->authid,
			     &text->reauth->e[val].authid, NULL);
		text->reauth->e[val].realm = text->realm; text->realm = NULL;
		text->reauth->e[val].nonce = text->nonce; text->nonce = NULL;
		text->reauth->e[val].nonce_count = text->nonce_count;
		text->reauth->e[val].cnonce = text->cnonce; text->cnonce = NULL;
		_plug_strdup(params->utils, params->serverFQDN,
			     &text->reauth->e[val].u.c.serverFQDN, NULL);
		text->reauth->e[val].u.c.protection = ctext->protection;
		text->reauth->e[val].u.c.cipher = ctext->cipher;
		text->reauth->e[val].u.c.server_maxbuf = ctext->server_maxbuf;
	    }
#ifndef _SUN_SDK_
	    else {
		/* reauth, we already incremented nonce_count */
	    }
#endif /* !_SUN_SDK_ */
	    break;
	default:
	    if (text->nonce_count > 1) {
		/* failed reauth, clear cache */
		clear_reauth_entry(&text->reauth->e[val], CLIENT, params->utils);
	    }
	    else {
		/* failed initial auth, leave existing cache */
	    }
	}
	params->utils->mutex_unlock(text->reauth->mutex); /* UNLOCK */
    }

    return result;
}

static int
digestmd5_client_mech_step(void *conn_context,
			   sasl_client_params_t *params,
			   const char *serverin,
			   unsigned serverinlen,
			   sasl_interact_t **prompt_need,
			   const char **clientout,
			   unsigned *clientoutlen,
			   sasl_out_params_t *oparams)
{
    context_t *text = (context_t *) conn_context;
    client_context_t *ctext = (client_context_t *) conn_context;
    unsigned val = hash(params->serverFQDN) % text->reauth->size;

    if (serverinlen > 2048) return SASL_BADPROT;

    *clientout = NULL;
    *clientoutlen = 0;

    switch (text->state) {

    case 1:
	if (!serverin) {
	    /* here's where we attempt fast reauth if possible */
	    int reauth = 0;

	    /* check if we have saved info for this server */
	    if (params->utils->mutex_lock(text->reauth->mutex) == SASL_OK) { /* LOCK */
		reauth = text->reauth->e[val].u.c.serverFQDN &&
		    !strcasecmp(text->reauth->e[val].u.c.serverFQDN,
				params->serverFQDN);
		params->utils->mutex_unlock(text->reauth->mutex); /* UNLOCK */
	    }
	    if (reauth) {
		return digestmd5_client_mech_step1(ctext, params,
						   serverin, serverinlen,
						   prompt_need,
						   clientout, clientoutlen,
						   oparams);
	    }
	    else {
		/* we don't have any reauth info, so just return
		 * that there is no initial client send */
		text->state = 2;
		return SASL_CONTINUE;
	    }
	}

	/* fall through and respond to challenge */

    case 3:
	if (serverin && !strncasecmp(serverin, "rspauth=", 8)) {
	    return digestmd5_client_mech_step3(ctext, params,
					       serverin, serverinlen,
					       prompt_need,
					       clientout, clientoutlen,
					       oparams);
	}

	/* fall through and respond to challenge */
	text->state = 2;

	/* cleanup after a failed reauth attempt */
	if (params->utils->mutex_lock(text->reauth->mutex) == SASL_OK) { /* LOCK */
	    clear_reauth_entry(&text->reauth->e[val], CLIENT, params->utils);

	    params->utils->mutex_unlock(text->reauth->mutex); /* UNLOCK */
	}

	if (text->realm) params->utils->free(text->realm);
	if (text->nonce) params->utils->free(text->nonce);
	if (text->cnonce) params->utils->free(text->cnonce);
#ifdef _SUN_SDK_
	text->realm = NULL;
	text->nonce = text->cnonce = NULL;
#else
	text->realm = text->nonce = text->cnonce = NULL;
#endif /* _SUN_SDK_ */
	ctext->cipher = NULL;

    case 2:
	return digestmd5_client_mech_step2(ctext, params,
					   serverin, serverinlen,
					   prompt_need,
					   clientout, clientoutlen,
					   oparams);

    default:
#ifdef _SUN_SDK_
	params->utils->log(params->utils->conn, SASL_LOG_ERR,
			   "Invalid DIGEST-MD5 client step %d", text->state);
#else
	params->utils->log(NULL, SASL_LOG_ERR,
			   "Invalid DIGEST-MD5 client step %d\n", text->state);
#endif /* _SUN_SDK_ */
	return SASL_FAIL;
    }

    return SASL_FAIL; /* should never get here */
}

static void
digestmd5_client_mech_dispose(void *conn_context, const sasl_utils_t *utils)
{
    client_context_t *ctext = (client_context_t *) conn_context;

    if (!ctext || !utils) return;

#ifdef _INTEGRATED_SOLARIS_
    convert_prompt(utils, &ctext->h, NULL);
#endif /* _INTEGRATED_SOLARIS_ */

    if (ctext->free_password) _plug_free_secret(utils, &ctext->password);

    digestmd5_common_mech_dispose(conn_context, utils);
}

static sasl_client_plug_t digestmd5_client_plugins[] =
{
    {
	"DIGEST-MD5",
#ifdef WITH_RC4				/* mech_name */
	128,				/* max ssf */
#elif WITH_DES
	112,
#else
	0,
#endif
	SASL_SEC_NOPLAINTEXT
	| SASL_SEC_NOANONYMOUS
	| SASL_SEC_MUTUAL_AUTH,		/* security_flags */
	SASL_FEAT_ALLOWS_PROXY, 	/* features */
	NULL,				/* required_prompts */
	NULL,				/* glob_context */
	&digestmd5_client_mech_new,	/* mech_new */
	&digestmd5_client_mech_step,	/* mech_step */
	&digestmd5_client_mech_dispose,	/* mech_dispose */
	&digestmd5_common_mech_free,	/* mech_free */
	NULL,				/* idle */
	NULL,				/* spare1 */
	NULL				/* spare2 */
    }
};

int digestmd5_client_plug_init(sasl_utils_t *utils,
			       int maxversion,
			       int *out_version,
			       sasl_client_plug_t **pluglist,
			       int *plugcount)
{
    reauth_cache_t *reauth_cache;
#if defined _SUN_SDK_  && defined USE_UEF
    int ret;
#endif /* _SUN_SDK_ && USE_UEF */

    if (maxversion < SASL_CLIENT_PLUG_VERSION)
	return SASL_BADVERS;

#if defined _SUN_SDK_  && defined USE_UEF
    if ((ret = uef_init(utils)) != SASL_OK)
	return ret;
#endif /* _SUN_SDK_ && USE_UEF */

    /* reauth cache */
    reauth_cache = utils->malloc(sizeof(reauth_cache_t));
    if (reauth_cache == NULL)
	return SASL_NOMEM;
    memset(reauth_cache, 0, sizeof(reauth_cache_t));
    reauth_cache->i_am = CLIENT;

    /* mutex */
    reauth_cache->mutex = utils->mutex_alloc();
    if (!reauth_cache->mutex)
	return SASL_FAIL;

    /* entries */
    reauth_cache->size = 10;
    reauth_cache->e = utils->malloc(reauth_cache->size *
				    sizeof(reauth_entry_t));
    if (reauth_cache->e == NULL)
	return SASL_NOMEM;
    memset(reauth_cache->e, 0, reauth_cache->size * sizeof(reauth_entry_t));

    digestmd5_client_plugins[0].glob_context = reauth_cache;
#ifdef _SUN_SDK_
#ifdef USE_UEF_CLIENT
    digestmd5_client_plugins[0].max_ssf = uef_max_ssf;
#endif /* USE_UEF_CLIENT */
#endif /* _SUN_SDK_ */

#ifdef _INTEGRATED_SOLARIS_
    /*
     * Let libsasl know that we are a "Sun" plugin so that privacy
     * and integrity will be allowed.
     */
    REG_PLUG("DIGEST-MD5", digestmd5_client_plugins);
#endif /* _INTEGRATED_SOLARIS_ */

    *out_version = SASL_CLIENT_PLUG_VERSION;
    *pluglist = digestmd5_client_plugins;
    *plugcount = 1;

    return SASL_OK;
}

#ifdef _SUN_SDK_
#ifdef USE_UEF
/* If we fail here - we should just not offer privacy or integrity */
static int
getSlotID(const sasl_utils_t *utils, CK_MECHANISM_TYPE mech_type,
	  CK_SLOT_ID *slot_id)
{
    CK_RV rv;
    CK_ULONG ulSlotCount;
    CK_ULONG ulMechTypeCount;
    CK_SLOT_ID *pSlotList = NULL;
    CK_SLOT_ID slotID;
    CK_MECHANISM_TYPE_PTR pMechTypeList = NULL;
    int i, m;

    rv = C_GetSlotList(CK_FALSE, NULL_PTR, &ulSlotCount);
    if (rv != CKR_OK || ulSlotCount == 0) {
#ifdef DEBUG
	utils->log(utils->conn, SASL_LOG_DEBUG,
		   "C_GetSlotList: 0x%.8X count:%d\n", rv, ulSlotCount);
#endif
	return SASL_FAIL;
    }

    pSlotList = utils->calloc(sizeof (CK_SLOT_ID), ulSlotCount);
    if (pSlotList == NULL)
	return SASL_NOMEM;

    rv = C_GetSlotList(CK_FALSE, pSlotList, &ulSlotCount);
    if (rv != CKR_OK) {
#ifdef DEBUG
	utils->log(utils->conn, SASL_LOG_DEBUG,
		   "C_GetSlotList: 0x%.8X count:%d\n", rv, ulSlotCount);
#endif
	return SASL_FAIL;
    }

    for (i = 0; i < ulSlotCount; i++) {
	slotID = pSlotList[i];
	rv = C_GetMechanismList(slotID, NULL_PTR, &ulMechTypeCount);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    utils->log(utils->conn, SASL_LOG_DEBUG,
		      "C_GetMechanismList returned 0x%.8X count:%d\n", rv,
		       ulMechTypeCount);
#endif
	    utils->free(pSlotList);
	    return SASL_FAIL;
	}
	pMechTypeList =
		utils->calloc(sizeof (CK_MECHANISM_TYPE), ulMechTypeCount);
	if (pMechTypeList == NULL_PTR) {
	    utils->free(pSlotList);
	    return SASL_NOMEM;
	}
	rv = C_GetMechanismList(slotID, pMechTypeList, &ulMechTypeCount);
	if (rv != CKR_OK) {
#ifdef DEBUG
	    utils->log(utils->conn, SASL_LOG_DEBUG,
	    	       "C_GetMechanismList returned 0x%.8X count:%d\n", rv,
		       ulMechTypeCount);
#endif
	    utils->free(pMechTypeList);
	    utils->free(pSlotList);
	    return SASL_FAIL;
	}

	for (m = 0; m < ulMechTypeCount; m++) {
	    if (pMechTypeList[m] == mech_type)
		break;
	}
	utils->free(pMechTypeList);
	pMechTypeList = NULL;
	if (m < ulMechTypeCount)
	    break;
    }
    utils->free(pSlotList);
    if (i < ulSlotCount) {
	*slot_id = slotID;
	return SASL_OK;
    }
    return SASL_FAIL;
}

static int
uef_init(const sasl_utils_t *utils)
{
    int got_rc4;
    int got_des;
    int got_3des;
    int next_c;
    CK_RV rv;

    if (got_uef_slot)
	return (SASL_OK);

    if (LOCK_MUTEX(&uef_init_mutex) < 0)
	return (SASL_FAIL);

    rv = C_Initialize(NULL_PTR);
    if (rv != CKR_OK && rv != CKR_CRYPTOKI_ALREADY_INITIALIZED) {
#ifdef DEBUG
	utils->log(utils->conn, SASL_LOG_DEBUG,
		   "C_Initialize returned 0x%.8X\n", rv);
#endif
	return SASL_FAIL;
    }

    got_rc4 = getSlotID(utils, CKM_RC4, &rc4_slot_id) == SASL_OK;
    if (!got_rc4)
	utils->log(utils->conn, SASL_LOG_WARN, "Could not get rc4");

    got_des = getSlotID(utils, CKM_DES_CBC, &des_slot_id) == SASL_OK;
    if (!got_des)
	utils->log(utils->conn, SASL_LOG_WARN, "Could not get des");

    got_3des = getSlotID(utils, CKM_DES3_CBC, &des3_slot_id) == SASL_OK;
    if (!got_3des)
	utils->log(utils->conn, SASL_LOG_WARN, "Could not get 3des");

    uef_max_ssf = got_rc4 ? 128 : got_3des ? 112 : got_des ? 55 : 0;

    /* adjust the available ciphers */
    next_c = (got_rc4) ? 3 : 0;

    if (got_des) {
        uef_ciphers[next_c].name = uef_ciphers[DES_CIPHER_INDEX].name;
        uef_ciphers[next_c].ssf = uef_ciphers[DES_CIPHER_INDEX].ssf;
        uef_ciphers[next_c].n = uef_ciphers[DES_CIPHER_INDEX].n;
        uef_ciphers[next_c].flag = uef_ciphers[DES_CIPHER_INDEX].flag;
        uef_ciphers[next_c].cipher_enc =
		uef_ciphers[DES_CIPHER_INDEX].cipher_enc;
        uef_ciphers[next_c].cipher_dec =
		uef_ciphers[DES_CIPHER_INDEX].cipher_dec;
        uef_ciphers[next_c].cipher_init =
		uef_ciphers[DES_CIPHER_INDEX].cipher_init;
	next_c++;
    }

    if (got_3des) {
        uef_ciphers[next_c].name = uef_ciphers[DES3_CIPHER_INDEX].name;
        uef_ciphers[next_c].ssf = uef_ciphers[DES3_CIPHER_INDEX].ssf;
        uef_ciphers[next_c].n = uef_ciphers[DES3_CIPHER_INDEX].n;
        uef_ciphers[next_c].flag = uef_ciphers[DES3_CIPHER_INDEX].flag;
        uef_ciphers[next_c].cipher_enc =
		uef_ciphers[DES3_CIPHER_INDEX].cipher_enc;
        uef_ciphers[next_c].cipher_dec =
		uef_ciphers[DES3_CIPHER_INDEX].cipher_dec;
        uef_ciphers[next_c].cipher_init =
		uef_ciphers[DES3_CIPHER_INDEX].cipher_init;
	next_c++;
    }
    uef_ciphers[next_c].name = NULL;

    got_uef_slot = TRUE;
    UNLOCK_MUTEX(&uef_init_mutex);

    return (SASL_OK);
}
#endif /* USE_UEF */
#endif /* _SUN_SDK_ */