/*

* Copyright (C) 2024 KeePassXC Team <[email protected]>

* Copyright (C) 2010 Felix Geyer <[email protected]>

*

* 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 or (at your option)

* version 3 of the License.

*

* 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, see <http://www.gnu.org/licenses/>.

*/

#include "Entry.h"

#include "core/Config.h"

#include "core/Database.h"

#include "core/Global.h"

#include "core/Group.h"

#include "core/Metadata.h"

#include "core/PasswordHealth.h"

#include "core/Tools.h"

#include "core/Totp.h"

#include <QDir>

#include <QRegularExpression>

#include <QStringBuilder>

#include <QUrl>

const int Entry::DefaultIconNumber = 0;

namespace

{

const int ResolveMaximumDepth = 10;

const QString AutoTypeSequenceUsername = "{USERNAME}{ENTER}";

const QString AutoTypeSequencePassword = "{PASSWORD}{ENTER}";

const QRegularExpression TagDelimiterRegex(R"([,;\t])");

} // namespace

Entry::Entry()

: m_attributes(new EntryAttributes(this))

, m_attachments(new EntryAttachments(this))

, m_autoTypeAssociations(new AutoTypeAssociations(this))

, m_customData(new CustomData(this))

, m_modifiedSinceBegin(false)

, m_updateTimeinfo(true)

{

m_data.iconNumber = DefaultIconNumber;

m_data.autoTypeEnabled = true;

m_data.autoTypeObfuscation = 0;

m_data.excludeFromReports = false;

connect(m_attributes, &EntryAttributes::modified, this, &Entry::updateTotp);

connect(m_attributes, &EntryAttributes::modified, this, &Entry::modified);

connect(m_attributes, &EntryAttributes::defaultKeyModified, this, &Entry::emitDataChanged);

connect(m_attachments, &EntryAttachments::modified, this, &Entry::modified);

connect(m_autoTypeAssociations, &AutoTypeAssociations::modified, this, &Entry::modified);

connect(m_customData, &CustomData::modified, this, &Entry::modified);

connect(this, &Entry::modified, this, &Entry::updateTimeinfo);

connect(this, &Entry::modified, this, &Entry::updateModifiedSinceBegin);

}

Entry::~Entry()

{

setUpdateTimeinfo(false);

if (m_group) {

m_group->removeEntry(this);

if (m_group->database()) {

m_group->database()->addDeletedObject(m_uuid);

}

}

qDeleteAll(m_history);

}

template <class T> inline bool Entry::set(T& property, const T& value)

{

if (property != value) {

property = value;

emitModified();

return true;

}

return false;

}

void Entry::updateTimeinfo()

{

if (m_updateTimeinfo) {

m_data.timeInfo.setLastModificationTime(Clock::currentDateTimeUtc());

m_data.timeInfo.setLastAccessTime(Clock::currentDateTimeUtc());

}

}

bool Entry::canUpdateTimeinfo() const

{

return m_updateTimeinfo;

}

void Entry::setUpdateTimeinfo(bool value)

{

m_updateTimeinfo = value;

}

QString Entry::buildReference(const QUuid& uuid, const QString& field)

{

Q_ASSERT(EntryAttributes::DefaultAttributes.count(field) > 0);

QString uuidStr = Tools::uuidToHex(uuid).toUpper();

QString shortField;

if (field == EntryAttributes::TitleKey) {

shortField = "T";

} else if (field == EntryAttributes::UserNameKey) {

shortField = "U";

} else if (field == EntryAttributes::PasswordKey) {

shortField = "P";

} else if (field == EntryAttributes::URLKey) {

shortField = "A";

} else if (field == EntryAttributes::NotesKey) {

shortField = "N";

}

if (shortField.isEmpty()) {

return {};

}

return QString("{REF:%1@I:%2}").arg(shortField, uuidStr);

}

EntryReferenceType Entry::referenceType(const QString& referenceStr)

{

const QString referenceLowerStr = referenceStr.toLower();

EntryReferenceType result = EntryReferenceType::Unknown;

if (referenceLowerStr == QLatin1String("t")) {

result = EntryReferenceType::Title;

} else if (referenceLowerStr == QLatin1String("u")) {

result = EntryReferenceType::UserName;

} else if (referenceLowerStr == QLatin1String("p")) {

result = EntryReferenceType::Password;

} else if (referenceLowerStr == QLatin1String("a")) {

result = EntryReferenceType::Url;

} else if (referenceLowerStr == QLatin1String("n")) {

result = EntryReferenceType::Notes;

} else if (referenceLowerStr == QLatin1String("i")) {

result = EntryReferenceType::QUuid;

} else if (referenceLowerStr == QLatin1String("o")) {

result = EntryReferenceType::CustomAttributes;

}

return result;

}

