svc_auth_des.c File Reference

#include <wintirpc.h>
#include <reentrant.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <rpc/des_crypt.h>
#include <rpc/types.h>
#include <rpc/xdr.h>
#include <rpc/auth.h>
#include <rpc/auth_des.h>
#include <rpc/svc.h>
#include <rpc/rpc_msg.h>
#include <rpc/svc_auth.h>
#include <libc_private.h>

Include dependency graph for svc_auth_des.c:

Go to the source code of this file.

Classes
struct	cache_entry

Macros
#define	debug(msg)   printf("svcauth_des: %s\n", msg)
#define	USEC_PER_SEC   ((u_long) 1000000L)
#define	BEFORE(t1, t2)   timercmp(t1, t2, <)
#define	AUTHDES_CACHESZ   64

Functions
int	key_decryptsession_pk (const char *, netobj *, des_block *)
static void	cache_init ()
static short	cache_spot ()
static void	cache_ref ()
static void	invalidate ()
enum auth_stat	_svcauth_des (struct svc_req *rqst, struct rpc_msg *msg)
static short	cache_victim ()
static void	cache_ref (short sid)
static short	cache_spot (des_block *key, char *name, struct timeval *timestamp)

Variables
static struct cache_entry *	authdes_cache
static short *	authdes_lru
struct {
u_long   ncachehits
u_long   ncachereplays
u_long   ncachemisses
}	svcauthdes_stats

Macro Definition Documentation

AUTHDES_CACHESZ

#define AUTHDES_CACHESZ   64

Definition at line 76 of file svc_auth_des.c.

BEFORE

#define BEFORE	(		t1,
			t2
	)		timercmp(t1, t2, <)

Definition at line 71 of file svc_auth_des.c.

debug

#define debug

(

msg

)

printf("svcauth_des: %s\n", msg)

Definition at line 68 of file svc_auth_des.c.

USEC_PER_SEC

#define USEC_PER_SEC   ((u_long) 1000000L)

Definition at line 70 of file svc_auth_des.c.

Function Documentation

_svcauth_des()

enum auth_stat _svcauth_des	(	struct svc_req *	rqst,
		struct rpc_msg *	msg
	)

Definition at line 106 of file svc_auth_des.c.

