rijndael-icm.c

srtp 1.0.1 比较适用于头一次看。其他版本的有需要也可以传上来。

/*
 * rijndael-icm.c
 *
 * Integer Counter Mode
 *
 * David A. McGrew
 * Cisco Systems, Inc.
 */

/*
 *	
 * Copyright  (c) 2001, 2002, Cisco Systems, Inc.
 * All rights reserved.
 * 
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 
 *   Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * 
 *   Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following
 *   disclaimer in the documentation and/or other materials provided
 *   with the distribution.
 * 
 *   Neither the name of the Cisco Systems, Inc. nor the names of its
 *   contributors may be used to endorse or promote products derived
 *   from this software without specific prior written permission.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
 * OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */


#define ALIGN_32 0

#include "rijndael-icm.h"

#define PRINT_REF_DATA    0  /* print out data for test vectors */
#define PRINT_DEBUG_DATA  0  /* print out data for debugging    */

#if PRINT_DEBUG_DATA
#include <stdio.h>
#endif


/*
 * integer counter mode works as follows:
 *
 * 16 bits
 * <----->
 * +------+------+------+------+------+------+------+------+ 
 * |           nonce           |    pakcet index    |  ctr |---+
 * +------+------+------+------+------+------+------+------+   |
 *                                                             |
 * +------+------+------+------+------+------+------+------+   v
 * |                      salt                      |000000|->(+)
 * +------+------+------+------+------+------+------+------+   |
 *                                                             |
 *                                                        +---------+
 *							  | encrypt |
 *							  +---------+
 *							       | 
 * +------+------+------+------+------+------+------+------+   |
 * |                    keystream block                    |<--+ 
 * +------+------+------+------+------+------+------+------+   
 *
 * All fields are big-endian
 *
 * ctr is the block counter, which increments from zero for
 * each packet (16 bits wide)
 * 
 * packet index is distinct for each packet (48 bits wide)
 *
 * nonce can be distinct across many uses of the same key, or
 * can be a fixed value per key, or can be per-packet randomness
 * (64 bits)
 *
 */

err_status_t
rijndael_icm_alloc(cipher_t **c, int key_len) {
  extern cipher_type_t rijndael_icm;
  void *pointer;
  int tmp;

  if (key_len != 16)
    return err_status_bad_param;
  
  /* allocate memory a cipher of type rijndael_icm */
  tmp = (sizeof(rijndael_icm_context) + sizeof(cipher_t));
  pointer = malloc(tmp);
  if (pointer == NULL) {
#if PRINT_DEBUG_DATA
    fprintf(stderr, "failed to allocate %d bytes\n", tmp);
#endif
    return err_status_alloc_fail;
  }
#if PRINT_DEBUG_DATA
  fprintf(stderr, "allocated %d bytes at %p\n", tmp, pointer);
#endif

  /* set pointers */
  *c = pointer;
  (*c)->type = &rijndael_icm;
  (*c)->state = pointer + sizeof(cipher_t);

  /* increment ref_count */
  rijndael_icm.ref_count++;

  /* set key size */
  (*c)->key_len = key_len;

  return err_status_ok;  
}

err_status_t
rijndael_icm_dealloc(cipher_t *c) {
  extern cipher_type_t rijndael_icm;

  /* free memory */
#if PRINT_DEBUG_DATA
  fprintf(stderr, "freeing %p\n", c);
#endif 
  free(c);

  /* decrement ref_count */
  rijndael_icm.ref_count--;
  
  return err_status_ok;  
}


/*
 * rijndael_icm_context_init(...) initializes the rijndael_sicm_context
 *  using the value in key[] and salt[].
 *
 * the key is the secret key 
 *
 * the salt is unpredictable (but not necessarily secret) data which
 * randomizes the starting point in the keystream
 */

err_status_t
rijndael_icm_context_init(rijndael_icm_context *c,
			  const unsigned char key[16],
			  const unsigned char salt[16]) {
  v128_t tmp_key;
  
  /* set counter and initial values to salt */
  v128_copy_octet_string(&c->counter, salt);
  v128_copy_octet_string(&c->offset, salt);
  
  /* set tmp_key (for alignment) */
  v128_copy_octet_string(&tmp_key, key);
  /* expand key */
  rijndael_expand_key(tmp_key, c->expanded_key);

  /* indicate that the keystream_buffer is empty */
  c->bytes_in_buffer = 0;

  return err_status_ok;
}

