postgresql/contrib/pgcrypto/pgp-cfb.c

/*
 * pgp-cfb.c
 *	  Implements both normal and PGP-specific CFB mode.
 *
 * Copyright (c) 2005 Marko Kreen
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *	  notice, this list of conditions and the following disclaimer.
 * 2. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
 *
 * contrib/pgcrypto/pgp-cfb.c
 */

#include "postgres.h"

#include "pgp.h"
#include "px.h"

typedef int (*mix_data_t) (PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst);

struct PGP_CFB
{
	PX_Cipher  *ciph;
	int			block_size;
	int			pos;
	int			block_no;
	int			resync;
	uint8		fr[PGP_MAX_BLOCK];
	uint8		fre[PGP_MAX_BLOCK];
	uint8		encbuf[PGP_MAX_BLOCK];
};

int
pgp_cfb_create(PGP_CFB **ctx_p, int algo, const uint8 *key, int key_len,
			   int resync, uint8 *iv)
{
	int			res;
	PX_Cipher  *ciph;
	PGP_CFB    *ctx;

	res = pgp_load_cipher(algo, &ciph);
	if (res < 0)
		return res;

	res = px_cipher_init(ciph, key, key_len, NULL);
	if (res < 0)
	{
		px_cipher_free(ciph);
		return res;
	}

	ctx = palloc0(sizeof(*ctx));
	ctx->ciph = ciph;
	ctx->block_size = px_cipher_block_size(ciph);
	ctx->resync = resync;

	if (iv)
		memcpy(ctx->fr, iv, ctx->block_size);

	*ctx_p = ctx;
	return 0;
}

void
pgp_cfb_free(PGP_CFB *ctx)
{
	px_cipher_free(ctx->ciph);
	px_memset(ctx, 0, sizeof(*ctx));
	pfree(ctx);
}

/*
 * Data processing for normal CFB.  (PGP_PKT_SYMENCRYPTED_DATA_MDC)
 */
static int
mix_encrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
	int			i;

	for (i = ctx->pos; i < ctx->pos + len; i++)
		*dst++ = ctx->encbuf[i] = ctx->fre[i] ^ (*data++);
	ctx->pos += len;
	return len;
}

static int
mix_decrypt_normal(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
	int			i;

	for (i = ctx->pos; i < ctx->pos + len; i++)
	{
		ctx->encbuf[i] = *data++;
		*dst++ = ctx->fre[i] ^ ctx->encbuf[i];
	}
	ctx->pos += len;
	return len;
}

/*
 * Data processing for old PGP CFB mode. (PGP_PKT_SYMENCRYPTED_DATA)
 *
 * The goal is to hide the horror from the rest of the code,
 * thus its all concentrated here.
 */
static int
mix_encrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
	int			i,
				n;

	/* block #2 is 2 bytes long */
	if (ctx->block_no == 2)
	{
		n = 2 - ctx->pos;
		if (len < n)
			n = len;
		for (i = ctx->pos; i < ctx->pos + n; i++)
			*dst++ = ctx->encbuf[i] = ctx->fre[i] ^ (*data++);

		ctx->pos += n;
		len -= n;

		if (ctx->pos == 2)
		{
			memcpy(ctx->fr, ctx->encbuf + 2, ctx->block_size - 2);
			memcpy(ctx->fr + ctx->block_size - 2, ctx->encbuf, 2);
			ctx->pos = 0;
			return n;
		}
	}
	for (i = ctx->pos; i < ctx->pos + len; i++)
		*dst++ = ctx->encbuf[i] = ctx->fre[i] ^ (*data++);
	ctx->pos += len;
	return len;
}

static int
mix_decrypt_resync(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
	int			i,
				n;

	/* block #2 is 2 bytes long */
	if (ctx->block_no == 2)
	{
		n = 2 - ctx->pos;
		if (len < n)
			n = len;
		for (i = ctx->pos; i < ctx->pos + n; i++)
		{
			ctx->encbuf[i] = *data++;
			*dst++ = ctx->fre[i] ^ ctx->encbuf[i];
		}
		ctx->pos += n;
		len -= n;

		if (ctx->pos == 2)
		{
			memcpy(ctx->fr, ctx->encbuf + 2, ctx->block_size - 2);
			memcpy(ctx->fr + ctx->block_size - 2, ctx->encbuf, 2);
			ctx->pos = 0;
			return n;
		}
	}
	for (i = ctx->pos; i < ctx->pos + len; i++)
	{
		ctx->encbuf[i] = *data++;
		*dst++ = ctx->fre[i] ^ ctx->encbuf[i];
	}
	ctx->pos += len;
	return len;
}

/*
 * common code for both encrypt and decrypt.
 */
static int
cfb_process(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst,
			mix_data_t mix_data)
{
	int			n;
	int			res;

	while (len > 0 && ctx->pos > 0)
	{
		n = ctx->block_size - ctx->pos;
		if (len < n)
			n = len;

		n = mix_data(ctx, data, n, dst);
		data += n;
		dst += n;
		len -= n;

		if (ctx->pos == ctx->block_size)
		{
			memcpy(ctx->fr, ctx->encbuf, ctx->block_size);
			ctx->pos = 0;
		}
	}

	while (len > 0)
	{
		unsigned	rlen;

		px_cipher_encrypt(ctx->ciph, 0, ctx->fr, ctx->block_size, ctx->fre, &rlen);
		if (ctx->block_no < 5)
			ctx->block_no++;

		n = ctx->block_size;
		if (len < n)
			n = len;

		res = mix_data(ctx, data, n, dst);
		data += res;
		dst += res;
		len -= res;

		if (ctx->pos == ctx->block_size)
		{
			memcpy(ctx->fr, ctx->encbuf, ctx->block_size);
			ctx->pos = 0;
		}
	}
	return 0;
}

/*
 * public interface
 */

int
pgp_cfb_encrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
	mix_data_t	mix = ctx->resync ? mix_encrypt_resync : mix_encrypt_normal;

	return cfb_process(ctx, data, len, dst, mix);
}

int
pgp_cfb_decrypt(PGP_CFB *ctx, const uint8 *data, int len, uint8 *dst)
{
	mix_data_t	mix = ctx->resync ? mix_decrypt_resync : mix_decrypt_normal;

	return cfb_process(ctx, data, len, dst, mix);
}