pike.git/ src/ post_modules/ Nettle/ nettle.cmod > 807294294849e4589526619e98bcc150adc9ac66 [Annotate]

/* nettle.cmod -*- c -*- */ 

/* $Id$ */ 

#include "global.h" 

#include "interpret.h" 

#include "svalue.h" 

/* For this_object() */ 

#include "object.h" 

#include "operators.h" 

#include "module_support.h" 

#include "threads.h" 

#include "nettle_config.h" 

#ifdef HAVE_LIBNETTLE 

#include "nettle.h" 

#include <nettle/yarrow.h> 

#include <nettle/knuth-lfib.h> 

#include <stdio.h> 

#include <stdarg.h> 

DECLARATIONS 

/*! @module Nettle 

 *! Low level crypto functions used by the @[Crypto] module. Unless 

 *! you are doing something very special, you would want to use the 

 *! Crypto module instead. 

 */ 

/*! @class Yarrow 

 *! 

 *! Yarrow is a family of pseudo-randomness generators, designed for 

 *! cryptographic use, by John Kelsey, Bruce Schneier and Niels Ferguson. 

 *! Yarrow-160 is described in a paper at 

 *! @url{http://www.counterpane.com/yarrow.html@}, and it uses SHA1 and 

 *! triple-DES, and has a 160-bit internal state. Nettle implements 

 *! Yarrow-256, which is similar, but uses SHA256 and AES to get an 

 *! internal state of 256 bits. 

 */ 

PIKECLASS Yarrow 

