Changeset 14356


Ignore:
Timestamp:
Dec 4, 2014, 12:37:08 PM (8 years ago)
Author:
mikedld
Message:

#4400, #5462: Move RC4 helpers to crypto-utils

On a way to factoring out OpenSSL support to a standalone file to ease
addition of other crypto libraries support in the future, move helpers
providing RC4 ciphering to crypto-utils.{c,h}. OpenSSL-related
functionality (RC4 context management) is moved to crypto-utils-openssl.c.

Add new tr_rc4_ctx_t type and functions to be implemented by crypto
backends:

  • tr_rc4_new - allocate RC4 context,
  • tr_rc4_free - free the context,
  • tr_rc4_set_key - set cipher key,
  • tr_rc4_process - cipher memory block.
Location:
trunk/libtransmission
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/libtransmission/crypto-utils-openssl.c

    r14355 r14356  
    1717#include "crypto-utils.h"
    1818#include "log.h"
     19#include "utils.h"
    1920
    2021/***
     
    132133***/
    133134
     135tr_rc4_ctx_t
     136tr_rc4_new (void)
     137{
     138  EVP_CIPHER_CTX * handle = EVP_CIPHER_CTX_new ();
     139
     140  if (check_result (EVP_CipherInit_ex (handle, EVP_rc4 (), NULL, NULL, NULL, -1)))
     141    return handle;
     142
     143  EVP_CIPHER_CTX_free (handle);
     144  return NULL;
     145}
     146
     147void
     148tr_rc4_free (tr_rc4_ctx_t handle)
     149{
     150  if (handle == NULL)
     151    return;
     152
     153  EVP_CIPHER_CTX_free (handle);
     154}
     155
     156void
     157tr_rc4_set_key (tr_rc4_ctx_t    handle,
     158                const uint8_t * key,
     159                size_t          key_length)
     160{
     161  assert (handle != NULL);
     162  assert (key != NULL);
     163
     164  if (!check_result (EVP_CIPHER_CTX_set_key_length (handle, key_length)))
     165    return;
     166  check_result (EVP_CipherInit_ex (handle, NULL, NULL, key, NULL, -1));
     167}
     168
     169void
     170tr_rc4_process (tr_rc4_ctx_t   handle,
     171                const void   * input,
     172                void         * output,
     173                size_t         length)
     174{
     175  int output_length;
     176
     177  assert (handle != NULL);
     178  assert (input != NULL);
     179  assert (output != NULL);
     180
     181  check_result (EVP_CipherUpdate (handle, output, &output_length, input, length));
     182}
     183
     184/***
     185****
     186***/
     187
    134188bool
    135189tr_rand_buffer (void   * buffer,
  • trunk/libtransmission/crypto-utils.h

    r14355 r14356  
    2323 /** @brief Opaque SHA1 context type. */
    2424typedef void * tr_sha1_ctx_t;
     25 /** @brief Opaque RC4 context type. */
     26typedef void * tr_rc4_ctx_t;
    2527
    2628/**
     
    4951bool             tr_sha1_final         (tr_sha1_ctx_t    handle,
    5052                                        uint8_t        * hash);
     53
     54/**
     55 * @brief Allocate and initialize new RC4 cipher context.
     56 */
     57tr_rc4_ctx_t     tr_rc4_new            (void);
     58
     59/**
     60 * @brief Free RC4 cipher context.
     61 */
     62void             tr_rc4_free           (tr_rc4_ctx_t     handle);
     63
     64/**
     65 * @brief Set RC4 cipher key.
     66 */
     67void             tr_rc4_set_key        (tr_rc4_ctx_t     handle,
     68                                        const uint8_t  * key,
     69                                        size_t           key_length);
     70
     71/**
     72 * @brief Process memory block with RC4 cipher.
     73 */
     74void             tr_rc4_process        (tr_rc4_ctx_t     handle,
     75                                        const void     * input,
     76                                        void           * output,
     77                                        size_t           length);
     78
    5179/**
    5280 * @brief Returns a random number in the range of [0...upper_bound).
  • trunk/libtransmission/crypto.c

    r14355 r14356  
    1010#include <assert.h>
    1111#include <stdarg.h>
    12 #include <string.h> /* memcpy (), memset (), strcmp () */
     12#include <string.h> /* memcpy (), memmove (), memset (), strcmp () */
    1313
    1414#include <openssl/bn.h>
    1515#include <openssl/dh.h>
    1616#include <openssl/err.h>
    17 #include <openssl/rc4.h>
    1817
    1918#include "transmission.h"
     
    119118  if (crypto->dh != NULL)
    120119    DH_free (crypto->dh);
     120  tr_rc4_free (crypto->enc_key);
     121  tr_rc4_free (crypto->dec_key);
    121122}
    122123
     
    172173
    173174static void
    174 initRC4 (tr_crypto  * crypto,
    175          RC4_KEY    * setme,
    176          const char * key)
     175initRC4 (tr_crypto    * crypto,
     176         tr_rc4_ctx_t * setme,
     177         const char   * key)
    177178{
    178179  uint8_t buf[SHA_DIGEST_LENGTH];
     
    180181  assert (crypto->torrentHashIsSet);
    181182  assert (crypto->mySecretIsSet);
     183
     184  if (*setme == NULL)
     185    *setme = tr_rc4_new ();
    182186
    183187  if (tr_sha1 (buf,
     
    186190               crypto->torrentHash, SHA_DIGEST_LENGTH,
    187191               NULL))
    188     RC4_set_key (setme, SHA_DIGEST_LENGTH, buf);
     192    tr_rc4_set_key (*setme, buf, SHA_DIGEST_LENGTH);
    189193}
    190194
     
    196200
    197201  initRC4 (crypto, &crypto->dec_key, txt);
    198   RC4 (&crypto->dec_key, sizeof (discard), discard, discard);
     202  tr_rc4_process (crypto->dec_key, discard, discard, sizeof (discard));
    199203}
    200204
     
    205209                  void       * buf_out)
    206210{
    207   RC4 (&crypto->dec_key, buf_len,
    208        (const unsigned char*)buf_in,
    209        (unsigned char*)buf_out);
     211  /* FIXME: someone calls this function with uninitialized key */
     212  if (crypto->dec_key == NULL)
     213    {
     214      if (buf_in != buf_out)
     215        memmove (buf_out, buf_in, buf_len);
     216      return;
     217    }
     218
     219  tr_rc4_process (crypto->dec_key, buf_in, buf_out, buf_len);
    210220}
    211221
     
    217227
    218228  initRC4 (crypto, &crypto->enc_key, txt);
    219   RC4 (&crypto->enc_key, sizeof (discard), discard, discard);
     229  tr_rc4_process (crypto->enc_key, discard, discard, sizeof (discard));
    220230}
    221231
     
    226236                  void       * buf_out)
    227237{
    228   RC4 (&crypto->enc_key, buf_len,
    229        (const unsigned char*)buf_in,
    230        (unsigned char*)buf_out);
     238  /* FIXME: someone calls this function with uninitialized key */
     239  if (crypto->enc_key == NULL)
     240    {
     241      if (buf_in != buf_out)
     242        memmove (buf_out, buf_in, buf_len);
     243      return;
     244    }
     245
     246  tr_rc4_process (crypto->enc_key, buf_in, buf_out, buf_len);
    231247}
    232248
  • trunk/libtransmission/crypto.h

    r14355 r14356  
    1717#include <inttypes.h>
    1818
     19#include "crypto-utils.h"
    1920#include "utils.h" /* TR_GNUC_NULL_TERMINATED */
    2021
     
    2425**/
    2526
    26 #include <openssl/dh.h> /* RC4_KEY */
    27 #include <openssl/rc4.h> /* DH */
     27#include <openssl/dh.h> /* DH */
    2828
    2929enum
     
    3535typedef struct
    3636{
    37     RC4_KEY         dec_key;
    38     RC4_KEY         enc_key;
     37    tr_rc4_ctx_t    dec_key;
     38    tr_rc4_ctx_t    enc_key;
    3939    DH *            dh;
    4040    uint8_t         myPublicKey[KEY_LEN];
Note: See TracChangeset for help on using the changeset viewer.