const QUuid& Entry::uuid() const

{

return m_uuid;

}

const QString Entry::uuidToHex() const

{

return Tools::uuidToHex(m_uuid);

}

int Entry::iconNumber() const

{

return m_data.iconNumber;

}

const QUuid& Entry::iconUuid() const

{

return m_data.customIcon;

}

QString Entry::foregroundColor() const

{

return m_data.foregroundColor;

}

QString Entry::backgroundColor() const

{

return m_data.backgroundColor;

}

QString Entry::overrideUrl() const

{

return m_data.overrideUrl;

}

QString Entry::tags() const

{

return m_data.tags.join(",");

}

QStringList Entry::tagList() const

{

return m_data.tags;

}

const TimeInfo& Entry::timeInfo() const

{

return m_data.timeInfo;

}

bool Entry::autoTypeEnabled() const

{

return m_data.autoTypeEnabled;

}

bool Entry::groupAutoTypeEnabled() const

{

return group() && group()->resolveAutoTypeEnabled();

}

int Entry::autoTypeObfuscation() const

{

return m_data.autoTypeObfuscation;

}

QString Entry::defaultAutoTypeSequence() const

{

return m_data.defaultAutoTypeSequence;

}

const QSharedPointer<PasswordHealth> Entry::passwordHealth()

{

if (!m_data.passwordHealth) {

m_data.passwordHealth.reset(new PasswordHealth(resolvePlaceholder(password())));

}

return m_data.passwordHealth;

}

const QSharedPointer<PasswordHealth> Entry::passwordHealth() const

{

if (!m_data.passwordHealth) {

return QSharedPointer<PasswordHealth>::create(resolvePlaceholder(password()));

}

return m_data.passwordHealth;

}

bool Entry::excludeFromReports() const

{

return m_data.excludeFromReports

|| (customData()->contains(CustomData::ExcludeFromReportsLegacy)

&& customData()->value(CustomData::ExcludeFromReportsLegacy) == TRUE_STR);

}

void Entry::setExcludeFromReports(bool state)

{

set(m_data.excludeFromReports, state);

}

/**

* Determine the effective sequence that will be injected

* This function return an empty string if a parent group has autotype disabled or if the entry has no parent

*/

QString Entry::effectiveAutoTypeSequence() const

{

if (!autoTypeEnabled()) {

return {};

}

const Group* parent = group();

if (!parent) {

return {};

}

QString sequence = parent->effectiveAutoTypeSequence();

if (sequence.isEmpty()) {

return {};

}

if (!m_data.defaultAutoTypeSequence.isEmpty()) {

return m_data.defaultAutoTypeSequence;

}

if (sequence == Group::RootAutoTypeSequence && (!username().isEmpty() || !password().isEmpty())) {

if (username().isEmpty()) {

return AutoTypeSequencePassword;

} else if (password().isEmpty()) {

return AutoTypeSequenceUsername;

}

return Group::RootAutoTypeSequence;

}

return sequence;

}

/**

* Retrieve the Auto-Type sequences matches for a given windowTitle

* This returns a list with priority ordering. If you don't want duplicates, convert it to a QSet<QString>.

*/

QList<QString> Entry::autoTypeSequences(const QString& windowTitle) const

