sw_ecrypt-sync.h File Reference

#include "sw_ecrypt-portable.h"

Data Structures
struct	ECRYPT_ctx

Macros
#define	ECRYPT_NAME   "ChaCha8"
#define	ECRYPT_PROFILE   "_____"
#define	ECRYPT_MAXKEYSIZE   256 /* [edit] */
#define	ECRYPT_KEYSIZE(i)   (128 + (i)*128) /* [edit] */
#define	ECRYPT_MAXIVSIZE   64 /* [edit] */
#define	ECRYPT_IVSIZE(i)   (64 + (i)*64) /* [edit] */
#define	ECRYPT_GENERATES_KEYSTREAM
#define	ECRYPT_USES_DEFAULT_ALL_IN_ONE   /* [edit] */
#define	ECRYPT_BLOCKLENGTH   64 /* [edit] */
#define	ECRYPT_USES_DEFAULT_BLOCK_MACROS   /* [edit] */
#define	ECRYPT_encrypt_blocks(ctx, plaintext, ciphertext, blocks)
#define	ECRYPT_decrypt_blocks(ctx, ciphertext, plaintext, blocks)
#define	ECRYPT_keystream_blocks(ctx, keystream, blocks)
#define	ECRYPT_MAXVARIANT   1 /* [edit] */
#define	ECRYPT_VARIANT   1

Functions
void	ECRYPT_init (void)
void	ECRYPT_keysetup (ECRYPT_ctx *ctx, const u8 *key, u32 keysize, u32 ivsize)
void	ECRYPT_ivsetup (ECRYPT_ctx *ctx, const u8 *iv)
void	ECRYPT_encrypt_bytes (ECRYPT_ctx *ctx, const u8 *plaintext, u8 *ciphertext, u32 msglen)
void	ECRYPT_decrypt_bytes (ECRYPT_ctx *ctx, const u8 *ciphertext, u8 *plaintext, u32 msglen)
void	ECRYPT_keystream_bytes (ECRYPT_ctx *ctx, u8 *keystream, u32 length)
void	ECRYPT_encrypt_packet (ECRYPT_ctx *ctx, const u8 *iv, const u8 *plaintext, u8 *ciphertext, u32 msglen)
void	ECRYPT_decrypt_packet (ECRYPT_ctx *ctx, const u8 *iv, const u8 *ciphertext, u8 *plaintext, u32 msglen)

Macro Definition Documentation

ECRYPT_BLOCKLENGTH

#define ECRYPT_BLOCKLENGTH   64 /* [edit] */

ECRYPT_decrypt_blocks

#define ECRYPT_decrypt_blocks	(		ctx,
			ciphertext,
			plaintext,
			blocks
	)

Value:

ECRYPT_decrypt_bytes(ctx, ciphertext, plaintext,                 \
    (blocks) * ECRYPT_BLOCKLENGTH)

ECRYPT_encrypt_blocks

#define ECRYPT_encrypt_blocks	(		ctx,
			plaintext,
			ciphertext,
			blocks
	)

Value:

ECRYPT_encrypt_bytes(ctx, plaintext, ciphertext,                 \
    (blocks) * ECRYPT_BLOCKLENGTH)

ECRYPT_GENERATES_KEYSTREAM

#define ECRYPT_GENERATES_KEYSTREAM

ECRYPT_IVSIZE

#define ECRYPT_IVSIZE

(

i

)

(64 + (i)*64) /* [edit] */

ECRYPT_KEYSIZE

#define ECRYPT_KEYSIZE

(

i

)

(128 + (i)*128) /* [edit] */

ECRYPT_keystream_blocks

#define ECRYPT_keystream_blocks	(		ctx,
			keystream,
			blocks
	)

Value:

ECRYPT_keystream_bytes(ctx, keystream,                        \
    (blocks) * ECRYPT_BLOCKLENGTH)

ECRYPT_MAXIVSIZE

#define ECRYPT_MAXIVSIZE   64 /* [edit] */

ECRYPT_MAXKEYSIZE

#define ECRYPT_MAXKEYSIZE   256 /* [edit] */

ECRYPT_MAXVARIANT

#define ECRYPT_MAXVARIANT   1 /* [edit] */

ECRYPT_NAME

#define ECRYPT_NAME   "ChaCha8"

ECRYPT_PROFILE

