pwmanager.h

来自「一款密码保险箱源码」· C头文件 代码 · 共 556 行 · 第 1/2 页

	DWORD dwKeyEncRounds;
} PW_DBHEADER, *PPW_DBHEADER;

typedef struct _PW_GROUP // Structure containing information about one group
{
	DWORD uGroupId;
	DWORD uImageId;
	TCHAR *pszGroupName;

	PW_TIME tCreation;
	PW_TIME tLastMod;
	PW_TIME tLastAccess;
	PW_TIME tExpire;

	USHORT usLevel;

#ifdef VPF_ALIGN
	USHORT usDummy;
#endif

	DWORD dwFlags; // Used by KeePass internally, don't use
} PW_GROUP, *PPW_GROUP;

typedef struct _PW_ENTRY // Structure containing information about one entry
{
	BYTE uuid[16];
	DWORD uGroupId;
	DWORD uImageId;

	TCHAR *pszTitle;
	TCHAR *pszURL;
	TCHAR *pszUserName;

	DWORD uPasswordLen;
	TCHAR *pszPassword;

	TCHAR *pszAdditional;

	PW_TIME tCreation;
	PW_TIME tLastMod;
	PW_TIME tLastAccess;
	PW_TIME tExpire;

	TCHAR *pszBinaryDesc; // A string describing what is in pBinaryData
	BYTE *pBinaryData;
	DWORD uBinaryDataLen;
} PW_ENTRY, *PPW_ENTRY;

typedef struct _PW_UUID_STRUCT
{
	BYTE uuid[16];
} PW_UUID_STRUCT;

typedef struct _PMS_SIMPLE_UI_STATE
{
	DWORD uLastSelectedGroupId;
	DWORD uLastTopVisibleGroupId;
	BYTE aLastSelectedEntryUuid[16];
	BYTE aLastTopVisibleEntryUuid[16];
	DWORD dwReserved01;
	DWORD dwReserved02;
	DWORD dwReserved03;
	DWORD dwReserved04;
	DWORD dwReserved05;
	DWORD dwReserved06;
	DWORD dwReserved07;
	DWORD dwReserved08;
	DWORD dwReserved09;
	DWORD dwReserved10;
	DWORD dwReserved11;
	DWORD dwReserved12;
	DWORD dwReserved13;
	DWORD dwReserved14;
	DWORD dwReserved15;
	DWORD dwReserved16;
} PMS_SIMPLE_UI_STATE;

typedef struct _PWDB_REPAIR_INFO
{
	DWORD dwOriginalGroupCount;
	DWORD dwOriginalEntryCount;
	DWORD dwRecognizedMetaStreamCount;
} PWDB_REPAIR_INFO, *PPWDB_REPAIR_INFO;

typedef struct _PWDB_META_STREAM
{
	std::basic_string<TCHAR> strName;
	std::vector<BYTE> vData;
} PWDB_META_STREAM;

#pragma pack()

#ifdef _DEBUG
#define ASSERT_ENTRY(pp) ASSERT((pp) != NULL); ASSERT((pp)->pszTitle != NULL); \
	ASSERT((pp)->pszUserName != NULL); ASSERT((pp)->pszURL != NULL); \
	ASSERT((pp)->pszPassword != NULL); ASSERT((pp)->pszAdditional != NULL); \
	ASSERT((pp)->pszBinaryDesc != NULL); \
	if(((pp)->uBinaryDataLen != 0) && ((pp)->pBinaryData == NULL)) { ASSERT(FALSE); }
#else
#define ASSERT_ENTRY(pp)
#endif
#ifndef DWORD_MAX
#define DWORD_MAX 0xFFFFFFFF
#endif

class CPP_CLASS_SHARE CPwManager
{
public:
	CPwManager();
	virtual ~CPwManager();

	void InitPrimaryInstance();

	// Set the master key for the database.
	int SetMasterKey(const TCHAR *pszMasterKey, BOOL bDiskDrive, const TCHAR *pszSecondKey, const CNewRandomInterface *pARI, BOOL bOverwrite);

	DWORD GetNumberOfEntries() const; // Returns number of entries in database
	DWORD GetNumberOfGroups() const; // Returns number of groups in database

	// Count items in groups
	DWORD GetNumberOfItemsInGroup(const TCHAR *pszGroup) const;
	DWORD GetNumberOfItemsInGroupN(DWORD idGroup) const;