{ 

  CVAR struct yarrow256_ctx ctx; 

  CVAR struct yarrow_source *sources; 

#ifndef HAVE_STRUCT_YARROW256_CTX_SEED_FILE 

  /* NOTE: Nettle 2.0 does not have the automatic seed_file maintenance 

   *       that Nettle 1.x had. This stuff is needed since it affected 

   *       the state emitted by random_string(). When Nettle 2.0 is the 

   *       default, consider implementing this via overloading of the 

   *       various seeding functions instead, since it does have a bit 

   *       of overhead. 

   * 

   *    /grubba 2009-07-05 

   */ 

  PIKEVAR string seed_file flags ID_PRIVATE|ID_STATIC; 

#endif 

  DECLARE_STORAGE; 

#ifndef HAVE_STRUCT_YARROW256_CTX_SEED_FILE 

  static void pike_generate_seed_file(void) 

  { 

    struct pike_string *seed_file = 

      begin_shared_string(YARROW256_SEED_FILE_SIZE); 

    yarrow256_random(&THIS->ctx, YARROW256_SEED_FILE_SIZE, STR0(seed_file)); 

    if (THIS->seed_file) { 

      free_string(THIS->seed_file); 

    } 

    THIS->seed_file = end_shared_string(seed_file); 

  } 

#else 

#define pike_generate_seed_file() 

#endif 

  /*! @decl void create(void|int sources) 

   *! The number of entropy sources that will feed entropy to the 

   *! random number generator is given as an argument to Yarrow 

   *! during instantiation. 

   *! @seealso 

   *!   @[update] 

   */ 

  PIKEFUN void create(void|int arg) 

    flags ID_PROTECTED; 

  { 

    INT32 num = 0; 

    if(arg) { 

      if (arg->type != PIKE_T_INT) 

        Pike_error("Bad argument type.\n"); 

      num = arg->u.integer; 

      if(num < 0) 

        Pike_error("Invalid number of sources.\n"); 

      free (THIS->sources); 

      THIS->sources = xalloc(sizeof(struct yarrow_source)*num); 

    } 

    else 

    { 

      free (THIS->sources); 

      THIS->sources = NULL; 

    } 

    yarrow256_init(&THIS->ctx, num, THIS->sources); 

  } 

  /*! @decl Yarrow seed(string data) 

   *! The random generator needs to be seeded before 

   *! it can be used. The seed must be at least 32 

   *! characters long. The seed could be stored from 

   *! a previous run by inserting the value returned 

   *! from @[get_seed]. 

   *! @returns 

   *!   Returns the called object. 

   *! @seealso 

   *!   @[min_seed_size], @[get_seed], @[is_seeded] 

   */ 

  PIKEFUN object seed(string data) 

    optflags OPT_SIDE_EFFECT; 

  { 

    if(data->len < YARROW256_SEED_FILE_SIZE) 

      Pike_error("Seed must be at least %d characters.\n", 

                 YARROW256_SEED_FILE_SIZE); 

    NO_WIDE_STRING(data); 

    yarrow256_seed(&THIS->ctx, data->len, STR0(data)); 

    pike_generate_seed_file(); 

    RETURN this_object(); 

  } 

  /*! @decl int(0..) min_seed_size() 

   *! Returns the minimal number of characters that the @[seed] 

   *! needs to properly seed the random number generator. 

   *! @seealso 

   *!   @[seed] 

   */ 

  PIKEFUN int(0..) min_seed_size() 

    optflags OPT_TRY_OPTIMIZE; 

  { 

    RETURN YARROW256_SEED_FILE_SIZE; 

  } 

  /*! @decl string(0..255) get_seed() 

   *!   Returns part of the internal state so that it can 

   *!   be saved for later seeding. 

   *! 

   *! @seealso 

   *!   @[seed()], @[random_string()] 

   */ 

  PIKEFUN string get_seed() 

    optflags OPT_EXTERNAL_DEPEND; 

    rawtype tDeprecated(tFunc(tNone, tStr8)); 

  { 

    if( !yarrow256_is_seeded(&THIS->ctx) ) 

      Pike_error("Random generator not seeded.\n"); 

#ifdef HAVE_STRUCT_YARROW256_CTX_SEED_FILE 

    RETURN make_shared_binary_string(THIS->ctx.seed_file, 

                                     YARROW256_SEED_FILE_SIZE); 

#else 

    if (THIS->seed_file) { 

      REF_RETURN THIS->seed_file; 

    } else { 

      struct pike_string *s = begin_shared_string(YARROW256_SEED_FILE_SIZE); 

      RETURN end_shared_string(s); 

    } 

#endif /* HAVE_STRUCT_YARROW256_CTX_SEED_FILE */ 

  } 

  /*! @decl int(0..1) is_seeded() 

   *! Returns 1 if the random generator is seeded and ready 

   *! to generator output. 0 otherwise. 

   *! @seealso 

   *!   @[seed] 

   */ 

  PIKEFUN int(0..1) is_seeded() 

    optflags OPT_EXTERNAL_DEPEND; 

  { 

    RETURN yarrow256_is_seeded(&THIS->ctx); 

  } 

  /*! @decl void force_reseed() 

   *! By calling this function entropy is moved from the slow 

   *! pool to the fast pool. Read more about Yarrow before using 

   *! this. 

   */ 

  PIKEFUN void force_reseed() 

    optflags OPT_SIDE_EFFECT; 

  { 

#ifdef HAVE_NETTLE_YARROW256_SLOW_RESEED 

    /* From change notes for Nettle 2.0: 

     * 

     * * Changes to the yarrow256 interface. The function 

     *   yarrow256_force_reseed has been replaced by the two 

     *   functions yarrow256_fast_reseed and yarrow256_slow_reseed, 

     *   which were previously static. 

     */ 

    yarrow256_slow_reseed(&THIS->ctx); 

#else 

    yarrow256_force_reseed(&THIS->ctx); 

#endif 

    pike_generate_seed_file(); 

  } 

  /*! @decl int(0..1) update(string data, int source, int entropy) 

   *! Inject additional entropy into the random number generator. 

   *! 

   *! @seealso 

   *!   @[create] 

   */ 

  PIKEFUN int(0..1) update(string data, int source, int entropy) 

    optflags OPT_SIDE_EFFECT; 

  { 

    int ret; 

    /* FIXME: Wide strings could actually be supported here */ 

    NO_WIDE_STRING(data); 

    if( !THIS->sources ) 

      Pike_error("This random generator has no sources.\n"); 

    if( source<0 || (unsigned)source>=THIS->ctx.nsources ) 

      Pike_error("Invalid random source.\n"); 

    if( entropy<0 ) 

      Pike_error("Entropy must be positive.\n"); 

    if( entropy>(data->len*8) ) 

      Pike_error("Impossibly large entropy value.\n"); 

    ret = yarrow256_update(&THIS->ctx, source, entropy, data->len, 

                           (const uint8_t *)data->str); 

    if (ret) { 

      pike_generate_seed_file(); 

    } 

    RETURN ret; 

  } 

  /*! @decl int(0..) needed_sources() 

   *! The number of sources that must reach the threshold before a 

   *! slow reseed will happen. 

   */ 

  PIKEFUN int(0..) needed_sources() 

    optflags OPT_EXTERNAL_DEPEND; 

  { 

    RETURN yarrow256_needed_sources(&THIS->ctx); 

  } 

  /*! @decl string random_string(int length) 

   *! Returns a pseudo-random string of the requested @[length]. 

   */ 

  PIKEFUN string random_string(int length) 

    optflags OPT_EXTERNAL_DEPEND|OPT_SIDE_EFFECT; 

  { 

    struct pike_string *rnd; 

    if(length < 0) 

      Pike_error("Invalid length, must be positive.\n"); 

    if( !yarrow256_is_seeded(&THIS->ctx) ) 

      Pike_error("Random generator not seeded.\n"); 

    rnd = begin_shared_string(length); 

    yarrow256_random(&THIS->ctx, length, (uint8_t *)rnd->str); 

    RETURN end_shared_string(rnd); 

  } 

  INIT 

  { 

    THIS->sources = NULL; 

    yarrow256_init(&THIS->ctx, 0, NULL); 

  } 

  EXIT 

    gc_trivial; 

  { 

    if( THIS->sources ) 

    { 

      free(THIS->sources); 

    } 

  } 

} 

