internal.c File Reference

#include "postgres.h"
#include <time.h>
#include "blf.h"
#include "md5.h"
#include "px.h"
#include "rijndael.h"
#include "sha1.h"

Include dependency graph for internal.c:

Go to the source code of this file.

Data Structures
struct	int_digest
struct	int_ctx
struct	int_cipher

Macros
#define	MD5_DIGEST_LENGTH   16
#define	SHA1_DIGEST_LENGTH   SHA1_RESULTLEN
#define	SHA1_BLOCK_SIZE   64
#define	MD5_BLOCK_SIZE   64
#define	INT_MAX_KEY   (512/8)
#define	INT_MAX_IV   (128/8)
#define	MODE_ECB   0
#define	MODE_CBC   1

Functions
static void	init_md5 (PX_MD *h)
static void	init_sha1 (PX_MD *h)
void	init_sha224 (PX_MD *h)
void	init_sha256 (PX_MD *h)
void	init_sha384 (PX_MD *h)
void	init_sha512 (PX_MD *h)
static unsigned	int_md5_len (PX_MD *h)
static unsigned	int_md5_block_len (PX_MD *h)
static void	int_md5_update (PX_MD *h, const uint8 *data, unsigned dlen)
static void	int_md5_reset (PX_MD *h)
static void	int_md5_finish (PX_MD *h, uint8 *dst)
static void	int_md5_free (PX_MD *h)
static unsigned	int_sha1_len (PX_MD *h)
static unsigned	int_sha1_block_len (PX_MD *h)
static void	int_sha1_update (PX_MD *h, const uint8 *data, unsigned dlen)
static void	int_sha1_reset (PX_MD *h)
static void	int_sha1_finish (PX_MD *h, uint8 *dst)
static void	int_sha1_free (PX_MD *h)
static void	intctx_free (PX_Cipher *c)
static unsigned	rj_block_size (PX_Cipher *c)
static unsigned	rj_key_size (PX_Cipher *c)
static unsigned	rj_iv_size (PX_Cipher *c)
static int	rj_init (PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
static int	rj_real_init (struct int_ctx *cx, int dir)
static int	rj_encrypt (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
static int	rj_decrypt (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
static PX_Cipher *	rj_load (int mode)
static unsigned	bf_block_size (PX_Cipher *c)
static unsigned	bf_key_size (PX_Cipher *c)
static unsigned	bf_iv_size (PX_Cipher *c)
static int	bf_init (PX_Cipher *c, const uint8 *key, unsigned klen, const uint8 *iv)
static int	bf_encrypt (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
static int	bf_decrypt (PX_Cipher *c, const uint8 *data, unsigned dlen, uint8 *res)
static PX_Cipher *	bf_load (int mode)
static PX_Cipher *	rj_128_ecb (void)
static PX_Cipher *	rj_128_cbc (void)
static PX_Cipher *	bf_ecb_load (void)
static PX_Cipher *	bf_cbc_load (void)
int	px_find_digest (const char *name, PX_MD **res)
int	px_find_cipher (const char *name, PX_Cipher **res)

Variables
static const struct int_digest	int_digest_list []
static const struct int_cipher	int_ciphers []
static const PX_Alias	int_aliases []

Macro Definition Documentation

INT_MAX_IV

#define INT_MAX_IV   (128/8)

Definition at line 225 of file internal.c.

INT_MAX_KEY

#define INT_MAX_KEY   (512/8)

Definition at line 224 of file internal.c.

MD5_BLOCK_SIZE

#define MD5_BLOCK_SIZE   64

Definition at line 55 of file internal.c.

Referenced by int_md5_block_len().

MD5_DIGEST_LENGTH

#define MD5_DIGEST_LENGTH   16

Definition at line 43 of file internal.c.

Referenced by int_md5_len().

MODE_CBC

#define MODE_CBC   1

Definition at line 259 of file internal.c.

Referenced by bf_cbc_load(), bf_decrypt(), bf_encrypt(), rj_128_cbc(), rj_decrypt(), and rj_encrypt().

MODE_ECB

#define MODE_ECB   0

Definition at line 258 of file internal.c.

Referenced by bf_decrypt(), bf_ecb_load(), bf_encrypt(), and rj_128_ecb().

SHA1_BLOCK_SIZE

#define SHA1_BLOCK_SIZE   64

Definition at line 54 of file internal.c.

Referenced by int_sha1_block_len().

SHA1_DIGEST_LENGTH

#define SHA1_DIGEST_LENGTH   SHA1_RESULTLEN

Definition at line 48 of file internal.c.

Referenced by int_sha1_len().

Function Documentation

bf_block_size()

static unsigned bf_block_size ( PX_Cipher *  c )

static

Definition at line 400 of file internal.c.

Referenced by bf_load().

{
    return 8;
}

bf_cbc_load()

static PX_Cipher* bf_cbc_load ( void  )

static

Definition at line 524 of file internal.c.

References bf_load(), and MODE_CBC.

{
    return bf_load(MODE_CBC);
}

bf_decrypt()

static int bf_decrypt ( PX_Cipher *  c, const uint8 *  data, unsigned  dlen, uint8 *  res  )

static

Definition at line 455 of file internal.c.

References int_ctx::bf, blowfish_decrypt_cbc(), blowfish_decrypt_ecb(), int_ctx::ctx, cx(), int_ctx::mode, MODE_CBC, MODE_ECB, px_cipher::ptr, and PXE_NOTBLOCKSIZE.

Referenced by bf_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;
    BlowfishContext *bfctx = &cx->ctx.bf;

    if (dlen == 0)
        return 0;

    if (dlen & 7)
        return PXE_NOTBLOCKSIZE;

    memcpy(res, data, dlen);
    switch (cx->mode)
    {
        case MODE_ECB:
            blowfish_decrypt_ecb(res, dlen, bfctx);
            break;
        case MODE_CBC:
            blowfish_decrypt_cbc(res, dlen, bfctx);
            break;
    }
    return 0;
}

bf_ecb_load()

static PX_Cipher* bf_ecb_load ( void  )

static

Definition at line 518 of file internal.c.

References bf_load(), and MODE_ECB.

{
    return bf_load(MODE_ECB);
}

bf_encrypt()

static int bf_encrypt ( PX_Cipher *  c, const uint8 *  data, unsigned  dlen, uint8 *  res  )

static

Definition at line 430 of file internal.c.

References int_ctx::bf, blowfish_encrypt_cbc(), blowfish_encrypt_ecb(), int_ctx::ctx, cx(), int_ctx::mode, MODE_CBC, MODE_ECB, px_cipher::ptr, and PXE_NOTBLOCKSIZE.

Referenced by bf_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;
    BlowfishContext *bfctx = &cx->ctx.bf;

    if (dlen == 0)
        return 0;

    if (dlen & 7)
        return PXE_NOTBLOCKSIZE;

    memcpy(res, data, dlen);
    switch (cx->mode)
    {
        case MODE_ECB:
            blowfish_encrypt_ecb(res, dlen, bfctx);
            break;
        case MODE_CBC:
            blowfish_encrypt_cbc(res, dlen, bfctx);
            break;
    }
    return 0;
}

bf_init()

static int bf_init ( PX_Cipher *  c, const uint8 *  key, unsigned  klen, const uint8 *  iv  )

static

Definition at line 418 of file internal.c.

References int_ctx::bf, blowfish_setiv(), blowfish_setkey(), int_ctx::ctx, cx(), and px_cipher::ptr.

Referenced by bf_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;

    blowfish_setkey(&cx->ctx.bf, key, klen);
    if (iv)
        blowfish_setiv(&cx->ctx.bf, iv);

    return 0;
}

bf_iv_size()

static unsigned bf_iv_size ( PX_Cipher *  c )

static

Definition at line 412 of file internal.c.

Referenced by bf_load().

{
    return 8;
}

bf_key_size()

static unsigned bf_key_size ( PX_Cipher *  c )

static

Definition at line 406 of file internal.c.

Referenced by bf_load().

{
    return 448 / 8;
}

bf_load()

static PX_Cipher* bf_load ( int  mode )

static

Definition at line 480 of file internal.c.

References bf_block_size(), bf_decrypt(), bf_encrypt(), bf_init(), bf_iv_size(), bf_key_size(), px_cipher::block_size, cx(), px_cipher::decrypt, px_cipher::encrypt, px_cipher::free, px_cipher::init, intctx_free(), px_cipher::iv_size, px_cipher::key_size, mode, int_ctx::mode, px_cipher::ptr, and px_alloc.

Referenced by bf_cbc_load(), and bf_ecb_load().

{
    PX_Cipher  *c;
    struct int_ctx *cx;

    c = px_alloc(sizeof *c);
    memset(c, 0, sizeof *c);

    c->block_size = bf_block_size;
    c->key_size = bf_key_size;
    c->iv_size = bf_iv_size;
    c->init = bf_init;
    c->encrypt = bf_encrypt;
    c->decrypt = bf_decrypt;
    c->free = intctx_free;

    cx = px_alloc(sizeof *cx);
    memset(cx, 0, sizeof *cx);
    cx->mode = mode;
    c->ptr = cx;
    return c;
}

init_md5()

static void init_md5 ( PX_MD *  h )

static

Definition at line 181 of file internal.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_md5_block_len(), int_md5_finish(), int_md5_free(), int_md5_len(), int_md5_reset(), int_md5_update(), MD5_CTX, px_digest::p, px_digest::ptr, px_alloc, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    MD5_CTX    *ctx;

    ctx = px_alloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));

    md->p.ptr = ctx;

    md->result_size = int_md5_len;
    md->block_size = int_md5_block_len;
    md->reset = int_md5_reset;
    md->update = int_md5_update;
    md->finish = int_md5_finish;
    md->free = int_md5_free;

    md->reset(md);
}

