You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdelibs/kwallet/backend/kwalletbackend.cc

839 lines
18 KiB

/* This file is part of the KDE project
*
* Copyright (C) 2001-2004 George Staikos <staikos@kde.org>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library 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
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#include "kwalletbackend.h"
#include <stdlib.h>
#include <kdebug.h>
#include <kglobal.h>
#include <klocale.h>
#include <kmdcodec.h>
#include <ksavefile.h>
#include <kstandarddirs.h>
#include <tqfile.h>
#include <tqfileinfo.h>
#include <tqregexp.h>
#include "blowfish.h"
#include "sha1.h"
#include "cbc.h"
#include <assert.h>
#define KWALLET_VERSION_MAJOR 0
#define KWALLET_VERSION_MINOR 0
#define KWALLET_CIPHER_BLOWFISH_CBC 0
#define KWALLET_CIPHER_3DES_CBC 1 // unsupported
#define KWALLET_HASH_SHA1 0
#define KWALLET_HASH_MD5 1 // unsupported
using namespace KWallet;
#define KWMAGIC "KWALLET\n\r\0\r\n"
#define KWMAGIC_LEN 12
static void initKWalletDir()
{
KGlobal::dirs()->addResourceType("kwallet", "share/apps/kwallet");
}
Backend::Backend(const TQString& name, bool isPath) : _name(name), _ref(0) {
initKWalletDir();
if (isPath) {
_path = name;
} else {
_path = KGlobal::dirs()->saveLocation("kwallet") + "/" + _name + ".kwl";
}
_open = false;
}
Backend::~Backend() {
if (_open) {
close();
}
}
int Backend::close() {
for (FolderMap::ConstIterator i = _entries.begin(); i != _entries.end(); ++i) {
for (EntryMap::ConstIterator j = i.data().begin(); j != i.data().end(); ++j) {
delete j.data();
}
}
_entries.clear();
return 0;
}
static int getRandomBlock(TQByteArray& randBlock) {
// First try /dev/urandom
if (TQFile::exists("/dev/urandom")) {
TQFile devrand("/dev/urandom");
if (devrand.open(IO_ReadOnly)) {
unsigned int rc = devrand.readBlock(randBlock.data(), randBlock.size());
if (rc != randBlock.size()) {
return -3; // not enough data read
}
return 0;
}
}
// If that failed, try /dev/random
// FIXME: open in noblocking mode!
if (TQFile::exists("/dev/random")) {
TQFile devrand("/dev/random");
if (devrand.open(IO_ReadOnly)) {
unsigned int rc = 0;
unsigned int cnt = 0;
do {
int rc2 = devrand.readBlock(randBlock.data() + rc, randBlock.size());
if (rc2 < 0) {
return -3; // read error
}
rc += rc2;
cnt++;
if (cnt > randBlock.size()) {
return -4; // reading forever?!
}
} while(rc < randBlock.size());
return 0;
}
}
// EGD method
char *randFilename;
if ((randFilename = getenv("RANDFILE"))) {
if (TQFile::exists(randFilename)) {
TQFile devrand(randFilename);
if (devrand.open(IO_ReadOnly)) {
unsigned int rc = devrand.readBlock(randBlock.data(), randBlock.size());
if (rc != randBlock.size()) {
return -3; // not enough data read
}
return 0;
}
}
}
// Couldn't get any random data!!
return -1;
}
// this should be SHA-512 for release probably
static int password2hash(const TQByteArray& password, TQByteArray& hash) {
SHA1 sha;
int shasz = sha.size() / 8;
assert(shasz >= 20);
TQByteArray block1(shasz);
sha.process(password.data(), QMIN(password.size(), 16));
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block1.data(), sha.hash(), shasz);
sha.reset();
sha.process(block1.data(), shasz);
}
sha.reset();
if (password.size() > 16) {
sha.process(password.data() + 16, QMIN(password.size() - 16, 16));
TQByteArray block2(shasz);
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block2.data(), sha.hash(), shasz);
sha.reset();
sha.process(block2.data(), shasz);
}
sha.reset();
if (password.size() > 32) {
sha.process(password.data() + 32, QMIN(password.size() - 32, 16));
TQByteArray block3(shasz);
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block3.data(), sha.hash(), shasz);
sha.reset();
sha.process(block3.data(), shasz);
}
sha.reset();
if (password.size() > 48) {
sha.process(password.data() + 48, password.size() - 48);
TQByteArray block4(shasz);
// To make brute force take longer
for (int i = 0; i < 2000; i++) {
memcpy(block4.data(), sha.hash(), shasz);
sha.reset();
sha.process(block4.data(), shasz);
}
sha.reset();
// split 14/14/14/14
hash.resize(56);
memcpy(hash.data(), block1.data(), 14);
memcpy(hash.data() + 14, block2.data(), 14);
memcpy(hash.data() + 28, block3.data(), 14);
memcpy(hash.data() + 42, block4.data(), 14);
block4.fill(0);
} else {
// split 20/20/16
hash.resize(56);
memcpy(hash.data(), block1.data(), 20);
memcpy(hash.data() + 20, block2.data(), 20);
memcpy(hash.data() + 40, block3.data(), 16);
}
block3.fill(0);
} else {
// split 20/20
hash.resize(40);
memcpy(hash.data(), block1.data(), 20);
memcpy(hash.data() + 20, block2.data(), 20);
}
block2.fill(0);
} else {
// entirely block1
hash.resize(20);
memcpy(hash.data(), block1.data(), 20);
}
block1.fill(0);
return 0;
}
bool Backend::exists(const TQString& wallet) {
initKWalletDir();
TQString path = KGlobal::dirs()->saveLocation("kwallet") + "/" + wallet + ".kwl";
// Note: 60 bytes is presently the minimum size of a wallet file.
// Anything smaller is junk.
return TQFile::exists(path) && TQFileInfo(path).size() >= 60;
}
TQString Backend::openRCToString(int rc) {
switch (rc) {
case -255:
return i18n("Already open.");
case -2:
return i18n("Error opening file.");
case -3:
return i18n("Not a wallet file.");
case -4:
return i18n("Unsupported file format revision.");
case -42:
return i18n("Unknown encryption scheme.");
case -43:
return i18n("Corrupt file?");
case -8:
return i18n("Error validating wallet integrity. Possibly corrupted.");
case -5:
case -7:
case -9:
return i18n("Read error - possibly incorrect password.");
case -6:
return i18n("Decryption error.");
default:
return TQString::null;
}
}
int Backend::open(const TQByteArray& password) {
if (_open) {
return -255; // already open
}
TQByteArray passhash;
// No wallet existed. Let's create it.
// Note: 60 bytes is presently the minimum size of a wallet file.
// Anything smaller is junk and should be deleted.
if (!TQFile::exists(_path) || TQFileInfo(_path).size() < 60) {
TQFile newfile(_path);
if (!newfile.open(IO_ReadWrite)) {
return -2; // error opening file
}
newfile.close();
_open = true;
sync(password);
return 1; // new file opened, but OK
}
TQFile db(_path);
if (!db.open(IO_ReadOnly)) {
return -2; // error opening file
}
char magicBuf[KWMAGIC_LEN];
db.readBlock(magicBuf, KWMAGIC_LEN);
if (memcmp(magicBuf, KWMAGIC, KWMAGIC_LEN) != 0) {
return -3; // bad magic
}
db.readBlock(magicBuf, 4);
// First byte is major version, second byte is minor version
if (magicBuf[0] != KWALLET_VERSION_MAJOR) {
return -4; // unknown version
}
if (magicBuf[1] != KWALLET_VERSION_MINOR) {
return -4; // unknown version
}
if (magicBuf[2] != KWALLET_CIPHER_BLOWFISH_CBC) {
return -42; // unknown cipher
}
if (magicBuf[3] != KWALLET_HASH_SHA1) {
return -42; // unknown hash
}
_hashes.clear();
// Read in the hashes
TQDataStream hds(&db);
TQ_UINT32 n;
hds >> n;
if (n > 0xffff) { // sanity check
return -43;
}
for (size_t i = 0; i < n; ++i) {
KMD5::Digest d, d2; // judgment day
MD5Digest ba;
TQMap<MD5Digest,TQValueList<MD5Digest> >::iterator it;
TQ_UINT32 fsz;
if (hds.atEnd()) return -43;
hds.readRawBytes(reinterpret_cast<char *>(d), 16);
hds >> fsz;
ba.duplicate(reinterpret_cast<char *>(d), 16);
it = _hashes.insert(ba, TQValueList<MD5Digest>());
for (size_t j = 0; j < fsz; ++j) {
hds.readRawBytes(reinterpret_cast<char *>(d2), 16);
ba.duplicate(reinterpret_cast<char *>(d2), 16);
(*it).append(ba);
}
}
// Read in the rest of the file.
TQByteArray encrypted = db.readAll();
assert(encrypted.size() < db.size());
BlowFish _bf;
CipherBlockChain bf(&_bf);
int blksz = bf.blockSize();
if ((encrypted.size() % blksz) != 0) {
return -5; // invalid file structure
}
// Decrypt the encrypted data
passhash.resize(bf.keyLen()/8);
password2hash(password, passhash);
bf.setKey((void *)passhash.data(), passhash.size()*8);
if (!encrypted.data()) {
passhash.fill(0);
encrypted.fill(0);
return -7; // file structure error
}
int rc = bf.decrypt(encrypted.data(), encrypted.size());
if (rc < 0) {
passhash.fill(0);
encrypted.fill(0);
return -6; // decrypt error
}
passhash.fill(0); // passhash is UNUSABLE NOW
const char *t = encrypted.data();
// strip the leading data
t += blksz; // one block of random data
// strip the file size off
long fsize = 0;
fsize |= (long(*t) << 24) & 0xff000000;
t++;
fsize |= (long(*t) << 16) & 0x00ff0000;
t++;
fsize |= (long(*t) << 8) & 0x0000ff00;
t++;
fsize |= long(*t) & 0x000000ff;
t++;
if (fsize < 0 || fsize > long(encrypted.size()) - blksz - 4) {
//kdDebug() << "fsize: " << fsize << " encrypted.size(): " << encrypted.size() << " blksz: " << blksz << endl;
encrypted.fill(0);
return -9; // file structure error.
}
// compute the hash ourself
SHA1 sha;
sha.process(t, fsize);
const char *testhash = (const char *)sha.hash();
// compare hashes
int sz = encrypted.size();
for (int i = 0; i < 20; i++) {
if (testhash[i] != static_cast<const char>(encrypted.tqat(sz - 20 + i))) {
encrypted.fill(0);
sha.reset();
return -8; // hash error.
}
}
sha.reset();
// chop off the leading blksz+4 bytes
TQByteArray tmpenc;
tmpenc.duplicate(encrypted.data()+blksz+4, fsize);
encrypted.fill(0);
encrypted.duplicate(tmpenc.data(), tmpenc.size());
tmpenc.fill(0);
// Load the data structures up
TQDataStream eStream(encrypted, IO_ReadOnly);
while (!eStream.atEnd()) {
TQString folder;
TQ_UINT32 n;
eStream >> folder;
eStream >> n;
// Force initialisation
_entries[folder].clear();
for (size_t i = 0; i < n; i++) {
TQString key;
KWallet::Wallet::EntryType et = KWallet::Wallet::Unknown;
Entry *e = new Entry;
eStream >> key;
TQ_INT32 x = 0; // necessary to read properly
eStream >> x;
et = static_cast<KWallet::Wallet::EntryType>(x);
switch (et) {
case KWallet::Wallet::Password:
case KWallet::Wallet::Stream:
case KWallet::Wallet::Map:
break;
default: // Unknown entry
delete e;
continue;
}
TQByteArray a;
eStream >> a;
e->setValue(a);
e->setType(et);
e->setKey(key);
_entries[folder][key] = e;
}
}
_open = true;
return 0;
}
int Backend::sync(const TQByteArray& password) {
if (!_open) {
return -255; // not open yet
}
KSaveFile sf(_path, 0600);
TQFile *qf = sf.file();
if (!qf) {
sf.abort();
return -1; // error opening file
}
qf->writeBlock(KWMAGIC, KWMAGIC_LEN);
// Write the version number
TQByteArray version(4);
version[0] = KWALLET_VERSION_MAJOR;
version[1] = KWALLET_VERSION_MINOR;
version[2] = KWALLET_CIPHER_BLOWFISH_CBC;
version[3] = KWALLET_HASH_SHA1;
qf->writeBlock(version, 4);
// Holds the hashes we write out
TQByteArray hashes;
TQDataStream hashStream(hashes, IO_WriteOnly);
KMD5 md5;
hashStream << static_cast<TQ_UINT32>(_entries.count());
// Holds decrypted data prior to encryption
TQByteArray decrypted;
// FIXME: we should estimate the amount of data we will write in each
// buffer and resize them approximately in order to avoid extra
// resizes.
// populate decrypted
TQDataStream dStream(decrypted, IO_WriteOnly);
for (FolderMap::ConstIterator i = _entries.begin(); i != _entries.end(); ++i) {
dStream << i.key();
dStream << static_cast<TQ_UINT32>(i.data().count());
md5.reset();
md5.update(i.key().utf8());
hashStream.writeRawBytes(reinterpret_cast<const char*>(&(md5.rawDigest()[0])), 16);
hashStream << static_cast<TQ_UINT32>(i.data().count());
for (EntryMap::ConstIterator j = i.data().begin(); j != i.data().end(); ++j) {
dStream << j.key();
dStream << static_cast<TQ_INT32>(j.data()->type());
dStream << j.data()->value();
md5.reset();
md5.update(j.key().utf8());
hashStream.writeRawBytes(reinterpret_cast<const char*>(&(md5.rawDigest()[0])), 16);
}
}
qf->writeBlock(hashes, hashes.size());
// calculate the hash of the file
SHA1 sha;
BlowFish _bf;
CipherBlockChain bf(&_bf);
sha.process(decrypted.data(), decrypted.size());
// prepend and append the random data
TQByteArray wholeFile;
long blksz = bf.blockSize();
long newsize = decrypted.size() +
blksz + // encrypted block
4 + // file size
20; // size of the SHA hash
int delta = (blksz - (newsize % blksz));
newsize += delta;
wholeFile.resize(newsize);
TQByteArray randBlock;
randBlock.resize(blksz+delta);
if (getRandomBlock(randBlock) < 0) {
sha.reset();
decrypted.fill(0);
sf.abort();
return -3; // Fatal error: can't get random
}
for (int i = 0; i < blksz; i++) {
wholeFile[i] = randBlock[i];
}
for (int i = 0; i < 4; i++) {
wholeFile[(int)(i+blksz)] = (decrypted.size() >> 8*(3-i))&0xff;
}
for (unsigned int i = 0; i < decrypted.size(); i++) {
wholeFile[(int)(i+blksz+4)] = decrypted[i];
}
for (int i = 0; i < delta; i++) {
wholeFile[(int)(i+blksz+4+decrypted.size())] = randBlock[(int)(i+blksz)];
}
const char *hash = (const char *)sha.hash();
for (int i = 0; i < 20; i++) {
wholeFile[(int)(newsize - 20 + i)] = hash[i];
}
sha.reset();
decrypted.fill(0);
// hash the passphrase
TQByteArray passhash;
password2hash(password, passhash);
// encrypt the data
if (!bf.setKey(passhash.data(), passhash.size() * 8)) {
passhash.fill(0);
wholeFile.fill(0);
sf.abort();
return -2;
}
int rc = bf.encrypt(wholeFile.data(), wholeFile.size());
if (rc < 0) {
passhash.fill(0);
wholeFile.fill(0);
sf.abort();
return -2; // encrypt error
}
passhash.fill(0); // passhash is UNUSABLE NOW
// write the file
qf->writeBlock(wholeFile, wholeFile.size());
if (!sf.close()) {
wholeFile.fill(0);
sf.abort();
return -4; // write error
}
wholeFile.fill(0);
return 0;
}
int Backend::close(const TQByteArray& password) {
int rc = sync(password);
_open = false;
if (rc != 0) {
return rc;
}
return close();
}
const TQString& Backend::walletName() const {
return _name;
}
bool Backend::isOpen() const {
return _open;
}
TQStringList Backend::folderList() const {
return _entries.keys();
}
TQStringList Backend::entryList() const {
return _entries[_folder].keys();
}
Entry *Backend::readEntry(const TQString& key) {
Entry *rc = 0L;
if (_open && hasEntry(key)) {
rc = _entries[_folder][key];
}
return rc;
}
TQPtrList<Entry> Backend::readEntryList(const TQString& key) {
TQPtrList<Entry> rc;
if (!_open) {
return rc;
}
TQRegExp re(key, true, true);
const EntryMap& map = _entries[_folder];
for (EntryMap::ConstIterator i = map.begin(); i != map.end(); ++i) {
if (re.exactMatch(i.key())) {
rc.append(i.data());
}
}
return rc;
}
bool Backend::createFolder(const TQString& f) {
if (_entries.tqcontains(f)) {
return false;
}
_entries.insert(f, EntryMap());
KMD5 folderMd5;
folderMd5.update(f.utf8());
_hashes.insert(MD5Digest(folderMd5.rawDigest()), TQValueList<MD5Digest>());
return true;
}
int Backend::renameEntry(const TQString& oldName, const TQString& newName) {
EntryMap& emap = _entries[_folder];
EntryMap::Iterator oi = emap.tqfind(oldName);
EntryMap::Iterator ni = emap.tqfind(newName);
if (oi != emap.end() && ni == emap.end()) {
Entry *e = oi.data();
emap.remove(oi);
emap[newName] = e;
KMD5 folderMd5;
folderMd5.update(_folder.utf8());
HashMap::iterator i = _hashes.tqfind(MD5Digest(folderMd5.rawDigest()));
if (i != _hashes.end()) {
KMD5 oldMd5, newMd5;
oldMd5.update(oldName.utf8());
newMd5.update(newName.utf8());
i.data().remove(MD5Digest(oldMd5.rawDigest()));
i.data().append(MD5Digest(newMd5.rawDigest()));
}
return 0;
}
return -1;
}
void Backend::writeEntry(Entry *e) {
if (!_open)
return;
if (!hasEntry(e->key())) {
_entries[_folder][e->key()] = new Entry;
}
_entries[_folder][e->key()]->copy(e);
KMD5 folderMd5;
folderMd5.update(_folder.utf8());
HashMap::iterator i = _hashes.tqfind(MD5Digest(folderMd5.rawDigest()));
if (i != _hashes.end()) {
KMD5 md5;
md5.update(e->key().utf8());
i.data().append(MD5Digest(md5.rawDigest()));
}
}
bool Backend::hasEntry(const TQString& key) const {
return _entries.tqcontains(_folder) && _entries[_folder].tqcontains(key);
}
bool Backend::removeEntry(const TQString& key) {
if (!_open) {
return false;
}
FolderMap::Iterator fi = _entries.tqfind(_folder);
EntryMap::Iterator ei = fi.data().tqfind(key);
if (fi != _entries.end() && ei != fi.data().end()) {
delete ei.data();
fi.data().remove(ei);
KMD5 folderMd5;
folderMd5.update(_folder.utf8());
HashMap::iterator i = _hashes.tqfind(MD5Digest(folderMd5.rawDigest()));
if (i != _hashes.end()) {
KMD5 md5;
md5.update(key.utf8());
i.data().remove(MD5Digest(md5.rawDigest()));
}
return true;
}
return false;
}
bool Backend::removeFolder(const TQString& f) {
if (!_open) {
return false;
}
FolderMap::Iterator fi = _entries.tqfind(f);
if (fi != _entries.end()) {
if (_folder == f) {
_folder = TQString::null;
}
for (EntryMap::Iterator ei = fi.data().begin(); ei != fi.data().end(); ++ei) {
delete ei.data();
}
_entries.remove(fi);
KMD5 folderMd5;
folderMd5.update(f.utf8());
_hashes.erase(MD5Digest(folderMd5.rawDigest()));
return true;
}
return false;
}
bool Backend::folderDoesNotExist(const TQString& folder) const {
KMD5 md5;
md5.update(folder.utf8());
return !_hashes.tqcontains(MD5Digest(md5.rawDigest()));
}
bool Backend::entryDoesNotExist(const TQString& folder, const TQString& entry) const {
KMD5 md5;
md5.update(folder.utf8());
HashMap::const_iterator i = _hashes.tqfind(MD5Digest(md5.rawDigest()));
if (i != _hashes.end()) {
md5.reset();
md5.update(entry.utf8());
return !i.data().tqcontains(MD5Digest(md5.rawDigest()));
}
return true;
}