/*! @endclass 

 */ 

/*! @decl string crypt_md5(string password, string salt) 

 *! Does the crypt_md5 abrakadabra (MD5 + snakeoil). 

 *! It is assumed that @[salt] does not contain "$". 

 */ 

PIKEFUN string crypt_md5(string pw, string salt) 

     optflags OPT_TRY_OPTIMIZE; 

{ 

  char *hash; 

  NO_WIDE_STRING(pw); 

  NO_WIDE_STRING(salt); 

  THREADS_ALLOW(); 

  hash = pike_crypt_md5(pw->len, pw->str,salt->len, salt->str); 

  THREADS_DISALLOW(); 

  push_text(hash); 

} 

static const char *crypto_functions[] = { 

  "block_size", 

  "key_size", 

  "set_encrypt_key", 

  "set_decrypt_key", 

  "crypt", 

  0 

}; 

static const char *assert_is_crypto_object(struct program *p, 

                                    const char *const *required) { 

  while (*required) { 

    if (find_identifier( (char *) *required, p) < 0) 

      return *required; 

    required++; 

  } 

  return 0; 

} 

static struct object *make_cipher_object(INT32 args) { 

  ptrdiff_t fun; 

  const char *missing; 

  struct svalue *top = Pike_sp-args; 

  struct object *obj; 

  switch(top->type) 

  { 

    case T_PROGRAM: 

      obj = clone_object(top->u.program, args-1); 

      break; 

    case T_FUNCTION: 

      apply_svalue(Pike_sp - args, args-1); 

      /* Check return value */ 

      if(Pike_sp[-1].type != T_OBJECT) 

        Pike_error("Returned value is not an object.\n"); 

      add_ref(obj = Pike_sp[-1].u.object); 

      break; 

    case T_OBJECT: 

      fun = -1; 

      missing = assert_is_crypto_object(top->u.object->prog, 

                                        crypto_functions); 

      if(missing) 

        fun = FIND_LFUN(top->u.object->prog, LFUN_CALL); 

      if(fun!=-1) { 

        apply_low(top->u.object, fun, args-1); 

        stack_swap(); 

        pop_stack(); 

      } 

      else 

        if(args!=1) Pike_error("Too many arguments.\n"); 

      add_ref(obj = top->u.object); 

      break; 

    default: 

      SIMPLE_BAD_ARG_ERROR("create", 1, "program|object|function"); 

    } 

  pop_stack(); 

  missing = assert_is_crypto_object(obj->prog, crypto_functions); 

  if(missing) { 

    free_object(obj); 

    Pike_error("Object is missing identifier \"%s\"\n", missing); 

  } 

  return obj; 

} 

/*! @class CBC 

 *! @belongs Crypto 

 *! Implementation of the cipher block chaining mode (CBC). Works as 

 *! a wrapper for the cipher algorithm put in create. 

 */ 

PIKECLASS CBC 