	// Access entry information
	PW_ENTRY *GetEntry(DWORD dwIndex);
	PW_ENTRY *GetEntryByGroup(DWORD idGroup, DWORD dwIndex);
	DWORD GetEntryByGroupN(DWORD idGroup, DWORD dwIndex) const;
	PW_ENTRY *GetEntryByUuid(const BYTE *pUuid);
	DWORD GetEntryByUuidN(const BYTE *pUuid) const; // Returns the index of the item with pUuid
	DWORD GetEntryPosInGroup(__in_ecount(1) const PW_ENTRY *pEntry) const;
	PW_ENTRY *GetLastEditedEntry();

	// Access group information
	PW_GROUP *GetGroup(DWORD dwIndex);
	PW_GROUP *GetGroupById(DWORD idGroup);
	DWORD GetGroupByIdN(DWORD idGroup) const;
	DWORD GetGroupId(const TCHAR *pszGroupName) const;
	DWORD GetGroupIdByIndex(DWORD uGroupIndex) const;
	DWORD GetLastChildGroup(DWORD dwParentGroupIndex) const;
	BOOL GetGroupTree(DWORD idGroup, DWORD *pGroupIndexes) const;

	// Add entries and groups
	BOOL AddGroup(__in_ecount(1) const PW_GROUP *pTemplate);
	BOOL AddEntry(__in_ecount(1) const PW_ENTRY *pTemplate);
	BOOL BackupEntry(__in_ecount(1) const PW_ENTRY *pe, __out_opt
		BOOL *pbGroupCreated); // pe must be unlocked already

	// Delete entries and groups
	BOOL DeleteEntry(DWORD dwIndex);
	BOOL DeleteGroupById(DWORD uGroupId);

	BOOL SetGroup(DWORD dwIndex, __in_ecount(1) const PW_GROUP *pTemplate);
	BOOL SetEntry(DWORD dwIndex, __in_ecount(1) const PW_ENTRY *pTemplate);
	// DWORD MakeGroupTree(LPCTSTR lpTreeString, TCHAR tchSeparator);

	// Use these functions to make passwords in PW_ENTRY structures readable
	void LockEntryPassword(__inout_ecount(1) PW_ENTRY *pEntry); // Lock password, encrypt it
	void UnlockEntryPassword(__inout_ecount(1) PW_ENTRY *pEntry); // Make password readable

	void NewDatabase();
	int OpenDatabase(const TCHAR *pszFile, __out_opt PWDB_REPAIR_INFO *pRepair);
	// int OpenDatabaseEx(const TCHAR *pszFile, __out_opt PWDB_REPAIR_INFO *pRepair,
	//	CPwErrorInfo *pErrorInfo);
	int SaveDatabase(const TCHAR *pszFile);

	// Move entries and groups
	void MoveInternal(DWORD dwFrom, DWORD dwTo);
	void MoveInGroup(DWORD idGroup, DWORD dwFrom, DWORD dwTo);
	BOOL MoveGroup(DWORD dwFrom, DWORD dwTo);

	// Sort entry and group lists
	void SortGroup(DWORD idGroup, DWORD dwSortByField);
	void SortGroupList();

	static BOOL MemAllocCopyEntry(__in_ecount(1) const PW_ENTRY *pExisting,
		__out_ecount(1) PW_ENTRY *pDestination);
	static void MemFreeEntry(__inout_ecount(1) PW_ENTRY *pEntry);

	void MergeIn(__inout_ecount(1) CPwManager *pDataSource, BOOL bCreateNewUUIDs,
		BOOL bCompareTimes);

	// Find an item
	DWORD Find(const TCHAR *pszFindString, BOOL bCaseSensitive, DWORD fieldFlags, DWORD nStart);

	// Get and set the algorithm used to encrypt the database
	BOOL SetAlgorithm(int nAlgorithm);
	int GetAlgorithm();

	DWORD GetKeyEncRounds() const;
	void SetKeyEncRounds(DWORD dwRounds);
	const PW_DBHEADER *GetLastDatabaseHeader() const;

	// Convert PW_TIME to 5-byte compressed structure and the other way round
	static void TimeToPwTime(__in_ecount(5) const BYTE *pCompressedTime,
		__out_ecount(1) PW_TIME *pPwTime);
	static void PwTimeToTime(__in_ecount(1) const PW_TIME *pPwTime,
		__out_ecount(5) BYTE *pCompressedTime);

