git.maemo.org Git - keepassx/blob - src/Kdb3Database.h

   1 /***************************************************************************
   2  *   Copyright (C) 2005-2007 by Tarek Saidi                                *
   3  *   tarek.saidi@arcor.de                                                  *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; version 2 of the License.               *
   8  *                                                                         *
   9  *   This program is distributed in the hope that it will be useful,       *
  10  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  11  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  12  *   GNU General Public License for more details.                          *
  13  *                                                                         *
  14  *   You should have received a copy of the GNU General Public License     *
  15  *   along with this program; if not, write to the                         *
  16  *   Free Software Foundation, Inc.,                                       *
  17  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  18  ***************************************************************************/
  19
  20 #ifndef _STD_DATABASE_H_
  21 #define _STD_DATABASE_H_
  22
  23 #include <QThread>
  24
  25 #define DB_HEADER_SIZE  124
  26 #define PWM_DBSIG_1             0x9AA2D903
  27 #define PWM_DBSIG_2     0xB54BFB65
  28 #define PWM_DBVER_DW    0x00030002
  29 #define PWM_FLAG_SHA2                   1
  30 #define PWM_FLAG_RIJNDAEL               2
  31 #define PWM_FLAG_ARCFOUR                4
  32 #define PWM_FLAG_TWOFISH                8
  33 #define PWM_STD_KEYENCROUNDS    6000
  34
  35 void memcpyFromLEnd32(quint32* dst,const char* src);
  36 void memcpyFromLEnd16(quint16* dst,const char* src);
  37 void memcpyToLEnd32(char* src,const quint32* dst);
  38 void memcpyToLEnd16(char* src,const quint16* dst);
  39
  40 //! Implementation of the standard KeePassX database.
  41 class Kdb3Database:public ICustomIcons,public IDatabase, public IKdbSettings{
  42 Q_OBJECT
  43 public:
  44         class StdGroup;
  45         class StdEntry;
  46         class EntryHandle:public IEntryHandle{
  47
  48                 friend class Kdb3Database;
  49                 public:
  50                         EntryHandle(Kdb3Database* db);
  51                         virtual void setImage(const quint32& ImageID);
  52                         virtual void setTitle(const QString& Title);
  53                         virtual void setUrl(const QString& URL);
  54                         virtual void setUsername(const QString& Username);
  55                         virtual void setPassword(const SecString& Password);
  56                         virtual void setComment(const QString& Comment);
  57                         virtual void setBinaryDesc(const QString& BinaryDesc);
  58                         virtual void setCreation(const KpxDateTime& Creation);
  59                         virtual void setLastMod(const KpxDateTime& LastMod);
  60                         virtual void setLastAccess(const KpxDateTime& LastAccess);
  61                         virtual void setExpire(const KpxDateTime& Expire);
  62                         virtual void setBinary(const QByteArray& BinaryData);
  63                         virtual KpxUuid uuid()const;
  64                         virtual IGroupHandle* group()const;
  65                         virtual quint32 image()const;
  66                         virtual int visualIndex() const;
  67                         virtual void setVisualIndex(int i);
  68                         virtual void setVisualIndexDirectly(int i);
  69                         virtual QString title()const;
  70                         virtual QString url()const;
  71                         virtual QString username()const;
  72                         virtual SecString password()const;
  73                         virtual QString comment()const;
  74                         virtual QString binaryDesc()const;
  75                         virtual KpxDateTime creation()const;
  76                         virtual KpxDateTime lastMod()const;
  77                         virtual KpxDateTime lastAccess()const;
  78                         virtual KpxDateTime expire()const;
  79                         virtual QByteArray binary()const;
  80                         virtual quint32 binarySize()const;
  81                         virtual QString friendlySize()const;
  82                         virtual bool isValid() const;
  83                         virtual CEntry data()const;
  84                 private:
  85                         void invalidate(){valid=false;}
  86                         bool valid;
  87                         //KpxUuid Uuid; ???
  88                         Kdb3Database* pDB;
  89                         StdEntry* Entry;
  90         };
  91
  92         class GroupHandle:public IGroupHandle{
  93                 friend class Kdb3Database;
  94                 GroupHandle(Kdb3Database* db);
  95                 public:
  96                         virtual void setTitle(const QString& Title);
  97                         virtual void setImage(const quint32& ImageId);
  98                         virtual QString title();
  99                         virtual quint32 image();
 100                         virtual bool isValid();
 101                         virtual IGroupHandle* parent();
 102                         virtual QList<IGroupHandle*> children();
 103                         virtual int index();
 104                         //virtual void setIndex(int index);
 105                         virtual int level();
 106                         virtual bool expanded();
 107                         virtual void setExpanded(bool IsExpanded);
 108                 private:
 109                         void invalidate(){valid=false;}
 110                         bool valid;
 111                         StdGroup* Group;
 112                         Kdb3Database* pDB;
 113         };
 114
 115         friend class EntryHandle;
 116         friend class GroupHandle;
 117
 118         class StdEntry:public CEntry{
 119                 public:
 120                                 StdEntry();
 121                                 quint16 Index;
 122                                 EntryHandle* Handle;
 123                                 StdGroup* Group;
 124         };
 125
 126         class StdGroup:public CGroup{
 127                 public:
 128                         StdGroup();
 129                         StdGroup(const CGroup&);
 130                         quint16 Index;
 131                         StdGroup* Parent;
 132                         GroupHandle* Handle;
 133                         QList<StdGroup*> Children;
 134                         QList<StdEntry*> Entries;
 135         };
 136
 137         Kdb3Database();
 138         virtual ~Kdb3Database(){};
 139         virtual bool load(QString identifier, bool readOnly);
 140         virtual bool save();
 141         virtual bool saveFileTransactional(char* buffer, int size);
 142         virtual bool close();
 143         virtual void create();
 144         virtual int numEntries();
 145         virtual int numGroups();
 146         virtual QString getError();
 147         virtual bool isKeyError();
 148         virtual void cleanUpHandles();
 149         virtual QPixmap& icon(int index);
 150         virtual int numIcons();
 151         virtual void addIcon(const QPixmap& icon);
 152         virtual void removeIcon(int index);
 153         virtual void replaceIcon(int index,const QPixmap& icon);
 154         virtual int builtinIcons(){return BUILTIN_ICONS;};
 155         virtual QList<IEntryHandle*> search(IGroupHandle* Group,const QString& SearchString, bool CaseSensitve, bool RegExp,bool Recursive,bool* Fields);
 156         virtual QFile* file(){return File;}
 157         virtual bool changeFile(const QString& filename);
 158         virtual void setCryptAlgorithm(CryptAlgorithm algo){Algorithm=algo;}
 159         virtual CryptAlgorithm cryptAlgorithm(){return Algorithm;}
 160         virtual unsigned int keyTransfRounds(){return KeyTransfRounds;}
 161         virtual void setKeyTransfRounds(unsigned int rounds){KeyTransfRounds=rounds;}
 162         virtual bool setKey(const QString& password, const QString& keyfile);
 163         virtual bool setPasswordKey(const QString& password);
 164         virtual bool setFileKey(const QString& filename);
 165         virtual bool setCompositeKey(const QString& password,const QString& filename);
 166
 167         virtual QList<IEntryHandle*> entries();
 168         virtual QList<IEntryHandle*> entries(IGroupHandle* Group);
 169         virtual QList<IEntryHandle*> entriesSortedStd(IGroupHandle* Group);
 170         virtual QList<IEntryHandle*> expiredEntries();
 171
 172         virtual IEntryHandle* cloneEntry(const IEntryHandle* entry);
 173         virtual void deleteEntry(IEntryHandle* entry);
 174         virtual void deleteEntries(QList<IEntryHandle*> entries);
 175         virtual IEntryHandle* newEntry(IGroupHandle* group);
 176         virtual IEntryHandle* addEntry(const CEntry* NewEntry, IGroupHandle* group);
 177         virtual void moveEntry(IEntryHandle* entry, IGroupHandle* group);
 178         virtual void deleteLastEntry();
 179
 180
 181         virtual QList<IGroupHandle*> groups();
 182         virtual QList<IGroupHandle*> sortedGroups();
 183         virtual void deleteGroup(IGroupHandle* group);
 184         virtual void moveGroup(IGroupHandle* Group,IGroupHandle* NewParent,int Position);
 185         virtual IGroupHandle* addGroup(const CGroup* Group,IGroupHandle* Parent);
 186         virtual IGroupHandle* backupGroup(bool create=false);
 187         virtual bool isParent(IGroupHandle* parent, IGroupHandle* child);
 188
 189         virtual void generateMasterKey();
 190         //virtual IDatabase* groupToNewDb(IGroupHandle* group);
 191
 192         inline bool hasPasswordEncodingChanged() { return passwordEncodingChanged; };
 193
 194 private:
 195         bool loadReal(QString filename, bool readOnly, bool differentEncoding);
 196         QDateTime dateFromPackedStruct5(const unsigned char* pBytes);
 197         void dateToPackedStruct5(const QDateTime& datetime, unsigned char* dst);
 198         bool isMetaStream(StdEntry& Entry);
 199         bool parseMetaStream(const StdEntry& Entry);
 200         void parseCustomIconsMetaStream(const QByteArray& data);
 201         void parseCustomIconsMetaStreamV3(const QByteArray& data);
 202         void parseGroupTreeStateMetaStream(const QByteArray& data);
 203         void createCustomIconsMetaStream(StdEntry* e);
 204         void createGroupTreeStateMetaStream(StdEntry* e);
 205         bool readEntryField(StdEntry* entry, quint16 FieldType, quint32 FieldSize, quint8 *pData);
 206         bool readGroupField(StdGroup* group,QList<quint32>& Levels,quint16 FieldType, quint8 *pData);
 207         bool createGroupTree(QList<quint32>& Levels);
 208         void createHandles();
 209         void invalidateHandle(StdEntry* entry);
 210         bool convHexToBinaryKey(char* HexKey, char* dst);
 211         quint32 getNewGroupId();
 212         void serializeEntries(QList<StdEntry>& EntryList,char* buffer,unsigned int& pos);
 213         void serializeGroups(char* buffer,unsigned int& pos);
 214         void appendChildrenToGroupList(QList<StdGroup*>& list,StdGroup& group);
 215         void appendChildrenToGroupList(QList<IGroupHandle*>& list,StdGroup& group);
 216         bool searchStringContains(const QString& search, const QString& string,bool Cs, bool RegExp);
 217         void getEntriesRecursive(IGroupHandle* Group, QList<IEntryHandle*>& EntryList);
 218         void rebuildIndices(QList<StdGroup*>& list);
 219         void restoreGroupTreeState();
 220         //void copyTree(Kdb3Database* db, GroupHandle* orgGroup, IGroupHandle* parent);
 221         static bool EntryHandleLessThan(const IEntryHandle* This,const IEntryHandle* Other);
 222         static bool EntryHandleLessThanStd(const IEntryHandle* This,const IEntryHandle* Other);
 223         static bool StdEntryLessThan(const Kdb3Database::StdEntry& This,const Kdb3Database::StdEntry& Other);
 224
 225         StdEntry* getEntry(const KpxUuid& uuid);
 226         StdEntry* getEntry(EntryHandle* handle);
 227         int getEntryListIndex(EntryHandle* handle);
 228         EntryHandle* getHandle(StdEntry* entry);
 229
 230         StdGroup* getGroup(quint32 Id);
 231         void deleteGroup(StdGroup* group);
 232
 233         QList<EntryHandle> EntryHandles;
 234         QList<GroupHandle> GroupHandles;
 235         QList<StdEntry> Entries;
 236         QList<StdGroup> Groups;
 237         StdGroup RootGroup;
 238         QList<QPixmap>CustomIcons;
 239         QFile* File;
 240         bool openedReadOnly;
 241         QString error;
 242         bool KeyError;
 243         bool PotentialEncodingIssueLatin1;
 244         bool PotentialEncodingIssueUTF8;
 245         QList<StdEntry> UnknownMetaStreams;
 246         QMap<quint32,bool> TreeStateMetaStream;
 247         unsigned int KeyTransfRounds;
 248         CryptAlgorithm Algorithm;
 249         SecData RawMasterKey;
 250         SecData RawMasterKey_CP1252;
 251         SecData RawMasterKey_Latin1;
 252         SecData RawMasterKey_UTF8;
 253         SecData MasterKey;
 254         quint8 TransfRandomSeed[32];
 255         bool hasV4IconMetaStream;
 256         bool passwordEncodingChanged;
 257 };
 258
 259 class KeyTransform : public QThread{
 260         Q_OBJECT
 261
 262         public:
 263                 static void transform(quint8* src, quint8* dst, quint8* KeySeed, int rounds);
 264
 265         private:
 266                 KeyTransform(quint8* pSrc, quint8* pDst, quint8* pKeySeed, int pRounds);
 267                 quint8* src;
 268                 quint8* dst;
 269                 quint8* KeySeed;
 270                 int rounds;
 271
 272         protected:
 273                 void run();
 274 };
 275
 276 class KeyTransformBenchmark : public QThread{
 277         Q_OBJECT
 278
 279         public:
 280                 static int benchmark(int pMSecs);
 281
 282         private:
 283                 KeyTransformBenchmark(int pMSecs);
 284                 int msecs;
 285                 int rounds;
 286
 287         protected:
 288                 void run();
 289 };
 290
 291 #endif