Return to cksum.c CVS log

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

Annotation of 43BSDReno/kerberosIV/des/cksum.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * $Source: /afs/athena.mit.edu/astaff/project/kerberos/src/lib/des/RCS/cksum.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:  * These routines perform encryption and decryption using the DES
        !            12:  * private key algorithm, or else a subset of it-- fewer inner loops.
        !            13:  * (AUTH_DES_ITER defaults to 16, may be less.)
        !            14:  *
        !            15:  * Under U.S. law, this software may not be exported outside the US
        !            16:  * without license from the U.S. Commerce department.
        !            17:  * 
        !            18:  * These routines form the library interface to the DES facilities.
        !            19:  *
        !            20:  *     spm     8/85    MIT project athena
        !            21:  */
        !            22: 
        !            23: #ifndef        lint
        !            24: static char rcsid_cksum_c[] =
        !            25: "$Id: cksum.c,v 4.10 90/01/02 13:46:25 jtkohl Exp $";
        !            26: #endif lint
        !            27: 
        !            28: #include <mit-copyright.h>
        !            29: #include <stdio.h>
        !            30: #include <strings.h>
        !            31: 
        !            32: #include <des.h>
        !            33: #include "des_internal.h"
        !            34: 
        !            35: extern int des_debug;
        !            36: extern int des_debug_print();
        !            37: 
        !            38: /*
        !            39:  * This routine performs DES cipher-block-chaining checksum operation,
        !            40:  * a.k.a.  Message Authentication Code.  It ALWAYS encrypts from input
        !            41:  * to a single 64 bit output MAC checksum.
        !            42:  *
        !            43:  * The key schedule is passed as an arg, as well as the cleartext or
        !            44:  * ciphertext. The cleartext and ciphertext should be in host order.
        !            45:  *
        !            46:  * NOTE-- the output is ALWAYS 8 bytes long.  If not enough space was
        !            47:  * provided, your program will get trashed.
        !            48:  *
        !            49:  * The input is null padded, at the end (highest addr), to an integral
        !            50:  * multiple of eight bytes.
        !            51:  */
        !            52: 
        !            53: unsigned long
        !            54: des_cbc_cksum(in,out,length,key,iv)
        !            55:     des_cblock *in;            /* >= length bytes of inputtext */
        !            56:     des_cblock *out;           /* >= length bytes of outputtext */
        !            57:     register long length;      /* in bytes */
        !            58:     des_key_schedule key;              /* precomputed key schedule */
        !            59:     des_cblock *iv;            /* 8 bytes of ivec */
        !            60: {
        !            61:     register unsigned long *input = (unsigned long *) in;
        !            62:     register unsigned long *output = (unsigned long *) out;
        !            63:     unsigned long *ivec = (unsigned long *) iv;
        !            64: 
        !            65:     unsigned long i,j;
        !            66:     static unsigned long t_input[2];
        !            67:     static unsigned long t_output[8];
        !            68:     static unsigned char *t_in_p;
        !            69: 
        !            70:     t_in_p = (unsigned char *) t_input;
        !            71: #ifdef MUSTALIGN
        !            72:     if ((long) ivec & 3) {
        !            73:        bcopy((char *)ivec++,(char *)&t_output[0],sizeof(t_output[0]));
        !            74:        bcopy((char *)ivec,(char *)&t_output[1],sizeof(t_output[1]));
        !            75:     }
        !            76:     else
        !            77: #endif
        !            78:     {
        !            79:        t_output[0] = *ivec++;
        !            80:        t_output[1] = *ivec;
        !            81:     }
        !            82: 
        !            83:     for (i = 0; length > 0; i++, length -= 8) {
        !            84:        /* get input */
        !            85: #ifdef MUSTALIGN
        !            86:        if ((long) input & 3) {
        !            87:            bcopy((char *)input++,(char *)&t_input[0],sizeof(t_input[0]));
        !            88:            bcopy((char *)input++,(char *)&t_input[1],sizeof(t_input[1]));
        !            89:        }
        !            90:        else
        !            91: #endif
        !            92:        {
        !            93:            t_input[0] = *input++;
        !            94:            t_input[1] = *input++;
        !            95:        }
        !            96: 
        !            97:        /* zero pad */
        !            98:        if (length < 8)
        !            99:            for (j = length; j <= 7; j++)
        !           100:                *(t_in_p+j)= 0;
        !           101: 
        !           102: #ifdef DEBUG
        !           103:        if (des_debug)
        !           104:            des_debug_print("clear",length,t_input[0],t_input[1]);
        !           105: #endif
        !           106:        /* do the xor for cbc into the temp */
        !           107:        t_input[0] ^= t_output[0] ;
        !           108:        t_input[1] ^= t_output[1] ;
        !           109:        /* encrypt */
        !           110:        (void) des_ecb_encrypt(t_input,t_output,key,1);
        !           111: #ifdef DEBUG
        !           112:        if (des_debug) {
        !           113:            des_debug_print("xor'ed",i,t_input[0],t_input[1]);
        !           114:            des_debug_print("cipher",i,t_output[0],t_output[1]);
        !           115:        }
        !           116: #else
        !           117: #ifdef lint
        !           118:        i = i;
        !           119: #endif
        !           120: #endif
        !           121:     }
        !           122:     /* copy temp output and save it for checksum */
        !           123: #ifdef MUSTALIGN
        !           124:     if ((long) output & 3) {
        !           125:        bcopy((char *)&t_output[0],(char *)output++,sizeof(t_output[0]));
        !           126:        bcopy((char *)&t_output[1],(char *)output,sizeof(t_output[1]));
        !           127:     }
        !           128:     else
        !           129: #endif
        !           130:     {
        !           131:        *output++ = t_output[0];
        !           132:        *output = t_output[1];
        !           133:     }
        !           134: 
        !           135:     return (unsigned long) t_output[1];
        !           136: }

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