thooge
/
keepassx1
Archived
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

added missing files to svn.

Browse Source 
git-svn-id: https://svn.code.sf.net/p/keepassx/code/trunk@126 b624d157-de02-0410-bad0-e51aec6abb33
master
tarek_saidi 18 years ago
parent 50a39d726a
commit 11b33969d8
20 changed files with 1817 additions and 24 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 22
      src/Database.cpp
  2. 2
      src/Database.h
  3. 29
      src/KpxFirefox.cpp
  4. 60
      src/KpxFirefox.h
  5. 541
      src/crypto/blowfish.cpp
  6. 115
      src/crypto/blowfish.h
  7. 257
      src/crypto/sha1.cpp
  8. 99
      src/crypto/sha1.h
  9. 37
      src/export/Export.cpp
  10. 44
      src/export/Export.h
  11. 116
      src/export/Export_KeePassX_Xml.cpp
  12. 39
      src/export/Export_KeePassX_Xml.h
  13. 43
      src/import/Import.cpp
  14. 42
      src/import/Import.h
  15. 130
      src/import/Import_GnuKeyRing.cpp
  16. 34
      src/import/Import_GnuKeyRing.h
  17. 147
      src/import/Import_KeePassX_Xml.cpp
  18. 41
      src/import/Import_KeePassX_Xml.h
  19. 35
      src/lib/EntryView.cpp
  20. 8
      src/mainwindow.cpp

22
src/Database.cpp
Unescape View File

