Git-Mirrors/keepassxc
1
0
Fork 0
mirror of https://github.com/keepassxreboot/keepassxc.git synced 2025-12-17 09:24:28 -05:00
Code Issues Projects Releases Packages Wiki Activity

Launch KeePassXC password generator popup from the extension

Browse source 
* Closes #6473
This commit is contained in:
varjolintu 2021-10-17 09:53:25 +03:00 • committed by Jonathan White
parent 2a9d92faeb
commit dd41f093e6
8 changed files with 66 additions and 341 deletions
Download patch file Download diff file Expand all files Collapse all files

273
src/browser/BrowserSettings.cpp
View file

@ -1,7 +1,7 @@
/*
* Copyright (C) 2013 Francois Ferrand
* Copyright (C) 2017 Sami Vänttinen <sami.vanttinen@protonmail.com>
* Copyright (C) 2017 KeePassXC Team <team@keepassxc.org>
* Copyright (C) 2021 KeePassXC Team <team@keepassxc.org>
*
* 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
@ -242,277 +242,6 @@ void BrowserSettings::setBrowserSupport(BrowserShared::SupportedBrowsers browser
m_nativeMessageInstaller.setBrowserEnabled(browser, enabled);
}
bool BrowserSettings::passwordUseNumbers()
{
return config()->get(Config::PasswordGenerator_Numbers).toBool();
}
void BrowserSettings::setPasswordUseNumbers(bool useNumbers)
{
config()->set(Config::PasswordGenerator_Numbers, useNumbers);
}
bool BrowserSettings::passwordUseLowercase()
{
return config()->get(Config::PasswordGenerator_LowerCase).toBool();
}
void BrowserSettings::setPasswordUseLowercase(bool useLowercase)
{
config()->set(Config::PasswordGenerator_LowerCase, useLowercase);
}
bool BrowserSettings::passwordUseUppercase()
{
return config()->get(Config::PasswordGenerator_UpperCase).toBool();
}
void BrowserSettings::setPasswordUseUppercase(bool useUppercase)
{
config()->set(Config::PasswordGenerator_UpperCase, useUppercase);
}
bool BrowserSettings::passwordUseSpecial()
{
return config()->get(Config::PasswordGenerator_SpecialChars).toBool();
}
void BrowserSettings::setPasswordUseSpecial(bool useSpecial)
{
config()->set(Config::PasswordGenerator_SpecialChars, useSpecial);
}
bool BrowserSettings::passwordUseBraces()
{
return config()->get(Config::PasswordGenerator_Braces).toBool();
}
void BrowserSettings::setPasswordUseBraces(bool useBraces)
{
config()->set(Config::PasswordGenerator_Braces, useBraces);
}
bool BrowserSettings::passwordUsePunctuation()
{
return config()->get(Config::PasswordGenerator_Punctuation).toBool();
}
void BrowserSettings::setPasswordUsePunctuation(bool usePunctuation)
{
config()->set(Config::PasswordGenerator_Punctuation, usePunctuation);
}
bool BrowserSettings::passwordUseQuotes()
{
return config()->get(Config::PasswordGenerator_Quotes).toBool();
}
void BrowserSettings::setPasswordUseQuotes(bool useQuotes)
{
config()->set(Config::PasswordGenerator_Quotes, useQuotes);
}
bool BrowserSettings::passwordUseDashes()
{
return config()->get(Config::PasswordGenerator_Dashes).toBool();
}
void BrowserSettings::setPasswordUseDashes(bool useDashes)
{
config()->set(Config::PasswordGenerator_Dashes, useDashes);
}
bool BrowserSettings::passwordUseMath()
{
return config()->get(Config::PasswordGenerator_Math).toBool();
}
void BrowserSettings::setPasswordUseMath(bool useMath)
{
config()->set(Config::PasswordGenerator_Math, useMath);
}
bool BrowserSettings::passwordUseLogograms()
{
return config()->get(Config::PasswordGenerator_Logograms).toBool();
}
void BrowserSettings::setPasswordUseLogograms(bool useLogograms)
{
config()->set(Config::PasswordGenerator_Logograms, useLogograms);
}
bool BrowserSettings::passwordUseEASCII()
{
return config()->get(Config::PasswordGenerator_EASCII).toBool();
}
void BrowserSettings::setPasswordUseEASCII(bool useEASCII)
{
config()->set(Config::PasswordGenerator_EASCII, useEASCII);
}
bool BrowserSettings::advancedMode()
{
return config()->get(Config::PasswordGenerator_AdvancedMode).toBool();
}
void BrowserSettings::setAdvancedMode(bool advancedMode)
{
config()->set(Config::PasswordGenerator_AdvancedMode, advancedMode);
}
QString BrowserSettings::passwordAdditionalChars()
{
return config()->get(Config::PasswordGenerator_AdditionalChars).toString();
}
void BrowserSettings::setPasswordAdditionalChars(const QString& chars)
{
config()->set(Config::PasswordGenerator_AdditionalChars, chars);
}
QString BrowserSettings::passwordExcludedChars()
{
return config()->get(Config::PasswordGenerator_ExcludedChars).toString();
}
void BrowserSettings::setPasswordExcludedChars(const QString& chars)
{
config()->set(Config::PasswordGenerator_ExcludedChars, chars);
}
int BrowserSettings::passPhraseWordCount()
{
return config()->get(Config::PasswordGenerator_WordCount).toInt();
}
void BrowserSettings::setPassPhraseWordCount(int wordCount)
{
config()->set(Config::PasswordGenerator_WordCount, wordCount);
}
QString BrowserSettings::passPhraseWordSeparator()
{
return config()->get(Config::PasswordGenerator_WordSeparator).toString();
}
void BrowserSettings::setPassPhraseWordSeparator(const QString& separator)
{
config()->set(Config::PasswordGenerator_WordSeparator, separator);
}
int BrowserSettings::generatorType()
{
return config()->get(Config::PasswordGenerator_Type).toInt();
}
void BrowserSettings::setGeneratorType(int type)
{
config()->set(Config::PasswordGenerator_Type, type);
}
bool BrowserSettings::passwordEveryGroup()
{
return config()->get(Config::PasswordGenerator_EnsureEvery).toBool();
}
void BrowserSettings::setPasswordEveryGroup(bool everyGroup)
{
config()->set(Config::PasswordGenerator_EnsureEvery, everyGroup);
}
bool BrowserSettings::passwordExcludeAlike()
{
return config()->get(Config::PasswordGenerator_ExcludeAlike).toBool();
}
void BrowserSettings::setPasswordExcludeAlike(bool excludeAlike)
{
config()->set(Config::PasswordGenerator_ExcludeAlike, excludeAlike);
}
int BrowserSettings::passwordLength()
{
return config()->get(Config::PasswordGenerator_Length).toInt();
}
void BrowserSettings::setPasswordLength(int length)
{
config()->set(Config::PasswordGenerator_Length, length);
m_passwordGenerator.setLength(length);
}
PasswordGenerator::CharClasses BrowserSettings::passwordCharClasses()
{
PasswordGenerator::CharClasses classes;
if (passwordUseLowercase()) {
classes |= PasswordGenerator::LowerLetters;
}
if (passwordUseUppercase()) {
classes |= PasswordGenerator::UpperLetters;
}
if (passwordUseNumbers()) {
classes |= PasswordGenerator::Numbers;
}
if (passwordUseSpecial()) {
classes |= PasswordGenerator::SpecialCharacters;
}
if (passwordUseBraces()) {
classes |= PasswordGenerator::Braces;
}
if (passwordUsePunctuation()) {
classes |= PasswordGenerator::Punctuation;
}
if (passwordUseQuotes()) {
classes |= PasswordGenerator::Quotes;
}
if (passwordUseDashes()) {
classes |= PasswordGenerator::Dashes;
}
if (passwordUseMath()) {
classes |= PasswordGenerator::Math;
}
if (passwordUseLogograms()) {
classes |= PasswordGenerator::Logograms;
}
if (passwordUseEASCII()) {
classes |= PasswordGenerator::EASCII;
}
return classes;
}
PasswordGenerator::GeneratorFlags BrowserSettings::passwordGeneratorFlags()
{
PasswordGenerator::GeneratorFlags flags;
if (passwordExcludeAlike()) {
flags |= PasswordGenerator::ExcludeLookAlike;
}
if (passwordEveryGroup()) {
flags |= PasswordGenerator::CharFromEveryGroup;
}
return flags;
}
QJsonObject BrowserSettings::generatePassword()
{
QJsonObject password;
if (generatorType() == 0) {
m_passwordGenerator.setLength(passwordLength());
m_passwordGenerator.setCharClasses(passwordCharClasses());
m_passwordGenerator.setFlags(passwordGeneratorFlags());
const QString pw = m_passwordGenerator.generatePassword();
password["entropy"] = PasswordHealth(pw).entropy();
password["password"] = pw;
} else {
m_passPhraseGenerator.setWordCount(passPhraseWordCount());
m_passPhraseGenerator.setWordSeparator(passPhraseWordSeparator());
password["entropy"] = m_passPhraseGenerator.estimateEntropy();
password["password"] = m_passPhraseGenerator.generatePassphrase();
}
return password;
}
void BrowserSettings::updateBinaryPaths()
{
m_nativeMessageInstaller.updateBinaryPaths();