{

    long *ixdr;
    des_block cryptbuf[2];
    struct authdes_cred *cred;
    struct authdes_verf verf;
    int status;
    struct cache_entry *entry;
    short sid = 0;
    des_block *sessionkey;
    des_block ivec;
    u_int window;
    struct timeval timestamp;
    u_long namelen;
    struct area {
        struct authdes_cred area_cred;
        char area_netname[MAXNETNAMELEN+1];
    } *area;

    if (authdes_cache == NULL) {
        cache_init();
    }

    area = (struct area *)rqst->rq_clntcred;
    cred = (struct authdes_cred *)&area->area_cred;

    /*
     * Get the credential
     */
    ixdr = (long *)msg->rm_call.cb_cred.oa_base;
    cred->adc_namekind = IXDR_GET_ENUM(ixdr, enum authdes_namekind);
    switch (cred->adc_namekind) {
    case ADN_FULLNAME:
        namelen = IXDR_GET_U_LONG(ixdr);
        if (namelen > MAXNETNAMELEN) {
            return (AUTH_BADCRED);
        }
        cred->adc_fullname.name = area->area_netname;
        bcopy((char *)ixdr, cred->adc_fullname.name, 
            (u_int)namelen);
        cred->adc_fullname.name[namelen] = 0;
        ixdr += (RNDUP(namelen) / BYTES_PER_XDR_UNIT);
        cred->adc_fullname.key.key.high = (u_long)*ixdr++;
        cred->adc_fullname.key.key.low = (u_long)*ixdr++;
        cred->adc_fullname.window = (u_long)*ixdr++;
        break;
    case ADN_NICKNAME:
        cred->adc_nickname = (u_long)*ixdr++;
        break;
    default:
        return (AUTH_BADCRED);  
    }

    /*
     * Get the verifier
     */
    ixdr = (long *)msg->rm_call.cb_verf.oa_base;
    verf.adv_xtimestamp.key.high = (u_long)*ixdr++;
    verf.adv_xtimestamp.key.low =  (u_long)*ixdr++;
    verf.adv_int_u = (u_long)*ixdr++;


    /*
     * Get the conversation key
     */
    if (cred->adc_namekind == ADN_FULLNAME) {
        netobj pkey;
        char pkey_data[1024];

        sessionkey = &cred->adc_fullname.key;
        if (! getpublickey(cred->adc_fullname.name, pkey_data)) {
            debug("getpublickey");
            return(AUTH_BADCRED);
        }
        pkey.n_bytes = pkey_data;
        pkey.n_len = strlen(pkey_data) + 1;
        if (key_decryptsession_pk(cred->adc_fullname.name, &pkey,
                       sessionkey) < 0) {
            debug("decryptsessionkey");
            return (AUTH_BADCRED); /* key not found */
        }
    } else { /* ADN_NICKNAME */ 
        sid = (short)cred->adc_nickname;
        if (sid < 0 || sid >= AUTHDES_CACHESZ) {
            debug("bad nickname");
            return (AUTH_BADCRED);  /* garbled credential */
        }
        sessionkey = &authdes_cache[sid].key;
    }


    /*
     * Decrypt the timestamp
     */
    cryptbuf[0] = verf.adv_xtimestamp; 
    if (cred->adc_namekind == ADN_FULLNAME) {
        cryptbuf[1].key.high = cred->adc_fullname.window;
        cryptbuf[1].key.low = verf.adv_winverf;
        ivec.key.high = ivec.key.low = 0;   
        status = cbc_crypt((char *)sessionkey, (char *)cryptbuf,
            2*sizeof(des_block), DES_DECRYPT | DES_HW, 
            (char *)&ivec);
    } else {
        status = ecb_crypt((char *)sessionkey, (char *)cryptbuf,
            sizeof(des_block), DES_DECRYPT | DES_HW);
    }
    if (DES_FAILED(status)) {
        debug("decryption failure");
        return (AUTH_FAILED);   /* system error */
    }

    /*
     * XDR the decrypted timestamp
     */
    ixdr = (long *)cryptbuf;
    timestamp.tv_sec = IXDR_GET_LONG(ixdr);
    timestamp.tv_usec = IXDR_GET_LONG(ixdr);

    /*
     * Check for valid credentials and verifiers.
     * They could be invalid because the key was flushed
     * out of the cache, and so a new session should begin.
     * Be sure and send AUTH_REJECTED{CRED, VERF} if this is the case.
     */
    {
        struct timeval current;
        int nick;
        int winverf;

        if (cred->adc_namekind == ADN_FULLNAME) {
            window = IXDR_GET_U_LONG(ixdr);
            winverf = IXDR_GET_U_LONG(ixdr);
            if (winverf != window - 1) {
                debug("window verifier mismatch");
                return (AUTH_BADCRED);  /* garbled credential */
            }
            sid = cache_spot(sessionkey, cred->adc_fullname.name, 
                &timestamp);
            if (sid < 0) {
                debug("replayed credential");
                return (AUTH_REJECTEDCRED); /* replay */
            }
            nick = 0;
        } else {    /* ADN_NICKNAME */
            window = authdes_cache[sid].window;
            nick = 1;
        }

        if ((u_long)timestamp.tv_usec >= USEC_PER_SEC) {
            debug("invalid usecs");
            /* cached out (bad key), or garbled verifier */
            return (nick ? AUTH_REJECTEDVERF : AUTH_BADVERF);
        }
        if (nick && BEFORE(&timestamp, 
                   &authdes_cache[sid].laststamp)) {
            debug("timestamp before last seen");
            return (AUTH_REJECTEDVERF); /* replay */
        }
        (void) gettimeofday(&current, (struct timezone *)NULL);
        current.tv_sec -= window;   /* allow for expiration */
        if (!BEFORE(&current, &timestamp)) {
            debug("timestamp expired");
            /* replay, or garbled credential */
            return (nick ? AUTH_REJECTEDVERF : AUTH_BADCRED);
        }
    }

    /*
     * Set up the reply verifier
     */
    verf.adv_nickname = (u_long)sid;

    /*
     * xdr the timestamp before encrypting
     */
    ixdr = (long *)cryptbuf;
    IXDR_PUT_LONG(ixdr, timestamp.tv_sec - 1);
    IXDR_PUT_LONG(ixdr, timestamp.tv_usec);

    /*   
     * encrypt the timestamp
     */
    status = ecb_crypt((char *)sessionkey, (char *)cryptbuf,
        sizeof(des_block), DES_ENCRYPT | DES_HW);
    if (DES_FAILED(status)) {
        debug("encryption failure");
        return (AUTH_FAILED);   /* system error */
    }
    verf.adv_xtimestamp = cryptbuf[0];

    /*
     * Serialize the reply verifier, and update rqst
     */
    ixdr = (long *)msg->rm_call.cb_verf.oa_base;
    *ixdr++ = (long)verf.adv_xtimestamp.key.high;
    *ixdr++ = (long)verf.adv_xtimestamp.key.low;
    *ixdr++ = (long)verf.adv_int_u;

    rqst->rq_xprt->xp_verf.oa_flavor = AUTH_DES;
    rqst->rq_xprt->xp_verf.oa_base = msg->rm_call.cb_verf.oa_base;
    rqst->rq_xprt->xp_verf.oa_length = 
        (char *)ixdr - msg->rm_call.cb_verf.oa_base;

    /*
     * We succeeded, commit the data to the cache now and
     * finish cooking the credential.
     */
    entry = &authdes_cache[sid];
    entry->laststamp = timestamp;
    cache_ref(sid);
    if (cred->adc_namekind == ADN_FULLNAME) {
        cred->adc_fullname.window = window;
        cred->adc_nickname = (u_long)sid;   /* save nickname */
        if (entry->rname != NULL) {
            mem_free(entry->rname, strlen(entry->rname) + 1);
        }
        entry->rname = (char *)mem_alloc((u_int)strlen(cred->adc_fullname.name)
                     + 1);
        if (entry->rname != NULL) {
            (void) strcpy(entry->rname, cred->adc_fullname.name);
        } else {
            debug("out of memory");
        }
        entry->key = *sessionkey;
        entry->window = window;
        invalidate(entry->localcred); /* mark any cached cred invalid */
    } else { /* ADN_NICKNAME */
        /*
         * nicknames are cooked into fullnames
         */ 
        cred->adc_namekind = ADN_FULLNAME;
        cred->adc_fullname.name = entry->rname;
        cred->adc_fullname.key = entry->key;
        cred->adc_fullname.window = entry->window;
    }
    return (AUTH_OK);   /* we made it!*/
}