@ -76,16 +76,22 @@ bool KpxUuid::operator!=(const KpxUuid& other)const{
QString KpxDateTime::toString(Qt::DateFormat format) const{
if(*this==Date_Never)return QObject::tr("Never");
else return QDateTime::toString(format);
if(*this==Date_Never)return QObject::tr("Never");
else return QDateTime::toString(format);
}
QString KpxDateTime::dateToString(Qt::DateFormat format) const{
if(*this==Date_Never)return QObject::tr("Never");
else return date().toString(format);
if(*this==Date_Never)return QObject::tr("Never");
else return date().toString(format);
}
KpxDateTime KpxDateTime::fromString(const QString& string,Qt::DateFormat format){
if(string.toLower()=="never")
return Date_Never;
else return QDateTime::fromString(string,format);
}
CEntry::CEntry(){
Image=0;
GroupId=0;
@ -96,6 +102,14 @@ CEntry::CEntry(){
Binary=QByteArray();
}
bool KpxDateTime::operator<(const QDateTime& other){
if(*this!=Date_Never && other!=Date_Never)return ((QDateTime)(*this)<other);
if(*this==Date_Never && other==Date_Never)return false;
if(*this==Date_Never)return false;
if(other==Date_Never)return true;
}
CGroup::CGroup(){
Image=0;

2
src/Database.h
Unescape View File

@ -70,6 +70,8 @@ class KpxDateTime:public QDateTime{
virtual QString toString(Qt::DateFormat format = Qt::TextDate ) const;
//! Returns a string representation of the date part of the DateTime object in the given format or "Never" if the DateTime value is 28.12.2999 23:59:59.
QString dateToString(Qt::DateFormat format = Qt::TextDate)const;
static KpxDateTime fromString(const QString& string,Qt::DateFormat format = Qt::TextDate);
bool operator<(const QDateTime& other);
};
//! Entry Data Structure

29
src/KpxFirefox.cpp
Unescape View File

@ -0,0 +1,29 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include "KpxFirefox.h"
KpxFirefoxAdaptor::KpxFirefoxAdaptor(KpxFirefox* obj): QDBusAbstractAdaptor(obj)
{ kpx=obj; }

60
src/KpxFirefox.h
Unescape View File

@ -0,0 +1,60 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef KPXFIREFOX_H
#define KPXFIREFOX_H
#include <QtDBus/QtDBus>
#include <QObject>
#include "Database.h"
class KpxFirefox:public QObject
{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.keepassx.DBus.KpxFirefox")
public:
KpxFirefox(IDatabase* db){};
//~KpxFirefox(){};
public slots:
QString getMyValue(int Zahl){return QString("You sent the number %1 over DBUS").arg(Zahl);}
};
class KpxFirefoxAdaptor:public QDBusAbstractAdaptor
{
Q_OBJECT
Q_CLASSINFO("D-Bus Interface", "org.keepassx.DBus.KpxFirefox")
public:
KpxFirefoxAdaptor(KpxFirefox* kpx);
~KpxFirefoxAdaptor(){};
public slots:
QString getMyValue(int Zahl){
QString serv=QDBusConnection::sender().baseService();
QDBusConnectionInterface *inter=QDBusConnection::sender().interface();
qDebug("PID=%i",inter->servicePid(serv).value());
return kpx->getMyValue(Zahl);
}
private:
KpxFirefox* kpx;
};
#endif

541
src/crypto/blowfish.cpp
Unescape View File

@ -0,0 +1,541 @@
/* 2003.05.02: Derived from libgcrypt-1.1.12 by Michael Buesch */
/* blowfish.c - Blowfish encryption
* Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
*
* This file is part of Libgcrypt.
*
* Libgcrypt is free software; you can redistribute it and/or modify
* it under the terms of the GNU Lesser general Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* Libgcrypt is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
*
* For a description of the algorithm, see:
* Bruce Schneier: Applied Cryptography. John Wiley & Sons, 1996.
* ISBN 0-471-11709-9. Pages 336 ff.
*/
/* Test values:
* key "abcdefghijklmnopqrstuvwxyz";
* plain "BLOWFISH"
* cipher 32 4E D0 FE F4 13 A2 03
*
*/
#include <string.h>
#include <stdlib.h>
#include "blowfish.h"
/* precomputed S boxes */
static const uint32_t ks0[256] = {
0xD1310BA6, 0x98DFB5AC, 0x2FFD72DB, 0xD01ADFB7, 0xB8E1AFED, 0x6A267E96,
0xBA7C9045, 0xF12C7F99, 0x24A19947, 0xB3916CF7, 0x0801F2E2, 0x858EFC16,
0x636920D8, 0x71574E69, 0xA458FEA3, 0xF4933D7E, 0x0D95748F, 0x728EB658,
0x718BCD58, 0x82154AEE, 0x7B54A41D, 0xC25A59B5, 0x9C30D539, 0x2AF26013,
0xC5D1B023, 0x286085F0, 0xCA417918, 0xB8DB38EF, 0x8E79DCB0, 0x603A180E,
0x6C9E0E8B, 0xB01E8A3E, 0xD71577C1, 0xBD314B27, 0x78AF2FDA, 0x55605C60,
0xE65525F3, 0xAA55AB94, 0x57489862, 0x63E81440, 0x55CA396A, 0x2AAB10B6,
0xB4CC5C34, 0x1141E8CE, 0xA15486AF, 0x7C72E993, 0xB3EE1411, 0x636FBC2A,
0x2BA9C55D, 0x741831F6, 0xCE5C3E16, 0x9B87931E, 0xAFD6BA33, 0x6C24CF5C,
0x7A325381, 0x28958677, 0x3B8F4898, 0x6B4BB9AF, 0xC4BFE81B, 0x66282193,
0x61D809CC, 0xFB21A991, 0x487CAC60, 0x5DEC8032, 0xEF845D5D, 0xE98575B1,
0xDC262302, 0xEB651B88, 0x23893E81, 0xD396ACC5, 0x0F6D6FF3, 0x83F44239,
0x2E0B4482, 0xA4842004, 0x69C8F04A, 0x9E1F9B5E, 0x21C66842, 0xF6E96C9A,
0x670C9C61, 0xABD388F0, 0x6A51A0D2, 0xD8542F68, 0x960FA728, 0xAB5133A3,
0x6EEF0B6C, 0x137A3BE4, 0xBA3BF050, 0x7EFB2A98, 0xA1F1651D, 0x39AF0176,
0x66CA593E, 0x82430E88, 0x8CEE8619, 0x456F9FB4, 0x7D84A5C3, 0x3B8B5EBE,
0xE06F75D8, 0x85C12073, 0x401A449F, 0x56C16AA6, 0x4ED3AA62, 0x363F7706,
0x1BFEDF72, 0x429B023D, 0x37D0D724, 0xD00A1248, 0xDB0FEAD3, 0x49F1C09B,
0x075372C9, 0x80991B7B, 0x25D479D8, 0xF6E8DEF7, 0xE3FE501A, 0xB6794C3B,
0x976CE0BD, 0x04C006BA, 0xC1A94FB6, 0x409F60C4, 0x5E5C9EC2, 0x196A2463,
0x68FB6FAF, 0x3E6C53B5, 0x1339B2EB, 0x3B52EC6F, 0x6DFC511F, 0x9B30952C,
0xCC814544, 0xAF5EBD09, 0xBEE3D004, 0xDE334AFD, 0x660F2807, 0x192E4BB3,
0xC0CBA857, 0x45C8740F, 0xD20B5F39, 0xB9D3FBDB, 0x5579C0BD, 0x1A60320A,
0xD6A100C6, 0x402C7279, 0x679F25FE, 0xFB1FA3CC, 0x8EA5E9F8, 0xDB3222F8,
0x3C7516DF, 0xFD616B15, 0x2F501EC8, 0xAD0552AB, 0x323DB5FA, 0xFD238760,
0x53317B48, 0x3E00DF82, 0x9E5C57BB, 0xCA6F8CA0, 0x1A87562E, 0xDF1769DB,
0xD542A8F6, 0x287EFFC3, 0xAC6732C6, 0x8C4F5573, 0x695B27B0, 0xBBCA58C8,
0xE1FFA35D, 0xB8F011A0, 0x10FA3D98, 0xFD2183B8, 0x4AFCB56C, 0x2DD1D35B,
0x9A53E479, 0xB6F84565, 0xD28E49BC, 0x4BFB9790, 0xE1DDF2DA, 0xA4CB7E33,
0x62FB1341, 0xCEE4C6E8, 0xEF20CADA, 0x36774C01, 0xD07E9EFE, 0x2BF11FB4,
0x95DBDA4D, 0xAE909198, 0xEAAD8E71, 0x6B93D5A0, 0xD08ED1D0, 0xAFC725E0,
0x8E3C5B2F, 0x8E7594B7, 0x8FF6E2FB, 0xF2122B64, 0x8888B812, 0x900DF01C,
0x4FAD5EA0, 0x688FC31C, 0xD1CFF191, 0xB3A8C1AD, 0x2F2F2218, 0xBE0E1777,
0xEA752DFE, 0x8B021FA1, 0xE5A0CC0F, 0xB56F74E8, 0x18ACF3D6, 0xCE89E299,
0xB4A84FE0, 0xFD13E0B7, 0x7CC43B81, 0xD2ADA8D9, 0x165FA266, 0x80957705,
0x93CC7314, 0x211A1477, 0xE6AD2065, 0x77B5FA86, 0xC75442F5, 0xFB9D35CF,
0xEBCDAF0C, 0x7B3E89A0, 0xD6411BD3, 0xAE1E7E49, 0x00250E2D, 0x2071B35E,
0x226800BB, 0x57B8E0AF, 0x2464369B, 0xF009B91E, 0x5563911D, 0x59DFA6AA,
0x78C14389, 0xD95A537F, 0x207D5BA2, 0x02E5B9C5, 0x83260376, 0x6295CFA9,
0x11C81968, 0x4E734A41, 0xB3472DCA, 0x7B14A94A, 0x1B510052, 0x9A532915,
0xD60F573F, 0xBC9BC6E4, 0x2B60A476, 0x81E67400, 0x08BA6FB5, 0x571BE91F,
0xF296EC6B, 0x2A0DD915, 0xB6636521, 0xE7B9F9B6, 0xFF34052E, 0xC5855664,
0x53B02D5D, 0xA99F8FA1, 0x08BA4799, 0x6E85076A
};
static const uint32_t ks1[256] = {
0x4B7A70E9, 0xB5B32944, 0xDB75092E, 0xC4192623, 0xAD6EA6B0, 0x49A7DF7D,
0x9CEE60B8, 0x8FEDB266, 0xECAA8C71, 0x699A17FF, 0x5664526C, 0xC2B19EE1,
0x193602A5, 0x75094C29, 0xA0591340, 0xE4183A3E, 0x3F54989A, 0x5B429D65,
0x6B8FE4D6, 0x99F73FD6, 0xA1D29C07, 0xEFE830F5, 0x4D2D38E6, 0xF0255DC1,
0x4CDD2086, 0x8470EB26, 0x6382E9C6, 0x021ECC5E, 0x09686B3F, 0x3EBAEFC9,
0x3C971814, 0x6B6A70A1, 0x687F3584, 0x52A0E286, 0xB79C5305, 0xAA500737,
0x3E07841C, 0x7FDEAE5C, 0x8E7D44EC, 0x5716F2B8, 0xB03ADA37, 0xF0500C0D,
0xF01C1F04, 0x0200B3FF, 0xAE0CF51A, 0x3CB574B2, 0x25837A58, 0xDC0921BD,
0xD19113F9, 0x7CA92FF6, 0x94324773, 0x22F54701, 0x3AE5E581, 0x37C2DADC,
0xC8B57634, 0x9AF3DDA7, 0xA9446146, 0x0FD0030E, 0xECC8C73E, 0xA4751E41,
0xE238CD99, 0x3BEA0E2F, 0x3280BBA1, 0x183EB331, 0x4E548B38, 0x4F6DB908,
0x6F420D03, 0xF60A04BF, 0x2CB81290, 0x24977C79, 0x5679B072, 0xBCAF89AF,
0xDE9A771F, 0xD9930810, 0xB38BAE12, 0xDCCF3F2E, 0x5512721F, 0x2E6B7124,
0x501ADDE6, 0x9F84CD87, 0x7A584718, 0x7408DA17, 0xBC9F9ABC, 0xE94B7D8C,
0xEC7AEC3A, 0xDB851DFA, 0x63094366, 0xC464C3D2, 0xEF1C1847, 0x3215D908,
0xDD433B37, 0x24C2BA16, 0x12A14D43, 0x2A65C451, 0x50940002, 0x133AE4DD,
0x71DFF89E, 0x10314E55, 0x81AC77D6, 0x5F11199B, 0x043556F1, 0xD7A3C76B,
0x3C11183B, 0x5924A509, 0xF28FE6ED, 0x97F1FBFA, 0x9EBABF2C, 0x1E153C6E,
0x86E34570, 0xEAE96FB1, 0x860E5E0A, 0x5A3E2AB3, 0x771FE71C, 0x4E3D06FA,
0x2965DCB9, 0x99E71D0F, 0x803E89D6, 0x5266C825, 0x2E4CC978, 0x9C10B36A,
0xC6150EBA, 0x94E2EA78, 0xA5FC3C53, 0x1E0A2DF4, 0xF2F74EA7, 0x361D2B3D,
0x1939260F, 0x19C27960, 0x5223A708, 0xF71312B6, 0xEBADFE6E, 0xEAC31F66,
0xE3BC4595, 0xA67BC883, 0xB17F37D1, 0x018CFF28, 0xC332DDEF, 0xBE6C5AA5,
0x65582185, 0x68AB9802, 0xEECEA50F, 0xDB2F953B, 0x2AEF7DAD, 0x5B6E2F84,
0x1521B628, 0x29076170, 0xECDD4775, 0x619F1510, 0x13CCA830, 0xEB61BD96,
0x0334FE1E, 0xAA0363CF, 0xB5735C90, 0x4C70A239, 0xD59E9E0B, 0xCBAADE14,
0xEECC86BC, 0x60622CA7, 0x9CAB5CAB, 0xB2F3846E, 0x648B1EAF, 0x19BDF0CA,
0xA02369B9, 0x655ABB50, 0x40685A32, 0x3C2AB4B3, 0x319EE9D5, 0xC021B8F7,
0x9B540B19, 0x875FA099, 0x95F7997E, 0x623D7DA8, 0xF837889A, 0x97E32D77,
0x11ED935F, 0x16681281, 0x0E358829, 0xC7E61FD6, 0x96DEDFA1, 0x7858BA99,
0x57F584A5, 0x1B227263, 0x9B83C3FF, 0x1AC24696, 0xCDB30AEB, 0x532E3054,
0x8FD948E4, 0x6DBC3128, 0x58EBF2EF, 0x34C6FFEA, 0xFE28ED61, 0xEE7C3C73,
0x5D4A14D9, 0xE864B7E3, 0x42105D14, 0x203E13E0, 0x45EEE2B6, 0xA3AAABEA,
0xDB6C4F15, 0xFACB4FD0, 0xC742F442, 0xEF6ABBB5, 0x654F3B1D, 0x41CD2105,
0xD81E799E, 0x86854DC7, 0xE44B476A, 0x3D816250, 0xCF62A1F2, 0x5B8D2646,
0xFC8883A0, 0xC1C7B6A3, 0x7F1524C3, 0x69CB7492, 0x47848A0B, 0x5692B285,
0x095BBF00, 0xAD19489D, 0x1462B174, 0x23820E00, 0x58428D2A, 0x0C55F5EA,
0x1DADF43E, 0x233F7061, 0x3372F092, 0x8D937E41, 0xD65FECF1, 0x6C223BDB,
0x7CDE3759, 0xCBEE7460, 0x4085F2A7, 0xCE77326E, 0xA6078084, 0x19F8509E,
0xE8EFD855, 0x61D99735, 0xA969A7AA, 0xC50C06C2, 0x5A04ABFC, 0x800BCADC,
0x9E447A2E, 0xC3453484, 0xFDD56705, 0x0E1E9EC9, 0xDB73DBD3, 0x105588CD,
0x675FDA79, 0xE3674340, 0xC5C43465, 0x713E38D8, 0x3D28F89E, 0xF16DFF20,
0x153E21E7, 0x8FB03D4A, 0xE6E39F2B, 0xDB83ADF7
};
static const uint32_t ks2[256] = {
0xE93D5A68, 0x948140F7, 0xF64C261C, 0x94692934, 0x411520F7, 0x7602D4F7,
0xBCF46B2E, 0xD4A20068, 0xD4082471, 0x3320F46A, 0x43B7D4B7, 0x500061AF,
0x1E39F62E, 0x97244546, 0x14214F74, 0xBF8B8840, 0x4D95FC1D, 0x96B591AF,
0x70F4DDD3, 0x66A02F45, 0xBFBC09EC, 0x03BD9785, 0x7FAC6DD0, 0x31CB8504,
0x96EB27B3, 0x55FD3941, 0xDA2547E6, 0xABCA0A9A, 0x28507825, 0x530429F4,
0x0A2C86DA, 0xE9B66DFB, 0x68DC1462, 0xD7486900, 0x680EC0A4, 0x27A18DEE,
0x4F3FFEA2, 0xE887AD8C, 0xB58CE006, 0x7AF4D6B6, 0xAACE1E7C, 0xD3375FEC,
0xCE78A399, 0x406B2A42, 0x20FE9E35, 0xD9F385B9, 0xEE39D7AB, 0x3B124E8B,
0x1DC9FAF7, 0x4B6D1856, 0x26A36631, 0xEAE397B2, 0x3A6EFA74, 0xDD5B4332,
0x6841E7F7, 0xCA7820FB, 0xFB0AF54E, 0xD8FEB397, 0x454056AC, 0xBA489527,
0x55533A3A, 0x20838D87, 0xFE6BA9B7, 0xD096954B, 0x55A867BC, 0xA1159A58,
0xCCA92963, 0x99E1DB33, 0xA62A4A56, 0x3F3125F9, 0x5EF47E1C, 0x9029317C,
0xFDF8E802, 0x04272F70, 0x80BB155C, 0x05282CE3, 0x95C11548, 0xE4C66D22,
0x48C1133F, 0xC70F86DC, 0x07F9C9EE, 0x41041F0F, 0x404779A4, 0x5D886E17,
0x325F51EB, 0xD59BC0D1, 0xF2BCC18F, 0x41113564, 0x257B7834, 0x602A9C60,
0xDFF8E8A3, 0x1F636C1B, 0x0E12B4C2, 0x02E1329E, 0xAF664FD1, 0xCAD18115,
0x6B2395E0, 0x333E92E1, 0x3B240B62, 0xEEBEB922, 0x85B2A20E, 0xE6BA0D99,
0xDE720C8C, 0x2DA2F728, 0xD0127845, 0x95B794FD, 0x647D0862, 0xE7CCF5F0,
0x5449A36F, 0x877D48FA, 0xC39DFD27, 0xF33E8D1E, 0x0A476341, 0x992EFF74,
0x3A6F6EAB, 0xF4F8FD37, 0xA812DC60, 0xA1EBDDF8, 0x991BE14C, 0xDB6E6B0D,
0xC67B5510, 0x6D672C37, 0x2765D43B, 0xDCD0E804, 0xF1290DC7, 0xCC00FFA3,
0xB5390F92, 0x690FED0B, 0x667B9FFB, 0xCEDB7D9C, 0xA091CF0B, 0xD9155EA3,
0xBB132F88, 0x515BAD24, 0x7B9479BF, 0x763BD6EB, 0x37392EB3, 0xCC115979,
0x8026E297, 0xF42E312D, 0x6842ADA7, 0xC66A2B3B, 0x12754CCC, 0x782EF11C,
0x6A124237, 0xB79251E7, 0x06A1BBE6, 0x4BFB6350, 0x1A6B1018, 0x11CAEDFA,
0x3D25BDD8, 0xE2E1C3C9, 0x44421659, 0x0A121386, 0xD90CEC6E, 0xD5ABEA2A,
0x64AF674E, 0xDA86A85F, 0xBEBFE988, 0x64E4C3FE, 0x9DBC8057, 0xF0F7C086,
0x60787BF8, 0x6003604D, 0xD1FD8346, 0xF6381FB0, 0x7745AE04, 0xD736FCCC,
0x83426B33, 0xF01EAB71, 0xB0804187, 0x3C005E5F, 0x77A057BE, 0xBDE8AE24,
0x55464299, 0xBF582E61, 0x4E58F48F, 0xF2DDFDA2, 0xF474EF38, 0x8789BDC2,
0x5366F9C3, 0xC8B38E74, 0xB475F255, 0x46FCD9B9, 0x7AEB2661, 0x8B1DDF84,
0x846A0E79, 0x915F95E2, 0x466E598E, 0x20B45770, 0x8CD55591, 0xC902DE4C,
0xB90BACE1, 0xBB8205D0, 0x11A86248, 0x7574A99E, 0xB77F19B6, 0xE0A9DC09,
0x662D09A1, 0xC4324633, 0xE85A1F02, 0x09F0BE8C, 0x4A99A025, 0x1D6EFE10,
0x1AB93D1D, 0x0BA5A4DF, 0xA186F20F, 0x2868F169, 0xDCB7DA83, 0x573906FE,
0xA1E2CE9B, 0x4FCD7F52, 0x50115E01, 0xA70683FA, 0xA002B5C4, 0x0DE6D027,
0x9AF88C27, 0x773F8641, 0xC3604C06, 0x61A806B5, 0xF0177A28, 0xC0F586E0,
0x006058AA, 0x30DC7D62, 0x11E69ED7, 0x2338EA63, 0x53C2DD94, 0xC2C21634,
0xBBCBEE56, 0x90BCB6DE, 0xEBFC7DA1, 0xCE591D76, 0x6F05E409, 0x4B7C0188,
0x39720A3D, 0x7C927C24, 0x86E3725F, 0x724D9DB9, 0x1AC15BB4, 0xD39EB8FC,
0xED545578, 0x08FCA5B5, 0xD83D7CD3, 0x4DAD0FC4, 0x1E50EF5E, 0xB161E6F8,
0xA28514D9, 0x6C51133C, 0x6FD5C7E7, 0x56E14EC4, 0x362ABFCE, 0xDDC6C837,
0xD79A3234, 0x92638212, 0x670EFA8E, 0x406000E0
};
static const uint32_t ks3[256] = {
0x3A39CE37, 0xD3FAF5CF, 0xABC27737, 0x5AC52D1B, 0x5CB0679E, 0x4FA33742,
0xD3822740, 0x99BC9BBE, 0xD5118E9D, 0xBF0F7315, 0xD62D1C7E, 0xC700C47B,
0xB78C1B6B, 0x21A19045, 0xB26EB1BE, 0x6A366EB4, 0x5748AB2F, 0xBC946E79,
0xC6A376D2, 0x6549C2C8, 0x530FF8EE, 0x468DDE7D, 0xD5730A1D, 0x4CD04DC6,
0x2939BBDB, 0xA9BA4650, 0xAC9526E8, 0xBE5EE304, 0xA1FAD5F0, 0x6A2D519A,
0x63EF8CE2, 0x9A86EE22, 0xC089C2B8, 0x43242EF6, 0xA51E03AA, 0x9CF2D0A4,
0x83C061BA, 0x9BE96A4D, 0x8FE51550, 0xBA645BD6, 0x2826A2F9, 0xA73A3AE1,
0x4BA99586, 0xEF5562E9, 0xC72FEFD3, 0xF752F7DA, 0x3F046F69, 0x77FA0A59,
0x80E4A915, 0x87B08601, 0x9B09E6AD, 0x3B3EE593, 0xE990FD5A, 0x9E34D797,
0x2CF0B7D9, 0x022B8B51, 0x96D5AC3A, 0x017DA67D, 0xD1CF3ED6, 0x7C7D2D28,
0x1F9F25CF, 0xADF2B89B, 0x5AD6B472, 0x5A88F54C, 0xE029AC71, 0xE019A5E6,
0x47B0ACFD, 0xED93FA9B, 0xE8D3C48D, 0x283B57CC, 0xF8D56629, 0x79132E28,
0x785F0191, 0xED756055, 0xF7960E44, 0xE3D35E8C, 0x15056DD4, 0x88F46DBA,
0x03A16125, 0x0564F0BD, 0xC3EB9E15, 0x3C9057A2, 0x97271AEC, 0xA93A072A,
0x1B3F6D9B, 0x1E6321F5, 0xF59C66FB, 0x26DCF319, 0x7533D928, 0xB155FDF5,
0x03563482, 0x8ABA3CBB, 0x28517711, 0xC20AD9F8, 0xABCC5167, 0xCCAD925F,
0x4DE81751, 0x3830DC8E, 0x379D5862, 0x9320F991, 0xEA7A90C2, 0xFB3E7BCE,
0x5121CE64, 0x774FBE32, 0xA8B6E37E, 0xC3293D46, 0x48DE5369, 0x6413E680,
0xA2AE0810, 0xDD6DB224, 0x69852DFD, 0x09072166, 0xB39A460A, 0x6445C0DD,
0x586CDECF, 0x1C20C8AE, 0x5BBEF7DD, 0x1B588D40, 0xCCD2017F, 0x6BB4E3BB,
0xDDA26A7E, 0x3A59FF45, 0x3E350A44, 0xBCB4CDD5, 0x72EACEA8, 0xFA6484BB,
0x8D6612AE, 0xBF3C6F47, 0xD29BE463, 0x542F5D9E, 0xAEC2771B, 0xF64E6370,
0x740E0D8D, 0xE75B1357, 0xF8721671, 0xAF537D5D, 0x4040CB08, 0x4EB4E2CC,
0x34D2466A, 0x0115AF84, 0xE1B00428, 0x95983A1D, 0x06B89FB4, 0xCE6EA048,
0x6F3F3B82, 0x3520AB82, 0x011A1D4B, 0x277227F8, 0x611560B1, 0xE7933FDC,
0xBB3A792B, 0x344525BD, 0xA08839E1, 0x51CE794B, 0x2F32C9B7, 0xA01FBAC9,
0xE01CC87E, 0xBCC7D1F6, 0xCF0111C3, 0xA1E8AAC7, 0x1A908749, 0xD44FBD9A,
0xD0DADECB, 0xD50ADA38, 0x0339C32A, 0xC6913667, 0x8DF9317C, 0xE0B12B4F,
0xF79E59B7, 0x43F5BB3A, 0xF2D519FF, 0x27D9459C, 0xBF97222C, 0x15E6FC2A,
0x0F91FC71, 0x9B941525, 0xFAE59361, 0xCEB69CEB, 0xC2A86459, 0x12BAA8D1,
0xB6C1075E, 0xE3056A0C, 0x10D25065, 0xCB03A442, 0xE0EC6E0E, 0x1698DB3B,
0x4C98A0BE, 0x3278E964, 0x9F1F9532, 0xE0D392DF, 0xD3A0342B, 0x8971F21E,
0x1B0A7441, 0x4BA3348C, 0xC5BE7120, 0xC37632D8, 0xDF359F8D, 0x9B992F2E,
0xE60B6F47, 0x0FE3F11D, 0xE54CDA54, 0x1EDAD891, 0xCE6279CF, 0xCD3E7E6F,
0x1618B166, 0xFD2C1D05, 0x848FD2C5, 0xF6FB2299, 0xF523F357, 0xA6327623,
0x93A83531, 0x56CCCD02, 0xACF08162, 0x5A75EBB5, 0x6E163697, 0x88D273CC,
0xDE966292, 0x81B949D0, 0x4C50901B, 0x71C65614, 0xE6C6C7BD, 0x327A140A,
0x45E1D006, 0xC3F27B9A, 0xC9AA53FD, 0x62A80F00, 0xBB25BFE2, 0x35BDD2F6,
0x71126905, 0xB2040222, 0xB6CBCF7C, 0xCD769C2B, 0x53113EC0, 0x1640E3D3,
0x38ABBD60, 0x2547ADF0, 0xBA38209C, 0xF746CE76, 0x77AFA1C5, 0x20756060,
0x85CBFE4E, 0x8AE88DD8, 0x7AAAF9B0, 0x4CF9AA7E, 0x1948C25C, 0x02FB8A8C,
0x01C36AE4, 0xD6EBE1F9, 0x90D4F869, 0xA65CDEA0, 0x3F09252D, 0xC208E69F,
0xB74E6132, 0xCE77E25B, 0x578FDFE3, 0x3AC372E6
};
static const uint32_t ps[BLOWFISH_ROUNDS + 2] = {
0x243F6A88, 0x85A308D3, 0x13198A2E, 0x03707344, 0xA4093822, 0x299F31D0,
0x082EFA98, 0xEC4E6C89, 0x452821E6, 0x38D01377, 0xBE5466CF, 0x34E90C6C,
0xC0AC29B7, 0xC97C50DD, 0x3F84D5B5, 0xB5470917, 0x9216D5D9, 0x8979FB1B
};
Blowfish::Blowfish()
{ static bool mustSelfTest = false;
}
void Blowfish::burn_stack(int bytes)
{
char buf[64];
memset(buf, 0, sizeof buf);
bytes -= sizeof buf;
if (bytes > 0)
burn_stack(bytes);
}
void Blowfish::do_encrypt(uint32_t * ret_xl, uint32_t * ret_xr)
{
#if BLOWFISH_ROUNDS == 16
uint32_t xl, xr, *s0, *s1, *s2, *s3, *p;
xl = *ret_xl;
xr = *ret_xr;
p = bc.p;
s0 = bc.s0;
s1 = bc.s1;
s2 = bc.s2;
s3 = bc.s3;
R(xl, xr, 0, p, s0, s1, s2, s3);
R(xr, xl, 1, p, s0, s1, s2, s3);
R(xl, xr, 2, p, s0, s1, s2, s3);
R(xr, xl, 3, p, s0, s1, s2, s3);
R(xl, xr, 4, p, s0, s1, s2, s3);
R(xr, xl, 5, p, s0, s1, s2, s3);
R(xl, xr, 6, p, s0, s1, s2, s3);
R(xr, xl, 7, p, s0, s1, s2, s3);
R(xl, xr, 8, p, s0, s1, s2, s3);
R(xr, xl, 9, p, s0, s1, s2, s3);
R(xl, xr, 10, p, s0, s1, s2, s3);
R(xr, xl, 11, p, s0, s1, s2, s3);
R(xl, xr, 12, p, s0, s1, s2, s3);
R(xr, xl, 13, p, s0, s1, s2, s3);
R(xl, xr, 14, p, s0, s1, s2, s3);
R(xr, xl, 15, p, s0, s1, s2, s3);
xl ^= p[BLOWFISH_ROUNDS];
xr ^= p[BLOWFISH_ROUNDS + 1];
*ret_xl = xr;
*ret_xr = xl;
#else
uint32_t xl, xr, temp, *p;
int i;
xl = *ret_xl;
xr = *ret_xr;
p = bc.p;
for (i = 0; i < BLOWFISH_ROUNDS; i++) {
xl ^= p[i];
xr ^= function_F(xl);
temp = xl;
xl = xr;
xr = temp;
}
temp = xl;
xl = xr;
xr = temp;
xr ^= p[BLOWFISH_ROUNDS];
xl ^= p[BLOWFISH_ROUNDS + 1];
*ret_xl = xl;
*ret_xr = xr;
#endif
}
void Blowfish::do_decrypt(uint32_t * ret_xl, uint32_t * ret_xr)
{
#if BLOWFISH_ROUNDS == 16
uint32_t xl, xr, *s0, *s1, *s2, *s3, *p;
xl = *ret_xl;
xr = *ret_xr;
p = bc.p;
s0 = bc.s0;
s1 = bc.s1;
s2 = bc.s2;
s3 = bc.s3;
R(xl, xr, 17, p, s0, s1, s2, s3);
R(xr, xl, 16, p, s0, s1, s2, s3);
R(xl, xr, 15, p, s0, s1, s2, s3);
R(xr, xl, 14, p, s0, s1, s2, s3);
R(xl, xr, 13, p, s0, s1, s2, s3);
R(xr, xl, 12, p, s0, s1, s2, s3);
R(xl, xr, 11, p, s0, s1, s2, s3);
R(xr, xl, 10, p, s0, s1, s2, s3);
R(xl, xr, 9, p, s0, s1, s2, s3);
R(xr, xl, 8, p, s0, s1, s2, s3);
R(xl, xr, 7, p, s0, s1, s2, s3);
R(xr, xl, 6, p, s0, s1, s2, s3);
R(xl, xr, 5, p, s0, s1, s2, s3);
R(xr, xl, 4, p, s0, s1, s2, s3);
R(xl, xr, 3, p, s0, s1, s2, s3);
R(xr, xl, 2, p, s0, s1, s2, s3);
xl ^= p[1];
xr ^= p[0];
*ret_xl = xr;
*ret_xr = xl;
#else
uint32_t xl, xr, temp, *p;
int i;
xl = *ret_xl;
xr = *ret_xr;
p = bc.p;
for (i = BLOWFISH_ROUNDS + 1; i > 1; i--) {
xl ^= p[i];
xr ^= function_F(xl);
temp = xl;
xl = xr;
xr = temp;
}
temp = xl;
xl = xr;
xr = temp;
xr ^= p[1];
xl ^= p[0];
*ret_xl = xl;
*ret_xr = xr;
#endif
}
void Blowfish::do_encrypt_block(byte * outbuf, byte * inbuf)
{
uint32_t d1, d2;
d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3];
d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7];
do_encrypt(&d1, &d2);
outbuf[0] = (d1 >> 24) & 0xff;
outbuf[1] = (d1 >> 16) & 0xff;
outbuf[2] = (d1 >> 8) & 0xff;
outbuf[3] = d1 & 0xff;
outbuf[4] = (d2 >> 24) & 0xff;
outbuf[5] = (d2 >> 16) & 0xff;
outbuf[6] = (d2 >> 8) & 0xff;
outbuf[7] = d2 & 0xff;
}
void Blowfish::encrypt_block(byte * outbuf, byte * inbuf)
{
do_encrypt_block(outbuf, inbuf);
burn_stack(64);
}
void Blowfish::do_decrypt_block(byte * outbuf, byte * inbuf)
{
uint32_t d1, d2;
d1 = inbuf[0] << 24 | inbuf[1] << 16 | inbuf[2] << 8 | inbuf[3];
d2 = inbuf[4] << 24 | inbuf[5] << 16 | inbuf[6] << 8 | inbuf[7];
do_decrypt(&d1, &d2);
outbuf[0] = (d1 >> 24) & 0xff;
outbuf[1] = (d1 >> 16) & 0xff;
outbuf[2] = (d1 >> 8) & 0xff;
outbuf[3] = d1 & 0xff;
outbuf[4] = (d2 >> 24) & 0xff;
outbuf[5] = (d2 >> 16) & 0xff;
outbuf[6] = (d2 >> 8) & 0xff;
outbuf[7] = d2 & 0xff;
}
void Blowfish::decrypt_block(byte * outbuf, byte * inbuf)
{
do_decrypt_block(outbuf, inbuf);
burn_stack(64);
}
int Blowfish::do_bf_setkey(byte * key, unsigned int keylen)
{
int i, j;
uint32_t data, datal, datar;
for (i = 0; i < BLOWFISH_ROUNDS + 2; ++i)
bc.p[i] = ps[i];
for (i = 0; i < 256; ++i) {
bc.s0[i] = ks0[i];
bc.s1[i] = ks1[i];
bc.s2[i] = ks2[i];
bc.s3[i] = ks3[i];
}
for (i = j = 0; i < BLOWFISH_ROUNDS + 2; ++i) {
#ifdef KEEPASS_BIG_ENDIAN
((byte *) & data)[0] = key[j];
((byte *) & data)[1] = key[(j + 1) % keylen];
((byte *) & data)[2] = key[(j + 2) % keylen];
((byte *) & data)[3] = key[(j + 3) % keylen];
#else
((byte *) & data)[3] = key[j];
((byte *) & data)[2] = key[(j + 1) % keylen];
((byte *) & data)[1] = key[(j + 2) % keylen];
((byte *) & data)[0] = key[(j + 3) % keylen];
#endif
bc.p[i] ^= data;
j = (j + 4) % keylen;
}
datal = datar = 0;
for (i = 0; i < BLOWFISH_ROUNDS + 2; i += 2) {
do_encrypt(&datal, &datar);
bc.p[i] = datal;
bc.p[i + 1] = datar;
}
for (i = 0; i < 256; i += 2) {
do_encrypt(&datal, &datar);
bc.s0[i] = datal;
bc.s0[i + 1] = datar;
}
for (i = 0; i < 256; i += 2) {
do_encrypt(&datal, &datar);
bc.s1[i] = datal;
bc.s1[i + 1] = datar;
}
for (i = 0; i < 256; i += 2) {
do_encrypt(&datal, &datar);
bc.s2[i] = datal;
bc.s2[i + 1] = datar;
}
for (i = 0; i < 256; i += 2) {
do_encrypt(&datal, &datar);
bc.s3[i] = datal;
bc.s3[i + 1] = datar;
}
/* Check for weak key. A weak key is a key in which a value in */
/* the P-array (here c) occurs more than once per table. */
for (i = 0; i < 255; ++i) {
for (j = i + 1; j < 256; ++j) {
if ((bc.s0[i] == bc.s0[j]) || (bc.s1[i] == bc.s1[j]) ||
(bc.s2[i] == bc.s2[j]) || (bc.s3[i] == bc.s3[j]))
return 1;
}
}
return 0;
}
int Blowfish::bf_setkey(byte * key, unsigned int keylen)
{
int rc = do_bf_setkey(key, keylen);
burn_stack(64);
return rc;
}
int Blowfish::bf_encrypt(byte * outbuf, byte * inbuf, unsigned int inbuf_len)
{
if (inbuf_len % 8)
return 1;
unsigned int i = 0;
while (i < inbuf_len) {
encrypt_block(outbuf + i, inbuf + i);
i += 8;
}
return 0;
}
int Blowfish::bf_decrypt(byte * outbuf, byte * inbuf, unsigned int inbuf_len)
{
if (inbuf_len % 8)
return 1;
unsigned int i = 0;
while (i < inbuf_len) {
decrypt_block(outbuf + i, inbuf + i);
i += 8;
}
return 0;
}
void Blowfish::padNull(string *buf)
{
buf->append(1, (char)0x01);
string::size_type append_null = 8 - (buf->length() % 8);
buf->append(append_null, (char)0x00);
}
bool Blowfish::unpadNull(string *buf)
{
if (buf->size() % 8)
return false;
string::size_type pos = buf->length() - 1;
while ((*buf)[pos] != (char)0x01) {
if (pos == 0)
return false;
--pos;
}
buf->erase(pos, buf->length() - pos);
return true;
}

115
src/crypto/blowfish.h
Unescape View File

@ -0,0 +1,115 @@
/***************************************************************************
* *
* copyright (C) 2003, 2004 by Michael Buesch *
* email: mbuesch@freenet.de *
* *
* 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

257
src/crypto/sha1.cpp
Unescape View File

@ -0,0 +1,257 @@
/*
100% free public domain implementation of the SHA-1 algorithm
by Dominik Reichl <dominik.reichl@t-online.de>
Version 1.5 - 2005-01-01
- 64-bit compiler compatibility added
- Made variable wiping optional (define SHA1_WIPE_VARIABLES)
- Removed unnecessary variable initializations
- ROL32 improvement for the Microsoft compiler (using _rotl)
======== Test Vectors (from FIPS PUB 180-1) ========
SHA1("abc") =
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
SHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") =
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
SHA1(A million repetitions of "a") =
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
*/
#include "global.h"
#include "sha1.h"
#define SHA1_MAX_FILE_BUFFER 8000
// Rotate x bits to the left
#ifndef ROL32
#define ROL32(_val32, _nBits) (((_val32)<<(_nBits))|((_val32)>>(32-(_nBits))))
#endif
#ifdef KEEPASS_LITTLE_ENDIAN
#define SHABLK0(i) (m_block->l[i] = \
(ROL32(m_block->l[i],24) & 0xFF00FF00) | (ROL32(m_block->l[i],8) & 0x00FF00FF))
#else
#define SHABLK0(i) (m_block->l[i])
#endif
#define SHABLK(i) (m_block->l[i&15] = ROL32(m_block->l[(i+13)&15] ^ m_block->l[(i+8)&15] \
^ m_block->l[(i+2)&15] ^ m_block->l[i&15],1))
// SHA-1 rounds
#define _R0(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK0(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
#define _R1(v,w,x,y,z,i) { z+=((w&(x^y))^y)+SHABLK(i)+0x5A827999+ROL32(v,5); w=ROL32(w,30); }
#define _R2(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0x6ED9EBA1+ROL32(v,5); w=ROL32(w,30); }
#define _R3(v,w,x,y,z,i) { z+=(((w|x)&y)|(w&x))+SHABLK(i)+0x8F1BBCDC+ROL32(v,5); w=ROL32(w,30); }
#define _R4(v,w,x,y,z,i) { z+=(w^x^y)+SHABLK(i)+0xCA62C1D6+ROL32(v,5); w=ROL32(w,30); }
CSHA1::CSHA1()
{
m_block = (SHA1_WORKSPACE_BLOCK *)m_workspace;
Reset();
}
CSHA1::~CSHA1()
{
Reset();
}
void CSHA1::Reset()
{
// SHA1 initialization constants
m_state[0] = 0x67452301;
m_state[1] = 0xEFCDAB89;
m_state[2] = 0x98BADCFE;
m_state[3] = 0x10325476;
m_state[4] = 0xC3D2E1F0;
m_count[0] = 0;
m_count[1] = 0;
}
void CSHA1::Update(unsigned char* data, int len){
quint_32 i, j;
j = (m_count[0] >> 3) & 63;
if((m_count[0] += len << 3) < (len << 3)) m_count[1]++;
m_count[1] += (len >> 29);
if((j + len) > 63)
{
i = 64 - j;
memcpy(&m_buffer[j], data, i);
Transform(m_state, m_buffer);
for( ; i + 63 < len; i += 64) Transform(m_state, &data[i]);
j = 0;
}
else i = 0;
memcpy(&m_buffer[j], &data[i], len - i);
}
void CSHA1::Transform(quint_32 *state, quint_8 *buffer)
{
// Copy state[] to working vars
quint_32 a = state[0], b = state[1], c = state[2], d = state[3], e = state[4];
memcpy(m_block, buffer, 64);
// 4 rounds of 20 operations each. Loop unrolled.
_R0(a,b,c,d,e, 0); _R0(e,a,b,c,d, 1); _R0(d,e,a,b,c, 2); _R0(c,d,e,a,b, 3);
_R0(b,c,d,e,a, 4); _R0(a,b,c,d,e, 5); _R0(e,a,b,c,d, 6); _R0(d,e,a,b,c, 7);
_R0(c,d,e,a,b, 8); _R0(b,c,d,e,a, 9); _R0(a,b,c,d,e,10); _R0(e,a,b,c,d,11);
_R0(d,e,a,b,c,12); _R0(c,d,e,a,b,13); _R0(b,c,d,e,a,14); _R0(a,b,c,d,e,15);
_R1(e,a,b,c,d,16); _R1(d,e,a,b,c,17); _R1(c,d,e,a,b,18); _R1(b,c,d,e,a,19);
_R2(a,b,c,d,e,20); _R2(e,a,b,c,d,21); _R2(d,e,a,b,c,22); _R2(c,d,e,a,b,23);
_R2(b,c,d,e,a,24); _R2(a,b,c,d,e,25); _R2(e,a,b,c,d,26); _R2(d,e,a,b,c,27);
_R2(c,d,e,a,b,28); _R2(b,c,d,e,a,29); _R2(a,b,c,d,e,30); _R2(e,a,b,c,d,31);
_R2(d,e,a,b,c,32); _R2(c,d,e,a,b,33); _R2(b,c,d,e,a,34); _R2(a,b,c,d,e,35);
_R2(e,a,b,c,d,36); _R2(d,e,a,b,c,37); _R2(c,d,e,a,b,38); _R2(b,c,d,e,a,39);
_R3(a,b,c,d,e,40); _R3(e,a,b,c,d,41); _R3(d,e,a,b,c,42); _R3(c,d,e,a,b,43);
_R3(b,c,d,e,a,44); _R3(a,b,c,d,e,45); _R3(e,a,b,c,d,46); _R3(d,e,a,b,c,47);
_R3(c,d,e,a,b,48); _R3(b,c,d,e,a,49); _R3(a,b,c,d,e,50); _R3(e,a,b,c,d,51);
_R3(d,e,a,b,c,52); _R3(c,d,e,a,b,53); _R3(b,c,d,e,a,54); _R3(a,b,c,d,e,55);
_R3(e,a,b,c,d,56); _R3(d,e,a,b,c,57); _R3(c,d,e,a,b,58); _R3(b,c,d,e,a,59);
_R4(a,b,c,d,e,60); _R4(e,a,b,c,d,61); _R4(d,e,a,b,c,62); _R4(c,d,e,a,b,63);
_R4(b,c,d,e,a,64); _R4(a,b,c,d,e,65); _R4(e,a,b,c,d,66); _R4(d,e,a,b,c,67);
_R4(c,d,e,a,b,68); _R4(b,c,d,e,a,69); _R4(a,b,c,d,e,70); _R4(e,a,b,c,d,71);
_R4(d,e,a,b,c,72); _R4(c,d,e,a,b,73); _R4(b,c,d,e,a,74); _R4(a,b,c,d,e,75);
_R4(e,a,b,c,d,76); _R4(d,e,a,b,c,77); _R4(c,d,e,a,b,78); _R4(b,c,d,e,a,79);
// Add the working vars back into state
state[0] += a;
state[1] += b;
state[2] += c;
state[3] += d;
state[4] += e;
// Wipe variables
#ifdef SHA1_WIPE_VARIABLES
a = b = c = d = e = 0;
#endif
}
// Hash in file contents
bool CSHA1::HashFile(char *szFileName)
{
unsigned long ulFileSize, ulRest, ulBlocks;
unsigned long i;
quint_8 uData[SHA1_MAX_FILE_BUFFER];
FILE *fIn;
if(szFileName == NULL) return false;
fIn = fopen(szFileName, "rb");
if(fIn == NULL) return false;
fseek(fIn, 0, SEEK_END);
ulFileSize = (unsigned long)ftell(fIn);
fseek(fIn, 0, SEEK_SET);
if(ulFileSize != 0)
{
ulBlocks = ulFileSize / SHA1_MAX_FILE_BUFFER;
ulRest = ulFileSize % SHA1_MAX_FILE_BUFFER;
}
else
{
ulBlocks = 0;
ulRest = 0;
}
for(i = 0; i < ulBlocks; i++)
{
fread(uData, 1, SHA1_MAX_FILE_BUFFER, fIn);
Update((quint_8 *)uData, SHA1_MAX_FILE_BUFFER);
}
if(ulRest != 0)
{
fread(uData, 1, ulRest, fIn);
Update((quint_8 *)uData, ulRest);
}
fclose(fIn); fIn = NULL;
return true;
}
void CSHA1::Final()
{
quint_32 i;
quint_8 finalcount[8];
for(i = 0; i < 8; i++)
finalcount[i] = (quint_8)((m_count[((i >= 4) ? 0 : 1)]
>> ((3 - (i & 3)) * 8) ) & 255); // Endian independent
Update((quint_8 *)"\200", 1);
while ((m_count[0] & 504) != 448)
Update((quint_8 *)"\0", 1);
Update(finalcount, 8); // Cause a SHA1Transform()
for(i = 0; i < 20; i++)
{
m_digest[i] = (quint_8)((m_state[i >> 2] >> ((3 - (i & 3)) * 8) ) & 255);
}
// Wipe variables for security reasons
#ifdef SHA1_WIPE_VARIABLES
i = 0;
memset(m_buffer, 0, 64);
memset(m_state, 0, 20);
memset(m_count, 0, 8);
memset(finalcount, 0, 8);
Transform(m_state, m_buffer);
#endif
}
// Get the final hash as a pre-formatted string
void CSHA1::ReportHash(char *szReport, unsigned char uReportType)
{
unsigned char i;
char szTemp[16];
if(szReport == NULL) return;
if(uReportType == REPORT_HEX)
{
sprintf(szTemp, "%02X", m_digest[0]);
strcat(szReport, szTemp);
for(i = 1; i < 20; i++)
{
sprintf(szTemp, " %02X", m_digest[i]);
strcat(szReport, szTemp);
}
}
else if(uReportType == REPORT_DIGIT)
{
sprintf(szTemp, "%u", m_digest[0]);
strcat(szReport, szTemp);
for(i = 1; i < 20; i++)
{
sprintf(szTemp, " %u", m_digest[i]);
strcat(szReport, szTemp);
}
}
else strcpy(szReport, "Error: Unknown report type!");
}
// Get the raw message digest
void CSHA1::GetHash(quint_8 *puDest)
{
memcpy(puDest, m_digest, 20);
}