{

// If no window just return the effective sequence

if (windowTitle.isEmpty()) {

return {effectiveAutoTypeSequence()};

}

// Define helper functions to match window titles

auto windowMatches = [&](const QString& pattern) {

// Regex searching

if (pattern.startsWith("//") && pattern.endsWith("//") && pattern.size() >= 4) {

QRegularExpression regExp(pattern.mid(2, pattern.size() - 4), QRegularExpression::CaseInsensitiveOption);

return regExp.match(windowTitle).hasMatch();

}

// Wildcard searching

const auto regExp = Tools::convertToRegex(

pattern, Tools::RegexConvertOpts::EXACT_MATCH | Tools::RegexConvertOpts::WILDCARD_UNLIMITED_MATCH);

return regExp.match(windowTitle).hasMatch();

};

auto windowMatchesTitle = [&](const QString& entryTitle) {

return !entryTitle.isEmpty() && windowTitle.contains(entryTitle, Qt::CaseInsensitive);

};

auto windowMatchesUrl = [&](const QString& entryUrl) {

if (!entryUrl.isEmpty() && windowTitle.contains(entryUrl, Qt::CaseInsensitive)) {

return true;

}

QUrl url(entryUrl);

if (url.isValid() && !url.host().isEmpty()) {

return windowTitle.contains(url.host(), Qt::CaseInsensitive);

}

return false;

};

QList<QString> sequenceList;

QList<QString> emptyWindowSequences;

// Add window association matches

const auto assocList = autoTypeAssociations()->getAll();

for (const auto& assoc : assocList) {

auto window = resolveMultiplePlaceholders(assoc.window);

if (assoc.window.isEmpty()) {

emptyWindowSequences << assoc.sequence;

} else if (windowMatches(window)) {

if (!assoc.sequence.isEmpty()) {

sequenceList << assoc.sequence;

} else {

sequenceList << effectiveAutoTypeSequence();

}

}

}

// Try to match window title

if (config()->get(Config::AutoTypeEntryTitleMatch).toBool() && windowMatchesTitle(resolvePlaceholder(title()))) {

sequenceList << effectiveAutoTypeSequence();

}

// Try to match url in window title

if (config()->get(Config::AutoTypeEntryURLMatch).toBool() && windowMatchesUrl(resolvePlaceholder(url()))) {

sequenceList << effectiveAutoTypeSequence();

}

// If any associations were made, include the empty window associations

if (!sequenceList.isEmpty()) {

sequenceList.append(emptyWindowSequences);

}

return sequenceList;

}

AutoTypeAssociations* Entry::autoTypeAssociations()

{

return m_autoTypeAssociations;

}

const AutoTypeAssociations* Entry::autoTypeAssociations() const

{

return m_autoTypeAssociations;

}

QString Entry::title() const

{

return m_attributes->value(EntryAttributes::TitleKey);

}

QString Entry::url() const

{

return m_attributes->value(EntryAttributes::URLKey);

}

QString Entry::resolveUrl() const

{

const auto entryUrl = url();

if (entryUrl.isEmpty()) {

return {};

}

return EntryAttributes::matchReference(entryUrl).hasMatch() ? resolveMultiplePlaceholders(entryUrl) : entryUrl;

}

QStringList Entry::getAllUrls() const

{

QStringList urlList;

const auto entryUrl = resolveUrl();

if (!entryUrl.isEmpty()) {

urlList << entryUrl;

}

return urlList << getAdditionalUrls();

}

QStringList Entry::getAdditionalUrls() const

{

QStringList urlList;

for (const auto& key : m_attributes->keys()) {

if (key.startsWith(EntryAttributes::AdditionalUrlAttribute)

|| key == QString("%1_RELYING_PARTY").arg(EntryAttributes::PasskeyAttribute)) {

auto additionalUrl = m_attributes->value(key);

if (!additionalUrl.isEmpty()) {

urlList << resolveMultiplePlaceholders(additionalUrl);

}

}

}

return urlList;

}

QString Entry::webUrl() const

{

QString url = resolveMultiplePlaceholders(m_attributes->value(EntryAttributes::URLKey));

return resolveUrl(url);

}

QString Entry::displayUrl() const

{

QString url = maskPasswordPlaceholders(m_attributes->value(EntryAttributes::URLKey));

return resolveMultiplePlaceholders(url);

}

QString Entry::username() const

{

return m_attributes->value(EntryAttributes::UserNameKey);

}

QString Entry::password() const

{

return m_attributes->value(EntryAttributes::PasswordKey);

}

QString Entry::notes() const

{

return m_attributes->value(EntryAttributes::NotesKey);

}

QString Entry::attribute(const QString& key) const

{

return m_attributes->value(key);

}

int Entry::size() const

{

int size = 0;

size += attributes()->attributesSize();

size += autoTypeAssociations()->associationsSize();

size += attachments()->attachmentsSize();

size += customData()->dataSize();

for (const QString& tag : tags().split(TagDelimiterRegex, Qt::SkipEmptyParts)) {

size += tag.toUtf8().size();

}

return size;

}

bool Entry::isExpired() const

{

return willExpireInDays(0);

}

