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

Added pronounceable password generator

Browse Source 
Improved RNG seeding on Windows
Updated AES implementation
Removed SHA1 implementation, replaced by QCryptographicHash
Replaced ARC4 implementation by the one from KeePass 1.11
Some cleanup

git-svn-id: https://svn.code.sf.net/p/keepassx/code/trunk@216 b624d157-de02-0410-bad0-e51aec6abb33
This commit is contained in:
sniperbeamer
2008-08-01 18:57:18 +00:00
parent 455e68ff60
commit 636f3b8af6
46 changed files with 5192 additions and 2662 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/lib/GroupView.cpp
View File

@@ -21,6 +21,9 @@
#include "EntryView.h"
#include "GroupView.h"
#include "dialogs/EditGroupDlg.h"
#include <QBrush>
#define INSERT_AREA_WIDTH 4
KeepassGroupView::KeepassGroupView(QWidget* parent):QTreeWidget(parent){

488
src/lib/IniReader.cpp
View File

@@ -1,488 +0,0 @@
// IniFile.cpp: Implementation of the CIniFile class.
// Written by: Adam Clauss
// Email: cabadam@houston.rr.com
// You may use this class/code as you wish in your programs. Feel free to distribute it, and
// email suggested changes to me.
//
// Rewritten by: Shane Hill
// Date: 21/08/2001
// Email: Shane.Hill@dsto.defence.gov.au
// Reason: Remove dependancy on MFC. Code should compile on any
// platform.
//////////////////////////////////////////////////////////////////////
// C++ Includes
#include <iostream>
#include <fstream>
#include <strstream>
// C Includes
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
// Local Includes
#include "IniReader.h"
#include <qglobal.h>
#if defined(Q_WS_WIN)
#define iniEOL endl
#else
#define iniEOL '\r' << endl
#endif
CIniFile::CIniFile( string const iniPath)
{
Path( iniPath);
caseInsensitive = true;
}
bool CIniFile::ReadFile()
{
// Normally you would use ifstream, but the SGI CC compiler has
// a few bugs with ifstream. So ... fstream used.
fstream f;
string line;
string keyname, valuename, value;
string::size_type pLeft, pRight;
f.open( path.c_str(), ios::in);
if ( f.fail())
return false;
while( getline( f, line)) {
// To be compatible with Win32, check for existence of '\r'.
// Win32 files have the '\r' and Unix files don't at the end of a line.
// Note that the '\r' will be written to INI files from
// Unix so that the created INI file can be read under Win32
// without change.
if( !line.length())continue;
if ( line[line.length() - 1] == '\r')
line = line.substr( 0, line.length() - 1);
if ( line.length()) {
// Check that the user hasn't openned a binary file by checking the first
// character of each line!
if ( !isprint( line[0])) {
printf( "Failing on char %d\n", line[0]);
f.close();
return false;
}
if (( pLeft = line.find_first_of(";#[=")) != string::npos) {
switch ( line[pLeft]) {
case '[':
if ((pRight = line.find_last_of("]")) != string::npos &&
pRight > pLeft) {
keyname = line.substr( pLeft + 1, pRight - pLeft - 1);
AddKeyName( keyname);
}
break;
case '=':
valuename = line.substr( 0, pLeft);
value = line.substr( pLeft + 1);
SetValue( keyname, valuename, value);
break;
case ';':
case '#':
if ( !names.size())
HeaderComment( line.substr( pLeft + 1));
else
KeyComment( keyname, line.substr( pLeft + 1));
break;
}
}
}
}
f.close();
if ( names.size())
return true;
return false;
}
bool CIniFile::WriteFile()
{
unsigned commentID, keyID, valueID;
// Normally you would use ofstream, but the SGI CC compiler has
// a few bugs with ofstream. So ... fstream used.
fstream f;
f.open( path.c_str(), ios::out);
if ( f.fail())
return false;
// Write header comments.
for ( commentID = 0; commentID < comments.size(); ++commentID)
f << ';' << comments[commentID] << iniEOL;
if ( comments.size())
f << iniEOL;
// Write keys and values.
for ( keyID = 0; keyID < keys.size(); ++keyID) {
f << '[' << names[keyID] << ']' << iniEOL;
// Comments.
for ( commentID = 0; commentID < keys[keyID].comments.size(); ++commentID)
f << ';' << keys[keyID].comments[commentID] << iniEOL;
// Values.
for ( valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
f << keys[keyID].names[valueID] << '=' << keys[keyID].values[valueID] << iniEOL;
f << iniEOL;
}
f.close();
return true;
}
long CIniFile::FindKey( string const keyname) const
{
for ( unsigned keyID = 0; keyID < names.size(); ++keyID)
if ( CheckCase( names[keyID]) == CheckCase( keyname))
return long(keyID);
return noID;
}
long CIniFile::FindValue( unsigned const keyID, string const valuename) const
{
if ( !keys.size() || keyID >= keys.size())
return noID;
for ( unsigned valueID = 0; valueID < keys[keyID].names.size(); ++valueID)
if ( CheckCase( keys[keyID].names[valueID]) == CheckCase( valuename))
return long(valueID);
return noID;
}
unsigned CIniFile::AddKeyName( string const keyname)
{
names.resize( names.size() + 1, keyname);
keys.resize( keys.size() + 1);
return names.size() - 1;
}
string CIniFile::KeyName( unsigned const keyID) const
{
if ( keyID < names.size())
return names[keyID];
else
return "";
}
unsigned CIniFile::NumValues( unsigned const keyID)
{
if ( keyID < keys.size())
return keys[keyID].names.size();
return 0;
}
unsigned CIniFile::NumValues( string const keyname)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return 0;
return keys[keyID].names.size();
}
string CIniFile::ValueName( unsigned const keyID, unsigned const valueID) const
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
return keys[keyID].names[valueID];
return "";
}
string CIniFile::ValueName( string const keyname, unsigned const valueID) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return "";
return ValueName( keyID, valueID);
}
bool CIniFile::SetValue( unsigned const keyID, unsigned const valueID, string const value)
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
keys[keyID].values[valueID] = value;
return false;
}
bool CIniFile::SetValue( string const keyname, string const valuename, string const value, bool const create)
{
long keyID = FindKey( keyname);
if ( keyID == noID) {
if ( create)
keyID = long( AddKeyName( keyname));
else
return false;
}
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID) {
if ( !create)
return false;
keys[keyID].names.resize( keys[keyID].names.size() + 1, valuename);
keys[keyID].values.resize( keys[keyID].values.size() + 1, value);
} else
keys[keyID].values[valueID] = value;
return true;
}
bool CIniFile::SetValueI( string const keyname, string const valuename, int const value, bool const create)
{
char svalue[MAX_VALUEDATA];
sprintf( svalue, "%d", value);
return SetValue( keyname, valuename, svalue);
}
bool CIniFile::SetValueF( string const keyname, string const valuename, double const value, bool const create)
{
char svalue[MAX_VALUEDATA];
sprintf( svalue, "%f", value);
return SetValue( keyname, valuename, svalue);
}
bool CIniFile::SetValueV( string const keyname, string const valuename, char *format, ...)
{
va_list args;
char value[MAX_VALUEDATA];
va_start( args, format);
vsprintf( value, format, args);
va_end( args);
return SetValue( keyname, valuename, value);
}
string CIniFile::GetValue( unsigned const keyID, unsigned const valueID, string const defValue) const
{
if ( keyID < keys.size() && valueID < keys[keyID].names.size())
return keys[keyID].values[valueID];
return defValue;
}
string CIniFile::GetValue( string const keyname, string const valuename, string const defValue) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return defValue;
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
return defValue;
return keys[keyID].values[valueID];
}
int CIniFile::GetValueI(string const keyname, string const valuename, int const defValue) const
{
char svalue[MAX_VALUEDATA];
sprintf( svalue, "%d", defValue);
return atoi( GetValue( keyname, valuename, svalue).c_str());
}
double CIniFile::GetValueF(string const keyname, string const valuename, double const defValue) const
{
char svalue[MAX_VALUEDATA];
sprintf( svalue, "%f", defValue);
return atof( GetValue( keyname, valuename, svalue).c_str());
}
// 16 variables may be a bit of over kill, but hey, it's only code.
unsigned CIniFile::GetValueV( string const keyname, string const valuename, char *format,
void *v1, void *v2, void *v3, void *v4,
void *v5, void *v6, void *v7, void *v8,
void *v9, void *v10, void *v11, void *v12,
void *v13, void *v14, void *v15, void *v16)
{
string value;
// va_list args;
unsigned nVals;
value = GetValue( keyname, valuename);
if ( !value.length())
return false;
// Why is there not vsscanf() function. Linux man pages say that there is
// but no compiler I've seen has it defined. Bummer!
//
// va_start( args, format);
// nVals = vsscanf( value.c_str(), format, args);
// va_end( args);
nVals = sscanf( value.c_str(), format,
v1, v2, v3, v4, v5, v6, v7, v8,
v9, v10, v11, v12, v13, v14, v15, v16);
return nVals;
}
bool CIniFile::DeleteValue( string const keyname, string const valuename)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
long valueID = FindValue( unsigned(keyID), valuename);
if ( valueID == noID)
return false;
// This looks strange, but is neccessary.
vector<string>::iterator npos = keys[keyID].names.begin() + valueID;
vector<string>::iterator vpos = keys[keyID].values.begin() + valueID;
keys[keyID].names.erase( npos, npos + 1);
keys[keyID].values.erase( vpos, vpos + 1);
return true;
}
bool CIniFile::DeleteKey( string const keyname)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
// Now hopefully this destroys the vector lists within keys.
// Looking at <vector> source, this should be the case using the destructor.
// If not, I may have to do it explicitly. Memory leak check should tell.
// memleak_test.cpp shows that the following not required.
//keys[keyID].names.clear();
//keys[keyID].values.clear();
vector<string>::iterator npos = names.begin() + keyID;
vector<key>::iterator kpos = keys.begin() + keyID;
names.erase( npos, npos + 1);
keys.erase( kpos, kpos + 1);
return true;
}
void CIniFile::Erase()
{
// This loop not needed. The vector<> destructor seems to do
// all the work itself. memleak_test.cpp shows this.
//for ( unsigned i = 0; i < keys.size(); ++i) {
// keys[i].names.clear();
// keys[i].values.clear();
//}
names.clear();
keys.clear();
comments.clear();
}
void CIniFile::HeaderComment( string const comment)
{
comments.resize( comments.size() + 1, comment);
}
string CIniFile::HeaderComment( unsigned const commentID) const
{
if ( commentID < comments.size())
return comments[commentID];
return "";
}
bool CIniFile::DeleteHeaderComment( unsigned commentID)
{
if ( commentID < comments.size()) {
vector<string>::iterator cpos = comments.begin() + commentID;
comments.erase( cpos, cpos + 1);
return true;
}
return false;
}
unsigned CIniFile::NumKeyComments( unsigned const keyID) const
{
if ( keyID < keys.size())
return keys[keyID].comments.size();
return 0;
}
unsigned CIniFile::NumKeyComments( string const keyname) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return 0;
return keys[keyID].comments.size();
}
bool CIniFile::KeyComment( unsigned const keyID, string const comment)
{
if ( keyID < keys.size()) {
keys[keyID].comments.resize( keys[keyID].comments.size() + 1, comment);
return true;
}
return false;
}
bool CIniFile::KeyComment( string const keyname, string const comment)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
return KeyComment( unsigned(keyID), comment);
}
string CIniFile::KeyComment( unsigned const keyID, unsigned const commentID) const
{
if ( keyID < keys.size() && commentID < keys[keyID].comments.size())
return keys[keyID].comments[commentID];
return "";
}
string CIniFile::KeyComment( string const keyname, unsigned const commentID) const
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return "";
return KeyComment( unsigned(keyID), commentID);
}
bool CIniFile::DeleteKeyComment( unsigned const keyID, unsigned const commentID)
{
if ( keyID < keys.size() && commentID < keys[keyID].comments.size()) {
vector<string>::iterator cpos = keys[keyID].comments.begin() + commentID;
keys[keyID].comments.erase( cpos, cpos + 1);
return true;
}
return false;
}
bool CIniFile::DeleteKeyComment( string const keyname, unsigned const commentID)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
return DeleteKeyComment( unsigned(keyID), commentID);
}
bool CIniFile::DeleteKeyComments( unsigned const keyID)
{
if ( keyID < keys.size()) {
keys[keyID].comments.clear();
return true;
}
return false;
}
bool CIniFile::DeleteKeyComments( string const keyname)
{
long keyID = FindKey( keyname);
if ( keyID == noID)
return false;
return DeleteKeyComments( unsigned(keyID));
}
string CIniFile::CheckCase( string s) const
{
if ( caseInsensitive)
for ( string::size_type i = 0; i < s.length(); ++i)
s[i] = tolower(s[i]);
return s;
}