99
src/crypto/sha1.h
Unescape View File

@ -0,0 +1,99 @@
/*
100% free public domain implementation of the SHA-1 algorithm
by Dominik Reichl <dominik.reichl@t-online.de>
Version 1.5 - 2005-01-01
- 64-bit compiler compatibility added
- Made variable wiping optional (define SHA1_WIPE_VARIABLES)
- Removed unnecessary variable initializations
- ROL32 improvement for the Microsoft compiler (using _rotl)
======== Test Vectors (from FIPS PUB 180-1) ========
SHA1("abc") =
A9993E36 4706816A BA3E2571 7850C26C 9CD0D89D
SHA1("abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq") =
84983E44 1C3BD26E BAAE4AA1 F95129E5 E54670F1
SHA1(A million repetitions of "a") =
34AA973C D4C4DAA4 F61EEB2B DBAD2731 6534016F
*/
#ifndef ___SHA1_HDR___
#define ___SHA1_HDR___
#include <stdio.h> // Needed for file access
#include <memory.h> // Needed for memset and memcpy
#include <string.h> // Needed for strcat and strcpy
// If you're compiling big endian, just comment out the following line
// #define or #undef this, if you want the CSHA1 class to wipe all
// temporary variables after processing
#define SHA1_WIPE_VARIABLES
/////////////////////////////////////////////////////////////////////////////
// Define 8- and 32-bit variables
#ifndef quint_32
#define quint_8 unsigned char
#if (ULONG_MAX == 0xFFFFFFFF)
#define quint_32 unsigned long
#else
#define quint_32 unsigned int
#endif
#endif
/////////////////////////////////////////////////////////////////////////////
// Declare SHA1 workspace
typedef union
{
quint_8 c[64];
quint_32 l[16];
} SHA1_WORKSPACE_BLOCK;
class CSHA1
{
public:
// Two different formats for ReportHash(...)
enum
{
REPORT_HEX = 0,
REPORT_DIGIT = 1
};
// Constructor and Destructor
CSHA1();
~CSHA1();
quint_32 m_state[5];
quint_32 m_count[2];
quint_8 m_buffer[64];
quint_8 m_digest[20];
void Reset();
// Update the hash value
void Update(unsigned char* data, int len);
bool HashFile(char *szFileName);
// Finalize hash and report
void Final();
void ReportHash(char *szReport, unsigned char uReportType = REPORT_HEX);
void GetHash(quint_8 *puDest);
private:
// Private SHA-1 transformation
void Transform(quint_32 *state, quint_8 *buffer);
// Member variables
quint_8 m_workspace[64];
SHA1_WORKSPACE_BLOCK *m_block; // SHA1 pointer to the byte array above
};
#endif

