Return to rijndael-api-fst.h CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / ipsec-tools / src / racoon / missing / crypto / rijndael

Annotation of embedaddon/ipsec-tools/src/racoon/missing/crypto/rijndael/rijndael-api-fst.h, revision 1.1.1.1

1.1       misho       1: /*     $NetBSD: rijndael-api-fst.h,v 1.4 2006/09/09 16:22:36 manu Exp $        */
                      2: 
                      3: /*     $KAME: rijndael-api-fst.h,v 1.1.1.1 2001/08/08 09:56:27 sakane Exp $    */
                      4: 
                      5: /*
                      6:  * rijndael-api-fst.h   v2.3   April '2000
                      7:  *
                      8:  * Optimised ANSI C code
                      9:  *
                     10:  * #define INTERMEDIATE_VALUE_KAT to generate the Intermediate Value Known Answer Test.
                     11:  */
                     12: 
                     13: #ifndef __RIJNDAEL_API_FST_H
                     14: #define __RIJNDAEL_API_FST_H
                     15: 
                     16: #include <crypto/rijndael/rijndael-alg-fst.h>
                     17: 
                     18: /*  Defines:
                     19:        Add any additional defines you need
                     20: */
                     21: 
                     22: #define     DIR_ENCRYPT           0 /*  Are we encrpyting?  */
                     23: #define     DIR_DECRYPT           1 /*  Are we decrpyting?  */
                     24: #define     MODE_ECB              1 /*  Are we ciphering in ECB mode?   */
                     25: #define     MODE_CBC              2 /*  Are we ciphering in CBC mode?   */
                     26: #define     MODE_CFB1             3 /*  Are we ciphering in 1-bit CFB mode? */
                     27: #define     TRUE                  1
                     28: #define     FALSE                 0
                     29: #define     BITSPERBLOCK        128 /* Default number of bits in a cipher block */
                     30: 
                     31: /*  Error Codes - CHANGE POSSIBLE: inclusion of additional error codes  */
                     32: #define     BAD_KEY_DIR          -1 /*  Key direction is invalid, e.g., unknown value */
                     33: #define     BAD_KEY_MAT          -2 /*  Key material not of correct length */
                     34: #define     BAD_KEY_INSTANCE     -3 /*  Key passed is not valid */
                     35: #define     BAD_CIPHER_MODE      -4 /*  Params struct passed to cipherInit invalid */
                     36: #define     BAD_CIPHER_STATE     -5 /*  Cipher in wrong state (e.g., not initialized) */
                     37: #define     BAD_BLOCK_LENGTH     -6
                     38: #define     BAD_CIPHER_INSTANCE  -7
                     39: #define     BAD_DATA             -8 /*  Data contents are invalid, e.g., invalid padding */
                     40: #define     BAD_OTHER            -9 /*  Unknown error */
                     41: 
                     42: /*  CHANGE POSSIBLE:  inclusion of algorithm specific defines  */
                     43: #define     MAX_KEY_SIZE         64 /* # of ASCII char's needed to represent a key */
                     44: #define     MAX_IV_SIZE          16 /* # bytes needed to represent an IV  */
                     45: 
                     46: /*  Typedefs:
                     47: 
                     48:        Typedef'ed data storage elements.  Add any algorithm specific 
                     49: parameters at the bottom of the structs as appropriate.
                     50: */
                     51: 
                     52: /*  The structure for key information */
                     53: typedef struct {
                     54:     u_int8_t  direction;            /* Key used for encrypting or decrypting? */
                     55:     int   keyLen;                   /* Length of the key  */
                     56:     char  keyMaterial[MAX_KEY_SIZE+1];  /* Raw key data in ASCII, e.g., user input or KAT values */
                     57:         /*  The following parameters are algorithm dependent, replace or add as necessary  */
                     58:        int   ROUNDS;                   /* key-length-dependent number of rounds */
                     59:     int   blockLen;                 /* block length */
                     60:     union {
                     61:        u_int8_t xkS8[RIJNDAEL_MAXROUNDS+1][4][4];      /* key schedule         */
                     62:        u_int32_t xkS32[RIJNDAEL_MAXROUNDS+1][4];       /* key schedule         */
                     63:     } xKeySched;
                     64: #define        keySched        xKeySched.xkS8
                     65: } keyInstance;
                     66: 
                     67: /*  The structure for cipher information */
                     68: typedef struct {                    /* changed order of the components */
                     69:     u_int8_t mode;                  /* MODE_ECB, MODE_CBC, or MODE_CFB1 */
                     70:     u_int8_t IV[MAX_IV_SIZE];       /* A possible Initialization Vector for ciphering */
                     71:         /*  Add any algorithm specific parameters needed here  */
                     72:     int   blockLen;                 /* Sample: Handles non-128 bit block sizes (if available) */
                     73: } cipherInstance;
                     74: 
                     75: /*  Function prototypes  */
                     76: /*  CHANGED: nothing
                     77:        TODO: implement the following extensions to setup 192-bit and 256-bit block lengths:
                     78:         makeKeyEx():    parameter blockLen added
                     79:                         -- this parameter is absolutely necessary if you want to
                     80:                         setup the round keys in a variable block length setting 
                     81:            cipherInitEx(): parameter blockLen added (for obvious reasons)              
                     82:  */
                     83: 
                     84: int rijndael_makeKey(keyInstance *key, u_int8_t direction, int keyLen, char *keyMaterial);
                     85: 
                     86: int rijndael_cipherInit(cipherInstance *cipher, u_int8_t mode, char *IV);
                     87: 
                     88: int rijndael_blockEncrypt(cipherInstance *cipher, keyInstance *key,
                     89:         u_int8_t *input, int inputLen, u_int8_t *outBuffer);
                     90: 
                     91: int rijndael_padEncrypt(cipherInstance *cipher, keyInstance *key,
                     92:                u_int8_t *input, int inputOctets, u_int8_t *outBuffer);
                     93: 
                     94: int rijndael_blockDecrypt(cipherInstance *cipher, keyInstance *key,
                     95:         u_int8_t *input, int inputLen, u_int8_t *outBuffer);
                     96: 
                     97: int rijndael_padDecrypt(cipherInstance *cipher, keyInstance *key,
                     98:                u_int8_t *input, int inputOctets, u_int8_t *outBuffer);
                     99: 
                    100: #ifdef INTERMEDIATE_VALUE_KAT
                    101: int rijndael_cipherUpdateRounds(cipherInstance *cipher, keyInstance *key,
                    102:         u_int8_t *input, int inputLen, u_int8_t *outBuffer, int Rounds);
                    103: #endif /* INTERMEDIATE_VALUE_KAT */
                    104: 
                    105: #endif /*  __RIJNDAEL_API_FST_H */