blowfish.h

KeePassX用于保护密码的安全

/***************************************************************************
 *                                                                         *
 *   copyright (C) 2003, 2004 by Michael Buesch                            *
 *   email: [e-mail]                                             *
 *                                                                         *
 *   blowfish.c  -  Blowfish encryption                                    *
 *       Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.     *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License version 2        *
 *   as published by the Free Software Foundation.                         *
 *                                                                         *
 ***************************************************************************/

#ifndef BLOWFISH_H
#define BLOWFISH_H

#include "global.h"
#include <qglobal.h>
//#include <stdint.h>
#include <string>
using std::string;

#define BLOWFISH_BLOCKSIZE	8
#define BLOWFISH_ROUNDS		16
#define CIPHER_ALGO_BLOWFISH	4	/* blowfish 128 bit key */

#define uint8_t quint8
#define uint16_t quint16
#define uint32_t quint32
#define byte quint8

/** blowfish encryption algorithm.
  * Derived from libgcrypt-1.1.12
  */

class Blowfish
{
	struct BLOWFISH_context
	{
		uint32_t s0[256];
		uint32_t s1[256];
		uint32_t s2[256];
		uint32_t s3[256];
		uint32_t p[BLOWFISH_ROUNDS+2];
	};

public:
	Blowfish();

	/** set key to encrypt. if return == 1, it is a weak key. */
	int bf_setkey( byte *key, unsigned int keylen );
	/** encrypt inbuf and return it in outbuf.
	  * inbuf and outbuf have to be: buf % 8 == 0
	  * You may check this with getPaddedLen() and pad with NULL.
	  */
	int bf_encrypt( byte *outbuf, byte *inbuf, unsigned int inbuf_len );
	/** decrypt inbuf and return it in outbuf.
	  * inbuf and outbuf have to be: buf % 8 == 0
	  * You may check this with getPaddedLen() and pad with NULL.
	  */
	int bf_decrypt( byte *outbuf, byte *inbuf, unsigned int inbuf_len );
	/** returns the length, the sting has to be padded to */
	static unsigned int getPaddedLen(unsigned int inLen)
			{ return ((8 - (inLen % 8)) + inLen); }
	/** pad up to 8 bytes. */
	static void padNull(string *buf);
	/** remove padded data */
	static bool unpadNull(string *buf);

protected:
#if BLOWFISH_ROUNDS != 16
	uint32_t function_F( uint32_t x)
	{
		uint16_t a, b, c, d;
	#ifdef KEEPASS_BIG_ENDIAN
		a = ((byte *) & x)[0];
		b = ((byte *) & x)[1];
		c = ((byte *) & x)[2];
		d = ((byte *) & x)[3];
	#else
		a = ((byte *) & x)[3];
		b = ((byte *) & x)[2];
		c = ((byte *) & x)[1];
		d = ((byte *) & x)[0];
	#endif
		return ((bc.s0[a] + bc.s1[b]) ^ bc.s2[c]) + bc.s3[d];
	}
#endif
	void R(uint32_t &l, uint32_t &r, uint32_t i, uint32_t *p,
	       uint32_t *s0, uint32_t *s1, uint32_t *s2, uint32_t *s3)
	{
		l ^= p[i];
	#ifdef KEEPASS_BIG_ENDIAN
		r ^= (( s0[((byte*)&l)[0]] + s1[((byte*)&l)[1]])
			^ s2[((byte*)&l)[2]]) + s3[((byte*)&l)[3]];
	#else
		r ^= (( s0[((byte*)&l)[3]] + s1[((byte*)&l)[2]])
			^ s2[((byte*)&l)[1]]) + s3[((byte*)&l)[0]];
	#endif
	}
	void encrypt_block(byte *outbuf, byte *inbuf);
	void decrypt_block(byte *outbuf, byte *inbuf);
	void burn_stack(int bytes);
	void do_encrypt(uint32_t *ret_xl, uint32_t *ret_xr);
	void do_decrypt(uint32_t *ret_xl, uint32_t *ret_xr);
	void do_encrypt_block(byte *outbuf, byte *inbuf);
	void do_decrypt_block(byte *outbuf, byte *inbuf);
	int do_bf_setkey(byte *key, unsigned int keylen);

protected:
	struct BLOWFISH_context bc;
};

#endif