Referenced by _authenticate().

cache_init()

static void cache_init ( )

static

Definition at line 352 of file svc_auth_des.c.

{
    int i;

    authdes_cache = (struct cache_entry *)
        mem_alloc(sizeof(struct cache_entry) * AUTHDES_CACHESZ);    
    bzero((char *)authdes_cache, 
        sizeof(struct cache_entry) * AUTHDES_CACHESZ);

    authdes_lru = (short *)mem_alloc(sizeof(short) * AUTHDES_CACHESZ);
    /*
     * Initialize the lru list
     */
    for (i = 0; i < AUTHDES_CACHESZ; i++) {
        authdes_lru[i] = i;
    }
}

Referenced by _svcauth_des().

cache_ref() [1/2]

static void cache_ref ( )

static

Referenced by _svcauth_des().

cache_ref() [2/2]

static void cache_ref ( short  sid )

static

Definition at line 384 of file svc_auth_des.c.

{
    int i;
    short curr;
    short prev;

    prev = authdes_lru[0];
    authdes_lru[0] = sid;
    for (i = 1; prev != sid; i++) {
        curr = authdes_lru[i];
        authdes_lru[i] = prev;
        prev = curr;
    }
}

cache_spot() [1/2]

static short cache_spot ( )

static

Referenced by _svcauth_des().

cache_spot() [2/2]

static short cache_spot ( des_block *  key, char *  name, struct timeval *  timestamp  )

static

Definition at line 407 of file svc_auth_des.c.

{
    struct cache_entry *cp;
    int i;
    u_long hi;

    hi = key->key.high;
    for (cp = authdes_cache, i = 0; i < AUTHDES_CACHESZ; i++, cp++) {
        if (cp->key.key.high == hi && 
            cp->key.key.low == key->key.low &&
            cp->rname != NULL &&
            bcmp(cp->rname, name, strlen(name) + 1) == 0) {
            if (BEFORE(timestamp, &cp->laststamp)) {
                svcauthdes_stats.ncachereplays++;
                return (-1); /* replay */
            }
            svcauthdes_stats.ncachehits++;
            return (i); /* refresh */
        }
    }
    svcauthdes_stats.ncachemisses++;
    return (cache_victim());    /* new credential */
}

cache_victim()

static short cache_victim ( )

static

Definition at line 375 of file svc_auth_des.c.

{
    return (authdes_lru[AUTHDES_CACHESZ-1]);
}

Referenced by cache_spot().

invalidate()

static void invalidate ( )

static

Referenced by _svcauth_des().

key_decryptsession_pk()

int key_decryptsession_pk	(	const char *	,
		netobj *	,
		des_block *
	)

Referenced by _svcauth_des().

Variable Documentation

authdes_cache

struct cache_entry* authdes_cache

static

Definition at line 84 of file svc_auth_des.c.

Referenced by _svcauth_des(), cache_init(), and cache_spot().

authdes_lru

short* authdes_lru

static

Definition at line 85 of file svc_auth_des.c.

Referenced by cache_init(), cache_ref(), and cache_victim().

ncachehits

u_long ncachehits

Definition at line 97 of file svc_auth_des.c.

ncachemisses

u_long ncachemisses

Definition at line 99 of file svc_auth_des.c.

ncachereplays

u_long ncachereplays

Definition at line 98 of file svc_auth_des.c.

svcauthdes_stats

struct { ... } svcauthdes_stats

Referenced by cache_spot().