{ 

  CVAR struct object *object; 

  CVAR unsigned INT8 *iv; 

  CVAR INT32 block_size; 

  CVAR INT32 mode; 

  INIT 

  { 

    THIS->object = NULL; 

    THIS->iv = NULL; 

    THIS->block_size = 0; 

    THIS->mode = 0; 

  } 

  EXIT 

    gc_trivial; 

  { 

    if(THIS->object) { 

      free_object(THIS->object); 

    } 

    if(THIS->iv) { 

      MEMSET(THIS->iv, 0, THIS->block_size); 

      free(THIS->iv); 

    } 

  } 

  INLINE static void cbc_encrypt_step(const unsigned INT8 *const source, 

                                      unsigned INT8 *dest) 

  { 

    INT32 block_size = THIS->block_size; 

    INT32 i; 

    for(i=0; i < block_size; i++) 

      THIS->iv[i] ^= source[i]; 

    push_string(make_shared_binary_string((INT8 *)THIS->iv, block_size)); 

    safe_apply(THIS->object, "crypt", 1); 

    if(Pike_sp[-1].type != T_STRING) 

      Pike_error("Expected string from crypt()\n"); 

    if(Pike_sp[-1].u.string->len != block_size) { 

      Pike_error("Bad string length %ld returned from crypt()\n", 

                 DO_NOT_WARN((long)Pike_sp[-1].u.string->len)); 

    } 

    MEMCPY(THIS->iv, Pike_sp[-1].u.string->str, block_size); 

    MEMCPY(dest, Pike_sp[-1].u.string->str, block_size); 

    pop_stack(); 

  } 

  INLINE static void cbc_decrypt_step(const unsigned INT8 *const source, 

                                      unsigned INT8 *dest) 

  { 

    INT32 block_size = THIS->block_size; 

    INT32 i; 

    push_string(make_shared_binary_string((const INT8 *)source, block_size)); 

    safe_apply(THIS->object, "crypt", 1); 

    if(Pike_sp[-1].type != T_STRING) 

      Pike_error("Expected string from crypt()\n"); 

    if(Pike_sp[-1].u.string->len != block_size) { 

      Pike_error("Bad string length %ld returned from crypt()\n", 

                 DO_NOT_WARN((long)Pike_sp[-1].u.string->len)); 

    } 

    for(i=0; i < block_size; i++) 

      dest[i] = THIS->iv[i] ^ Pike_sp[-1].u.string->str[i]; 

    pop_stack(); 

    MEMCPY(THIS->iv, source, block_size); 

  } 

  /*! @decl void create(program|object|function cipher, mixed ... args) 

   *! Initialize the CBC wrapper with a cipher algorithm. If it is a 

   *! program, an object will be instantiated with @[args] as arguments. 

   *! If it is an object that doesn't conform to the cipher API, but has 

   *! an @[LFUN::`()], that LFUN will be called. If it is a function, 

   *! that function will be called with @[args] as arguments. 

   */ 

  PIKEFUN void create(program|object|function cipher, mixed ... more) 

    flags ID_PROTECTED; 

  { 

    int old_block_size = THIS->block_size; 

    THIS->object = make_cipher_object(args); 

    safe_apply(THIS->object, "block_size", 0); 

    if(Pike_sp[-1].type != T_INT) 

      Pike_error("block_size() didn't return an int.\n"); 

    THIS->block_size = Pike_sp[-1].u.integer; 

    pop_stack(); 

    if ((!THIS->block_size) || 

        (THIS->block_size > 4096)) 

      Pike_error("Bad block size %d.\n", THIS->block_size); 

    if(THIS->iv) { 

      MEMSET(THIS->iv, 0, old_block_size); 

      free(THIS->iv); 

    } 

    THIS->iv = (unsigned INT8 *)xalloc(THIS->block_size); 

    MEMSET(THIS->iv, 0, THIS->block_size); 

  } 

  /*! @decl string name() 

   *! Returns the string @expr{"CBC(x)"@} where x is the 

   *! encapsulated algorithm. 

   */ 

  PIKEFUN string name() 

    optflags OPT_TRY_OPTIMIZE; 

  { 

    push_constant_text("CBC("); 

    safe_apply(THIS->object, "name", 0); 

    push_constant_text(")"); 

    f_add(3); 

  } 

  /*! @decl int block_size() 

   *! Reurns the block size of the encapsulated cipher. 

   */ 

  PIKEFUN int block_size() 

    optflags OPT_TRY_OPTIMIZE; 

  { 

    RETURN THIS->block_size; 

  } 

  /*! @decl int key_size() 

   *! Returns the key size of the encapsulated cipher. 

   */ 

  PIKEFUN int key_size() 

    optflags OPT_EXTERNAL_DEPEND; 

  { 

    safe_apply(THIS->object, "key_size", args); 

  } 

  /*! @decl this_program set_encrypt_key(string key) 

   *! Prepare the cipher and the wrapper for encrypting 

   *! with the given @[key]. 

   */ 

  PIKEFUN object set_encrypt_key(string key) 

    optflags OPT_SIDE_EFFECT; 

  { 

    assert(THIS->block_size); 

    THIS->mode = 0; 

    safe_apply(THIS->object, "set_encrypt_key", args); 

    pop_stack(); 

    RETURN this_object(); 

  } 

  /*! @decl this_program set_decrypt_key(string key) 

   *! Prepare the cipher and the wrapper for decrypting 

   *! with the given @[key]. 

   */ 

  PIKEFUN object set_decrypt_key(string key) 

    optflags OPT_SIDE_EFFECT; 

  { 

    assert(THIS->block_size); 

    THIS->mode = 1; 

    safe_apply(THIS->object, "set_decrypt_key", args); 

    pop_stack(); 

    RETURN this_object(); 

  } 

  /*! @decl this_program set_iv(string iv) 

   *! Set the initialization vector to @[iv]. 

   */ 

  PIKEFUN object set_iv(string iv) 

    optflags OPT_SIDE_EFFECT; 

  { 

    assert(THIS->iv); 

    NO_WIDE_STRING(iv); 

    if(iv->len != THIS->block_size) 

      Pike_error("Argument incompatible with cipher block size.\n"); 

    MEMCPY(THIS->iv, iv->str, THIS->block_size); 

    RETURN this_object(); 

  } 

  /*! @decl string crypt(string data) 

   *! Encrypt/decrypt @[data] and return the result. @[data] must 

   *! be an integral number of blocks. 

   */ 

  PIKEFUN string crypt(string data) { 

    unsigned INT8 *result; 

    INT32 offset = 0; 

    NO_WIDE_STRING(data); 

    if(data->len % THIS->block_size) 

      Pike_error("Data length not multiple of block size.\n"); 

    if(!(result = alloca(data->len))) 

      SIMPLE_OUT_OF_MEMORY_ERROR("crypt", data->len); 

    if(THIS->mode == 0) { 

      while (offset < data->len) { 

        cbc_encrypt_step((const unsigned INT8 *)data->str + offset, 

                         result + offset); 

        offset += THIS->block_size; 

      } 

    } 

    else { 

      while (offset < data->len) { 

        cbc_decrypt_step((const unsigned INT8 *)data->str + offset, 

                         result + offset); 

        offset += THIS->block_size; 

      } 

    } 

    pop_n_elems(args); 

    push_string(make_shared_binary_string((INT8 *)result, offset)); 

    MEMSET(result, 0, offset); 

  } 

} 