/*
 * rijndael_icm_set_segment(...) sets the segment index of
 * the counter of the context which it is passed, and resets the
 * block index to the start of the segment
 */

err_status_t
rijndael_icm_set_segment(rijndael_icm_context *c,
			 xtd_seq_num_t index) {

  /*
   * see counter mode diagram above for alignment 
   */
  c->counter.v32[0] = c->offset.v32[0];
  c->counter.v32[1] = c->offset.v32[1];  /* includes ssrc!   */
  c->counter.v32[2] = ntohl(index.roc) ^ c->offset.v32[2]; 
  c->counter.v32[3] = (((uint32_t) ntohs(index.seq)) << 16) ^ c->offset.v32[3];
  c->counter.v32[3] &= ntohl(0xffff0000); /* force low salt bits to zero */
  
#if PRINT_REF_DATA
  printf("set_segment: %s\n", v128_hex_string(c->counter)); 
#endif  

  /* indicate that the keystream_buffer is empty */
  c->bytes_in_buffer = 0;

  return err_status_ok;
}

/*
 * rijndael_icm_advance(...) refills the keystream_buffer and
 * advances the block index of the sicm_context forward by one
 *
 * this is an internal, hopefully inlined function
 */
  
inline void
rijndael_icm_advance(rijndael_icm_context *c) {

  /* fill buffer with new keystream */
  v128_copy(&c->keystream_buffer, &c->counter);
  rijndael_encrypt(&c->keystream_buffer, c->expanded_key);
  c->bytes_in_buffer = 16;

#if PRINT_REF_DATA
    printf("counter:    %s\n", v128_hex_string(c->counter));
    printf("ciphertext: %s\n", v128_hex_string(c->keystream_buffer));    
#endif /* PRINT_REF_DATA */
  
  /* clock counter forward */
  if (!++(c->counter.octet[15])) 
    ++(c->counter.octet[14]);
  
}

/*
 * icm_encrypt deals with the following cases:
 *
 * bytes_to_encr < bytes_in_buffer
 *  - add keystream into data
 *
 * bytes_to_encr > bytes_in_buffer
 *  - add keystream into data until keystream_buffer is depleted
 *  - loop over blocks, filling keystream_buffer and then
 *    adding keystream into data
 *  - fill buffer then add in remaining (< 16) bytes of keystream 
 */