bool Entry::willExpireInDays(int days) const

{

return m_data.timeInfo.expires() && m_data.timeInfo.expiryTime() < Clock::currentDateTime().addDays(days);

}

void Entry::expireNow()

{

setExpiryTime(Clock::currentDateTimeUtc());

setExpires(true);

}

bool Entry::isRecycled() const

{

const Database* db = database();

if (!db) {

return false;

}

return m_group->isRecycled();

}

bool Entry::isAttributeReference(const QString& key) const

{

return m_attributes->isReference(key);

}

bool Entry::isAttributeReferenceOf(const QString& key, const QUuid& uuid) const

{

if (!m_attributes->isReference(key)) {

return false;

}

return m_attributes->value(key).contains(Tools::uuidToHex(uuid), Qt::CaseInsensitive);

}

bool Entry::hasReferences() const

{

for (const QString& key : EntryAttributes::DefaultAttributes) {

if (m_attributes->isReference(key)) {

return true;

}

}

return false;

}

bool Entry::hasReferencesTo(const QUuid& uuid) const

{

for (const QString& key : EntryAttributes::DefaultAttributes) {

if (isAttributeReferenceOf(key, uuid)) {

return true;

}

}

return false;

}

void Entry::replaceReferencesWithValues(const Entry* other)

{

for (const QString& key : EntryAttributes::DefaultAttributes) {

if (isAttributeReferenceOf(key, other->uuid())) {

setDefaultAttribute(key, other->attribute(key));

}

}

}

EntryAttributes* Entry::attributes()

{

return m_attributes;

}

const EntryAttributes* Entry::attributes() const

{

return m_attributes;

}

EntryAttachments* Entry::attachments()

{

return m_attachments;

}

const EntryAttachments* Entry::attachments() const

{

return m_attachments;

}

CustomData* Entry::customData()

{

return m_customData;

}

const CustomData* Entry::customData() const

{

return m_customData;

}

bool Entry::hasTotp() const

{

return !m_data.totpSettings.isNull();

}

bool Entry::hasValidTotp() const

{

auto error = Totp::checkValidSettings(m_data.totpSettings);

return error.isEmpty();

}

bool Entry::hasPasskey() const

{

return m_attributes->hasPasskey();

}

void Entry::removePasskey()

{

m_attributes->removePasskeyAttributes();

removeTag(tr("Passkey"));

}

QString Entry::totp(bool* isValid) const

{

if (hasTotp()) {

return Totp::generateTotp(m_data.totpSettings, isValid);

}

if (isValid) {

*isValid = false;

}

return {};

}

void Entry::setTotp(QSharedPointer<Totp::Settings> settings)

{

beginUpdate();

m_attributes->remove(Totp::ATTRIBUTE_OTP);

m_attributes->remove(Totp::ATTRIBUTE_SEED);

m_attributes->remove(Totp::ATTRIBUTE_SETTINGS);

if (!settings || settings->key.isEmpty()) {

m_data.totpSettings.reset();

} else {

m_data.totpSettings = std::move(settings);

auto text = Totp::writeSettings(

m_data.totpSettings, resolveMultiplePlaceholders(title()), resolveMultiplePlaceholders(username()));

if (m_data.totpSettings->format != Totp::StorageFormat::LEGACY) {

m_attributes->set(Totp::ATTRIBUTE_OTP, text, true);

} else {

m_attributes->set(Totp::ATTRIBUTE_SEED, m_data.totpSettings->key, true);

m_attributes->set(Totp::ATTRIBUTE_SETTINGS, text);

}

}

endUpdate();

}

void Entry::updateTotp()

{

if (m_attributes->contains(Totp::ATTRIBUTE_SETTINGS)) {

m_data.totpSettings = Totp::parseSettings(m_attributes->value(Totp::ATTRIBUTE_SETTINGS),

m_attributes->value(Totp::ATTRIBUTE_SEED));

} else if (m_attributes->contains(Totp::ATTRIBUTE_OTP)) {

m_data.totpSettings = Totp::parseSettings(m_attributes->value(Totp::ATTRIBUTE_OTP));

} else if (m_attributes->contains(Totp::KP2_TOTP_SECRET)) {

m_data.totpSettings = Totp::fromKeePass2Totp(m_attributes->value(Totp::KP2_TOTP_SECRET),

m_attributes->value(Totp::KP2_TOTP_ALGORITHM),

m_attributes->value(Totp::KP2_TOTP_LENGTH),

m_attributes->value(Totp::KP2_TOTP_PERIOD));

} else {

m_data.totpSettings.reset();

}

}