/*! @endclass 

 */ 

/*! @class Buffer 

 *! @belongs Crypto 

 *! Acts as a buffer so that data can be fed to a cipher in blocks 

 *! that don't correspond to cipher block sizes. 

 */ 

PIKECLASS Proxy { 

  CVAR struct object *object; 

  CVAR int block_size; 

  CVAR unsigned char *backlog; 

  CVAR int backlog_len; 

  INIT { 

    THIS->object = NULL; 

    THIS->block_size = 0; 

    THIS->backlog = NULL; 

    THIS->backlog_len = 0; 

  } 

  EXIT 

    gc_trivial; 

  { 

    if(THIS->backlog) { 

      MEMSET(THIS->backlog, 0, THIS->block_size); 

      free(THIS->backlog); 

      THIS->backlog = NULL; 

    } 

    if(THIS->object) { 

      free_object(THIS->object); 

      THIS->object = NULL; 

    } 

  } 

  /*! @decl void create(program|object|function cipher, mixed ... args) 

   *! Initialize the Proxy wrapper with a cipher algorithm. If it is a 

   *! program, an object will be instantiated with @[args] as arguments. 

   *! If it is an object that doesn't conform to the cipher API, but has 

   *! an @[LFUN::`()], that LFUN will be called. If it is a function, 

   *! that function will be called with @[args] as arguments. 

   */ 

  PIKEFUN void create(program|object|function cipher, mixed ... more) 

    flags ID_PROTECTED; 

  { 

    exit_Proxy_struct(); 

    THIS->object = make_cipher_object(args); 

    safe_apply(THIS->object, "block_size", 0); 

    if (Pike_sp[-1].type != T_INT) 

      Pike_error("block_size() didn't return an int\n"); 

    THIS->block_size = Pike_sp[-1].u.integer; 

    pop_stack(); 

    if ((!THIS->block_size) || 

        (THIS->block_size > 4096)) 

      Pike_error("Bad block size %ld\n", DO_NOT_WARN((long)THIS->block_size)); 

    THIS->backlog = (unsigned char *)xalloc(THIS->block_size); 

    THIS->backlog_len = 0; 

    MEMSET(THIS->backlog, 0, THIS->block_size); 

  } 

  /*! @decl string name() 

   *! Returns the string @expr{"Proxy(x)"@} where x is the 

   *! encapsulated algorithm. 

   */ 

  PIKEFUN string name() 

    optflags OPT_TRY_OPTIMIZE; 

  { 

    push_constant_text("Proxy("); 

    safe_apply(THIS->object, "name", 0);