err_status_t
rijndael_icm_encrypt(rijndael_icm_context *c,
		     unsigned char *buf, int bytes_to_encr) {
  int i;
#if ALIGN_32
  uint32_t *b;
#endif

  /* check that there's enough segment left */
  if ((bytes_to_encr + htons(c->counter.v16[7])) > 0xffff)
    return err_status_terminus;

#if PRINT_REF_DATA
  printf("block index: %d\n", htons(c->counter.v16[7]));
#endif
  
  if (bytes_to_encr <= c->bytes_in_buffer) {
    
    /* deal with odd case of small bytes_to_encr */
    for (i = (16 - c->bytes_in_buffer);
	 i < (16 - c->bytes_in_buffer + bytes_to_encr); i++) 
      *buf++ ^= c->keystream_buffer.octet[i];

    c->bytes_in_buffer -= bytes_to_encr;

    /* return now to avoid the main loop */
    return err_status_ok;

  } else {
    
    /* encrypt bytes until the remaining data is 16-byte aligned */    
    for (i=(16 - c->bytes_in_buffer); i < 16; i++) 
      *buf++ ^= c->keystream_buffer.octet[i];

    bytes_to_encr -= c->bytes_in_buffer;
    c->bytes_in_buffer = 0;

  }
  
  /* now loop over entire 16-byte blocks of keystream */
  for (i=0; i < (bytes_to_encr/16); i++) {

    /* fill buffer with new keystream */
    rijndael_icm_advance(c);

    /*
     * add keystream into the data buffer (this would be a lot faster
     * if we could assume 32-bit alignment!)
     */

#if ALIGN_32
    b = (uint32_t *)buf;
    *b++ ^= c->keystream_buffer.v32[0];
    *b++ ^= c->keystream_buffer.v32[1];
    *b++ ^= c->keystream_buffer.v32[2];
    *b++ ^= c->keystream_buffer.v32[3];
    buf = (octet_t *)b;
#else    
    *buf++ ^= c->keystream_buffer.octet[0];
    *buf++ ^= c->keystream_buffer.octet[1];
    *buf++ ^= c->keystream_buffer.octet[2];
    *buf++ ^= c->keystream_buffer.octet[3];
    *buf++ ^= c->keystream_buffer.octet[4];
    *buf++ ^= c->keystream_buffer.octet[5];
    *buf++ ^= c->keystream_buffer.octet[6];
    *buf++ ^= c->keystream_buffer.octet[7];
    *buf++ ^= c->keystream_buffer.octet[8];
    *buf++ ^= c->keystream_buffer.octet[9];
    *buf++ ^= c->keystream_buffer.octet[10];
    *buf++ ^= c->keystream_buffer.octet[11];
    *buf++ ^= c->keystream_buffer.octet[12];
    *buf++ ^= c->keystream_buffer.octet[13];
    *buf++ ^= c->keystream_buffer.octet[14];
    *buf++ ^= c->keystream_buffer.octet[15];
#endif /* #if ALIGN_32 */

  }
  
  /* if there is a tail end of the data, process it */
  if ((bytes_to_encr & 0xf) != 0) {
    
    /* fill buffer with new keystream */
    rijndael_icm_advance(c);
    
    for (i=0; i < (bytes_to_encr & 0xf); i++)
      *buf++ ^= c->keystream_buffer.octet[i];
    
    /* reset the keystream buffer size to right value */
    c->bytes_in_buffer = 16 - i;  
  } else {

    /* no tail, so just reset the keystream buffer size to zero */
    c->bytes_in_buffer = 0;

  }

  return err_status_ok;
}

char 
rijndael_icm_description[] = "rijndael integer counter mode";

octet_t rijndael_icm_test_case_0_key[16] = {
  0x2b, 0x7e, 0x15, 0x16, 0x28, 0xae, 0xd2, 0xa6,
  0xab, 0xf7, 0x15, 0x88, 0x09, 0xcf, 0x4f, 0x3c
};

octet_t rijndael_icm_test_case_0_salt[16] = {
  0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
  0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0x00, 0x00
};

octet_t rijndael_icm_test_case_0_plaintext[32] =  {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
};

octet_t rijndael_icm_test_case_0_ciphertext[32] = {
  0xe0, 0x3e, 0xad, 0x09, 0x35, 0xc9, 0x5e, 0x80,
  0xe1, 0x66, 0xb1, 0x6d, 0xd9, 0x2b, 0x4e, 0xb4,
  0xd2, 0x35, 0x13, 0x16, 0x2b, 0x02, 0xd0, 0xf7,
  0x2a, 0x43, 0xa2, 0xfe, 0x4a, 0x5f, 0x97, 0xab
};

cipher_test_case_t rijndael_icm_test_case_0 = {
  16,                                         /* octets in key            */
  rijndael_icm_test_case_0_key,               /* key                      */
  16,                                         /* octets in salt           */
  rijndael_icm_test_case_0_salt,              /* salt                     */
  { 0, 0 },                                   /* packet index             */
  32,                                         /* octets in plaintext      */
  rijndael_icm_test_case_0_plaintext,         /* plaintext                */
  rijndael_icm_test_case_0_ciphertext,        /* ciphertext               */
  NULL                                        /* pointer to next testcase */
};


cipher_type_t rijndael_icm = {
  (cipher_alloc_func_t)       rijndael_icm_alloc,
  (cipher_dealloc_func_t)     rijndael_icm_dealloc,  
  (cipher_init_func_t)        rijndael_icm_context_init,
  (cipher_set_segment_func_t) rijndael_icm_set_segment,
  (cipher_encrypt_func_t)     rijndael_icm_encrypt,
  (char *)                    rijndael_icm_description,
  (int)                       0,
  (cipher_test_case_t *)     &rijndael_icm_test_case_0
};