37
src/export/Export.cpp
Unescape View File

@ -0,0 +1,37 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <QMessageBox>
#include "main.h"
#include "Export.h"
#include "lib/FileDialogs.h"
#include "dialogs/SimplePasswordDlg.h"
QFile* ExporterBase::openFile(QWidget* parent, QString id, QStringList Filters){
QString filename=KpxFileDialogs::saveFile(parent,id,tr("Import File..."),Filters);
if(filename==QString())return NULL;
QFile* file=new QFile(filename);
if(!file->open(QIODevice::ReadWrite|QIODevice::Truncate)){
QMessageBox::critical(parent,tr("Export Failed"),decodeFileError(file->error()));
delete file;
return NULL;
}
return file;
}

44
src/export/Export.h
Unescape View File

@ -0,0 +1,44 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef _EXPORT_H_
#define _EXPORT_H_
#include <QWidget>
#include <QFile>
#include "Database.h"
class IExport{
public:
virtual ~IExport(){};
virtual bool exportDatabase(QWidget* GuiParent, IDatabase* Database)=0;
virtual QString identifier()=0;
virtual QString title()=0;
};
class ExporterBase:public QObject{
protected:
virtual QFile* openFile(QWidget* GuiParent,QString id,QStringList Filter);
};
#endif