init_sha1()

static void init_sha1 ( PX_MD *  h )

static

Definition at line 201 of file internal.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha1_block_len(), int_sha1_finish(), int_sha1_free(), int_sha1_len(), int_sha1_reset(), int_sha1_update(), px_digest::p, px_digest::ptr, px_alloc, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    SHA1_CTX   *ctx;

    ctx = px_alloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));

    md->p.ptr = ctx;

    md->result_size = int_sha1_len;
    md->block_size = int_sha1_block_len;
    md->reset = int_sha1_reset;
    md->update = int_sha1_update;
    md->finish = int_sha1_finish;
    md->free = int_sha1_free;

    md->reset(md);
}

init_sha224()

void init_sha224

(

PX_MD *

h

)

Definition at line 239 of file internal-sha2.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha224_block_len(), int_sha224_finish(), int_sha224_free(), int_sha224_len(), int_sha224_reset(), int_sha224_update(), px_digest::p, px_digest::ptr, px_alloc, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_sha224_ctx *ctx;

    ctx = px_alloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));

    md->p.ptr = ctx;

    md->result_size = int_sha224_len;
    md->block_size = int_sha224_block_len;
    md->reset = int_sha224_reset;
    md->update = int_sha224_update;
    md->finish = int_sha224_finish;
    md->free = int_sha224_free;

    md->reset(md);
}