	// Get the never-expire time
	static void GetNeverExpireTime(__out_ecount(1) PW_TIME *pPwTime);

	// Checks and corrects the group tree (level order, etc.)
	void FixGroupTree();
	int DeleteLostEntries();

	void SubstEntryGroupIds(DWORD dwExistingId, DWORD dwNewId);

	static BOOL AttachFileAsBinaryData(__inout_ecount(1) PW_ENTRY *pEntry,
		const TCHAR *lpFile);
	static BOOL SaveBinaryData(__in_ecount(1) const PW_ENTRY *pEntry,
		const TCHAR *lpFile);
	static BOOL RemoveBinaryData(__inout_ecount(1) PW_ENTRY *pEntry);

	static BOOL IsAllowedStoreGroup(LPCTSTR lpGroupName, LPCTSTR lpSearchGroupName);

	void GetRawMasterKey(__out_ecount(32) BYTE *pStorage) const;
	void SetRawMasterKey(__in_ecount(32) const BYTE *pNewKey);

	static BOOL IsZeroUUID(__in_ecount(16) const BYTE *pUUID);

	static BOOL IsTANEntry(const PW_ENTRY *pe);

	DWORD m_dwLastSelectedGroupId;
	DWORD m_dwLastTopVisibleGroupId;
	BYTE m_aLastSelectedEntryUuid[16];
	BYTE m_aLastTopVisibleEntryUuid[16];

protected:
	virtual BOOL ReadGroupField(USHORT usFieldType, DWORD dwFieldSize, const BYTE *pData, PW_GROUP *pGroup);
	virtual BOOL ReadEntryField(USHORT usFieldType, DWORD dwFieldSize, const BYTE *pData, PW_ENTRY *pEntry);

private:
	void CleanUp(); // Delete everything and release all allocated memory

	void _AllocEntries(DWORD uEntries);
	void _DeleteEntryList(BOOL bFreeStrings);
	void _AllocGroups(DWORD uGroups);
	void _DeleteGroupList(BOOL bFreeStrings);

	BOOL _OpenDatabaseV1(const TCHAR *pszFile);
	BOOL _OpenDatabaseV2(const TCHAR *pszFile);
	BOOL _ReadGroupFieldV2(USHORT usFieldType, DWORD dwFieldSize, BYTE *pData, PW_GROUP *pGroup);
	BOOL _ReadEntryFieldV2(USHORT usFieldType, DWORD dwFieldSize, BYTE *pData, PW_ENTRY *pEntry);

	BOOL _AddAllMetaStreams();
	DWORD _LoadAndRemoveAllMetaStreams(bool bAcceptUnknown);
	BOOL _AddMetaStream(LPCTSTR lpMetaDataDesc, BYTE *pData, DWORD dwLength);
	BOOL _IsMetaStream(const PW_ENTRY *p) const;
	void _ParseMetaStream(PW_ENTRY *p, bool bAcceptUnknown);
	BOOL _CanIgnoreUnknownMetaStream(const PWDB_META_STREAM& msUnknown) const;

	// Encrypt the master key a few times to make brute-force key-search harder
	BOOL _TransformMasterKey(const BYTE *pKeySeed);

	PW_ENTRY *m_pEntries; // List containing all entries
	DWORD m_dwMaxEntries; // Maximum number of items that can be stored in the list
	DWORD m_dwNumEntries; // Current number of items stored in the list

	PW_GROUP *m_pGroups; // List containing all groups
	DWORD m_dwMaxGroups; // Maximum number of groups that can be stored in the list
	DWORD m_dwNumGroups; // Current number of groups stored in the list

	PW_DBHEADER m_dbLastHeader;
	PW_ENTRY *m_pLastEditedEntry; // Last modified entry, use GetLastEditedEntry() to get it

	CNewRandom m_random; // Pseudo-random number generator

	BYTE m_pSessionKey[PWM_SESSION_KEY_SIZE]; // Used for in-memory encryption of passwords
	BYTE m_pMasterKey[32]; // Master key used to encrypt the whole database
	BYTE m_pTransformedMasterKey[32]; // Master key encrypted several times
	int m_nAlgorithm; // Algorithm used to encrypt the database
	DWORD m_dwKeyEncRounds;

	std::vector<PWDB_META_STREAM> m_vUnknownMetaStreams;
};

#endif // ___KEEPASS_PASSWORD_MANAGER_H___