116
src/export/Export_KeePassX_Xml.cpp
Unescape View File

@ -0,0 +1,116 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <QtXml>
#include "Export_KeePassX_Xml.h"
bool Export_KeePassX_Xml::exportDatabase(QWidget* GuiParent,IDatabase* database){
db=database;
QFile *file=openFile(GuiParent,identifier(),QStringList()<<tr("XML Files (*.xml)") << tr("All Files (*)"));
if(!file)return false;
QDomDocument doc("KEEPASSX_DATABASE");
QDomElement root=doc.createElement("database");
doc.appendChild(root);
QList<IGroupHandle*> Groups=db->groups();
for(int i=0;i<Groups.size();i++){
if(Groups[i]->parent()==NULL){
addGroup(Groups[i],root,doc);
}
}
file->write(doc.toByteArray());
file->close();
delete file;
return true;
}
void Export_KeePassX_Xml::addGroup(IGroupHandle* group,QDomElement& parent,QDomDocument& doc){
QDomElement GroupElement=doc.createElement("group");
parent.appendChild(GroupElement);
QDomElement Title=doc.createElement("title");
QDomElement Icon=doc.createElement("icon");
Title.appendChild(doc.createTextNode(group->title()));
Icon.appendChild(doc.createTextNode(QString::number(group->image())));
GroupElement.appendChild(Title);
GroupElement.appendChild(Icon);
QList<IGroupHandle*> childs=group->childs();
for(int i=0;i<childs.size();i++){
addGroup(childs[i],GroupElement,doc);
}
QList<IEntryHandle*> entries=db->entries(group);
for(int i=0;i<entries.size();i++){
addEntry(entries[i],GroupElement,doc);
}
}
void Export_KeePassX_Xml::addEntry(IEntryHandle* entry,QDomElement& parent,QDomDocument& doc){
QDomElement GroupElement=doc.createElement("entry");
parent.appendChild(GroupElement);
QDomElement Title=doc.createElement("title");
QDomElement Username=doc.createElement("username");
QDomElement Password=doc.createElement("password");
QDomElement Url=doc.createElement("url");
QDomElement Comment=doc.createElement("comment");
QDomElement BinaryDesc=doc.createElement("bindesc");
QDomElement Binary=doc.createElement("bin");
QDomElement Icon=doc.createElement("icon");
QDomElement Creation=doc.createElement("creation");
QDomElement LastAccess=doc.createElement("lastaccess");
QDomElement LastMod=doc.createElement("lastmod");
QDomElement Expire=doc.createElement("expire");
Title.appendChild(doc.createTextNode(entry->title()));
Username.appendChild(doc.createTextNode(entry->username()));
SecString password=entry->password();
password.unlock();
Password.appendChild(doc.createTextNode(password.string()));
password.lock();
Url.appendChild(doc.createTextNode(entry->url()));
QStringList CommentLines=entry->comment().split('\n');
for(int i=0;i<CommentLines.size();i++){
Comment.appendChild(doc.createTextNode(CommentLines[i]));
if(i==CommentLines.size()-1)break;
Comment.appendChild(doc.createElement("br"));
}
bool HasAttachment=!entry->binary().isNull();
if(HasAttachment){
BinaryDesc.appendChild(doc.createTextNode(entry->binaryDesc()));
Binary.appendChild(doc.createTextNode(entry->binary().toBase64()));
}
Icon.appendChild(doc.createTextNode(QString::number(entry->image())));
Creation.appendChild(doc.createTextNode(entry->creation().toString(Qt::ISODate)));
LastAccess.appendChild(doc.createTextNode(entry->lastAccess().toString(Qt::ISODate)));
LastMod.appendChild(doc.createTextNode(entry->lastMod().toString(Qt::ISODate)));
Expire.appendChild(doc.createTextNode(entry->expire().toString(Qt::ISODate)));
GroupElement.appendChild(Title);
GroupElement.appendChild(Username);
GroupElement.appendChild(Password);
GroupElement.appendChild(Url);
GroupElement.appendChild(Comment);
if(HasAttachment){
GroupElement.appendChild(BinaryDesc);
GroupElement.appendChild(Binary);
}
GroupElement.appendChild(Icon);
GroupElement.appendChild(Creation);
GroupElement.appendChild(LastAccess);
GroupElement.appendChild(LastMod);
GroupElement.appendChild(Expire);
}

