crypto.h

Go to the documentation of this file.

#ifndef _GPXE_CRYPTO_H
#define _GPXE_CRYPTO_H

/** @file
 *
 * Cryptographic API
 *
 */

FILE_LICENCE ( GPL2_OR_LATER );

#include <stdint.h>
#include <stddef.h>

/** A message digest algorithm */
struct digest_algorithm {
        /** Algorithm name */
        const char *name;
        /** Context size */
        size_t ctxsize;
        /** Block size */
        size_t blocksize;
        /** Digest size */
        size_t digestsize;
        /** Initialise digest
         *
         * @v ctx               Context
         */
        void ( * init ) ( void *ctx );
        /** Update digest with new data
         *
         * @v ctx               Context
         * @v src               Data to digest
         * @v len               Length of data
         *
         * @v len is not necessarily a multiple of @c blocksize.
         */
        void ( * update ) ( void *ctx, const void *src, size_t len );
        /** Finalise digest
         *
         * @v ctx               Context
         * @v out               Buffer for digest output
         */
        void ( * final ) ( void *ctx, void *out );
};

/** A cipher algorithm */
struct cipher_algorithm {
        /** Algorithm name */
        const char *name;
        /** Context size */
        size_t ctxsize;
        /** Block size */
        size_t blocksize;
        /** Set key
         *
         * @v ctx               Context
         * @v key               Key
         * @v keylen            Key length
         * @ret rc              Return status code
         */
        int ( * setkey ) ( void *ctx, const void *key, size_t keylen );
        /** Set initialisation vector
         *
         * @v ctx               Context
         * @v iv                Initialisation vector
         */
        void ( * setiv ) ( void *ctx, const void *iv );
        /** Encrypt data
         *
         * @v ctx               Context
         * @v src               Data to encrypt
         * @v dst               Buffer for encrypted data
         * @v len               Length of data
         *
         * @v len is guaranteed to be a multiple of @c blocksize.
         */
        void ( * encrypt ) ( void *ctx, const void *src, void *dst,
                             size_t len );
        /** Decrypt data
         *
         * @v ctx               Context
         * @v src               Data to decrypt
         * @v dst               Buffer for decrypted data
         * @v len               Length of data
         *
         * @v len is guaranteed to be a multiple of @c blocksize.
         */
        void ( * decrypt ) ( void *ctx, const void *src, void *dst,
                             size_t len );
};

/** A public key algorithm */
struct pubkey_algorithm {
        /** Algorithm name */
        const char *name;
        /** Context size */
        size_t ctxsize;
};

static inline void digest_init ( struct digest_algorithm *digest,
                                 void *ctx ) {
        digest->init ( ctx );
}

static inline void digest_update ( struct digest_algorithm *digest,
                                   void *ctx, const void *data, size_t len ) {
        digest->update ( ctx, data, len );
}

static inline void digest_final ( struct digest_algorithm *digest,
                                  void *ctx, void *out ) {
        digest->final ( ctx, out );
}

static inline int cipher_setkey ( struct cipher_algorithm *cipher,
                                  void *ctx, const void *key, size_t keylen ) {
        return cipher->setkey ( ctx, key, keylen );
}

static inline void cipher_setiv ( struct cipher_algorithm *cipher,
                                  void *ctx, const void *iv ) {
        cipher->setiv ( ctx, iv );
}

static inline void cipher_encrypt ( struct cipher_algorithm *cipher,
                                    void *ctx, const void *src, void *dst,
                                    size_t len ) {
        cipher->encrypt ( ctx, src, dst, len );
}
#define cipher_encrypt( cipher, ctx, src, dst, len ) do {               \
        assert ( ( (len) & ( (cipher)->blocksize - 1 ) ) == 0 );        \
        cipher_encrypt ( (cipher), (ctx), (src), (dst), (len) );        \
        } while ( 0 )

static inline void cipher_decrypt ( struct cipher_algorithm *cipher,
                                    void *ctx, const void *src, void *dst,
                                    size_t len ) {
        cipher->decrypt ( ctx, src, dst, len );
}
#define cipher_decrypt( cipher, ctx, src, dst, len ) do {               \
        assert ( ( (len) & ( (cipher)->blocksize - 1 ) ) == 0 );        \
        cipher_decrypt ( (cipher), (ctx), (src), (dst), (len) );        \
        } while ( 0 )

static inline int is_stream_cipher ( struct cipher_algorithm *cipher ) {
        return ( cipher->blocksize == 1 );
}

extern struct digest_algorithm digest_null;
extern struct cipher_algorithm cipher_null;
extern struct pubkey_algorithm pubkey_null;

void get_random_bytes ( void *buf, size_t len );

#endif /* _GPXE_CRYPTO_H */