X-Git-Url: http://git.tuebingen.mpg.de/?p=paraslash.git;a=blobdiff_plain;f=crypt.h;h=9be7a23e6da4d6d1796d4d98da7d8280152c6c2a;hp=21abe41f68cd8c5b335cc133b5c6f3050869c4ee;hb=eacc2982fbf7e0c0b69508b57f85e839d1ba1013;hpb=32e646780461f96682d1191d31e08e4602ab125e diff --git a/crypt.h b/crypt.h index 21abe41f..9be7a23e 100644 --- a/crypt.h +++ b/crypt.h @@ -1,33 +1,108 @@ /* - * Copyright (C) 2005-2011 Andre Noll + * Copyright (C) 2005 Andre Noll * * Licensed under the GPL v2. For licencing details see COPYING. */ -/** \file crypt.h Prototypes for paraslash crypto functions. */ +/** \file crypt.h Public crypto interface. */ + + +/* These are used to distinguish between loading of private/public key. */ + +/** The key to load is a public key. */ +#define LOAD_PUBLIC_KEY 0 +/** The key to load is a private key. */ +#define LOAD_PRIVATE_KEY 1 +/** The size of the challenge sent to the client. */ +#define CHALLENGE_SIZE 64 /** Opaque structure for public and private keys. */ struct asymmetric_key; +/** + * Encrypt a buffer using asymmetric keys. + * + * \param pub: The public key. + * \param inbuf The input buffer. + * \param len The length of \a inbuf. + * \param outbuf The output buffer. + * + * \return The size of the encrypted data on success, negative on errors. + */ int pub_encrypt(struct asymmetric_key *pub, unsigned char *inbuf, unsigned len, unsigned char *outbuf); + +/** + * Decrypt a buffer using a private key. + * + * \param key_file Full path of the key. + * \param outbuf The output buffer. + * \param inbuf The encrypted input buffer. + * \param inlen The length of \a inbuf. + * + * The \a outbuf must be large enough to hold at least 512 bytes. + * + * \return The size of the recovered plaintext on success, negative on errors. + */ int priv_decrypt(const char *key_file, unsigned char *outbuf, unsigned char *inbuf, int inlen); + +/** + * Read an asymmetric key from a file. + * + * \param key_file The file containing the key. + * \param private if non-zero, read the private key, otherwise the public key. + * \param result The key structure is returned here. + * + * \return The size of the key on success, negative on errors. + */ int get_asymmetric_key(const char *key_file, int private, struct asymmetric_key **result); + +/** + * Deallocate an asymmetric key structure. + * + * \param key Pointer to the key structure to free. + * + * This must be called for any key obtained by get_asymmetric_key(). + */ void free_asymmetric_key(struct asymmetric_key *key); + +/** + * Fill a buffer with random content. + * + * \param buf The buffer to fill. + * \param num The size of \a buf in bytes. + * + * This function puts \a num cryptographically strong pseudo-random bytes into + * buf. If it can not guarantee an unpredictable byte sequence (for example + * because the PRNG has not been seeded with enough randomness) the function + * logs an error message and calls exit(). + */ void get_random_bytes_or_die(unsigned char *buf, int num); + +/** + * Seed pseudo random number generators. + * + * This function seeds the PRNG used by random() with a random seed obtained + * from the crypto implementation. On errors, an error message is logged and + * the function calls exit(). + * + * \sa \ref get_random_bytes_or_die(), srandom(3), random(3), \ref + * para_random(). + */ void init_random_seed_or_die(void); -/** Opaque structure for stream cipher crypto. */ + +/** Opaque structure for stream ciphers. */ struct stream_cipher; -/** Number of bytes of the session key. */ +/** Number of bytes of the session key for stream ciphers. */ #define SESSION_KEY_LEN 32 /** - * Used on the server-side for client-server communication encryption. + * Used for client-server communication encryption. * * The traffic between (the forked child of) para_server and the remote client * process is crypted by a symmetric session key. This structure contains the @@ -43,50 +118,70 @@ struct stream_cipher_context { struct stream_cipher *send; }; -struct stream_cipher *sc_new(const unsigned char *data, int len); -void sc_free(struct stream_cipher *sc); +/** + * Allocate and initialize a stream cipher structure. + * + * \param data The key. + * \param len The size of the key. + * \param use_aes True: Use the aes_ctr128 stream cipher, false: Use RC4. + * + * \return A new stream cipher structure. + */ +struct stream_cipher *sc_new(const unsigned char *data, int len, + bool use_aes); -int sc_send_bin_buffer(struct stream_cipher_context *scc, const char *buf, - size_t len); -int sc_send_buffer(struct stream_cipher_context *scc, const char *buf); -__printf_2_3 int sc_send_va_buffer(struct stream_cipher_context *scc, - const char *fmt, ...); -int sc_recv_bin_buffer(struct stream_cipher_context *scc, char *buf, - size_t size); -int sc_recv_buffer(struct stream_cipher_context *scc, char *buf, size_t size); +/** + * Encrypt or decrypt a buffer using a stream cipher. + * + * \param sc Crypto key. + * \param src The source buffer and length. + * \param dst The destination buffer and length, filled out by the function. + * + * It is up to the implementation to decide whether the crypt operation is + * performed in place. The caller can tell by looking if the buffers given by + * \a src and \a dst coincide after the call. If (and only if) the crypt + * operation was not performed in place, the function allocated a new buffer + * for the result, so dst->iov_base is different from src->iov_base. In this + * case, the destination buffer must be freed by the caller when it is no + * longer needed. + */ +void sc_crypt(struct stream_cipher *sc, struct iovec *src, struct iovec *dst); -/** \cond used to distinguish between loading of private/public key */ -#define LOAD_PUBLIC_KEY 0 -#define LOAD_PRIVATE_KEY 1 -#define CHALLENGE_SIZE 64 -/** \endcond **/ +/** + * Wrapper for \ref sc_crypt() that can be used as a sideband transformation. + * + * \param src Passed verbatim to \ref sc_crypt(). + * \param dst Passed verbatim to \ref sc_crypt(). + * \param trafo_context Must point to an initialized stream cipher. + */ +_static_inline_ void sc_trafo(struct iovec *src, struct iovec *dst, + void *trafo_context) +{ + sc_crypt(trafo_context, src, dst); +} + +/** + * Deallocate a stream cipher structure. + * + * \param sc A stream cipher previously obtained by sc_new(). + */ +void sc_free(struct stream_cipher *sc); /** Size of the hash value in bytes. */ #define HASH_SIZE 20 -void hash_function(const char *data, unsigned long len, unsigned char *hash); - /** - * Compare two hashes. + * Compute the hash of the given input data. * - * \param h1 Pointer to the first hash value. - * \param h2 Pointer to the second hash value. + * \param data Pointer to the data to compute the hash value from. + * \param len The length of \a data in bytes. + * \param hash Result pointer. * - * \return 1, -1, or zero, depending on whether \a h1 is greater than, - * less than or equal to h2, respectively. - */ -_static_inline_ int hash_compare(unsigned char *h1, unsigned char *h2) -{ - int i; - - for (i = 0; i < HASH_SIZE; i++) { - if (h1[i] < h2[i]) - return -1; - if (h1[i] > h2[i]) - return 1; - } - return 0; -} + * \a hash must point to an area at least \p HASH_SIZE bytes large. + * + * \sa sha(3), openssl(1). + * */ +void hash_function(const char *data, unsigned long len, unsigned char *hash); /** * Convert a hash value to ascii format. @@ -98,14 +193,15 @@ _static_inline_ int hash_compare(unsigned char *h1, unsigned char *h2) * will be filled by the function with the ascii representation of the hash * value given by \a hash, and a terminating \p NULL byte. */ -_static_inline_ void hash_to_asc(unsigned char *hash, char *asc) -{ - int i; - const char hexchar[] = "0123456789abcdef"; - - for (i = 0; i < HASH_SIZE; i++) { - asc[2 * i] = hexchar[hash[i] >> 4]; - asc[2 * i + 1] = hexchar[hash[i] & 0xf]; - } - asc[2 * HASH_SIZE] = '\0'; -} +void hash_to_asc(unsigned char *hash, char *asc); + +/** + * Compare two hashes. + * + * \param h1 Pointer to the first hash value. + * \param h2 Pointer to the second hash value. + * + * \return 1, -1, or zero, depending on whether \a h1 is greater than, + * less than or equal to h2, respectively. + */ +int hash_compare(unsigned char *h1, unsigned char *h2);