39
src/export/Export_KeePassX_Xml.h
Unescape View File

@ -0,0 +1,39 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef _EXPORT_KPX_XML_H_
#define _EXPORT_KPX_XML_H_
#include <QObject>
#include "Export.h"
class Export_KeePassX_Xml:public IExport, public ExporterBase{
public:
virtual bool exportDatabase(QWidget* GuiParent, IDatabase* Database);
virtual QString identifier(){return "EXPORT_KEEPASSX_XML";}
virtual QString title(){return "KeePassX XML File";}
private:
void addGroup(IGroupHandle* group,QDomElement& parent,QDomDocument& doc);
void addEntry(IEntryHandle* group,QDomElement& parent,QDomDocument& doc);
IDatabase* db;
};
#endif

43
src/import/Import.cpp
Unescape View File

@ -0,0 +1,43 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <QMessageBox>
#include "main.h"
#include "Import.h"
#include "lib/FileDialogs.h"
#include "dialogs/SimplePasswordDlg.h"
QFile* ImporterBase::openFile(QWidget* parent, QString id, QStringList Filters){
QString filename=KpxFileDialogs::openExistingFile(parent,id,tr("Import File..."),Filters);
if(filename==QString())return NULL;
QFile* file=new QFile(filename);
if(!file->open(QIODevice::ReadOnly)){
QMessageBox::critical(parent,tr("Import Failed"),decodeFileError(file->error()));
delete file;
return NULL;
}
return file;
}
QString ImporterBase::getPassword(QWidget* parent){
SimplePasswordDialog dlg(parent);
dlg.exec();
return dlg.password;
}

