internal.c File Reference

#include "postgres.h"
#include <time.h>
#include "blf.h"
#include "px.h"
#include "rijndael.h"
#include "sha1.h"
#include "common/cryptohash.h"
#include "common/md5.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	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 223 of file internal.c.

INT_MAX_KEY

#define INT_MAX_KEY   (512/8)

Definition at line 222 of file internal.c.

MD5_BLOCK_SIZE

#define MD5_BLOCK_SIZE   64

Definition at line 53 of file internal.c.

Referenced by int_md5_block_len().

MODE_CBC

#define MODE_CBC   1

Definition at line 257 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 256 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 52 of file internal.c.

Referenced by int_sha1_block_len().

SHA1_DIGEST_LENGTH

#define SHA1_DIGEST_LENGTH   SHA1_RESULTLEN

Definition at line 46 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 396 of file internal.c.

Referenced by bf_load().

{
    return 8;
}

bf_cbc_load()

static PX_Cipher* bf_cbc_load ( void  )

static

Definition at line 518 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 451 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 512 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 426 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 414 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 408 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 402 of file internal.c.

Referenced by bf_load().

{
    return 448 / 8;
}

bf_load()

static PX_Cipher* bf_load ( int  mode )

static

Definition at line 476 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, palloc0(), and px_cipher::ptr.

Referenced by bf_cbc_load(), and bf_ecb_load().

{
    PX_Cipher  *c;
    struct int_ctx *cx;

    c = palloc0(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 = palloc0(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(), px_digest::p, pg_cryptohash_create(), PG_MD5, px_digest::ptr, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_cryptohash_ctx *ctx;

    ctx = pg_cryptohash_create(PG_MD5);

    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 200 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, palloc0(), px_digest::ptr, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    SHA1_CTX   *ctx;

    ctx = palloc0(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 137 of file internal-sha2.c.

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha224_block_len(), int_sha224_len(), int_sha2_finish(), int_sha2_free(), int_sha2_reset(), int_sha2_update(), px_digest::p, pg_cryptohash_create(), PG_SHA224, px_digest::ptr, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_cryptohash_ctx *ctx;

    ctx = pg_cryptohash_create(PG_SHA224);
    md->p.ptr = ctx;

    md->result_size = int_sha224_len;
    md->block_size = int_sha224_block_len;
    md->reset = int_sha2_reset;
    md->update = int_sha2_update;
    md->finish = int_sha2_finish;
    md->free = int_sha2_free;

    md->reset(md);
}

init_sha256()

void init_sha256

(

PX_MD *

h

)

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

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha256_block_len(), int_sha256_len(), int_sha2_finish(), int_sha2_free(), int_sha2_reset(), int_sha2_update(), px_digest::p, pg_cryptohash_create(), PG_SHA256, px_digest::ptr, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_cryptohash_ctx *ctx;

    ctx = pg_cryptohash_create(PG_SHA256);
    md->p.ptr = ctx;

    md->result_size = int_sha256_len;
    md->block_size = int_sha256_block_len;
    md->reset = int_sha2_reset;
    md->update = int_sha2_update;
    md->finish = int_sha2_finish;
    md->free = int_sha2_free;

    md->reset(md);
}

init_sha384()

void init_sha384

(

PX_MD *

h

)

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

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha2_finish(), int_sha2_free(), int_sha2_reset(), int_sha2_update(), int_sha384_block_len(), int_sha384_len(), px_digest::p, pg_cryptohash_create(), PG_SHA384, px_digest::ptr, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_cryptohash_ctx *ctx;

    ctx = pg_cryptohash_create(PG_SHA384);
    md->p.ptr = ctx;

    md->result_size = int_sha384_len;
    md->block_size = int_sha384_block_len;
    md->reset = int_sha2_reset;
    md->update = int_sha2_update;
    md->finish = int_sha2_finish;
    md->free = int_sha2_free;

    md->reset(md);
}

init_sha512()

void init_sha512

(

PX_MD *

h

)

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

References px_digest::block_size, px_digest::finish, px_digest::free, int_sha2_finish(), int_sha2_free(), int_sha2_reset(), int_sha2_update(), int_sha512_block_len(), int_sha512_len(), px_digest::p, pg_cryptohash_create(), PG_SHA512, px_digest::ptr, px_digest::reset, px_digest::result_size, and px_digest::update.

{
    pg_cryptohash_ctx *ctx;

    ctx = pg_cryptohash_create(PG_SHA512);
    md->p.ptr = ctx;

    md->result_size = int_sha512_len;
    md->block_size = int_sha512_block_len;
    md->reset = int_sha2_reset;
    md->update = int_sha2_update;
    md->finish = int_sha2_finish;
    md->free = int_sha2_free;

    md->reset(md);
}

int_md5_block_len()

static unsigned int_md5_block_len ( PX_MD *  h )

static

Definition at line 89 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 elog, ERROR, px_digest::p, pg_cryptohash_final(), and px_digest::ptr.

Referenced by init_md5().

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

    if (pg_cryptohash_final(ctx, dst) < 0)
        elog(ERROR, "could not finalize %s context", "MD5");
}

int_md5_free()

static void int_md5_free ( PX_MD *  h )

static

Definition at line 122 of file internal.c.

References px_digest::p, pfree(), pg_cryptohash_free(), and px_digest::ptr.

Referenced by init_md5().

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

    pg_cryptohash_free(ctx);
    pfree(h);
}

int_md5_len()

static unsigned int_md5_len ( PX_MD *  h )

static

Definition at line 83 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 104 of file internal.c.

References elog, ERROR, px_digest::p, pg_cryptohash_init(), and px_digest::ptr.

Referenced by init_md5().

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

    if (pg_cryptohash_init(ctx) < 0)
        elog(ERROR, "could not initialize %s context", "MD5");
}

int_md5_update()

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

static

Definition at line 95 of file internal.c.

References elog, ERROR, px_digest::p, pg_cryptohash_update(), and px_digest::ptr.

Referenced by init_md5().

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

    if (pg_cryptohash_update(ctx, data, dlen) < 0)
        elog(ERROR, "could not update %s context", "MD5");
}

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, pfree(), px_digest::ptr, and px_memset().

Referenced by init_sha1().

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

    px_memset(ctx, 0, sizeof(*ctx));
    pfree(ctx);
    pfree(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 240 of file internal.c.

References cx(), pfree(), px_cipher::ptr, 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);
        pfree(cx);
    }
    pfree(c);
}

px_find_cipher()

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

Definition at line 572 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 553 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 = palloc(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 506 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 500 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 260 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 337 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 307 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 278 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 272 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 266 of file internal.c.

Referenced by rj_load().

{
    return 256 / 8;
}

rj_load()

static PX_Cipher* rj_load ( int  mode )

static

Definition at line 369 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, palloc0(), px_cipher::ptr, 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 = palloc0(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 = palloc0(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 300 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 538 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 530 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 70 of file internal.c.