182
src/lib/IniReader.h
View File

@@ -1,182 +0,0 @@
// IniFile.cpp: Implementation of the CIniFile class.
// Written by: Adam Clauss
// Email: cabadam@tamu.edu
// You may use this class/code as you wish in your programs. Feel free to distribute it, and
// email suggested changes to me.
//
// Rewritten by: Shane Hill
// Date: 21/08/2001
// Email: Shane.Hill@dsto.defence.gov.au
// Reason: Remove dependancy on MFC. Code should compile on any
// platform. Tested on Windows/Linux/Irix
//////////////////////////////////////////////////////////////////////
#ifndef CIniFile_H
#define CIniFile_H
// C++ Includes
#include <string>
#include <vector>
// C Includes
#include <stdlib.h>
using namespace std;
#define MAX_KEYNAME 128
#define MAX_VALUENAME 128
#define MAX_VALUEDATA 2048
class CIniFile
{
private:
bool caseInsensitive;
string path;
struct key {
vector<string> names;
vector<string> values;
vector<string> comments;
};
vector<key> keys;
vector<string> names;
vector<string> comments;
string CheckCase( string s) const;
public:
enum errors{ noID = -1};
CIniFile( string const iniPath = "");
virtual ~CIniFile() {}
// Sets whether or not keynames and valuenames should be case sensitive.
// The default is case insensitive.
void CaseSensitive() {caseInsensitive = false;}
void CaseInsensitive() {caseInsensitive = true;}
// Sets path of ini file to read and write from.
void Path(string const newPath) {path = newPath;}
string Path() const {return path;}
void SetPath(string const newPath) {Path( newPath);}
// Reads ini file specified using path.
// Returns true if successful, false otherwise.
bool ReadFile();
// Writes data stored in class to ini file.
bool WriteFile();
// Deletes all stored ini data.
void Erase();
void Clear() {Erase();}
void Reset() {Erase();}
// Returns index of specified key, or noID if not found.
long FindKey( string const keyname) const;
// Returns index of specified value, in the specified key, or noID if not found.
long FindValue( unsigned const keyID, string const valuename) const;
// Returns number of keys currently in the ini.
unsigned NumKeys() const {return names.size();}
unsigned GetNumKeys() const {return NumKeys();}
// Add a key name.
unsigned AddKeyName( string const keyname);
// Returns key names by index.
string KeyName( unsigned const keyID) const;
string GetKeyName( unsigned const keyID) const {return KeyName(keyID);}
// Returns number of values stored for specified key.
unsigned NumValues( unsigned const keyID);
unsigned GetNumValues( unsigned const keyID) {return NumValues( keyID);}
unsigned NumValues( string const keyname);
unsigned GetNumValues( string const keyname) {return NumValues( keyname);}
// Returns value name by index for a given keyname or keyID.
string ValueName( unsigned const keyID, unsigned const valueID) const;
string GetValueName( unsigned const keyID, unsigned const valueID) const {
return ValueName( keyID, valueID);
}
string ValueName( string const keyname, unsigned const valueID) const;
string GetValueName( string const keyname, unsigned const valueID) const {
return ValueName( keyname, valueID);
}
// Gets value of [keyname] valuename =.
// Overloaded to return string, int, and double.
// Returns defValue if key/value not found.
string GetValue( unsigned const keyID, unsigned const valueID, string const defValue = "") const;
string GetValue(string const keyname, string const valuename, string const defValue = "") const;
int GetValueI(string const keyname, string const valuename, int const defValue = 0) const;
bool GetValueB(string const keyname, string const valuename, bool const defValue = false) const {
return bool( GetValueI( keyname, valuename, int( defValue)));
}
double GetValueF(string const keyname, string const valuename, double const defValue = 0.0) const;
// This is a variable length formatted GetValue routine. All these voids
// are required because there is no vsscanf() like there is a vsprintf().
// Only a maximum of 8 variable can be read.
unsigned GetValueV( string const keyname, string const valuename, char *format,
void *v1 = 0, void *v2 = 0, void *v3 = 0, void *v4 = 0,
void *v5 = 0, void *v6 = 0, void *v7 = 0, void *v8 = 0,
void *v9 = 0, void *v10 = 0, void *v11 = 0, void *v12 = 0,
void *v13 = 0, void *v14 = 0, void *v15 = 0, void *v16 = 0);
// Sets value of [keyname] valuename =.
// Specify the optional paramter as false (0) if you do not want it to create
// the key if it doesn't exist. Returns true if data entered, false otherwise.
// Overloaded to accept string, int, and double.
bool SetValue( unsigned const keyID, unsigned const valueID, string const value);
bool SetValue( string const keyname, string const valuename, string const value, bool const create = true);
bool SetValueI( string const keyname, string const valuename, int const value, bool const create = true);
bool SetValueB( string const keyname, string const valuename, bool const value, bool const create = true) {
return SetValueI( keyname, valuename, int(value), create);
}
bool SetValueF( string const keyname, string const valuename, double const value, bool const create = true);
bool SetValueV( string const keyname, string const valuename, char *format, ...);
// Deletes specified value.
// Returns true if value existed and deleted, false otherwise.
bool DeleteValue( string const keyname, string const valuename);
// Deletes specified key and all values contained within.
// Returns true if key existed and deleted, false otherwise.
bool DeleteKey(string keyname);
// Header comment functions.
// Header comments are those comments before the first key.
//
// Number of header comments.
unsigned NumHeaderComments() {return comments.size();}
// Add a header comment.
void HeaderComment( string const comment);
// Return a header comment.
string HeaderComment( unsigned const commentID) const;
// Delete a header comment.
bool DeleteHeaderComment( unsigned commentID);
// Delete all header comments.
void DeleteHeaderComments() {comments.clear();}
// Key comment functions.
// Key comments are those comments within a key. Any comments
// defined within value names will be added to this list. Therefore,
// these comments will be moved to the top of the key definition when
// the CIniFile::WriteFile() is called.
//
// Number of key comments.
unsigned NumKeyComments( unsigned const keyID) const;
unsigned NumKeyComments( string const keyname) const;
// Add a key comment.
bool KeyComment( unsigned const keyID, string const comment);
bool KeyComment( string const keyname, string const comment);
// Return a key comment.
string KeyComment( unsigned const keyID, unsigned const commentID) const;
string KeyComment( string const keyname, unsigned const commentID) const;
// Delete a key comment.
bool DeleteKeyComment( unsigned const keyID, unsigned const commentID);
bool DeleteKeyComment( string const keyname, unsigned const commentID);
// Delete all comments for a key.
bool DeleteKeyComments( unsigned const keyID);
bool DeleteKeyComments( string const keyname);
};
#endif