42
src/import/Import.h
Unescape View File

@ -0,0 +1,42 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef _IMPORT_H_
#define _IMPORT_H_
#include <QWidget>
#include <QFile>
#include "Database.h"
class IImport{
public:
virtual ~IImport(){};
virtual bool importDatabase(QWidget* GuiParent, IDatabase* Database)=0;
virtual QString identifier()=0;
virtual QString title()=0;
};
class ImporterBase:public QObject{
protected:
virtual QFile* openFile(QWidget* GuiParent,QString id,QStringList Filter);
virtual QString getPassword(QWidget* GuiParent);
};
#endif

130
src/import/Import_GnuKeyRing.cpp
Unescape View File

@ -0,0 +1,130 @@
/***************************************************************************
* Copyright (C) 2006 by Brian Johnson *
* dev-keepassx@sherbang.com *
* *
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <iostream>
#include <QtXml>
#include <QtCore>
#include "IImport.h"
#include "Import_GnuKeyRing.h"
#include "lib/FileDialogs.h"
#include "main.h"
using namespace std;
QString Import_GnuKeyRing::importDatabase(QWidget* GuiParent, IDatabase* Database){
QString FileName=KpxFileDialogs::openExistingFile(GuiParent,
"Import_Keyring",
tr("Import Database..."),
QStringList()<<tr("All Files (*)"));
if(FileName==QString())
return QString();
QFile file(FileName);
if(!file.exists()){
return tr("File not found.");
}
if(!file.open(QIODevice::ReadOnly)){
return decodeFileError(file.error());
}
int len=file.size();
if(len==0){
return tr("File is empty.");
}
QTextStream ts(&file);
uint entryNum = 0;
QRegExp newEntry("^#\\d*$");
QMap<QString, CGroup*> categories;
/*
CGroup* DefaultGroup=pwm->addGroup(NULL);
DefaultGroup->Name="def-group";
QString* field = NULL;
QString category;
QString name;
QString account;
QString password;
QString note;
while (!ts.atEnd()){
QString line = ts.readLine(400);
if (newEntry.exactMatch(line)){
//Save entry
CGroup* newGroup;
if (entryNum != 0){
if (category != ""){
if (categories.contains(category)){
newGroup=categories[category];
}else{
newGroup=pwm->addGroup(NULL);
newGroup->Name=category;
categories.insert(category, newGroup);
}
}else{
newGroup = DefaultGroup;
}
CEntry* NewEntry=pwm->addEntry();
NewEntry->GroupID=newGroup->ID;
NewEntry->Title=name;
NewEntry->UserName=account;
NewEntry->Password.setString(password,true);
NewEntry->Additional=note;
}
//New Entry
category = "";
name = "";
account = "";
password = "";
note = "";
entryNum = line.remove(0,1).toUInt();
}else if(entryNum == 0){
//Do nothing (waiting for start of first entry)
}else if(line.startsWith("Category:")){
category = line.remove(0,10);
field = &category;
}else if(line.startsWith("Name:")){
name = line.remove(0,6);
field = &name;
}else if(line.startsWith("Account:")){
account = line.remove(0,9);
field = &account;
}else if(line.startsWith("Password:")){
password = line.remove(0,10);
field = &password;
}else if(line.startsWith("Notes:")){
note = line.remove(0,7);
field = &note;
}else if(field != NULL){
field->append("\n");
field->append(line);
}
}
file.close();
pwm->SearchGroupID=-1;
pwm->CryptoAlgorithmus=ALGO_AES;
pwm->KeyEncRounds=6000;
return true;
*/
return QString();
}

34
src/import/Import_GnuKeyRing.h
Unescape View File

@ -0,0 +1,34 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef _IMPORT_KEYRING_H_
#define _IMPORT_KEYRING_H_
#include <QWidget>
#include "Database.h"
class Import_GnuKeyRing:public QObject,public IImport{
public:
virtual QString importDatabase(QWidget* GuiParent, IDatabase* Database);
virtual QString name(){return "GnuKeyRing";}
};
#endif

147
src/import/Import_KeePassX_Xml.cpp
Unescape View File