init_sha256()

void init_sha256

(

PX_MD *

h

)

Definition at line 259 of file internal-sha2.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha256_block_len(), int_sha256_finish(), int_sha256_free(), int_sha256_len(), int_sha256_reset(), int_sha256_update(), px_digest::p, px_digest::ptr, px_alloc, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_sha256_ctx *ctx;

    ctx = px_alloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));

    md->p.ptr = ctx;

    md->result_size = int_sha256_len;
    md->block_size = int_sha256_block_len;
    md->reset = int_sha256_reset;
    md->update = int_sha256_update;
    md->finish = int_sha256_finish;
    md->free = int_sha256_free;

    md->reset(md);
}

init_sha384()

void init_sha384

(

PX_MD *

h

)

Definition at line 279 of file internal-sha2.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha384_block_len(), int_sha384_finish(), int_sha384_free(), int_sha384_len(), int_sha384_reset(), int_sha384_update(), px_digest::p, px_digest::ptr, px_alloc, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_sha384_ctx *ctx;

    ctx = px_alloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));

    md->p.ptr = ctx;

    md->result_size = int_sha384_len;
    md->block_size = int_sha384_block_len;
    md->reset = int_sha384_reset;
    md->update = int_sha384_update;
    md->finish = int_sha384_finish;
    md->free = int_sha384_free;

    md->reset(md);
}

init_sha512()

void init_sha512

(

PX_MD *

h

)

Definition at line 299 of file internal-sha2.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha512_block_len(), int_sha512_finish(), int_sha512_free(), int_sha512_len(), int_sha512_reset(), int_sha512_update(), px_digest::p, px_digest::ptr, px_alloc, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_sha512_ctx *ctx;

    ctx = px_alloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));

    md->p.ptr = ctx;

    md->result_size = int_sha512_len;
    md->block_size = int_sha512_block_len;
    md->reset = int_sha512_reset;
    md->update = int_sha512_update;
    md->finish = int_sha512_finish;
    md->free = int_sha512_free;

    md->reset(md);
}

