X-Git-Url: http://git.tuebingen.mpg.de/?a=blobdiff_plain;f=crypt.c;h=8e1814dd3d82e5fd1d50301402faea6b0d9a9934;hb=54cf5827;hp=206b93486914aaf7896b0f6109bdd7aa57c235c9;hpb=037059c8a25ce134af1eaa6c3fa8ac96b9f7e0b6;p=paraslash.git diff --git a/crypt.c b/crypt.c index 206b9348..8e1814dd 100644 --- a/crypt.c +++ b/crypt.c @@ -7,13 +7,13 @@ /** \file crypt.c Openssl-based encryption/decryption routines. */ #include -#include #include #include #include #include #include #include +#include #include "para.h" #include "error.h" @@ -219,7 +219,6 @@ int pub_encrypt(struct asymmetric_key *pub, unsigned char *inbuf, return ret < 0? -E_ENCRYPT : ret; } -#define RC4_ALIGN 8 struct stream_cipher { RC4_KEY key; }; @@ -232,7 +231,7 @@ struct stream_cipher { * * \return A new stream cipher structure. */ -struct stream_cipher *stream_cipher_new(const unsigned char *data, int len) +struct stream_cipher *sc_new(const unsigned char *data, int len) { struct stream_cipher *sc = para_malloc(sizeof(*sc)); RC4_set_key(&sc->key, len, data); @@ -242,17 +241,24 @@ struct stream_cipher *stream_cipher_new(const unsigned char *data, int len) /** * Deallocate a stream cipher structure. * - * \param sc A stream cipher previously obtained by stream_cipher_new(). + * \param sc A stream cipher previously obtained by sc_new(). */ -void stream_cipher_free(struct stream_cipher *sc) +void sc_free(struct stream_cipher *sc) { free(sc); } +/** + * The RC4() implementation of openssl apparently reads and writes data in + * blocks of 8 bytes. So we have to make sure our buffer sizes are a multiple + * of this. + */ +#define RC4_ALIGN 8 + /** * Encrypt and send a buffer. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param buf The buffer to send. * \param len The size of \a buf in bytes. * @@ -260,7 +266,8 @@ void stream_cipher_free(struct stream_cipher *sc) * * \sa \ref write_all(), RC4(3). */ -int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len) +int sc_send_bin_buffer(struct stream_cipher_context *scc, const char *buf, + size_t len) { int ret; unsigned char *tmp; @@ -269,12 +276,12 @@ int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len) assert(len); tmp = para_malloc(l2); - RC4(&rc4c->send->key, l1, (const unsigned char *)buf, tmp); + RC4(&scc->send->key, l1, (const unsigned char *)buf, tmp); if (len > l1) { memcpy(remainder, buf + l1, len - l1); - RC4(&rc4c->send->key, len - l1, remainder, tmp + l1); + RC4(&scc->send->key, len - l1, remainder, tmp + l1); } - ret = write_all(rc4c->fd, (char *)tmp, &len); + ret = write_all(scc->fd, (char *)tmp, &len); free(tmp); return ret; } @@ -282,31 +289,32 @@ int rc4_send_bin_buffer(struct rc4_context *rc4c, const char *buf, size_t len) /** * Encrypt and send a \p NULL-terminated buffer. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param buf The buffer to send. * - * \return The return value of the underyling call to rc4_send_bin_buffer(). + * \return The return value of the underyling call to sc_send_bin_buffer(). */ -int rc4_send_buffer(struct rc4_context *rc4c, const char *buf) +int sc_send_buffer(struct stream_cipher_context *scc, const char *buf) { - return rc4_send_bin_buffer(rc4c, buf, strlen(buf)); + return sc_send_bin_buffer(scc, buf, strlen(buf)); } /** * Format, encrypt and send a buffer. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param fmt A format string. * - * \return The return value of the underyling call to rc4_send_buffer(). + * \return The return value of the underyling call to sc_send_buffer(). */ -__printf_2_3 int rc4_send_va_buffer(struct rc4_context *rc4c, const char *fmt, ...) +__printf_2_3 int sc_send_va_buffer(struct stream_cipher_context *scc, + const char *fmt, ...) { char *msg; int ret; PARA_VSPRINTF(fmt, msg); - ret = rc4_send_buffer(rc4c, msg); + ret = sc_send_buffer(scc, msg); free(msg); return ret; } @@ -314,7 +322,7 @@ __printf_2_3 int rc4_send_va_buffer(struct rc4_context *rc4c, const char *fmt, . /** * Receive a buffer and decrypt it. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param buf The buffer to write the decrypted data to. * \param size The size of \a buf. * @@ -323,13 +331,14 @@ __printf_2_3 int rc4_send_va_buffer(struct rc4_context *rc4c, const char *fmt, . * * \sa recv(2), RC4(3). */ -int rc4_recv_bin_buffer(struct rc4_context *rc4c, char *buf, size_t size) +int sc_recv_bin_buffer(struct stream_cipher_context *scc, char *buf, + size_t size) { unsigned char *tmp = para_malloc(size); - ssize_t ret = recv(rc4c->fd, tmp, size, 0); + ssize_t ret = recv(scc->fd, tmp, size, 0); if (ret > 0) - RC4(&rc4c->recv->key, ret, tmp, (unsigned char *)buf); + RC4(&scc->recv->key, ret, tmp, (unsigned char *)buf); else if (ret < 0) ret = -ERRNO_TO_PARA_ERROR(errno); free(tmp); @@ -339,26 +348,44 @@ int rc4_recv_bin_buffer(struct rc4_context *rc4c, char *buf, size_t size) /** * Receive a buffer, decrypt it and write terminating NULL byte. * - * \param rc4c The rc4 crypt context. + * \param scc The context. * \param buf The buffer to write the decrypted data to. * \param size The size of \a buf. * - * Read at most \a size - 1 bytes from file descriptor given by \a rc4c, - * decrypt the received data and write a NULL byte at the end of the decrypted - * data. + * Read at most \a size - 1 bytes from file descriptor given by \a scc, decrypt + * the received data and write a NULL byte at the end of the decrypted data. * * \return The return value of the underlying call to \ref - * rc4_recv_bin_buffer(). + * sc_recv_bin_buffer(). */ -int rc4_recv_buffer(struct rc4_context *rc4c, char *buf, size_t size) +int sc_recv_buffer(struct stream_cipher_context *scc, char *buf, size_t size) { int n; assert(size); - n = rc4_recv_bin_buffer(rc4c, buf, size - 1); + n = sc_recv_bin_buffer(scc, buf, size - 1); if (n >= 0) buf[n] = '\0'; else *buf = '\0'; return n; } + +/** + * Compute the hash of the given input data. + * + * \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. + * + * \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) +{ + SHA_CTX c; + SHA1_Init(&c); + SHA1_Update(&c, data, len); + SHA1_Final(hash, &c); +}