@ -0,0 +1,147 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#include <QStringList>
#include <QMessageBox>
#include <QtXml>
#include "Import_KeePassX_Xml.h"
bool Import_KeePassX_Xml::importDatabase(QWidget* Parent, IDatabase* database){
db=database;
GuiParent=Parent;
QFile* file=openFile(GuiParent,identifier(),QStringList()<<tr("KeePass XML Files (*.xml)")<<tr("All Files (*)"));
if(!file)return false;
QDomDocument doc;
QString ErrMsg;
int ErrLine;
int ErrCol;
if(!doc.setContent(file,false,&ErrMsg,&ErrLine,&ErrCol)){
QMessageBox::critical(GuiParent,tr("Import Failed"),tr("XML parsing error on line %1 column %2:\n%3").arg(ErrLine).arg(ErrCol).arg(ErrMsg));
delete file;
return false;
}
delete file;
QDomElement root=doc.documentElement();
if(root.tagName()!="database"){
QMessageBox::critical(GuiParent,tr("Import Failed"),tr("Parsing error: File is no valid KeePassX XML file."));
return false;
}
QDomNodeList TopLevelGroupNodes=root.childNodes();
QStringList GroupNames;
for(int i=0;i<TopLevelGroupNodes.count();i++){
if(TopLevelGroupNodes.at(i).toElement().tagName()!="group"){
qWarning("Import_KeePassX_Xml: Error: Unknow tag '%s'",TopLevelGroupNodes.at(i).toElement().tagName());
QMessageBox::critical(GuiParent,tr("Import Failed"),tr("Parsing error: File is no valid KeePassX XML file."));
return false;
}
if(!parseGroup(TopLevelGroupNodes.at(i).toElement(),NULL)){
QMessageBox::critical(GuiParent,tr("Import Failed"),tr("Parsing error: File is no valid KeePassX XML file."));
return false;}
}
return true;
}
bool Import_KeePassX_Xml::parseGroup(const QDomElement& GroupElement,IGroupHandle* ParentGroup){
CGroup Group;
QDomNodeList ChildNodes=GroupElement.childNodes();
for(int i=0;i<ChildNodes.size();i++){
if(!ChildNodes.item(i).isElement()){
qWarning("Import_KeePassX_Xml: Error: Invalid node.");
return false;
}
if(ChildNodes.item(i).toElement().tagName()=="icon")
Group.Image=ChildNodes.item(i).toElement().text().toInt();
else if(ChildNodes.item(i).toElement().tagName()=="title")
Group.Title=ChildNodes.item(i).toElement().text();
}
IGroupHandle* GroupHandle=db->addGroup(&Group,ParentGroup);
for(int i=0;i<ChildNodes.size();i++){
if(ChildNodes.item(i).toElement().tagName()=="entry"){
if(!parseEntry(ChildNodes.item(i).toElement(), GroupHandle))return false;
}else if(ChildNodes.item(i).toElement().tagName()=="group"){
if(!parseGroup(ChildNodes.item(i).toElement(),GroupHandle))return false;
}
}
return true;
}
bool Import_KeePassX_Xml::parseEntry(const QDomElement& EntryElement,IGroupHandle* Group){
if(EntryElement.isNull()){
qWarning("Import_KeePassX_Xml: Error: Entry element is null.");
return false;
}
IEntryHandle* entry=db->newEntry(Group);
QDomNodeList ChildNodes=EntryElement.childNodes();
for(int i=0;i<ChildNodes.size();i++){
if(!ChildNodes.item(i).isElement()){
qWarning("Import_KeePassX_Xml: Error: Invalid node.");
return false;
}
if(ChildNodes.item(i).toElement().tagName()=="title")
entry->setTitle(ChildNodes.item(i).toElement().text());
else if(ChildNodes.item(i).toElement().tagName()=="username")
entry->setUsername(ChildNodes.item(i).toElement().text());
else if(ChildNodes.item(i).toElement().tagName()=="password"){
SecString pw;
QString cpw=ChildNodes.item(i).toElement().text();
pw.setString(cpw,true);
entry->setPassword(pw);
}
else if(ChildNodes.item(i).toElement().tagName()=="url")
entry->setUrl(ChildNodes.item(i).toElement().text());
else if(ChildNodes.item(i).toElement().tagName()=="icon")
entry->setImage(ChildNodes.item(i).toElement().text().toInt());
else if(ChildNodes.item(i).toElement().tagName()=="creation")
entry->setCreation(KpxDateTime::fromString(ChildNodes.item(i).toElement().text(),Qt::ISODate));
else if(ChildNodes.item(i).toElement().tagName()=="lastaccess")
entry->setLastAccess(KpxDateTime::fromString(ChildNodes.item(i).toElement().text(),Qt::ISODate));
else if(ChildNodes.item(i).toElement().tagName()=="lastmod")
entry->setLastMod(KpxDateTime::fromString(ChildNodes.item(i).toElement().text(),Qt::ISODate));
else if(ChildNodes.item(i).toElement().tagName()=="expire")
entry->setExpire(KpxDateTime::fromString(ChildNodes.item(i).toElement().text(),Qt::ISODate));
else if(ChildNodes.item(i).toElement().tagName()=="bindesc")
entry->setBinaryDesc(ChildNodes.item(i).toElement().text());
else if(ChildNodes.item(i).toElement().tagName()=="bin")
entry->setBinary(QByteArray::fromBase64(ChildNodes.item(i).toElement().text().toAscii()));
else if(ChildNodes.item(i).toElement().tagName()=="comment"){
QDomNodeList Lines=ChildNodes.item(i).childNodes();
QString comment;
for(int i=0;i<Lines.size();i++){
if(Lines.item(i).isText())
comment+=Lines.item(i).toText().data();
else if(Lines.item(i).toElement().tagName()=="br")
comment+="\n";
else{
qWarning("Import_KeePassX_Xml: Error: Comment element contains invalid nodes.");
return false;
}
}
entry->setComment(comment);
}
}
return true;
}

41
src/import/Import_KeePassX_Xml.h
Unescape View File

@ -0,0 +1,41 @@
/***************************************************************************
* Copyright (C) 2007 by Tarek Saidi *
* tarek.saidi@arcor.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef _IMPORT_KPX_XML_H_
#define _IMPORT_KPX_XML_H_
#include <QDomElement>
#include "Import.h"
class Import_KeePassX_Xml:public IImport, public ImporterBase{
public:
virtual bool importDatabase(QWidget* GuiParent, IDatabase* Database);
virtual QString identifier(){return "KeePassX_Xml";}
virtual QString title(){return "KeePassX XML (*.xml)";}
private:
bool parseGroup(const QDomElement& GroupElement,IGroupHandle* ParentGroup);
bool parseEntry(const QDomElement& EntryElement,IGroupHandle* Group);
IDatabase* db;
QWidget* GuiParent;
};
#endif

35
src/lib/EntryView.cpp
Unescape View File

@ -476,11 +476,11 @@ resizeColumns();
}
void KeepassEntryView::mousePressEvent(QMouseEvent *event){
//save event position - maybe this is the start of a drag
if (event->button() == Qt::LeftButton)
DragStartPos = event->pos();
//call base function
QTreeWidget::mousePressEvent(event);
//save event position - maybe this is the start of a drag
if (event->button() == Qt::LeftButton)
DragStartPos = event->pos();
//call base function
QTreeWidget::mousePressEvent(event);
}
void KeepassEntryView::mouseMoveEvent(QMouseEvent *event){
@ -574,27 +574,24 @@ bool EntryViewItem::operator<(const QTreeWidgetItem& other)const{
else
return false;
}
QDateTime DateThis;
QDateTime DateOther;
KpxDateTime DateThis;
KpxDateTime DateOther;
//@NICHTVERGESSEN
return false;
/*
switch(SortCol){
case 5: DateThis=&pEntry->Expire;
DateOther=&((EntryViewItem&)other).pEntry->Expire;
case 5: DateThis=EntryHandle->expire();
DateOther=((EntryViewItem&)other).EntryHandle->expire();
break;
case 6: DateThis=&pEntry->Creation;
DateOther=&((EntryViewItem&)other).pEntry->Creation;
case 6: DateThis=EntryHandle->creation();
DateOther=((EntryViewItem&)other).EntryHandle->creation();
break;
case 7: DateThis=&pEntry->LastMod;
DateOther=&((EntryViewItem&)other).pEntry->LastMod;
case 7: DateThis=EntryHandle->lastMod();
DateOther=((EntryViewItem&)other).EntryHandle->lastMod();
break;
case 8: DateThis=&pEntry->LastAccess;
DateOther=&((EntryViewItem&)other).pEntry->LastAccess;
case 8: DateThis=EntryHandle->lastAccess();
DateOther=((EntryViewItem&)other).EntryHandle->lastAccess();
break;
default:Q_ASSERT(false);
}
return DateThis < DateOther;
*/
}

8
src/mainwindow.cpp
Unescape View File

@ -398,7 +398,7 @@ void KeepassMainWindow::OnFileNewKdb(){
IDatabase* db_new=dynamic_cast<IDatabase*>(new StandardDatabase());
db_new->create();
CPasswordDialog dlg(this,db_new,false,true);
dlg.setWindowTitle("New Database");
dlg.setWindowTitle(tr("New Database"));
if(dlg.exec()==1){
if(FileOpen)
if(!closeDatabase())return;
@ -694,6 +694,12 @@ void KeepassMainWindow::OnImport(QAction* action){
IDatabase* tmpdb=dynamic_cast<IDatabase*>(new StandardDatabase());
tmpdb->create();
if(dynamic_cast<IImport*>(action->data().value<QObject*>())->importDatabase(this,tmpdb)){
CPasswordDialog dlg(this,tmpdb,false,true);
dlg.setWindowTitle(tr("Set Master Key"));
if(!dlg.exec()){
delete tmpdb;
return;
}
db=tmpdb;
GroupView->db=db;
EntryView->db=db;