int_md5_block_len()

static unsigned int_md5_block_len ( PX_MD *  h )

static

Definition at line 91 of file internal.c.

References MD5_BLOCK_SIZE.

Referenced by init_md5().

{
    return MD5_BLOCK_SIZE;
}

int_md5_finish()

static void int_md5_finish ( PX_MD *  h, uint8 *  dst  )

static

Definition at line 113 of file internal.c.

References MD5_CTX, MD5Final, px_digest::p, and px_digest::ptr.

Referenced by init_md5().

{
    MD5_CTX    *ctx = (MD5_CTX *) h->p.ptr;

    MD5Final(dst, ctx);
}

int_md5_free()

static void int_md5_free ( PX_MD *  h )

static

Definition at line 121 of file internal.c.

References MD5_CTX, px_digest::p, px_digest::ptr, px_free, and px_memset().

Referenced by init_md5().

{
    MD5_CTX    *ctx = (MD5_CTX *) h->p.ptr;

    px_memset(ctx, 0, sizeof(*ctx));
    px_free(ctx);
    px_free(h);
}

int_md5_len()

static unsigned int_md5_len ( PX_MD *  h )

static

Definition at line 85 of file internal.c.

References MD5_DIGEST_LENGTH.

Referenced by init_md5().

{
    return MD5_DIGEST_LENGTH;
}

int_md5_reset()

static void int_md5_reset ( PX_MD *  h )

static

Definition at line 105 of file internal.c.

References MD5_CTX, MD5Init, px_digest::p, and px_digest::ptr.

Referenced by init_md5().

{
    MD5_CTX    *ctx = (MD5_CTX *) h->p.ptr;

    MD5Init(ctx);
}

int_md5_update()

static void int_md5_update ( PX_MD *  h, const uint8 *  data, unsigned  dlen  )

static

Definition at line 97 of file internal.c.

References MD5_CTX, MD5Update, px_digest::p, and px_digest::ptr.

Referenced by init_md5().

{
    MD5_CTX    *ctx = (MD5_CTX *) h->p.ptr;

    MD5Update(ctx, data, dlen);
}

int_sha1_block_len()

static unsigned int_sha1_block_len ( PX_MD *  h )

static

Definition at line 139 of file internal.c.

References SHA1_BLOCK_SIZE.

Referenced by init_sha1().

{
    return SHA1_BLOCK_SIZE;
}

int_sha1_finish()

static void int_sha1_finish ( PX_MD *  h, uint8 *  dst  )

static

Definition at line 161 of file internal.c.

References px_digest::p, px_digest::ptr, and SHA1Final.

Referenced by init_sha1().

{
    SHA1_CTX   *ctx = (SHA1_CTX *) h->p.ptr;

    SHA1Final(dst, ctx);
}

int_sha1_free()

static void int_sha1_free ( PX_MD *  h )

static

Definition at line 169 of file internal.c.

References px_digest::p, px_digest::ptr, px_free, and px_memset().

Referenced by init_sha1().

{
    SHA1_CTX   *ctx = (SHA1_CTX *) h->p.ptr;

    px_memset(ctx, 0, sizeof(*ctx));
    px_free(ctx);
    px_free(h);
}

int_sha1_len()

static unsigned int_sha1_len ( PX_MD *  h )

static

Definition at line 133 of file internal.c.

References SHA1_DIGEST_LENGTH.

Referenced by init_sha1().

{
    return SHA1_DIGEST_LENGTH;
}

int_sha1_reset()

static void int_sha1_reset ( PX_MD *  h )

static

Definition at line 153 of file internal.c.

References px_digest::p, px_digest::ptr, and SHA1Init.

Referenced by init_sha1().

{
    SHA1_CTX   *ctx = (SHA1_CTX *) h->p.ptr;

    SHA1Init(ctx);
}

int_sha1_update()

static void int_sha1_update ( PX_MD *  h, const uint8 *  data, unsigned  dlen  )

static

Definition at line 145 of file internal.c.

References px_digest::p, px_digest::ptr, and SHA1Update.

Referenced by init_sha1().

{
    SHA1_CTX   *ctx = (SHA1_CTX *) h->p.ptr;

    SHA1Update(ctx, data, dlen);
}

