comment change

2 files changed, 2 insertions, 2 deletions

diff --git a/pwmanager/pwmanager/libgcryptif.cpp b/pwmanager/pwmanager/libgcryptif.cpp
index 8175510..eafd318 100644
--- a/pwmanager/pwmanager/libgcryptif.cpp
+++ b/pwmanager/pwmanager/libgcryptif.cpp
@@ -1,274 +1,274 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   hashPassphrase() is derived from GnuPG and is                         *
  *   Copyright (C) 1998, 1999, 2000, 2001, 2003                            *
  *   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.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
- * This file is originaly based on version 2.0 of pwmanager
+ * This file is originaly based on version 1.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #include "libgcryptif.h"
 
 #ifdef CONFIG_PWMANAGER_GCRY
 
 #include "pwmdoc.h"
 #include "randomizer.h"
 
 #include <gcrypt.h>
 
 #ifdef PWM_EMBEDDED
 #include <pwmprefs.h>
 #endif
 
 
 PwMerror LibGCryptIf::encrypt(unsigned char **outBuf,
 			      size_t *outBufLen,
 			      unsigned char *inBuf,
 			      size_t inBufLen,
 			      const unsigned char *key,
 			      size_t keylen,
 			      char _algo)
 {
 	PwMerror ret = e_success;
 	gcry_error_t err;
 	gcry_cipher_hd_t handle;
 	size_t blklen;
 	size_t unpaddedLen = inBufLen;
 	size_t cipherKeylen;
 	unsigned char *hashedKey;
 	unsigned char salt[STRING2KEY_SALTLEN];
 	int algo = mapCipherId(_algo);
 
 	if (!inBufLen || !keylen)
 		return e_invalidArg;
 
 	// test if algo is ready for encryption
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_TEST_ALGO,
 				    0, 0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): GCRYCTL_TEST_ALGO failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// get the algo block length
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_GET_BLKLEN,
 				    0,
 				    &blklen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): GCRYCTL_GET_BLKLEN failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	/* double check if we have enough space.
 	 * We have only 1024 extra bytes for padding and salt.
 	 */
 	BUG_ON(blklen > 1024 - STRING2KEY_SALTLEN);
 	// get the algo key length
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_GET_KEYLEN,
 				    0,
 				    &cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): GCRYCTL_GET_KEYLEN failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// now open the algo and get a handle
 	err = gcry_cipher_open(&handle,
 			       algo,
 			       GCRY_CIPHER_MODE_CBC,
 			       0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_open() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// hash the "key" to a fixed size hash matching "cipherKeylen"
 	hashedKey = new unsigned char[cipherKeylen];
 	hashPassphrase(key, keylen, salt, hashedKey, cipherKeylen, true);
 	// so now set the hashed key
 	err = gcry_cipher_setkey(handle, hashedKey, cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_setkey() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		delete [] hashedKey;
 		goto out_close;
 	}
 	delete [] hashedKey;
 	/* allocate a buffer for the encrypted data.
 	 * The size of the buffer is the inBuf length, but blklen
 	 * aligned and plus the length of the salt, that is appended.
 	 */
 	*outBufLen = getBufLen(unpaddedLen, blklen) + STRING2KEY_SALTLEN;
 	*outBuf = new unsigned char[*outBufLen];
 	padData(inBuf, unpaddedLen, blklen);
 	// encrypt the padded data
 	err = gcry_cipher_encrypt(handle,
 				  *outBuf,
 				  *outBufLen - STRING2KEY_SALTLEN,
 				  inBuf,
 				  *outBufLen - STRING2KEY_SALTLEN);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_encrypt() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out_delete;
 	}
 	// append the salt to the encrypted data
 	memcpy(*outBuf + *outBufLen - STRING2KEY_SALTLEN, salt, STRING2KEY_SALTLEN);
 	goto out_close;
 out_delete:
 	delete [] *outBuf;
 out_close:
 	gcry_cipher_close(handle);
 out:
 	return ret;
 }
 
 PwMerror LibGCryptIf::decrypt(unsigned char **outBuf,
 			      size_t *outBufLen,
 			      const unsigned char *inBuf,
 			      size_t inBufLen,
 			      const unsigned char *key,
 			      size_t keylen,
 			      char _algo)
 {
 	PwMerror ret = e_success;
 	gcry_error_t err;
 	gcry_cipher_hd_t handle;
 	size_t cipherKeylen;
 	unsigned char *hashedKey;
 	unsigned char salt[STRING2KEY_SALTLEN];
 	int algo = mapCipherId(_algo);
 
 	if (!inBufLen || !keylen)
 		return e_invalidArg;
 
 	// test if algo is ready for encryption
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_TEST_ALGO,
 				    0, 0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): GCRYCTL_TEST_ALGO failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// get algo key length
 	err = gcry_cipher_algo_info(algo,
 				    GCRYCTL_GET_KEYLEN,
 				    0,
 				    &cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): GCRYCTL_GET_KEYLEN failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// extract the salt of the encrypted data buffer
 	memcpy(salt, inBuf + inBufLen - STRING2KEY_SALTLEN, STRING2KEY_SALTLEN);
 	// open the algo and get a handle
 	err = gcry_cipher_open(&handle,
 			       algo,
 			       GCRY_CIPHER_MODE_CBC,
 			       0);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): gcry_cipher_open() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out;
 	}
 	// hash the "key" to a fixed size hash matching "cipherKeylen"
 	hashedKey = new unsigned char[cipherKeylen];
 	hashPassphrase(key, keylen, salt, hashedKey, cipherKeylen, false);
 	// so now set the hashed key
 	err = gcry_cipher_setkey(handle, hashedKey, cipherKeylen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doDecrypt(): gcry_cipher_setkey() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		delete [] hashedKey;
 		goto out_close;
 	}
 	delete [] hashedKey;
 	*outBufLen = inBufLen - STRING2KEY_SALTLEN;
 	*outBuf = new unsigned char[*outBufLen];
 	// decrypt the data
 	err = gcry_cipher_decrypt(handle,
 				  *outBuf,
 				  *outBufLen,
 				  inBuf,
 				  *outBufLen);
 	if (err != GPG_ERR_NO_ERROR) {
 		printDebug(string("LibGCryptIf::doEncrypt(): gcry_cipher_encrypt() failed: ")
 			   + gcry_strerror(err));
 		ret = e_cryptNotImpl;
 		goto out_delete;
 	}
 	// remove all random padding
 	unpadData(*outBuf, outBufLen);
 	goto out_close;
 out_delete:
 	delete [] *outBuf;
 out_close:
 	gcry_cipher_close(handle);
 out:
 	return ret;
 }
 
 PwMerror LibGCryptIf::hash(unsigned char **outBuf,
 			   size_t *outBufLen,
 			   const unsigned char *inBuf,
 			   size_t inBufLen,
 			   char _algo)
 {
 	PwMerror ret = e_success;
 	unsigned int hashLen;
 	int algo = mapHashId(_algo);
 
 	hashLen = gcry_md_get_algo_dlen(algo);
 	*outBufLen = hashLen;
 	*outBuf = new unsigned char[*outBufLen];
 	gcry_md_hash_buffer(algo,
 			    *outBuf,
 			    inBuf,
 			    inBufLen);
 	return ret;
 }
 
 unsigned int LibGCryptIf::hashLength(char _algo)
 {
 	unsigned int ret;
 	int algo = mapHashId(_algo);
 	ret = gcry_md_get_algo_dlen(algo);
 	return ret;
 }
 
 int LibGCryptIf::mapCipherId(char algo)
 {
 	switch (algo) {
 	case PWM_CRYPT_AES128:
 		return GCRY_CIPHER_AES;
 	case PWM_CRYPT_AES192:
 		return GCRY_CIPHER_AES192;
diff --git a/pwmanager/pwmanager/libgcryptif.h b/pwmanager/pwmanager/libgcryptif.h
index ce76675..dffd55b 100644
--- a/pwmanager/pwmanager/libgcryptif.h
+++ b/pwmanager/pwmanager/libgcryptif.h
@@ -1,166 +1,166 @@
 /***************************************************************************
  *                                                                         *
  *   copyright (C) 2004 by Michael Buesch                                  *
  *   email: mbuesch@freenet.de                                             *
  *                                                                         *
  *   hashPassphrase() is derived from GnuPG and is                         *
  *   Copyright (C) 1998, 1999, 2000, 2001, 2003                            *
  *   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.                         *
  *                                                                         *
  ***************************************************************************/
 
 /***************************************************************************
  * copyright (C) 2004 by Ulf Schenk
- * This file is originaly based on version 2.0 of pwmanager
+ * This file is originaly based on version 1.1 of pwmanager
  * and was modified to run on embedded devices that run microkde
  *
  * $Id$
  **************************************************************************/  
 
 #ifndef __LIBGCRYPTIF_H
 #define __LIBGCRYPTIF_H
 
 #include "pwmexception.h"
 
 //#undef CONFIG_PWMANAGER_GCRY // for debugging only.
 #ifdef CONFIG_PWMANAGER_GCRY
 
 #include <stddef.h>
 #include <sys/types.h>
 #include <stdint.h>
 
 #define STRING2KEY_SALTLEN	8
 
 /** interface class for the libgcrypt cipher and hash algorithms
   * NOTE: Always allocate 1024 extra bytes for the inBuf (for padding)
   */
 class LibGCryptIf
 {
 protected:
 	struct STRING2KEY
 	{
 		int  mode;
 		int hash_algo;
 		uint8_t salt[STRING2KEY_SALTLEN];
 		uint32_t  count;
 	};
 	struct DEK
 	{
 		size_t keylen;
 		uint8_t key[32]; // this is the largest used keylen (256 bit)
 	};
 
 public:
 	LibGCryptIf() { }
 	/** is libgcrypt available? */
 	static bool available()
 			{ return true; }
 	/** encrypt data. _algo is the PWM_CRYPT_* ID
 	  * of the algorithm.
 	  */
 	PwMerror encrypt(unsigned char **outBuf,
 			 size_t *outBufLen,
 			 unsigned char *inBuf,
 			 size_t inBufLen,
 			 const unsigned char *key,
 			 size_t keylen,
 			 char _algo);
 	/** decrypt data. _algo is the PWM_CRYPT_* ID
 	  * of the algorithm.
 	  */
 	PwMerror decrypt(unsigned char **outBuf,
 			 size_t *outBufLen,
 			 const unsigned char *inBuf,
 			 size_t inBufLen,
 			 const unsigned char *key,
 			 size_t keylen,
 			 char _algo);
 	/** hash data. _algo is the PWM_HASH_* ID of the hash */
 	PwMerror hash(unsigned char **outBuf,
 		      size_t *outBufLen,
 		      const unsigned char *inBuf,
 		      size_t inBufLen,
 		      char _algo);
 	/** returns the length of the hash. _algo is the PWM_HASH_*
 	  * id of the hash. returns 0 on error.
 	  */
 	unsigned int hashLength(char _algo);
 
 protected:
 	/** returns the total buffer length */
 	size_t getBufLen(size_t inBufLen, size_t boundary)
 		{
 			return ((boundary - (inBufLen % boundary)) + inBufLen);
 		}
 	/** pad the data up to the given boundary.
 	  * "buf" has to be big enough!
 	  */
 	void padData(unsigned char *buf,
 		     size_t bufLen,
 		     size_t boundary);
 	/** unpad the data */
 	void unpadData(const unsigned char *buf,
 		       size_t *bufLen);
 	/** maps the PWM_CRYPT_* ID of an algorithm
 	  * to the libgcrypt GCRY_CIPHER_* ID
 	  */
 	int mapCipherId(char algo);
 	/** maps the PWM_HASH_* ID of an algorithm
 	  * to the libgcrypt GCRY_MD_* ID
 	  */
 	int mapHashId(char algo);
 	/** hash a passphrase to a cipher key */
 	bool hashPassphrase(const unsigned char *pw,
 			    size_t pwlen,
 			    unsigned char *salt,
 			    unsigned char *key,
 			    size_t keylen,
 			    bool create);
 	/** hash a passphrase to a cipher key */
 	bool doHashPassphrase(DEK *dek,
 			      const unsigned char *pw,
 			      size_t pwlen,
 			      STRING2KEY *s2k,
 			      bool create);
 };
 
 
 #else // CONFIG_PWMANAGER_GCRY
 /** libgcrypt is not installed. This is a NOP wrapper. */
 class LibGCryptIf
 {
 public:
 	LibGCryptIf() { }
 	static bool available()
 			{ return false; }
 	PwMerror encrypt(unsigned char **,
 			 size_t *,
 			 unsigned char *,
 			 size_t,
 			 const unsigned char *,
 			 size_t,
 			 char)
 			{ return e_cryptNotImpl; }
 	PwMerror decrypt(unsigned char **,
 			 size_t *,
 			 const unsigned char *,
 			 size_t,
 			 const unsigned char *,
 			 size_t,
 			 char)
 			{ return e_cryptNotImpl; }
 	PwMerror hash(unsigned char **,
 		      size_t *,
 		      const unsigned char *,
 		      size_t,
 		      char)
 			{ return e_hashNotImpl; }
 	unsigned int hashLength(char)
 			{ return 0; }
 };
 #endif // CONFIG_PWMANAGER_GCRY
 #endif // __LIBGCRYPTIF_H