QSharedPointer<Totp::Settings> Entry::totpSettings() const

{

return m_data.totpSettings;

}

QString Entry::totpSettingsString() const

{

if (m_data.totpSettings) {

return Totp::writeSettings(

m_data.totpSettings, resolveMultiplePlaceholders(title()), resolveMultiplePlaceholders(username()), true);

}

return {};

}

QString Entry::path() const

{

auto path = group()->hierarchy();

path << title();

return path.mid(1).join("/");

}

void Entry::setUuid(const QUuid& uuid)

{

Q_ASSERT(!uuid.isNull());

set(m_uuid, uuid);

}

void Entry::setIcon(int iconNumber)

{

Q_ASSERT(iconNumber >= 0);

if (m_data.iconNumber != iconNumber || !m_data.customIcon.isNull()) {

m_data.iconNumber = iconNumber;

m_data.customIcon = QUuid();

emitModified();

emitDataChanged();

}

}

void Entry::setIcon(const QUuid& uuid)

{

Q_ASSERT(!uuid.isNull());

if (m_data.customIcon != uuid) {

m_data.customIcon = uuid;

m_data.iconNumber = 0;

emitModified();

emitDataChanged();

}

}

void Entry::setForegroundColor(const QString& colorStr)

{

set(m_data.foregroundColor, colorStr);

}

void Entry::setBackgroundColor(const QString& colorStr)

{

set(m_data.backgroundColor, colorStr);

}

void Entry::setOverrideUrl(const QString& url)

{

set(m_data.overrideUrl, url);

}

void Entry::setTags(const QString& tags)

{

auto taglist = tags.split(TagDelimiterRegex, Qt::SkipEmptyParts);

// Trim whitespace before/after tag text

for (auto& tag : taglist) {

tag = tag.trimmed();

}

// Remove duplicates

taglist = Tools::asSet(taglist).values();

// Sort alphabetically

taglist.sort();

set(m_data.tags, taglist);

}

void Entry::addTag(const QString& tag)

{

auto cleanTag = tag.trimmed();

cleanTag.remove(TagDelimiterRegex);

auto taglist = m_data.tags;

if (!taglist.contains(cleanTag)) {

taglist.append(cleanTag);

taglist.sort();

set(m_data.tags, taglist);

}

}

void Entry::removeTag(const QString& tag)

{

auto cleanTag = tag.trimmed();

cleanTag.remove(TagDelimiterRegex);

auto taglist = m_data.tags;

if (taglist.removeAll(tag) > 0) {

set(m_data.tags, taglist);

}

}

void Entry::setTimeInfo(const TimeInfo& timeInfo)

{

m_data.timeInfo = timeInfo;

}

void Entry::setAutoTypeEnabled(bool enable)

{

set(m_data.autoTypeEnabled, enable);

}

void Entry::setAutoTypeObfuscation(int obfuscation)

{

set(m_data.autoTypeObfuscation, obfuscation);

}

void Entry::setDefaultAutoTypeSequence(const QString& sequence)

{

set(m_data.defaultAutoTypeSequence, sequence);

}

void Entry::setTitle(const QString& title)

{

m_attributes->set(EntryAttributes::TitleKey, title, m_attributes->isProtected(EntryAttributes::TitleKey));

}

void Entry::setUrl(const QString& url)

{

bool remove = url != m_attributes->value(EntryAttributes::URLKey)

&& (m_attributes->value(EntryAttributes::RememberCmdExecAttr) == "1"

|| m_attributes->value(EntryAttributes::RememberCmdExecAttr) == "0");

if (remove) {

m_attributes->remove(EntryAttributes::RememberCmdExecAttr);

}

m_attributes->set(EntryAttributes::URLKey, url, m_attributes->isProtected(EntryAttributes::URLKey));

}

void Entry::setUsername(const QString& username)

{

m_attributes->set(EntryAttributes::UserNameKey, username, m_attributes->isProtected(EntryAttributes::UserNameKey));

}

void Entry::setPassword(const QString& password)

{

// Reset Password Health

m_data.passwordHealth.reset();

m_attributes->set(EntryAttributes::PasswordKey, password, m_attributes->isProtected(EntryAttributes::PasswordKey));

}