intctx_free()

static void intctx_free ( PX_Cipher *  c )

static

Definition at line 242 of file internal.c.

References cx(), px_cipher::ptr, px_free, and px_memset().

Referenced by bf_load(), and rj_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;

    if (cx)
    {
        px_memset(cx, 0, sizeof *cx);
        px_free(cx);
    }
    px_free(c);
}

px_find_cipher()

int px_find_cipher	(	const char *	name,
		PX_Cipher **	res
	)

Definition at line 578 of file internal.c.

Referenced by pgp_load_cipher(), and px_find_combo().

{
    int         i;
    PX_Cipher  *c = NULL;

    name = px_resolve_alias(int_aliases, name);

    for (i = 0; int_ciphers[i].name; i++)
        if (strcmp(int_ciphers[i].name, name) == 0)
        {
            c = int_ciphers[i].load();
            break;
        }

    if (c == NULL)
        return PXE_NO_CIPHER;

    *res = c;
    return 0;
}

px_find_digest()

int px_find_digest	(	const char *	name,
		PX_MD **	res
	)

Definition at line 559 of file internal.c.

Referenced by pg_digest(), pgp_load_digest(), px_crypt_md5(), and px_find_hmac().

{
    const struct int_digest *p;
    PX_MD      *h;

    for (p = int_digest_list; p->name; p++)
        if (pg_strcasecmp(p->name, name) == 0)
        {
            h = px_alloc(sizeof(*h));
            p->init(h);

            *res = h;

            return 0;
        }
    return PXE_NO_HASH;
}

rj_128_cbc()

static PX_Cipher* rj_128_cbc ( void  )

static

Definition at line 512 of file internal.c.

References MODE_CBC, and rj_load().

{
    return rj_load(MODE_CBC);
}

rj_128_ecb()

static PX_Cipher* rj_128_ecb ( void  )

static

Definition at line 506 of file internal.c.

References MODE_ECB, and rj_load().

{
    return rj_load(MODE_ECB);
}

rj_block_size()

static unsigned rj_block_size ( PX_Cipher *  c )

static

Definition at line 262 of file internal.c.

Referenced by rj_load().

{
    return 128 / 8;
}

rj_decrypt()

static int rj_decrypt ( PX_Cipher *  c, const uint8 *  data, unsigned  dlen, uint8 *  res  )

static

Definition at line 339 of file internal.c.

References aes_cbc_decrypt(), aes_ecb_decrypt(), int_ctx::ctx, cx(), int_ctx::is_init, int_ctx::iv, int_ctx::mode, MODE_CBC, px_cipher::ptr, PXE_CIPHER_INIT, PXE_NOTBLOCKSIZE, int_ctx::rj, and rj_real_init().

Referenced by rj_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;

    if (!cx->is_init)
        if (rj_real_init(cx, 0))
            return PXE_CIPHER_INIT;

    if (dlen == 0)
        return 0;

    if (dlen & 15)
        return PXE_NOTBLOCKSIZE;

    memcpy(res, data, dlen);

    if (cx->mode == MODE_CBC)
    {
        aes_cbc_decrypt(&cx->ctx.rj, cx->iv, res, dlen);
        memcpy(cx->iv, data + dlen - 16, 16);
    }
    else
        aes_ecb_decrypt(&cx->ctx.rj, res, dlen);

    return 0;
}

rj_encrypt()

static int rj_encrypt ( PX_Cipher *  c, const uint8 *  data, unsigned  dlen, uint8 *  res  )

static

Definition at line 309 of file internal.c.

References aes_cbc_encrypt(), aes_ecb_encrypt(), int_ctx::ctx, cx(), int_ctx::is_init, int_ctx::iv, int_ctx::mode, MODE_CBC, px_cipher::ptr, PXE_CIPHER_INIT, PXE_NOTBLOCKSIZE, int_ctx::rj, and rj_real_init().

Referenced by rj_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;

    if (!cx->is_init)
    {
        if (rj_real_init(cx, 1))
            return PXE_CIPHER_INIT;
    }

    if (dlen == 0)
        return 0;

    if (dlen & 15)
        return PXE_NOTBLOCKSIZE;

    memcpy(res, data, dlen);

    if (cx->mode == MODE_CBC)
    {
        aes_cbc_encrypt(&cx->ctx.rj, cx->iv, res, dlen);
        memcpy(cx->iv, res + dlen - 16, 16);
    }
    else
        aes_ecb_encrypt(&cx->ctx.rj, res, dlen);

    return 0;
}

