Return to decomp_ticket.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / kerberosIV / krb

Annotation of 43BSDReno/kerberosIV/krb/decomp_ticket.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * $Source: /mit/kerberos/src/lib/krb/RCS/decomp_ticket.c,v $
        !             3:  * $Author: jtkohl $
        !             4:  *
        !             5:  * Copyright 1985, 1986, 1987, 1988 by the Massachusetts Institute
        !             6:  * of Technology.
        !             7:  *
        !             8:  * For copying and distribution information, please see the file
        !             9:  * <mit-copyright.h>.
        !            10:  */
        !            11: 
        !            12: #ifndef lint
        !            13: static char *rcsid_decomp_ticket_c =
        !            14: "$Header: decomp_ticket.c,v 4.12 89/05/16 18:44:46 jtkohl Exp $";
        !            15: #endif /* lint */
        !            16: 
        !            17: #include <mit-copyright.h>
        !            18: #include <stdio.h>
        !            19: #include <des.h>
        !            20: #include <krb.h>
        !            21: #include <prot.h>
        !            22: #include <strings.h>
        !            23: 
        !            24: /*
        !            25:  * This routine takes a ticket and pointers to the variables that
        !            26:  * should be filled in based on the information in the ticket.  It
        !            27: #ifndef NOENCRYPTION
        !            28:  * decrypts the ticket using the given key, and 
        !            29: #endif
        !            30:  * fills in values for its arguments.
        !            31:  *
        !            32:  * Note: if the client realm field in the ticket is the null string,
        !            33:  * then the "prealm" variable is filled in with the local realm (as
        !            34:  * defined by KRB_REALM).
        !            35:  *
        !            36:  * If the ticket byte order is different than the host's byte order
        !            37:  * (as indicated by the byte order bit of the "flags" field), then
        !            38:  * the KDC timestamp "time_sec" is byte-swapped.  The other fields
        !            39:  * potentially affected by byte order, "paddress" and "session" are
        !            40:  * not byte-swapped.
        !            41:  *
        !            42:  * The routine returns KFAILURE if any of the "pname", "pinstance",
        !            43:  * or "prealm" fields is too big, otherwise it returns KSUCCESS.
        !            44:  *
        !            45:  * The corresponding routine to generate tickets is create_ticket.
        !            46:  * When changes are made to this routine, the corresponding changes
        !            47:  * should also be made to that file.
        !            48:  *
        !            49:  * See create_ticket.c for the format of the ticket packet.
        !            50:  */
        !            51: 
        !            52: decomp_ticket(tkt, flags, pname, pinstance, prealm, paddress, session,
        !            53:               life, time_sec, sname, sinstance, key, key_s)
        !            54:     KTEXT tkt;                 /* The ticket to be decoded */
        !            55:     unsigned char *flags;       /* Kerberos ticket flags */
        !            56:     char *pname;               /* Authentication name */
        !            57:     char *pinstance;           /* Principal's instance */
        !            58:     char *prealm;              /* Principal's authentication domain */
        !            59:     unsigned long *paddress;    /* Net address of entity
        !            60:                                  * requesting ticket */
        !            61:     C_Block session;           /* Session key inserted in ticket */
        !            62:     int *life;                         /* Lifetime of the ticket */
        !            63:     unsigned long *time_sec;    /* Issue time and date */
        !            64:     char *sname;               /* Service name */
        !            65:     char *sinstance;           /* Service instance */
        !            66:     C_Block key;               /* Service's secret key
        !            67:                                  * (to decrypt the ticket) */
        !            68:     Key_schedule key_s;                /* The precomputed key schedule */
        !            69: {
        !            70:     static int tkt_swap_bytes;
        !            71:     unsigned char *uptr;
        !            72:     char *ptr = (char *)tkt->dat;
        !            73: 
        !            74: #ifndef NOENCRYPTION
        !            75:     /* Do the decryption */
        !            76:     pcbc_encrypt((C_Block *)tkt->dat,(C_Block *)tkt->dat,
        !            77:                  (long) tkt->length,key_s,key,0);
        !            78: #endif /* ! NOENCRYPTION */
        !            79: 
        !            80:     *flags = *ptr;              /* get flags byte */
        !            81:     ptr += sizeof(*flags);
        !            82:     tkt_swap_bytes = 0;
        !            83:     if (HOST_BYTE_ORDER != ((*flags >> K_FLAG_ORDER)& 1))
        !            84:         tkt_swap_bytes++;
        !            85: 
        !            86:     if (strlen(ptr) > ANAME_SZ)
        !            87:         return(KFAILURE);
        !            88:     (void) strcpy(pname,ptr);   /* pname */
        !            89:     ptr += strlen(pname) + 1;
        !            90: 
        !            91:     if (strlen(ptr) > INST_SZ)
        !            92:         return(KFAILURE);
        !            93:     (void) strcpy(pinstance,ptr); /* instance */
        !            94:     ptr += strlen(pinstance) + 1;
        !            95: 
        !            96:     if (strlen(ptr) > REALM_SZ)
        !            97:         return(KFAILURE);
        !            98:     (void) strcpy(prealm,ptr);  /* realm */
        !            99:     ptr += strlen(prealm) + 1;
        !           100:     /* temporary hack until realms are dealt with properly */
        !           101:     if (*prealm == 0)
        !           102:         (void) strcpy(prealm,KRB_REALM);
        !           103: 
        !           104:     bcopy(ptr,(char *)paddress,4); /* net address */
        !           105:     ptr += 4;
        !           106: 
        !           107:     bcopy(ptr,(char *)session,8); /* session key */
        !           108:     ptr+= 8;
        !           109: #ifdef notdef /* DONT SWAP SESSION KEY spm 10/22/86 */
        !           110:     if (tkt_swap_bytes)
        !           111:         swap_C_Block(session);
        !           112: #endif
        !           113: 
        !           114:     /* get lifetime, being certain we don't get negative lifetimes */
        !           115:     uptr = (unsigned char *) ptr++;
        !           116:     *life = (int) *uptr;
        !           117: 
        !           118:     bcopy(ptr,(char *) time_sec,4); /* issue time */
        !           119:     ptr += 4;
        !           120:     if (tkt_swap_bytes)
        !           121:         swap_u_long(*time_sec);
        !           122: 
        !           123:     (void) strcpy(sname,ptr);   /* service name */
        !           124:     ptr += 1 + strlen(sname);
        !           125: 
        !           126:     (void) strcpy(sinstance,ptr); /* instance */
        !           127:     ptr += 1 + strlen(sinstance);
        !           128:     return(KSUCCESS);
        !           129: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.