#define ECRYPT_PROFILE   "_____"

ECRYPT_USES_DEFAULT_ALL_IN_ONE

#define ECRYPT_USES_DEFAULT_ALL_IN_ONE   /* [edit] */

ECRYPT_USES_DEFAULT_BLOCK_MACROS

#define ECRYPT_USES_DEFAULT_BLOCK_MACROS   /* [edit] */

ECRYPT_VARIANT

#define ECRYPT_VARIANT   1

Function Documentation

ECRYPT_decrypt_bytes()

void ECRYPT_decrypt_bytes	(	ECRYPT_ctx *	ctx,
		const u8 *	ciphertext,
		u8 *	plaintext,
		u32	msglen
	)

{
  ECRYPT_encrypt_bytes(x,c,m,bytes);
}

Here is the call graph for this function:

ECRYPT_decrypt_packet()

void ECRYPT_decrypt_packet	(	ECRYPT_ctx *	ctx,
		const u8 *	iv,
		const u8 *	ciphertext,
		u8 *	plaintext,
		u32	msglen
	)

ECRYPT_encrypt_bytes()

void ECRYPT_encrypt_bytes	(	ECRYPT_ctx *	ctx,
		const u8 *	plaintext,
		u8 *	ciphertext,
		u32	msglen
	)

Referenced by ECRYPT_decrypt_bytes(), and ECRYPT_keystream_bytes().

{
  u8 output[64];
  int i;

  if (!bytes) return;
  for (;;) {
    salsa20_wordtobyte(output,x->input);
    x->input[12] = PLUSONE(x->input[12]);
    if (!x->input[12]) {
      x->input[13] = PLUSONE(x->input[13]);
      /* stopping at 2^70 bytes per nonce is user's responsibility */
    }
    if (bytes <= 64) {
      for (i = 0;i < bytes;++i) c[i] = m[i] ^ output[i];
      return;
    }
    for (i = 0;i < 64;++i) c[i] = m[i] ^ output[i];
    bytes -= 64;
    c += 64;
    m += 64;
  }
}

Here is the call graph for this function:

ECRYPT_encrypt_packet()

void ECRYPT_encrypt_packet	(	ECRYPT_ctx *	ctx,
		const u8 *	iv,
		const u8 *	plaintext,
		u8 *	ciphertext,
		u32	msglen
	)

ECRYPT_init()

void ECRYPT_init

(

void

)

{
  return;
}

ECRYPT_ivsetup()

void ECRYPT_ivsetup	(	ECRYPT_ctx *	ctx,
		const u8 *	iv
	)

{
  x->input[12] = 0;
  x->input[13] = 0;
  x->input[14] = U8TO32_LITTLE(iv + 0);
  x->input[15] = U8TO32_LITTLE(iv + 4);
}

ECRYPT_keysetup()

void ECRYPT_keysetup	(	ECRYPT_ctx *	ctx,
		const u8 *	key,
		u32	keysize,
		u32	ivsize
	)

{
  const char *constants;

  x->input[4] = U8TO32_LITTLE(k + 0);
  x->input[5] = U8TO32_LITTLE(k + 4);
  x->input[6] = U8TO32_LITTLE(k + 8);
  x->input[7] = U8TO32_LITTLE(k + 12);
  if (kbits == 256) { /* recommended */
    k += 16;
    constants = sigma;
  } else { /* kbits == 128 */
    constants = tau;
  }
  x->input[8] = U8TO32_LITTLE(k + 0);
  x->input[9] = U8TO32_LITTLE(k + 4);
  x->input[10] = U8TO32_LITTLE(k + 8);
  x->input[11] = U8TO32_LITTLE(k + 12);
  x->input[0] = U8TO32_LITTLE(constants + 0);
  x->input[1] = U8TO32_LITTLE(constants + 4);
  x->input[2] = U8TO32_LITTLE(constants + 8);
  x->input[3] = U8TO32_LITTLE(constants + 12);
}

ECRYPT_keystream_bytes()

void ECRYPT_keystream_bytes	(	ECRYPT_ctx *	ctx,
		u8 *	keystream,
		u32	length
	)

{
  u32 i;
  for (i = 0;i < bytes;++i) stream[i] = 0;
  ECRYPT_encrypt_bytes(x,stream,stream,bytes);
}

Here is the call graph for this function: