Return to basslib.h CVS log

Up to [PGP] / pgp / src

Annotation of pgp/src/basslib.h, revision 1.1

1.1     ! root        1: /*     basslib.h - include file for BassOmatic encipherment functions.
        !             2: 
        !             3:        (c) Copyright 1988 by Philip Zimmermann.  All rights reserved.  
        !             4:        This software may not be copied without the written permission of 
        !             5:        Philip Zimmermann.  The author assumes no liability for damages
        !             6:        resulting from the use of this software, even if the damage results
        !             7:        from defects in this software.  No warranty is expressed or implied.
        !             8: */
        !             9: 
        !            10: /* Elaborate protection mechanisms to assure no redefinitions of types...*/
        !            11: #ifndef BOOLSTUFF
        !            12: #define BOOLSTUFF
        !            13: #ifndef TRUE
        !            14: #define FALSE 0
        !            15: #define TRUE (!FALSE)
        !            16: #endif /* if TRUE not already defined */
        !            17: typedef unsigned char boolean; /* values are TRUE or FALSE */
        !            18: #endif /* if BOOLSTUFF not already defined */
        !            19: #ifndef BYTESTUFF
        !            20: #define BYTESTUFF
        !            21: typedef unsigned char byte;    /* values are 0-255 */
        !            22: typedef byte *byteptr; /* pointer to byte */
        !            23: typedef char *string;  /* pointer to ASCII character string */
        !            24: #endif /* if BYTESTUFF not already defined */
        !            25: #ifndef WORDSTUFF
        !            26: #define WORDSTUFF
        !            27: typedef unsigned short word16; /* values are 0-65536 */
        !            28: typedef unsigned long word32;  /* values are 0-4294967296 */
        !            29: #endif /* if WORDSTUFF not already defined */
        !            30: #ifndef min    /* if min macro not already defined */
        !            31: #define min(a,b) ( (a)<(b) ? (a) : (b) )
        !            32: #define max(a,b) ( (a)>(b) ? (a) : (b) )
        !            33: #endif /* if min macro not already defined */
        !            34: 
        !            35: 
        !            36: #define MAXKEYLEN 254  /* max byte length of BassOmatic key */
        !            37: 
        !            38: #define NTABLES 8              /* number of random permutation vectors */
        !            39: 
        !            40: typedef struct {
        !            41:        boolean initialized;    /* determines whether key context is defined */
        !            42:        byteptr tlist[NTABLES]; /* list of permutation table pointers */
        !            43:        byte    bitmasks[NTABLES]; /* bitshredder bitmasks with 50% bits set */
        !            44:        byteptr iv; /* CFB Initialization Vector used by initcfb and basscfb */
        !            45:        boolean cfbuncryp;      /* TRUE means decrypting (in CFB mode) */
        !            46:        boolean uncryp;         /* TRUE means decrypting (in ECB mode) */
        !            47: /* The following parameters are computed from the key control byte...*/
        !            48:        char    nrounds;        /* specifies number of rounds thru BassOmatic */
        !            49:        boolean hardrand;       /* means regenerate tables with BassOmatic */
        !            50:        boolean shred8ways;     /* means use 8-way bit shredding */
        !            51:        boolean rerand;         /* means replenish tables with every block */
        !            52:        byteptr lfsr;           /* Linear Feedback Shift Register */
        !            53:        byte    rtail;          /* rtail is an index into LFSR buffer */
        !            54:        } KEYCONTEXT;
        !            55: 
        !            56: 
        !            57: /*
        !            58: **     initbassrand - initialize bassrand, BassOmatic random number generator.
        !            59: **             Must close via closebass().
        !            60: */
        !            61: void initbassrand(byteptr key, short keylen, byteptr seed, short seedlen);
        !            62: 
        !            63: 
        !            64: /*
        !            65: **     bassrand - BassOmatic pseudo-random number generator.
        !            66: */
        !            67: byte bassrand(void);
        !            68: 
        !            69: 
        !            70: /*
        !            71: **     bass_save - saves BassOmatic key context in context structure.
        !            72: */
        !            73: void bass_save(KEYCONTEXT *context);
        !            74: 
        !            75: 
        !            76: /*
        !            77: **     bass_restore - restore BassOmatic key context from context structure.
        !            78: */
        !            79: void bass_restore(KEYCONTEXT *context);
        !            80: 
        !            81: 
        !            82: /*
        !            83: **     closebass - end the current BassOmatic key context, freeing its buffers.
        !            84: */
        !            85: void closebass(void);
        !            86: 
        !            87: int initkey(byteptr key, short keylen, boolean decryp);
        !            88:        /* Sets up key schedule for BassOmatic. */
        !            89: 
        !            90: void bassomatic(byteptr in, byteptr out);
        !            91:        /* Encipher 1 block with the BassOmatic ECB mode. */
        !            92: 
        !            93: /*
        !            94: **     initcfb - Initializes the BassOmatic key schedule tables via key,
        !            95: **     and initializes the Cipher Feedback mode IV.
        !            96: */
        !            97: int initcfb(byteptr iv0, byteptr key, short keylen, boolean decryp);
        !            98: 
        !            99: 
        !           100: /*
        !           101: **     basscfb - encipher 1 block with BassOmatic enciphering algorithm,
        !           102: **             using Cipher Feedback (CFB) mode.
        !           103: **
        !           104: **     Assumes initcfb has already been called.  References global iv byteptr.
        !           105: */
        !           106: void basscfb(byteptr buf, int count);
        !           107: 
        !           108: 
        !           109: /*
        !           110: **     fillbuf(dst,count,c) - fill byte buffer dst with byte c
        !           111: */
        !           112: void fillbuf(register byteptr dst, register short count, register byte c);
        !           113: 
        !           114: 
        !           115: /*
        !           116: **     crc() - compute CRC-16 of buffer
        !           117: */
        !           118: word16 crc(register byteptr buf, int count);
        !           119: 
        !           120: 

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