29
src/lib/SecString.cpp
View File

@@ -18,11 +18,6 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef Q_WS_X11
#include <sys/mman.h>
#include <limits.h>
#endif
using namespace std;
CArcFour SecString::RC4;
@@ -54,7 +49,7 @@ void SecString::unlock(){
if(!crypt.length())
return;
const unsigned char* buffer = new unsigned char[crypt.length()];
SecString::RC4.decrypt( (byte*)crypt.data(), (unsigned char*)buffer, crypt.length() );
RC4.decrypt( (byte*)crypt.data(), (unsigned char*)buffer, crypt.length() );
plain = QString::fromUtf8((const char*)buffer, crypt.size());
overwrite((unsigned char*)buffer, crypt.size());
delete [] buffer;
@@ -69,7 +64,7 @@ void SecString::setString(QString& str, bool DeleteSource){
QByteArray StrData = str.toUtf8();
int len = StrData.size();
unsigned char* buffer = new unsigned char[len];
SecString::RC4.encrypt((const unsigned char*)StrData.data(), buffer, len);
RC4.encrypt((const unsigned char*)StrData.data(), buffer, len);
crypt = QByteArray((const char*)buffer, len);
overwrite(buffer, len);
overwrite((unsigned char*)StrData.data(), len);
@@ -98,20 +93,8 @@ void SecString::overwrite(QString& str){
}
void SecString::generateSessionKey(){
CArcFour arc;
unsigned char sessionkey[32];
#ifdef Q_WS_X11
#ifdef PAGESIZE
mlock(sessionkey - sessionkey%PAGESIZE, 32);
#else
mlock(sessionkey, 32);
#endif
#endif // Q_WS_X11
randomize(sessionkey,32);
RC4.setKey(sessionkey,32);
overwrite(sessionkey,32);
quint8* sessionkey = new quint8[32];
lockPage(sessionkey, 32);
randomize(sessionkey, 32);
RC4.setKey(sessionkey, 32);
}

4
src/lib/SecString.h
View File

@@ -20,6 +20,8 @@
#ifndef _SECSTRING_H_
#define _SECSTRING_H_
#include "crypto/arcfour.h"
//! QString based class with in-memory encryption of its content.
/*!
This class can hold a QString object in an encrypted buffer. To get access to the string it is neccassary to unlock the SecString object.
@@ -47,8 +49,8 @@ public:
static void generateSessionKey();
private:
bool locked;
static CArcFour RC4;
bool locked;
QByteArray crypt;
QString plain;

72
src/lib/random.cpp
View File

@@ -28,39 +28,56 @@
#include <QSysInfo>
#endif
#include <QCryptographicHash>
#include <QCursor>
#include <QDataStream>
#include <QDateTime>
#include <QTime>
void Random::getEntropy(quint8* buffer, int length){
#if defined(Q_WS_X11) || defined(Q_WS_MAC)
QFile dev_urandom("/dev/urandom");
if (dev_urandom.open(QIODevice::ReadOnly|QIODevice::Unbuffered) && dev_urandom.read((char*)buffer,length)==length)
return;
#elif defined(Q_WS_WIN)
// RtlGenRandom
if (QSysInfo::WindowsVersion>=QSysInfo::WV_XP){
bool success=false;
HMODULE hLib=LoadLibraryA("ADVAPI32.DLL");
if (hLib) {
BOOLEAN (APIENTRY *pfn)(void*, ULONG) = (BOOLEAN (APIENTRY *)(void*,ULONG))GetProcAddress(hLib,"SystemFunction036");
if (pfn && pfn(buffer,length)) {
success=true;
}
FreeLibrary(hLib);
void initStdRand();
bool getNativeEntropy(quint8* buffer, int length);
void getEntropy(quint8* buffer, int length){
if (!getNativeEntropy(buffer, length)) {
qWarning("Entropy collection failed, using fallback");
initStdRand();
for(int i=0;i<length;i++){
((quint8*)buffer)[i] = (quint8) (qrand()%256);
}
if (success)
return;
}
#endif
initStdRand();
for(int i=0;i<length;i++){
((quint8*)buffer)[i] = (quint8) (qrand()%256);
}
}
void Random::initStdRand(){
quint32 randint(quint32 n){
quint32 rand;
randomize(&rand, 4);
return (rand % n);
}
#if defined(Q_WS_X11) || defined(Q_WS_MAC)
extern bool getNativeEntropy(quint8* buffer, int length) {
QFile dev_urandom("/dev/urandom");
if (!dev_urandom.open(QIODevice::ReadOnly|QIODevice::Unbuffered))
return false;
return (dev_urandom.read((char*)buffer,length) == length);
}
#elif defined(Q_WS_WIN)
extern bool getNativeEntropy(quint8* buffer, int length) {
HCRYPTPROV handle;
if (!CryptAcquireContext(&handle, 0, 0, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT))
return false;
CryptGenRandom(handle, length, buffer);
CryptReleaseContext(handle, 0);
return true;
}
#endif
extern void initStdRand(){
static bool initalized = false;
if (initalized)
return;
@@ -72,9 +89,8 @@ void Random::initStdRand(){
stream << QDateTime::currentDateTime().toTime_t();
stream << QTime::currentTime().msec();
quint8 hash[32];
SHA256::hashBuffer(buffer.data(), hash, buffer.size());
QByteArray hash = QCryptographicHash::hash(buffer, QCryptographicHash::Md4);
qsrand( (uint) *hash );
qsrand( (uint) hash.constData() );
initalized = true;
}

22
src/lib/random.h
View File

@@ -20,11 +20,23 @@
#ifndef RANDOM_H_
#define RANDOM_H_
#include <QObject>
#ifndef quint8
typedef unsigned char quint8;
#endif
namespace Random {
void getEntropy(quint8* buffer, int length);
void initStdRand();
};
#ifndef quint32
typedef unsigned int quint32;
#endif
#ifdef __cplusplus
extern "C" {
#endif
void getEntropy(quint8* buffer, int length);
quint32 randint(quint32 n);
#ifdef __cplusplus
}
#endif
#endif

16
src/lib/tools.cpp
View File

@@ -20,6 +20,12 @@
#include <QProcess>
#include <QDesktopServices>
#if defined(Q_WS_X11) || defined(Q_WS_MAC)
#include <sys/mman.h>
#elif defined(Q_WS_WIN)
#include <windows.h>
#endif
void createBanner(QPixmap* Pixmap,const QPixmap* IconAlpha,const QString& Text,int Width){
createBanner(Pixmap,IconAlpha,Text,Width,config->bannerColor1(),config->bannerColor2(),config->bannerTextColor());
}
@@ -209,4 +215,12 @@ bool createKeyFile(const QString& filename,QString* error,int length, bool Hex){
return true;
}
bool lockPage(void* addr, int len){
#if defined(Q_WS_X11) || defined(Q_WS_MAC)
return (mlock(addr, len)==0);
#elif defined(Q_WS_WIN)
return VirtualLock(addr, len);
#else
return false;
#endif
}

1
src/lib/tools.h
View File

@@ -33,5 +33,6 @@ QString decodeFileError(QFile::FileError Code);
QString makePathRelative(const QString& Abs,const QString& Cur);
QString getImageFile(const QString& name);
bool createKeyFile(const QString& filename,QString* err, int length=32, bool Hex=true);
bool lockPage(void* addr, int len);
#endif //TOOLS_H