void Entry::setNotes(const QString& notes)

{

m_attributes->set(EntryAttributes::NotesKey, notes, m_attributes->isProtected(EntryAttributes::NotesKey));

}

void Entry::setDefaultAttribute(const QString& attribute, const QString& value)

{

Q_ASSERT(EntryAttributes::isDefaultAttribute(attribute));

if (!EntryAttributes::isDefaultAttribute(attribute)) {

return;

}

m_attributes->set(attribute, value, m_attributes->isProtected(attribute));

}

void Entry::setExpires(const bool& value)

{

if (m_data.timeInfo.expires() != value) {

m_data.timeInfo.setExpires(value);

emitModified();

}

}

void Entry::setExpiryTime(const QDateTime& dateTime)

{

if (m_data.timeInfo.expiryTime() != dateTime) {

m_data.timeInfo.setExpiryTime(dateTime);

emitModified();

}

}

QList<Entry*> Entry::historyItems()

{

return m_history;

}

const QList<Entry*>& Entry::historyItems() const

{

return m_history;

}

void Entry::addHistoryItem(Entry* entry)

{

Q_ASSERT(!entry->parent());

entry->setHistoryOwner(this);

m_history.append(entry);

emitModified();

}

void Entry::setHistoryOwner(Entry* entry)

{

m_historyOwner = entry;

}

Entry* Entry::historyOwner() const

{

return m_historyOwner;

}

void Entry::removeHistoryItems(const QList<Entry*>& historyEntries)

{

if (historyEntries.isEmpty()) {

return;

}

for (Entry* entry : historyEntries) {

Q_ASSERT(!entry->parent());

Q_ASSERT(entry->uuid().isNull() || entry->uuid() == uuid());

Q_ASSERT(m_history.contains(entry));

m_history.removeOne(entry);

delete entry;

}

emitModified();

}

void Entry::truncateHistory()

{

const Database* db = database();

if (!db) {

return;

}

bool changed = false;

int histMaxItems = db->metadata()->historyMaxItems();

if (histMaxItems > -1) {

int historyCount = 0;

QMutableListIterator<Entry*> i(m_history);

i.toBack();

while (i.hasPrevious()) {

historyCount++;

Entry* entry = i.previous();

if (historyCount > histMaxItems) {

delete entry;

i.remove();

changed = true;

}

}

}

int histMaxSize = db->metadata()->historyMaxSize();

if (histMaxSize > -1) {

int size = 0;

QMutableListIterator<Entry*> i(m_history);

i.toBack();

while (i.hasPrevious()) {

Entry* historyItem = i.previous();

// don't calculate size if it's already above the maximum

if (size <= histMaxSize) {

size += historyItem->size();

}

if (size > histMaxSize) {

delete historyItem;

i.remove();

changed = true;

}

}

}

if (changed) {

emitModified();

}

}

bool Entry::equals(const Entry* other, CompareItemOptions options) const

{

if (!other) {

return false;

}

if (m_uuid != other->uuid()) {

return false;

}

if (!m_data.equals(other->m_data, options)) {

return false;

}

if (*m_customData != *other->m_customData) {

return false;

}

if (*m_attributes != *other->m_attributes) {

return false;

}

if (*m_attachments != *other->m_attachments) {

return false;

}

if (*m_autoTypeAssociations != *other->m_autoTypeAssociations) {

return false;

}

if (!options.testFlag(CompareItemIgnoreHistory)) {

if (m_history.count() != other->m_history.count()) {

return false;

}

for (int i = 0; i < m_history.count(); ++i) {

if (!m_history[i]->equals(other->m_history[i], options)) {

return false;

}

}

}

return true;

}

QStringList Entry::calculateDifference(const Entry* other)

{

QStringList modifiedFields;

if (*attributes() != *other->attributes()) {

bool foundAttribute = false;

if (title() != other->title()) {

modifiedFields << tr("Title");

foundAttribute = true;

}

if (username() != other->username()) {

modifiedFields << tr("Username");

foundAttribute = true;

}

if (password() != other->password()) {

modifiedFields << tr("Password");

foundAttribute = true;

}

if (url() != other->url()) {

modifiedFields << tr("URL");

foundAttribute = true;

}

if (notes() != other->notes()) {

modifiedFields << tr("Notes");

foundAttribute = true;

}

if (!foundAttribute) {

modifiedFields << tr("Custom Attributes");

}