rj_init()

static int rj_init ( PX_Cipher *  c, const uint8 *  key, unsigned  klen, const uint8 *  iv  )

static

Definition at line 280 of file internal.c.

References cx(), int_ctx::iv, int_ctx::keybuf, int_ctx::keylen, px_cipher::ptr, and PXE_KEY_TOO_BIG.

Referenced by rj_load().

{
    struct int_ctx *cx = (struct int_ctx *) c->ptr;

    if (klen <= 128 / 8)
        cx->keylen = 128 / 8;
    else if (klen <= 192 / 8)
        cx->keylen = 192 / 8;
    else if (klen <= 256 / 8)
        cx->keylen = 256 / 8;
    else
        return PXE_KEY_TOO_BIG;

    memcpy(&cx->keybuf, key, klen);

    if (iv)
        memcpy(cx->iv, iv, 128 / 8);

    return 0;
}

rj_iv_size()

static unsigned rj_iv_size ( PX_Cipher *  c )

static

Definition at line 274 of file internal.c.

Referenced by rj_load().

{
    return 128 / 8;
}

rj_key_size()

static unsigned rj_key_size ( PX_Cipher *  c )

static

Definition at line 268 of file internal.c.

Referenced by rj_load().

{
    return 256 / 8;
}

rj_load()

static PX_Cipher* rj_load ( int  mode )

static

Definition at line 371 of file internal.c.

References px_cipher::block_size, cx(), px_cipher::decrypt, px_cipher::encrypt, px_cipher::free, px_cipher::init, intctx_free(), px_cipher::iv_size, px_cipher::key_size, mode, int_ctx::mode, px_cipher::ptr, px_alloc, rj_block_size(), rj_decrypt(), rj_encrypt(), rj_init(), rj_iv_size(), and rj_key_size().

Referenced by rj_128_cbc(), and rj_128_ecb().

{
    PX_Cipher  *c;
    struct int_ctx *cx;

    c = px_alloc(sizeof *c);
    memset(c, 0, sizeof *c);

    c->block_size = rj_block_size;
    c->key_size = rj_key_size;
    c->iv_size = rj_iv_size;
    c->init = rj_init;
    c->encrypt = rj_encrypt;
    c->decrypt = rj_decrypt;
    c->free = intctx_free;

    cx = px_alloc(sizeof *cx);
    memset(cx, 0, sizeof *cx);
    cx->mode = mode;

    c->ptr = cx;
    return c;
}

rj_real_init()

static int rj_real_init ( struct int_ctx *  cx, int  dir  )

static

Definition at line 302 of file internal.c.

References aes_set_key(), int_ctx::ctx, int_ctx::keybuf, int_ctx::keylen, and int_ctx::rj.

Referenced by rj_decrypt(), and rj_encrypt().

{
    aes_set_key(&cx->ctx.rj, cx->keybuf, cx->keylen * 8, dir);
    return 0;
}

Variable Documentation

int_aliases

const PX_Alias int_aliases[]

static

Initial value:

= {
    {"bf", "bf-cbc"},
    {"blowfish", "bf-cbc"},
    {"aes", "aes-128-cbc"},
    {"aes-ecb", "aes-128-ecb"},
    {"aes-cbc", "aes-128-cbc"},
    {"aes-128", "aes-128-cbc"},
    {"rijndael", "aes-128-cbc"},
    {"rijndael-128", "aes-128-cbc"},
    {NULL, NULL}
}

Definition at line 544 of file internal.c.

int_ciphers

const struct int_cipher int_ciphers[]

static

Initial value:

= {
    {"bf-cbc", bf_cbc_load},
    {"bf-ecb", bf_ecb_load},
    {"aes-128-cbc", rj_128_cbc},
    {"aes-128-ecb", rj_128_ecb},
    {NULL, NULL}
}

Definition at line 536 of file internal.c.

int_digest_list

const struct int_digest int_digest_list[]

static

Initial value:

= {
    {"md5", init_md5},
    {"sha1", init_sha1},
    {"sha224", init_sha224},
    {"sha256", init_sha256},
    {"sha384", init_sha384},
    {"sha512", init_sha512},
    {NULL, NULL}
}

Definition at line 72 of file internal.c.