cmssigner/main.cpp

The code below shows how to use Cryptographic Message Syntax (CMS) in a GUI application.

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef CERTITEM_H
#define CERTITEM_H

#include <QAbstractListModel>
#include <QSharedDataPointer>

class QString;
class QStringList;

namespace QCA
{
        class PrivateKey;
        class CertificateChain;
        class KeyStoreEntry;
}

class CertItemStore;
class CertItemStorePrivate;
class CertItemPrivateLoaderPrivate;

class CertItem
{
public:
        enum StorageType
        {
                File,
                KeyStore
        };

        CertItem();
        CertItem(const CertItem &from);
        ~CertItem();
        CertItem & operator=(const CertItem &from);

        QString name() const;
        QCA::CertificateChain certificateChain() const;
        bool havePrivate() const;
        StorageType storageType() const; // private key storage type
        bool isUsable() const; // file/provider present

private:
        class Private;
        QSharedDataPointer<Private> d;

        friend class CertItemStore;
        friend class CertItemStorePrivate;
        friend class CertItemPrivateLoader;
        friend class CertItemPrivateLoaderPrivate;
};

class CertItemStore : public QAbstractListModel
{
        Q_OBJECT
public:
        enum IconType
        {
                IconCert,
                IconCrl,
                IconKeyBundle,
                IconPgpPub,
                IconPgpSec
        };

        CertItemStore(QObject *parent = 0);
        ~CertItemStore();

        int idFromRow(int row) const;
        int rowFromId(int id) const;
        CertItem itemFromId(int id) const;
        CertItem itemFromRow(int row) const;

        QList<CertItem> items() const;

        QStringList save() const;
        bool load(const QStringList &in);

        // returns a reqId
        int addFromFile(const QString &fileName);
        int addFromKeyStore(const QCA::KeyStoreEntry &entry);
        int addUser(const QCA::CertificateChain &chain);

        void updateChain(int id, const QCA::CertificateChain &chain);

        void removeItem(int id);

        void setIcon(IconType type, const QPixmap &icon);

        // reimplemented
        int rowCount(const QModelIndex &parent = QModelIndex()) const;
        QVariant data(const QModelIndex &index, int role) const;
        Qt::ItemFlags flags(const QModelIndex &index) const;
        bool setData(const QModelIndex &index, const QVariant &value, int role);

signals:
        void addSuccess(int reqId, int id);
        void addFailed(int reqId);

private:
        friend class CertItemStorePrivate;
        CertItemStorePrivate *d;

        friend class CertItemPrivateLoader;
        friend class CertItemPrivateLoaderPrivate;
};

class CertItemPrivateLoader : public QObject
{
        Q_OBJECT
public:
        CertItemPrivateLoader(CertItemStore *store, QObject *parent = 0);
        ~CertItemPrivateLoader();

        void start(int id);

        QCA::PrivateKey privateKey() const;

signals:
        void finished();

private:
        friend class CertItemPrivateLoaderPrivate;
        CertItemPrivateLoaderPrivate *d;
};

#endif

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include "certitem.h"

#include <QtCore>
#include <QtGui>
#include <QtCrypto>
#include "prompter.h"

typedef QMap<CertItemStore::IconType,QPixmap> CertItemIconset;

//----------------------------------------------------------------------------
// MyPrompter
//----------------------------------------------------------------------------
class MyPrompter : public Prompter
{
        Q_OBJECT
private:
        QMap<QString,QCA::SecureArray> known;
        QMap<QString,QCA::SecureArray> maybe;

public:
        MyPrompter(QObject *parent = 0) :
                Prompter(parent)
        {
        }

        void fileSuccess(const QString &fileName)
        {
                if(maybe.contains(fileName))
                {
                        known[fileName] = maybe[fileName];
                        maybe.remove(fileName);
                }
        }

        void fileFailed(const QString &fileName)
        {
                maybe.remove(fileName);
                known.remove(fileName);
        }

protected:
        virtual QCA::SecureArray knownPassword(const QCA::Event &event)
        {
                if(event.source() == QCA::Event::Data && !event.fileName().isEmpty())
                        return known.value(event.fileName());
                else
                        return QCA::SecureArray();
        }

        virtual void userSubmitted(const QCA::SecureArray &password, const QCA::Event &event)
        {
                if(event.source() == QCA::Event::Data && !event.fileName().isEmpty())
                        maybe[event.fileName()] = password;
        }
};

//----------------------------------------------------------------------------
// CertItem
//----------------------------------------------------------------------------
static QString escape(const QString &in)
{
        QString out;
        for(int n = 0; n < in.length(); ++n)
        {
                if(in[n] == '\\')
                        out += "\\\\";
                else if(in[n] == ':')
                        out += "\\c";
                else if(in[n] == '\n')
                        out += "\\n";
                else
                        out += in[n];
        }
        return out;
}

static QString unescape(const QString &in)
{
        QString out;
        for(int n = 0; n < in.length(); ++n)
        {
                if(in[n] == '\\')
                {
                        if(n + 1 < in.length())
                        {
                                ++n;
                                if(in[n] == '\\')
                                        out += '\\';
                                else if(in[n] == 'c')
                                        out += ':';
                                else if(in[n] == 'n')
                                        out += '\n';
                        }
                }
                else
                        out += in[n];
        }
        return out;
}

class CertItem::Private : public QSharedData
{
public:
        QString name;
        QCA::CertificateChain chain;
        bool havePrivate;
        StorageType storageType;
        bool usable;

        QString fileName;
        QCA::KeyStoreEntry keyStoreEntry;
        QString keyStoreEntryString;

        Private() :
                havePrivate(false),
                storageType(File),
                usable(false)
        {
        }

        QString toString() const
        {
                QStringList parts;

                parts += name;
                parts += QString::number(chain.count());
                foreach(const QCA::Certificate &cert, chain)
                        parts += QCA::Base64().arrayToString(cert.toDER());

                if(havePrivate)
                {
                        if(storageType == File)
                        {
                                parts += "privateFile";
                                parts += fileName;
                        }
                        else // KeyStoreEntry
                        {
                                parts += "privateEntry";
                                if(!keyStoreEntry.isNull())
                                        parts += keyStoreEntry.toString();
                                else
                                        parts += keyStoreEntryString;
                        }
                }

                for(int n = 0; n < parts.count(); ++n)
                        parts[n] = escape(parts[n]);
                return parts.join(":");
        }

        bool fromString(const QString &in)
        {
                QStringList parts = in.split(':');
                for(int n = 0; n < parts.count(); ++n)
                        parts[n] = unescape(parts[n]);

                if(parts.count() < 3)
                        return false;

                name = parts[0];
                int chainCount = parts[1].toInt();
                if(chainCount < 1 || chainCount > parts.count() - 2)
                        return false;
                chain.clear();
                for(int n = 0; n < chainCount; ++n)
                {
                        QCA::Certificate cert = QCA::Certificate::fromDER(QCA::Base64().stringToArray(parts[n + 2]).toByteArray());
                        if(cert.isNull())
                                return false;
                        chain += cert;
                }
                int at = chain.count() + 2;

                if(at < parts.count())
                {
                        havePrivate = true;
                        usable = false;

                        if(parts[at] == "privateFile")
                        {
                                storageType = File;
                                fileName = parts[at + 1];
                                if(QFile::exists(fileName))
                                        usable = true;
                        }
                        else if(parts[at] == "privateEntry")
                        {
                                storageType = KeyStore;
                                keyStoreEntryString = parts[at + 1];
                                keyStoreEntry = QCA::KeyStoreEntry(keyStoreEntryString);
                                if(!keyStoreEntry.isNull())
                                        usable = true;
                        }
                        else
                                return false;
                }

                return true;
        }
};

CertItem::CertItem()
{
}

CertItem::CertItem(const CertItem &from) :
        d(from.d)
{
}

CertItem::~CertItem()
{
}

CertItem & CertItem::operator=(const CertItem &from)
{
        d = from.d;
        return *this;
}

QString CertItem::name() const
{
        return d->name;
}

QCA::CertificateChain CertItem::certificateChain() const
{
        return d->chain;
}

bool CertItem::havePrivate() const
{
        return d->havePrivate;
}

CertItem::StorageType CertItem::storageType() const
{
        return d->storageType;
}

bool CertItem::isUsable() const
{
        return d->usable;
}

//----------------------------------------------------------------------------
// CertItemStore
//----------------------------------------------------------------------------
class CertItemStorePrivate : public QObject
{
        Q_OBJECT
public:
        CertItemStore *q;
        MyPrompter *prompter;
        QList<CertItem> list;
        QList<int> idList;
        CertItemIconset iconset;
        int next_id;
        int next_req_id;

        class LoaderItem
        {
        public:
                int req_id;
                QCA::KeyLoader *keyLoader;
                QString fileName;
        };

        QList<LoaderItem> loaders;

        CertItemStorePrivate(CertItemStore *_q) :
                QObject(_q),
                q(_q),
                next_id(0),
                next_req_id(0)
        {
                prompter = new MyPrompter(this);
        }

        ~CertItemStorePrivate()
        {
                foreach(const LoaderItem &i, loaders)
                        delete i.keyLoader;
        }

        QString getUniqueName(const QString &name)
        {
                int num = 1;
                while(1)
                {
                        QString tryname;
                        if(num == 1)
                                tryname = name;
                        else
                                tryname = name + QString(" (%1)").arg(num);

                        bool found = false;
                        foreach(const CertItem &i, list)
                        {
                                if(i.name() == tryname)
                                {
                                        found = true;
                                        break;
                                }
                        }
                        if(!found)
                                return tryname;

                        ++num;
                }
        }

        static QString convertErrorToString(QCA::ConvertResult r)
        {
                QString str;
                switch(r)
                {
                        case QCA::ConvertGood:      break;
                        case QCA::ErrorPassphrase:  str = tr("Incorrect passphrase.");
                        case QCA::ErrorFile:        str = tr("Unable to open or read file.");
                        case QCA::ErrorDecode:
                        default:                    str = tr("Unable to decode format.");
                }
                return str;
        }

public slots:
        void loader_finished()
        {
                QCA::KeyLoader *keyLoader = (QCA::KeyLoader *)sender();
                int at = -1;
                for(int n = 0; n < loaders.count(); ++n)
                {
                        if(loaders[n].keyLoader == keyLoader)
                        {
                                at = n;
                                break;
                        }
                }
                Q_ASSERT(at != -1);

                int req_id = loaders[at].req_id;
                QString fileName = loaders[at].fileName;
                loaders.removeAt(at);

                QCA::ConvertResult r = keyLoader->convertResult();
                if(r != QCA::ConvertGood)
                {
                        delete keyLoader;
                        prompter->fileFailed(fileName);
                        QMessageBox::information(0, tr("Error"),
                                tr("Error importing certificate and private key.\nReason: %1").arg(convertErrorToString(r)));
                        emit q->addFailed(req_id);
                        return;
                }

                prompter->fileSuccess(fileName);

                QCA::KeyBundle kb = keyLoader->keyBundle();
                delete keyLoader;

                QCA::CertificateChain chain = kb.certificateChain();
                QCA::Certificate cert = chain.primary();

                QString name = getUniqueName(cert.commonName());

                CertItem i;
                i.d = new CertItem::Private;
                i.d->name = name;
                i.d->chain = chain;
                i.d->havePrivate = true;
                i.d->storageType = CertItem::File;
                i.d->usable = true;
                i.d->fileName = fileName;

                int id = next_id++;

                q->beginInsertRows(QModelIndex(), list.size(), list.size());
                list += i;
                idList += id;
                q->endInsertRows();

                emit q->addSuccess(req_id, id);
        }
};

CertItemStore::CertItemStore(QObject *parent) :
        QAbstractListModel(parent)
{
        d = new CertItemStorePrivate(this);
}

CertItemStore::~CertItemStore()
{
        delete d;
}

int CertItemStore::idFromRow(int row) const
{
        return d->idList[row];
}

int CertItemStore::rowFromId(int id) const
{
        for(int n = 0; n < d->idList.count(); ++n)
        {
                if(d->idList[n] == id)
                        return n;
        }
        return -1;
}

CertItem CertItemStore::itemFromId(int id) const
{
        return d->list[rowFromId(id)];
}

CertItem CertItemStore::itemFromRow(int row) const
{
        return d->list[row];
}

QList<CertItem> CertItemStore::items() const
{
        return d->list;
}

QStringList CertItemStore::save() const
{
        QStringList out;
        foreach(const CertItem &i, d->list)
                out += i.d->toString();
        return out;
}

bool CertItemStore::load(const QStringList &in)
{
        QList<CertItem> addList;
        QList<int> addIdList;
        foreach(const QString &s, in)
        {
                CertItem i;
                i.d = new CertItem::Private;
                if(i.d->fromString(s))
                {
                        addList += i;
                        addIdList += d->next_id++;
                }
        }

        if(addList.isEmpty())
                return true;

        beginInsertRows(QModelIndex(), d->list.size(), d->list.size() + addList.count() - 1);
        d->list += addList;
        d->idList += addIdList;
        endInsertRows();

        return true;
}

int CertItemStore::addFromFile(const QString &fileName)
{
        CertItemStorePrivate::LoaderItem i;
        i.req_id = d->next_req_id++;
        i.keyLoader = new QCA::KeyLoader(d);
        i.fileName = fileName;
        connect(i.keyLoader, SIGNAL(finished()), d, SLOT(loader_finished()));
        d->loaders += i;
        i.keyLoader->loadKeyBundleFromFile(fileName);
        return i.req_id;
}

int CertItemStore::addFromKeyStore(const QCA::KeyStoreEntry &entry)
{
        QCA::KeyBundle kb = entry.keyBundle();

        QCA::CertificateChain chain = kb.certificateChain();
        QCA::Certificate cert = chain.primary();

        QString name = d->getUniqueName(entry.name());

        CertItem i;
        i.d = new CertItem::Private;
        i.d->name = name;
        i.d->chain = chain;
        i.d->havePrivate = true;
        i.d->storageType = CertItem::KeyStore;
        i.d->usable = true;
        i.d->keyStoreEntry = entry;

        int id = d->next_id++;

        beginInsertRows(QModelIndex(), d->list.size(), d->list.size());
        d->list += i;
        d->idList += id;
        endInsertRows();

        int req_id = d->next_req_id++;
        QMetaObject::invokeMethod(this, "addSuccess", Qt::QueuedConnection, Q_ARG(int, req_id), Q_ARG(int, id));
        return req_id;
}

int CertItemStore::addUser(const QCA::CertificateChain &chain)
{
        QCA::Certificate cert = chain.primary();

        QString name = d->getUniqueName(cert.commonName());

        CertItem i;
        i.d = new CertItem::Private;
        i.d->name = name;
        i.d->chain = chain;

        int id = d->next_id++;

        beginInsertRows(QModelIndex(), d->list.size(), d->list.size());
        d->list += i;
        d->idList += id;
        endInsertRows();

        int req_id = d->next_req_id++;
        QMetaObject::invokeMethod(this, "addSuccess", Qt::QueuedConnection, Q_ARG(int, req_id), Q_ARG(int, id));
        return req_id;
}

void CertItemStore::updateChain(int id, const QCA::CertificateChain &chain)
{
}

void CertItemStore::removeItem(int id)
{
        int at = rowFromId(id);

        beginRemoveRows(QModelIndex(), at, at);
        d->list.removeAt(at);
        d->idList.removeAt(at);
        endRemoveRows();
}

void CertItemStore::setIcon(IconType type, const QPixmap &icon)
{
        d->iconset[type] = icon;
}

int CertItemStore::rowCount(const QModelIndex &parent) const
{
        Q_UNUSED(parent);
        return d->list.count();
}

QVariant CertItemStore::data(const QModelIndex &index, int role) const
{
        if(!index.isValid())
                return QVariant();

        int at = index.row();
        QList<CertItem> &list = d->list;

        if(at >= list.count())
                return QVariant();

        if(role == Qt::DisplayRole)
        {
                QString str = list[at].name();
                if(list[at].havePrivate() && !list[at].isUsable())
                        str += QString(" ") + tr("(not usable)");
                return str;
        }
        else if(role == Qt::EditRole)
                return list[at].name();
        else if(role == Qt::DecorationRole)
        {
                if(list[at].havePrivate())
                        return d->iconset[CertItemStore::IconKeyBundle];
                else
                        return d->iconset[CertItemStore::IconCert];
        }
        else
                return QVariant();
}

Qt::ItemFlags CertItemStore::flags(const QModelIndex &index) const
{
        if(!index.isValid())
                return Qt::ItemIsEnabled;

        return Qt::ItemIsEnabled | Qt::ItemIsSelectable | Qt::ItemIsEditable;
}

bool CertItemStore::setData(const QModelIndex &index, const QVariant &value, int role)
{
        if(index.isValid() && role == Qt::EditRole)
        {
                QString str = value.toString();
                d->list[index.row()].d->name = str;
                emit dataChanged(index, index);
                return true;
        }
        return false;
}

//----------------------------------------------------------------------------
// CertItemPrivateLoader
//----------------------------------------------------------------------------
class CertItemPrivateLoaderPrivate : public QObject
{
        Q_OBJECT
public:
        CertItemPrivateLoader *q;
        CertItemStore *store;
        QCA::KeyLoader *loader;
        QString fileName;
        QCA::PrivateKey key;

        CertItemPrivateLoaderPrivate(CertItemPrivateLoader *_q) :
                QObject(_q),
                q(_q)
        {
        }

public slots:
        void loader_finished()
        {
                QCA::ConvertResult r = loader->convertResult();
                if(r != QCA::ConvertGood)
                {
                        delete loader;
                        loader = 0;
                        store->d->prompter->fileFailed(fileName);
                        QMessageBox::information(0, tr("Error"),
                                tr("Error accessing private key.\nReason: %1").arg(CertItemStorePrivate::convertErrorToString(r)));
                        emit q->finished();
                        return;
                }

                store->d->prompter->fileSuccess(fileName);

                key = loader->keyBundle().privateKey();
                delete loader;
                loader = 0;
                emit q->finished();
        }
};

CertItemPrivateLoader::CertItemPrivateLoader(CertItemStore *store, QObject *parent) :
        QObject(parent)
{
        d = new CertItemPrivateLoaderPrivate(this);
        d->store = store;
}

CertItemPrivateLoader::~CertItemPrivateLoader()
{
        delete d;
}

void CertItemPrivateLoader::start(int id)
{
        CertItem i = d->store->itemFromId(id);

        if(i.storageType() == CertItem::KeyStore)
        {
                d->key = i.d->keyStoreEntry.keyBundle().privateKey();
                QMetaObject::invokeMethod(this, "finished", Qt::QueuedConnection);
                return;
        }

        d->key = QCA::PrivateKey();
        d->fileName = i.d->fileName;
        d->loader = new QCA::KeyLoader(d);
        connect(d->loader, SIGNAL(finished()), d, SLOT(loader_finished()));
        d->loader->loadKeyBundleFromFile(d->fileName);
}

QCA::PrivateKey CertItemPrivateLoader::privateKey() const
{
        return d->key;
}

#include "certitem.moc"

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef CERTVIEWDLG_H
#define CERTVIEWDLG_H

#include <QDialog>

namespace QCA
{
        class CertificateChain;
}

class CertViewDlg : public QDialog
{
        Q_OBJECT
public:
        CertViewDlg(const QCA::CertificateChain &chain, QWidget *parent = 0);
        ~CertViewDlg();

private:
        class Private;
        Private *d;
};

#endif

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include "certviewdlg.h"

#include <QtCore>
#include <QtGui>
#include <QtCrypto>
#include "ui_certview.h"

// from qcatool
class InfoType
{
public:
        QCA::CertificateInfoType type;
        QString varname;
        QString shortname;
        QString name;
        QString desc;

        InfoType()
        {
        }

        InfoType(QCA::CertificateInfoType _type, const QString &_varname, const QString &_shortname, const QString &_name, const QString &_desc) :
                type(_type),
                varname(_varname),
                shortname(_shortname),
                name(_name),
                desc(_desc)
        {
        }
};

static QList<InfoType> makeInfoTypeList(bool legacyEmail = false)
{
        QList<InfoType> out;
        out += InfoType(QCA::CommonName,             "CommonName",             "CN",  CertViewDlg::tr("Common Name (CN)"),          "Full name, domain, anything");
        out += InfoType(QCA::Email,                  "Email",                  "",    CertViewDlg::tr("Email Address"),             "");
        if(legacyEmail)
                out += InfoType(QCA::EmailLegacy,            "EmailLegacy",       "",    CertViewDlg::tr("PKCS#9 Email Address"),      "");
        out += InfoType(QCA::Organization,           "Organization",           "O",   CertViewDlg::tr("Organization (O)"),          "Company, group, etc");
        out += InfoType(QCA::OrganizationalUnit,     "OrganizationalUnit",     "OU",  CertViewDlg::tr("Organizational Unit (OU)"),  "Division/branch of organization");
        out += InfoType(QCA::Locality,               "Locality",               "",    CertViewDlg::tr("Locality (L)"),              "City, shire, part of a state");
        out += InfoType(QCA::State,                  "State",                  "",    CertViewDlg::tr("State (ST)"),                "State within the country");
        out += InfoType(QCA::Country,                "Country",                "C",   CertViewDlg::tr("Country Code (C)"),          "2-letter code");
        out += InfoType(QCA::IncorporationLocality,  "IncorporationLocality",  "",    CertViewDlg::tr("Incorporation Locality"),    "For EV certificates");
        out += InfoType(QCA::IncorporationState,     "IncorporationState",     "",    CertViewDlg::tr("Incorporation State"),       "For EV certificates");
        out += InfoType(QCA::IncorporationCountry,   "IncorporationCountry",   "",    CertViewDlg::tr("Incorporation Country"),     "For EV certificates");
        out += InfoType(QCA::URI,                    "URI",                    "",    CertViewDlg::tr("URI"),                       "");
        out += InfoType(QCA::DNS,                    "DNS",                    "",    CertViewDlg::tr("Domain Name"),               "Domain (dnsName)");
        out += InfoType(QCA::IPAddress,              "IPAddress",              "",    CertViewDlg::tr("IP Adddress"),               "");
        out += InfoType(QCA::XMPP,                   "XMPP",                   "",    CertViewDlg::tr("XMPP Address (JID)"),        "From RFC 3920 (id-on-xmppAddr)");
        return out;
}

static QString try_print_info(const QString &name, const QStringList &values)
{
        QString out;
        if(!values.isEmpty())
        {
                QString value = values.join(", ");
                out = QString("   ") + CertViewDlg::tr("%1: %2").arg(name, value) + '\n';
        }
        return out;
}

static QString print_info(const QString &title, const QCA::CertificateInfo &info)
{
        QString out;
        QList<InfoType> list = makeInfoTypeList();
        out += title + '\n';
        foreach(const InfoType &t, list)
                out += try_print_info(t.name, info.values(t.type));
        return out;
}

static QString cert_info_string(const QCA::Certificate &cert)
{
        QString out;
        out += CertViewDlg::tr("Serial Number: %1").arg(cert.serialNumber().toString()) + '\n';
        out += print_info(CertViewDlg::tr("Subject"), cert.subjectInfo());
        out += print_info(CertViewDlg::tr("Issuer"), cert.issuerInfo());
        out += CertViewDlg::tr("Validity") + '\n';
        out += QString("   ") + CertViewDlg::tr("Not before: %1").arg(cert.notValidBefore().toString()) + '\n';
        out += QString("   ") + CertViewDlg::tr("Not after:  %1").arg(cert.notValidAfter().toString()) + '\n';
        return out;
}

class CertViewDlg::Private : public QObject
{
        Q_OBJECT
public:
        CertViewDlg *q;
        Ui_CertView ui;
        QCA::CertificateChain chain;

        Private(CertViewDlg *_q) :
                QObject(_q),
                q(_q)
        {
                ui.setupUi(q);
                connect(ui.cb_chain, SIGNAL(activated(int)), SLOT(cb_activated(int)));
                ui.lb_info->setTextInteractionFlags(Qt::TextSelectableByMouse);
        }

        void update()
        {
                QStringList names = QCA::makeFriendlyNames(chain);
                ui.cb_chain->clear();
                foreach(const QString &s, names)
                        ui.cb_chain->insertItem(ui.cb_chain->count(), s);
                updateInfo();
        }

        void updateInfo()
        {
                int x = ui.cb_chain->currentIndex();
                if(x == -1)
                {
                        ui.lb_info->setText("");
                        return;
                }

                ui.lb_info->setText(cert_info_string(chain[x]));
        }

private slots:
        void cb_activated(int)
        {
                updateInfo();
        }
};

CertViewDlg::CertViewDlg(const QCA::CertificateChain &chain, QWidget *parent) :
        QDialog(parent)
{
        d = new Private(this);
        d->chain = chain;
        d->update();
}

CertViewDlg::~CertViewDlg()
{
        delete d;
}

#include "certviewdlg.moc"

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef KEYSELECTDLG_H
#define KEYSELECTDLG_H

#include <QDialog>

class QPixmap;

namespace QCA
{
        class CertificateChain;
        class KeyStoreEntry;
}

class KeySelectDlg : public QDialog
{
        Q_OBJECT
public:
        enum IconType
        {
                IconCert,
                IconCrl,
                IconKeyBundle,
                IconPgpPub,
                IconPgpSec
        };

        KeySelectDlg(QWidget *parent = 0);
        ~KeySelectDlg();

        void setIcon(IconType type, const QPixmap &icon);

signals:
        void selected(const QCA::KeyStoreEntry &entry);
        void viewCertificate(const QCA::CertificateChain &chain);

protected slots:
        virtual void accept();

private:
        class Private;
        friend class Private;
        Private *d;
};

#endif

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include "keyselectdlg.h"

#include <QtCore>
#include <QtGui>
#include <QtCrypto>
#include "ui_keyselect.h"

#define ONLY_SHOW_KEYBUNDLE

typedef QMap<KeySelectDlg::IconType,QPixmap> KeyStoreIconset;

class KeyStoreItemShared
{
public:
        KeyStoreIconset iconset;
        QString notAvailableString;
};

class KeyStoreItem : public QStandardItem
{
public:
        enum Type
        {
                Store = UserType,
                Entry
        };

        enum Role
        {
                NameRole = Qt::UserRole,
                SubTypeRole,
                AvailabilityRole,
                PositionRole
        };

        QPixmap entryTypeToIcon(QCA::KeyStoreEntry::Type type) const
        {
                QPixmap out;
                if(!_shared)
                        return out;
                const KeyStoreIconset &iconset = _shared->iconset;
                switch(type)
                {
                        case QCA::KeyStoreEntry::TypeKeyBundle:     out = iconset[KeySelectDlg::IconKeyBundle]; break;
                        case QCA::KeyStoreEntry::TypeCertificate:   out = iconset[KeySelectDlg::IconCert]; break;
                        case QCA::KeyStoreEntry::TypeCRL:           out = iconset[KeySelectDlg::IconCrl]; break;
                        case QCA::KeyStoreEntry::TypePGPSecretKey:  out = iconset[KeySelectDlg::IconPgpSec]; break;
                        case QCA::KeyStoreEntry::TypePGPPublicKey:  out = iconset[KeySelectDlg::IconPgpPub]; break;
                        default:                                    break;
                }
                return out;
        }

        Type _type;
        KeyStoreItemShared *_shared;

        QCA::KeyStore *keyStore;
        QCA::KeyStoreEntry keyStoreEntry;

        KeyStoreItem(Type type, KeyStoreItemShared *shared) :
                _type(type),
                _shared(shared)
        {
                setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
        }

        void setStore(const QString &name, QCA::KeyStore::Type type)
        {
                setData(name, NameRole);
                setData((int)type, SubTypeRole);
        }

        void setEntry(const QString &name, QCA::KeyStoreEntry::Type type, bool available, int pos)
        {
                setData(name, NameRole);
                setData((int)type, SubTypeRole);
                setData(available, AvailabilityRole);
                setData(pos, PositionRole);
        }

        virtual QVariant data(int role) const
        {
                if(role == Qt::DisplayRole)
                {
                        if(_type == Store)
                        {
                                return data(NameRole).toString();
                        }
                        else if(_type == Entry)
                        {
                                QString str = data(NameRole).toString();
                                if(_shared && !data(AvailabilityRole).toBool())
                                        str += QString(" ") + _shared->notAvailableString;
                                return str;
                        }
                        else
                                return QStandardItem::data(role);
                }
                else if(role == Qt::DecorationRole)
                {
                        if(_type == Entry)
                        {
                                QCA::KeyStoreEntry::Type type = (QCA::KeyStoreEntry::Type)data(SubTypeRole).toInt();
                                return entryTypeToIcon(type);
                        }
                        else
                                return QStandardItem::data(role);
                }
                else
                        return QStandardItem::data(role);
        }

        virtual int type() const
        {
                return _type;
        }

        virtual QStandardItem *clone() const
        {
                return new KeyStoreItem(*this);
        }
};

class KeyStoreModel : public QStandardItemModel
{
        Q_OBJECT
public:
        KeyStoreItemShared shared;

        QCA::KeyStoreManager ksm;

        KeyStoreModel(QObject *parent = 0) :
                QStandardItemModel(parent), ksm(this)
        {
                shared.notAvailableString = tr("(not available)");

                // make sure keystores are started
                QCA::KeyStoreManager::start();

                connect(&ksm, SIGNAL(keyStoreAvailable(const QString &)), SLOT(ks_available(const QString &)));
                QStringList list = ksm.keyStores();
                foreach(const QString &s, list)
                        ks_available(s);

                setSortRole(KeyStoreItem::PositionRole);
        }

        KeyStoreItem *itemFromStore(QCA::KeyStore *ks) const
        {
                for(int n = 0; n < rowCount(); ++n)
                {
                        KeyStoreItem *i = (KeyStoreItem *)item(n);
                        if(i->keyStore == ks)
                                return i;
                }
                return 0;
        }

private slots:
        void ks_available(const QString &keyStoreId)
        {
                QCA::KeyStore *ks = new QCA::KeyStore(keyStoreId, &ksm);

#ifdef ONLY_SHOW_KEYBUNDLE
                // only list stores containing keybundles (non-pgp identities)
                if(!ks->holdsIdentities() || ks->type() == QCA::KeyStore::PGPKeyring)
                        return;
#endif

                connect(ks, SIGNAL(updated()), SLOT(ks_updated()));
                connect(ks, SIGNAL(unavailable()), SLOT(ks_unavailable()));

                KeyStoreItem *store_item = new KeyStoreItem(KeyStoreItem::Store, &shared);
                store_item->setStore(ks->name(), ks->type());
                store_item->keyStore = ks;
                ks->startAsynchronousMode();
                appendRow(store_item);
        }

        void ks_updated()
        {
                QCA::KeyStore *ks = (QCA::KeyStore *)sender();
                KeyStoreItem *store_item = itemFromStore(ks);
                Q_ASSERT(store_item);

                QList<QCA::KeyStoreEntry> newEntries = ks->entryList();

#ifdef ONLY_SHOW_KEYBUNDLE
                // ignore entries that are not keybundles
                for(int n = 0; n < newEntries.count(); ++n)
                {
                        if(newEntries[n].type() != QCA::KeyStoreEntry::TypeKeyBundle)
                        {
                                newEntries.removeAt(n);
                                --n; // adjust position
                        }
                }
#endif

                // update the store item itself
                store_item->setStore(ks->name(), ks->type());

                // handle removed child entries
                for(int n = 0; n < store_item->rowCount(); ++n)
                {
                        KeyStoreItem *i = (KeyStoreItem *)store_item->child(n);

                        // is the existing entry in the new list?
                        bool found = false;
                        foreach(const QCA::KeyStoreEntry &ne, newEntries)
                        {
                                if(ne.id() == i->keyStoreEntry.id())
                                {
                                        found = true;
                                        break;
                                }
                        }

                        // if not, remove it
                        if(!found)
                        {
                                store_item->removeRow(n);
                                --n; // adjust position
                        }
                }

                // handle added/updated child entries
                for(int n = 0; n < newEntries.count(); ++n)
                {
                        const QCA::KeyStoreEntry &ne = newEntries[n];

                        // was this entry in the original list?
                        KeyStoreItem *entry_item = 0;
                        for(int k = 0; k < store_item->rowCount(); ++k)
                        {
                                KeyStoreItem *i = (KeyStoreItem *)store_item->child(k);
                                if(i->keyStoreEntry.id() == ne.id())
                                {
                                        entry_item = i;
                                        break;
                                }
                        }

                        // if not, add it
                        if(!entry_item)
                        {
                                entry_item = new KeyStoreItem(KeyStoreItem::Entry, &shared);
                                entry_item->keyStoreEntry = ne;
                                entry_item->setEntry(newEntries[n].name(), newEntries[n].type(), newEntries[n].isAvailable(), n);
                                store_item->appendRow(entry_item);
                        }
                        // if so, update it
                        else
                        {
                                entry_item->keyStoreEntry = ne;
                                entry_item->setEntry(newEntries[n].name(), newEntries[n].type(), newEntries[n].isAvailable(), n);
                        }
                }

                store_item->sortChildren(0);
        }

        void ks_unavailable()
        {
                QCA::KeyStore *ks = (QCA::KeyStore *)sender();
                KeyStoreItem *store_item = itemFromStore(ks);
                Q_ASSERT(store_item);

                store_item->removeRows(0, store_item->rowCount());
                removeRow(store_item->row());
                delete ks;
        }
};

class KeySelectDlg::Private : public QObject
{
        Q_OBJECT
public:
        KeySelectDlg *q;
        Ui_KeySelect ui;
        KeyStoreModel *model;
        QCA::KeyStoreEntry cur_entry;
        QAction *actionView;

        Private(KeySelectDlg *_q) :
                QObject(_q),
                q(_q)
        {
                ui.setupUi(q);

                model = new KeyStoreModel(this);
                connect(&model->ksm, SIGNAL(busyStarted()), SLOT(ksm_busyStarted()));
                connect(&model->ksm, SIGNAL(busyFinished()), SLOT(ksm_busyFinished()));
                if(model->ksm.isBusy())
                        ksm_busyStarted();

                ui.lv_stores->header()->hide();
                ui.buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
                ui.lv_stores->setModel(model);
                ui.lv_stores->setContextMenuPolicy(Qt::CustomContextMenu);
                connect(ui.lv_stores->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), SLOT(stores_selectionChanged(const QItemSelection &, const QItemSelection &)));
                connect(ui.lv_stores, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(stores_customContextMenuRequested(const QPoint &)));

                actionView = new QAction(tr("&View"), this);
                connect(actionView, SIGNAL(triggered()), SLOT(view()));
                actionView->setEnabled(false);
        }

private slots:
        void ksm_busyStarted()
        {
                ui.lb_busy->setText(tr("Looking for devices..."));
        }

        void ksm_busyFinished()
        {
                ui.lb_busy->setText("");
        }

        void stores_selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
        {
                Q_UNUSED(deselected);

                KeyStoreItem *i = 0;
                if(!selected.indexes().isEmpty())
                {
                        QModelIndex index = selected.indexes().first();
                        i = (KeyStoreItem *)model->itemFromIndex(index);
                }

                bool viewable = false;
                bool choosable = false;
                if(i && i->type() == KeyStoreItem::Entry)
                {
                        QCA::KeyStoreEntry entry = i->keyStoreEntry;
                        if(entry.type() == QCA::KeyStoreEntry::TypeKeyBundle)
                        {
                                viewable = true;
                                choosable = true;
                                cur_entry = entry;
                        }
                }

                if(!choosable)
                        cur_entry = QCA::KeyStoreEntry();

                actionView->setEnabled(viewable);

                QPushButton *ok = ui.buttonBox->button(QDialogButtonBox::Ok);
                if(choosable && !ok->isEnabled())
                        ok->setEnabled(true);
                else if(!choosable && ok->isEnabled())
                        ok->setEnabled(false);
        }

        void stores_customContextMenuRequested(const QPoint &pos)
        {
                QItemSelection selection = ui.lv_stores->selectionModel()->selection();
                if(selection.indexes().isEmpty())
                        return;

                QModelIndex index = selection.indexes().first();
                KeyStoreItem *i = (KeyStoreItem *)model->itemFromIndex(index);
                if(i && i->type() == KeyStoreItem::Entry)
                {
                        QMenu menu(q);
                        menu.addAction(actionView);
                        menu.exec(ui.lv_stores->viewport()->mapToGlobal(pos));
                }
        }

        void view()
        {
                emit q->viewCertificate(cur_entry.keyBundle().certificateChain());
        }
};

KeySelectDlg::KeySelectDlg(QWidget *parent) :
        QDialog(parent)
{
        d = new Private(this);
}

KeySelectDlg::~KeySelectDlg()
{
        delete d;
}

void KeySelectDlg::setIcon(IconType type, const QPixmap &icon)
{
        d->model->shared.iconset[type] = icon;
}

void KeySelectDlg::accept()
{
        QCA::KeyStoreEntry entry = d->cur_entry;
        QDialog::accept();
        emit selected(entry);
}

#include "keyselectdlg.moc"

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#ifndef PROMPTER_H
#define PROMPTER_H

#include <QObject>

namespace QCA
{
        class SecureArray;
        class Event;
}

class Prompter : public QObject
{
        Q_OBJECT
public:
        Prompter(QObject *parent = 0);
        ~Prompter();

protected:
        // called with every password event, to check for a known value.
        //   reimplement it to provide known/cached passwords.
        virtual QCA::SecureArray knownPassword(const QCA::Event &event);

        // called when a user-entered password is submitted.  note that this
        //   does not mean the password was correct.  to know if the password
        //   was correct, you'll have to match up the event information with
        //   the operation that triggered it.
        virtual void userSubmitted(const QCA::SecureArray &password, const QCA::Event &event);

private:
        class Private;
        friend class Private;
        Private *d;
};

#endif

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include "prompter.h"

#include <QtCore>
#include <QtGui>
#include <QtCrypto>

class Prompter::Private : public QObject
{
        Q_OBJECT
public:
        Prompter *q;

        class Item
        {
        public:
                int id;
                QCA::Event event;
        };

        QCA::EventHandler handler;
        QList<Item> pending;
        bool prompting;
        QMessageBox *token_prompt;
        bool auto_accept;

        QCA::KeyStoreManager ksm;
        QList<QCA::KeyStore*> keyStores;

        Private(Prompter *_q) :
                QObject(_q),
                q(_q),
                handler(this),
                prompting(false),
                token_prompt(0),
                ksm(this)
        {
                connect(&handler, SIGNAL(eventReady(int, const QCA::Event &)), SLOT(ph_eventReady(int, const QCA::Event &)));
                handler.start();

                connect(&ksm, SIGNAL(keyStoreAvailable(const QString &)), SLOT(ks_available(const QString &)));
                foreach(const QString &keyStoreId, ksm.keyStores())
                        ks_available(keyStoreId);
        }

        ~Private()
        {
                qDeleteAll(keyStores);

                while(!pending.isEmpty())
                        handler.reject(pending.takeFirst().id);
        }

private slots:
        void ph_eventReady(int id, const QCA::Event &event)
        {
                Item i;
                i.id = id;
                i.event = event;
                pending += i;
                nextEvent();
        }

        void nextEvent()
        {
                if(prompting || pending.isEmpty())
                        return;

                prompting = true;

                const Item &i = pending.first();
                const int &id = i.id;
                const QCA::Event &event = i.event;

                if(event.type() == QCA::Event::Password)
                {
                        QCA::SecureArray known = q->knownPassword(event);
                        if(!known.isEmpty())
                        {
                                handler.submitPassword(id, known);
                                goto end;
                        }

                        QString type = Prompter::tr("password");
                        if(event.passwordStyle() == QCA::Event::StylePassphrase)
                                type = Prompter::tr("passphrase");
                        else if(event.passwordStyle() == QCA::Event::StylePIN)
                                type = Prompter::tr("PIN");

                        QString str;
                        if(event.source() == QCA::Event::KeyStore)
                        {
                                QString name;
                                QCA::KeyStoreEntry entry = event.keyStoreEntry();
                                if(!entry.isNull())
                                {
                                        name = entry.name();
                                }
                                else
                                {
                                        if(event.keyStoreInfo().type() == QCA::KeyStore::SmartCard)
                                                name = Prompter::tr("the '%1' token").arg(event.keyStoreInfo().name());
                                        else
                                                name = event.keyStoreInfo().name();
                                }
                                str = Prompter::tr("Enter %1 for %2").arg(type, name);
                        }
                        else if(!event.fileName().isEmpty())
                        {
                                QFileInfo fi(event.fileName());
                                str = Prompter::tr("Enter %1 for %2:").arg(type, fi.fileName());
                        }
                        else
                                str = Prompter::tr("Enter %1:").arg(type);

                        bool ok;
                        QString pass = QInputDialog::getText(0, QApplication::instance()->applicationName() + ": " + tr("Prompt"), str, QLineEdit::Password, QString(), &ok);
                        if(ok)
                        {
                                QCA::SecureArray password = pass.toUtf8();
                                q->userSubmitted(password, event);
                                handler.submitPassword(id, password);
                        }
                        else
                                handler.reject(id);
                }
                else if(event.type() == QCA::Event::Token)
                {
                        // even though we're being prompted for a missing token,
                        //   we should still check if the token is present, due to
                        //   a possible race between insert and token request.
                        bool found = false;

                        // token-only
                        if(event.keyStoreEntry().isNull())
                        {
                                foreach(QCA::KeyStore *ks, keyStores)
                                {
                                        if(ks->id() == event.keyStoreInfo().id())
                                        {
                                                found = true;
                                                break;
                                        }
                                }
                        }
                        // token-entry
                        else
                        {
                                QCA::KeyStoreEntry kse = event.keyStoreEntry();

                                QCA::KeyStore *ks = 0;
                                foreach(QCA::KeyStore *i, keyStores)
                                {
                                        if(i->id() == event.keyStoreInfo().id())
                                        {
                                                ks = i;
                                                break;
                                        }
                                }
                                if(ks)
                                {
                                        QList<QCA::KeyStoreEntry> list = ks->entryList();
                                        foreach(const QCA::KeyStoreEntry &e, list)
                                        {
                                                if(e.id() == kse.id() && kse.isAvailable())
                                                {
                                                        found = true;
                                                        break;
                                                }
                                        }
                                }
                        }
                        if(found)
                        {
                                // auto-accept
                                handler.tokenOkay(id);
                                return;
                        }

                        QCA::KeyStoreEntry entry = event.keyStoreEntry();
                        QString name;
                        if(!entry.isNull())
                        {
                                name = Prompter::tr("Please make %1 (of %2) available").arg(entry.name(), entry.storeName());
                        }
                        else
                        {
                                name = Prompter::tr("Please insert the '%1' token").arg(event.keyStoreInfo().name());
                        }

                        QString str = Prompter::tr("%1 and click OK.").arg(name);

                        QMessageBox msgBox(QMessageBox::Information, QApplication::instance()->applicationName() + ": " + tr("Prompt"), str, QMessageBox::Ok | QMessageBox::Cancel, 0);
                        token_prompt = &msgBox;
                        auto_accept = false;
                        if(msgBox.exec() == QMessageBox::Ok || auto_accept)
                                handler.tokenOkay(id);
                        else
                                handler.reject(id);
                        token_prompt = 0;
                }
                else
                        handler.reject(id);

        end:
                pending.removeFirst();
                prompting = false;

                if(!pending.isEmpty())
                        QMetaObject::invokeMethod(this, "nextEvent", Qt::QueuedConnection);
        }

        void ks_available(const QString &keyStoreId)
        {
                QCA::KeyStore *ks = new QCA::KeyStore(keyStoreId, &ksm);
                connect(ks, SIGNAL(updated()), SLOT(ks_updated()));
                connect(ks, SIGNAL(unavailable()), SLOT(ks_unavailable()));
                keyStores += ks;
                ks->startAsynchronousMode();

                // are we currently in a token-only prompt?
                if(token_prompt && pending.first().event.type() == QCA::Event::Token && pending.first().event.keyStoreEntry().isNull())
                {
                        // was the token we're looking for just inserted?
                        if(pending.first().event.keyStoreInfo().id() == keyStoreId)
                        {
                                // auto-accept
                                auto_accept = true;
                                token_prompt->accept();
                        }
                }
        }

        void ks_unavailable()
        {
                QCA::KeyStore *ks = (QCA::KeyStore *)sender();
                keyStores.removeAll(ks);
                delete ks;
        }

        void ks_updated()
        {
                QCA::KeyStore *ks = (QCA::KeyStore *)sender();

                // are we currently in a token-entry prompt?
                if(token_prompt && pending.first().event.type() == QCA::Event::Token && !pending.first().event.keyStoreEntry().isNull())
                {
                        QCA::KeyStoreEntry kse = pending.first().event.keyStoreEntry();

                        // was the token of the entry we're looking for updated?
                        if(pending.first().event.keyStoreInfo().id() == ks->id())
                        {
                                // is the entry available?
                                bool avail = false;
                                QList<QCA::KeyStoreEntry> list = ks->entryList();
                                foreach(const QCA::KeyStoreEntry &e, list)
                                {
                                        if(e.id() == kse.id())
                                        {
                                                avail = kse.isAvailable();
                                                break;
                                        }
                                }
                                if(avail)
                                {
                                        // auto-accept
                                        auto_accept = true;
                                        token_prompt->accept();
                                }
                        }
                }
        }
};

Prompter::Prompter(QObject *parent) :
        QObject(parent)
{
        d = new Private(this);
}

Prompter::~Prompter()
{
        delete d;
}

QCA::SecureArray Prompter::knownPassword(const QCA::Event &event)
{
        Q_UNUSED(event);
        return QCA::SecureArray();
}

void Prompter::userSubmitted(const QCA::SecureArray &password, const QCA::Event &event)
{
        Q_UNUSED(password);
        Q_UNUSED(event);
}

#include "prompter.moc"

/*
 Copyright (C) 2007 Justin Karneges <justin@affinix.com>

 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
 in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:

 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.

 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
 AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
 AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/

#include <QtCore>
#include <QtGui>
#include <QtCrypto>

#include "ui_mainwin.h"
#include "prompter.h"
#include "certviewdlg.h"
#include "keyselectdlg.h"
#include "pkcs11configdlg/pkcs11configdlg.h"
#include "certitem.h"

#define VERSION "1.0.0"

class Icons
{
public:
        QPixmap cert, crl, keybundle, pgppub, pgpsec;
};

Icons *g_icons = 0;

//----------------------------------------------------------------------------
// Operation
//----------------------------------------------------------------------------
class Operation : public QObject
{
        Q_OBJECT
public:
        Operation(QObject *parent = 0) :
                QObject(parent)
        {
        }

signals:
        void error(const QString &str);
};

static QString validityToString(QCA::Validity v)
{
        QString s;
        switch(v)
        {
                case QCA::ValidityGood:
                        s = Operation::tr("Validated");
                        break;
                case QCA::ErrorRejected:
                        s = Operation::tr("Root CA is marked to reject the specified purpose");
                        break;
                case QCA::ErrorUntrusted:
                        s = Operation::tr("Certificate not trusted for the required purpose");
                        break;
                case QCA::ErrorSignatureFailed:
                        s = Operation::tr("Invalid signature");
                        break;
                case QCA::ErrorInvalidCA:
                        s = Operation::tr("Invalid CA certificate");
                        break;
                case QCA::ErrorInvalidPurpose:
                        s = Operation::tr("Invalid certificate purpose");
                        break;
                case QCA::ErrorSelfSigned:
                        s = Operation::tr("Certificate is self-signed");
                        break;
                case QCA::ErrorRevoked:
                        s = Operation::tr("Certificate has been revoked");
                        break;
                case QCA::ErrorPathLengthExceeded:
                        s = Operation::tr("Maximum certificate chain length exceeded");
                        break;
                case QCA::ErrorExpired:
                        s = Operation::tr("Certificate has expired");
                        break;
                case QCA::ErrorExpiredCA:
                        s = Operation::tr("CA has expired");
                        break;
                case QCA::ErrorValidityUnknown:
                default:
                        s = Operation::tr("General certificate validation error");
                        break;
        }
        return s;
}

static QString smErrorToString(QCA::SecureMessage::Error e)
{
        QString s;
        switch(e)
        {
                case QCA::SecureMessage::ErrorPassphrase:
                        s = Operation::tr("Invalid passphrase.");
                        break;
                case QCA::SecureMessage::ErrorFormat:
                        s = Operation::tr("Bad input format.");
                        break;
                case QCA::SecureMessage::ErrorSignerExpired:
                        s = Operation::tr("Signer key is expired.");
                        break;
                case QCA::SecureMessage::ErrorSignerInvalid:
                        s = Operation::tr("Signer key is invalid.");
                        break;
                case QCA::SecureMessage::ErrorEncryptExpired:
                        s = Operation::tr("Encrypting key is expired.");
                        break;
                case QCA::SecureMessage::ErrorEncryptUntrusted:
                        s = Operation::tr("Encrypting key is untrusted.");
                        break;
                case QCA::SecureMessage::ErrorEncryptInvalid:
                        s = Operation::tr("Encrypting key is invalid.");
                        break;
                case QCA::SecureMessage::ErrorNeedCard:
                        s = Operation::tr("Card was needed but not found.");
                        break;
                case QCA::SecureMessage::ErrorCertKeyMismatch:
                        s = Operation::tr("Certificate and private key don't match.");
                        break;
                case QCA::SecureMessage::ErrorUnknown:
                default:
                        s = Operation::tr("General error.");
                        break;
        }
        return s;
}

static QString smsIdentityToString(const QCA::SecureMessageSignature &sig)
{
        QString s;
        switch(sig.identityResult())
        {
                case QCA::SecureMessageSignature::Valid:
                        break;
                case QCA::SecureMessageSignature::InvalidSignature:
                        s = Operation::tr("Invalid signature");
                        break;
                case QCA::SecureMessageSignature::InvalidKey:
                        s = Operation::tr("Invalid key: %1").arg(validityToString(sig.keyValidity()));
                        break;
                case QCA::SecureMessageSignature::NoKey:
                        s = Operation::tr("Key not found");
                        break;
                default: // this should not really be possible
                        s = Operation::tr("Unknown");
                        break;
        }
        return s;
}

class SignOperation : public Operation
{
        Q_OBJECT
private:
        QByteArray in;
        CertItemStore *store;
        int id;
        QCA::CMS *cms;
        CertItemPrivateLoader *loader;
        QCA::SecureMessage *msg;
        int pending;

public:
        SignOperation(const QByteArray &_in, CertItemStore *_store, int _id, QCA::CMS *_cms, QObject *parent = 0) :
                Operation(parent),
                in(_in),
                store(_store),
                id(_id),
                cms(_cms),
                msg(0)
        {
                loader = new CertItemPrivateLoader(store, this);
                connect(loader, SIGNAL(finished()), SLOT(loader_finished()));
                loader->start(id);
        }

signals:
        void loadError();
        void finished(const QString &sig);

private slots:
        void loader_finished()
        {
                QCA::PrivateKey privateKey = loader->privateKey();
                delete loader;
                loader = 0;

                if(privateKey.isNull())
                {
                        emit loadError();
                        return;
                }

                CertItem item = store->itemFromId(id);

                QCA::SecureMessageKey signer;
                signer.setX509CertificateChain(item.certificateChain());
                signer.setX509PrivateKey(privateKey);

                msg = new QCA::SecureMessage(cms);
                connect(msg, SIGNAL(bytesWritten(int)), SLOT(msg_bytesWritten(int)));
                connect(msg, SIGNAL(finished()), SLOT(msg_finished()));
                msg->setFormat(QCA::SecureMessage::Ascii);
                msg->setSigner(signer);
                msg->startSign(QCA::SecureMessage::Detached);

                pending = 0;
                update();
        }

        void update()
        {
                QByteArray buf = in.mid(0, 16384 - pending); // 16k chunks
                in = in.mid(buf.size());
                pending += buf.size();
                msg->update(buf);
        }

        void msg_bytesWritten(int x)
        {
                pending -= x;

                if(in.isEmpty() && pending == 0)
                        msg->end();
                else
                        update();
        }

        void msg_finished()
        {
                if(!msg->success())
                {
                        QString str = smErrorToString(msg->errorCode());
                        delete msg;
                        msg = 0;
                        emit error(tr("Error during sign operation.\nReason: %1").arg(str));
                        return;
                }

                QByteArray result = msg->signature();
                delete msg;
                msg = 0;
                emit finished(QString::fromLatin1(result));
        }
};

class VerifyOperation : public Operation
{
        Q_OBJECT
private:
        QByteArray in, sig;
        QCA::CMS *cms;
        QCA::SecureMessage *msg;
        int pending;

public:
        QCA::SecureMessageSignature signer;

        VerifyOperation(const QByteArray &_in, const QByteArray &_sig, QCA::CMS *_cms, QObject *parent = 0) :
                Operation(parent),
                in(_in),
                sig(_sig),
                cms(_cms),
                msg(0)
        {
                msg = new QCA::SecureMessage(cms);
                connect(msg, SIGNAL(bytesWritten(int)), SLOT(msg_bytesWritten(int)));
                connect(msg, SIGNAL(finished()), SLOT(msg_finished()));
                msg->setFormat(QCA::SecureMessage::Ascii);
                msg->startVerify(sig);

                pending = 0;
                update();
        }

signals:
        void finished();

private slots:
        void update()
        {
                QByteArray buf = in.mid(0, 16384 - pending); // 16k chunks
                in = in.mid(buf.size());
                pending += buf.size();
                msg->update(buf);
        }

        void msg_bytesWritten(int x)
        {
                pending -= x;

                if(in.isEmpty() && pending == 0)
                        msg->end();
                else
                        update();
        }

        void msg_finished()
        {
                if(!msg->success())
                {
                        QString str = smErrorToString(msg->errorCode());
                        delete msg;
                        msg = 0;
                        emit error(tr("Error during verify operation.\nReason: %1").arg(str));
                        return;
                }

                signer = msg->signer();
                delete msg;
                msg = 0;

                if(signer.identityResult() != QCA::SecureMessageSignature::Valid)
                {
                        QString str = smsIdentityToString(signer);
                        emit error(tr("Verification failed!\nReason: %1").arg(str));
                        return;
                }

                emit finished();
        }
};

//----------------------------------------------------------------------------
// MainWin
//----------------------------------------------------------------------------
static QString get_fingerprint(const QCA::Certificate &cert)
{
        QString hex = QCA::Hash("sha1").hashToString(cert.toDER());
        QString out;
        for(int n = 0; n < hex.count(); ++n)
        {
                if(n != 0 && n % 2 == 0)
                        out += ':';
                out += hex[n];
        }
        return out;
}

class MainWin : public QMainWindow
{
        Q_OBJECT
private:
        Ui_MainWin ui;
        CertItemStore *users, *roots;
        QCA::CMS *cms;
        Operation *op;
        QAction *actionView, *actionRename, *actionRemove;
        QCA::Certificate self_signed_verify_cert;
        int auto_import_req_id;

public:
        MainWin(QWidget *parent = 0) :
                QMainWindow(parent),
                op(0),
                auto_import_req_id(-1)
        {
                ui.setupUi(this);

                g_icons = new Icons;
                g_icons->cert = QPixmap(":/gfx/icons/cert16.png");
                g_icons->crl = QPixmap(":/gfx/icons/crl16.png");
                g_icons->keybundle = QPixmap(":/gfx/icons/keybundle16.png");
                g_icons->pgppub = QPixmap(":/gfx/icons/publickey16.png");
                g_icons->pgpsec = QPixmap(":/gfx/icons/keypair16.png");
                if(g_icons->cert.isNull() || g_icons->crl.isNull() || g_icons->keybundle.isNull() || g_icons->pgppub.isNull() || g_icons->pgpsec.isNull())
                        printf("Warning: not all icons loaded\n");

                users = new CertItemStore(this);
                roots = new CertItemStore(this);

                setIcons(users);
                setIcons(roots);

                connect(users, SIGNAL(addSuccess(int, int)), SLOT(users_addSuccess(int, int)));
                connect(users, SIGNAL(addFailed(int)), SLOT(users_addFailed(int)));

                actionView = new QAction(tr("&View"), this);
                actionRename = new QAction(tr("Re&name"), this);
                actionRemove = new QAction(tr("Rem&ove"), this);

                connect(ui.actionLoadIdentityFile, SIGNAL(triggered()), SLOT(load_file()));
                connect(ui.actionLoadIdentityEntry, SIGNAL(triggered()), SLOT(load_device()));
                connect(ui.actionLoadAuthority, SIGNAL(triggered()), SLOT(load_root()));
                connect(ui.actionConfigurePkcs11, SIGNAL(triggered()), SLOT(mod_config()));
                connect(ui.actionQuit, SIGNAL(triggered()), SLOT(close()));
                connect(ui.actionAbout, SIGNAL(triggered()), SLOT(about()));
                connect(ui.pb_sign, SIGNAL(clicked()), SLOT(do_sign()));
                connect(ui.pb_verify, SIGNAL(clicked()), SLOT(do_verify()));

                connect(actionView, SIGNAL(triggered()), SLOT(item_view()));
                connect(actionRename, SIGNAL(triggered()), SLOT(item_rename()));
                connect(actionRemove, SIGNAL(triggered()), SLOT(item_remove()));

                ui.pb_sign->setEnabled(false);

                ui.lv_users->setModel(users);
                connect(ui.lv_users->selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), SLOT(users_selectionChanged(const QItemSelection &, const QItemSelection &)));

                ui.lv_users->setContextMenuPolicy(Qt::CustomContextMenu);
                connect(ui.lv_users, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(users_customContextMenuRequested(const QPoint &)));

                ui.lv_authorities->setModel(roots);

                ui.lv_authorities->setContextMenuPolicy(Qt::CustomContextMenu);
                connect(ui.lv_authorities, SIGNAL(customContextMenuRequested(const QPoint &)), SLOT(roots_customContextMenuRequested(const QPoint &)));

                cms = new QCA::CMS(this);

                QStringList ulist, rlist;
                {
                        QSettings settings("Affinix", "CMS Signer");
                        ulist = settings.value("users").toStringList();
                        rlist = settings.value("roots").toStringList();
                }

                users->load(ulist);
                roots->load(rlist);
        }

        ~MainWin()
        {
                QStringList ulist = users->save();
                QStringList rlist = roots->save();

                QSettings settings("Affinix", "CMS Signer");
                settings.setValue("users", ulist);
                settings.setValue("roots", rlist);

                delete g_icons;
                g_icons = 0;
        }

        void setIcons(CertItemStore *store)
        {
                store->setIcon(CertItemStore::IconCert, g_icons->cert);
                store->setIcon(CertItemStore::IconCrl, g_icons->crl);
                store->setIcon(CertItemStore::IconKeyBundle, g_icons->keybundle);
                store->setIcon(CertItemStore::IconPgpPub, g_icons->pgppub);
                store->setIcon(CertItemStore::IconPgpSec, g_icons->pgpsec);
        }

        QCA::CertificateCollection allCerts()
        {
                QCA::CertificateCollection col;

                // system store
                col += QCA::systemStore();

                // additional roots configured in application
                foreach(const CertItem &i, roots->items())
                        col.addCertificate(i.certificateChain().primary());

                // user chains
                foreach(const CertItem &i, users->items())
                {
                        foreach(const QCA::Certificate &cert, i.certificateChain())
                                col.addCertificate(cert);
                }

                return col;
        }

        QCA::CertificateChain complete(const QCA::CertificateChain &chain)
        {
                return chain.complete(allCerts().certificates());
        }

private slots:
        void load_file()
        {
                QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QString(), tr("X.509 Identities (*.p12 *.pfx)"));
                if(fileName.isEmpty())
                        return;

                setEnabled(false);
                users->addFromFile(fileName);
        }

        void load_device()
        {
                KeySelectDlg *w = new KeySelectDlg(this);
                w->setAttribute(Qt::WA_DeleteOnClose, true);
                w->setWindowModality(Qt::WindowModal);
                connect(w, SIGNAL(selected(const QCA::KeyStoreEntry &)), SLOT(load_device_finished(const QCA::KeyStoreEntry &)));
                connect(w, SIGNAL(viewCertificate(const QCA::CertificateChain &)), SLOT(keyselect_viewCertificate(const QCA::CertificateChain &)));
                w->setIcon(KeySelectDlg::IconCert, g_icons->cert);
                w->setIcon(KeySelectDlg::IconCrl, g_icons->crl);
                w->setIcon(KeySelectDlg::IconKeyBundle, g_icons->keybundle);
                w->setIcon(KeySelectDlg::IconPgpPub, g_icons->pgppub);
                w->setIcon(KeySelectDlg::IconPgpSec, g_icons->pgpsec);
                w->show();
        }

        void load_device_finished(const QCA::KeyStoreEntry &entry)
        {
                users->addFromKeyStore(entry);
        }

        void load_root()
        {
                QString fileName = QFileDialog::getOpenFileName(this, tr("Open File"), QString(), tr("X.509 Certificates (*.pem *.crt)"));
                if(fileName.isEmpty())
                        return;

                QCA::Certificate cert = QCA::Certificate::fromPEMFile(fileName);
                if(cert.isNull())
                {
                        QMessageBox::information(this, tr("Error"), tr("Error opening certificate file."));
                        return;
                }

                roots->addUser(cert);
        }

        void users_addSuccess(int req_id, int id)
        {
                if(req_id == auto_import_req_id)
                {
                        auto_import_req_id = -1;

                        CertItem i = users->itemFromId(id);

                        QMessageBox::information(this, tr("User added"), tr(
                                "This signature was made by a previously unknown user, and so the "
                                "user has now been added to the keyring as \"%1\"."
                                ).arg(i.name()));

                        verify_next();
                        return;
                }

                ui.lv_users->selectionModel()->select(users->index(users->rowFromId(id)), QItemSelectionModel::Clear | QItemSelectionModel::Select | QItemSelectionModel::Current);

                setEnabled(true);
        }

        void users_addFailed(int req_id)
        {
                Q_UNUSED(req_id);

                setEnabled(true);
        }

        void mod_config()
        {
                if(!Pkcs11ConfigDlg::isSupported())
                {
                        QMessageBox::information(this, tr("Error"), tr("No provider available supporting standard PKCS#11 configuration."));
                        return;
                }

                Pkcs11ConfigDlg *w = new Pkcs11ConfigDlg(this);
                w->setAttribute(Qt::WA_DeleteOnClose, true);
                w->setWindowModality(Qt::WindowModal);
                w->show();
        }

        void users_selectionChanged(const QItemSelection &selected, const QItemSelection &deselected)
        {
                Q_UNUSED(deselected);

                int at = -1;
                if(!selected.indexes().isEmpty())
                {
                        QModelIndex index = selected.indexes().first();
                        at = index.row();
                }

                bool usable = false;
                if(at != -1 && users->itemFromRow(at).isUsable())
                        usable = true;

                if(usable && !ui.pb_sign->isEnabled())
                        ui.pb_sign->setEnabled(true);
                else if(!usable && ui.pb_sign->isEnabled())
                        ui.pb_sign->setEnabled(false);
        }

        void item_view()
        {
                if(ui.lv_users->hasFocus())
                {
                        QItemSelection selection = ui.lv_users->selectionModel()->selection();
                        if(selection.indexes().isEmpty())
                                return;
                        QModelIndex index = selection.indexes().first();
                        users_view(index.row());
                }
                else // lv_authorities
                {
                        QItemSelection selection = ui.lv_authorities->selectionModel()->selection();
                        if(selection.indexes().isEmpty())
                                return;
                        QModelIndex index = selection.indexes().first();
                        roots_view(index.row());
                }
        }

        void item_rename()
        {
                if(ui.lv_users->hasFocus())
                {
                        QItemSelection selection = ui.lv_users->selectionModel()->selection();
                        if(selection.indexes().isEmpty())
                                return;
                        QModelIndex index = selection.indexes().first();
                        users_rename(index.row());
                }
                else // lv_authorities
                {
                        QItemSelection selection = ui.lv_authorities->selectionModel()->selection();
                        if(selection.indexes().isEmpty())
                                return;
                        QModelIndex index = selection.indexes().first();
                        roots_rename(index.row());
                }
        }

        void item_remove()
        {
                if(ui.lv_users->hasFocus())
                {
                        QItemSelection selection = ui.lv_users->selectionModel()->selection();
                        if(selection.indexes().isEmpty())
                                return;
                        QModelIndex index = selection.indexes().first();
                        users_remove(index.row());
                }
                else // lv_authorities
                {
                        QItemSelection selection = ui.lv_authorities->selectionModel()->selection();
                        if(selection.indexes().isEmpty())
                                return;
                        QModelIndex index = selection.indexes().first();
                        roots_remove(index.row());
                }
        }

        void users_view(int at)
        {
                CertItem i = users->itemFromRow(at);
                CertViewDlg *w = new CertViewDlg(complete(i.certificateChain()), this);
                w->setAttribute(Qt::WA_DeleteOnClose, true);
                w->show();
        }

        void users_rename(int at)
        {
                QModelIndex index = users->index(at);
                ui.lv_users->setFocus();
                ui.lv_users->setCurrentIndex(index);
                ui.lv_users->selectionModel()->select(index, QItemSelectionModel::Clear | QItemSelectionModel::Select | QItemSelectionModel::Current);
                ui.lv_users->edit(index);
        }

        void users_remove(int at)
        {
                users->removeItem(users->idFromRow(at));
        }

        void roots_view(int at)
        {
                CertItem i = roots->itemFromRow(at);
                CertViewDlg *w = new CertViewDlg(complete(i.certificateChain()), this);
                w->setAttribute(Qt::WA_DeleteOnClose, true);
                w->show();
        }

        void roots_rename(int at)
        {
                QModelIndex index = roots->index(at);
                ui.lv_authorities->setFocus();
                ui.lv_authorities->setCurrentIndex(index);
                ui.lv_authorities->selectionModel()->select(index, QItemSelectionModel::Clear | QItemSelectionModel::Select | QItemSelectionModel::Current);
                ui.lv_authorities->edit(index);
        }

        void roots_remove(int at)
        {
                roots->removeItem(roots->idFromRow(at));
        }

        void keyselect_viewCertificate(const QCA::CertificateChain &chain)
        {
                CertViewDlg *w = new CertViewDlg(complete(chain), (QWidget *)sender());
                w->setAttribute(Qt::WA_DeleteOnClose, true);
                w->show();
        }

        void users_customContextMenuRequested(const QPoint &pos)
        {
                QItemSelection selection = ui.lv_users->selectionModel()->selection();
                if(selection.indexes().isEmpty())
                        return;

                QMenu menu(this);
                menu.addAction(actionView);
                menu.addAction(actionRename);
                menu.addAction(actionRemove);
                menu.exec(ui.lv_users->viewport()->mapToGlobal(pos));
        }

        void roots_customContextMenuRequested(const QPoint &pos)
        {
                QItemSelection selection = ui.lv_authorities->selectionModel()->selection();
                if(selection.indexes().isEmpty())
                        return;

                QMenu menu(this);
                menu.addAction(actionView);
                menu.addAction(actionRename);
                menu.addAction(actionRemove);
                menu.exec(ui.lv_authorities->viewport()->mapToGlobal(pos));
        }

        void do_sign()
        {
                QItemSelection selection = ui.lv_users->selectionModel()->selection();
                if(selection.indexes().isEmpty())
                        return;
                QModelIndex index = selection.indexes().first();
                int at = index.row();

                setEnabled(false);

                op = new SignOperation(ui.te_data->toPlainText().toUtf8(), users, users->idFromRow(at), cms, this);
                connect(op, SIGNAL(loadError()), SLOT(sign_loadError()));
                connect(op, SIGNAL(finished(const QString &)), SLOT(sign_finished(const QString &)));
                connect(op, SIGNAL(error(const QString &)), SLOT(sign_error(const QString &)));
        }

        void do_verify()
        {
                // prepare root certs
                QCA::CertificateCollection col;

                // system store
                col += QCA::systemStore();

                // additional roots configured in application
                foreach(const CertItem &i, roots->items())
                        col.addCertificate(i.certificateChain().primary());

                // consider self-signed users as roots
                // (it is therefore not possible with this application to
                // have people in your keyring that you don't trust)
                foreach(const CertItem &i, users->items())
                {
                        QCA::Certificate cert = i.certificateChain().primary();
                        if(cert.isSelfSigned())
                                col.addCertificate(cert);
                }

                // the self signed verify cert, if applicable
                if(!self_signed_verify_cert.isNull())
                {
                        col.addCertificate(self_signed_verify_cert);
                        self_signed_verify_cert = QCA::Certificate();
                }

                cms->setTrustedCertificates(col);

                setEnabled(false);

                op = new VerifyOperation(ui.te_data->toPlainText().toUtf8(), ui.te_sig->toPlainText().toUtf8(), cms, this);
                connect(op, SIGNAL(finished()), SLOT(verify_finished()));
                connect(op, SIGNAL(error(const QString &)), SLOT(verify_error(const QString &)));
        }

        void about()
        {
                int ver = qcaVersion();
                int maj = (ver >> 16) & 0xff;
                int min = (ver >> 8) & 0xff;
                int bug = ver & 0xff;
                QString verstr;
                verstr.sprintf("%d.%d.%d", maj, min, bug);

                QString str;
                str += tr("CMS Signer version %1 by Justin Karneges").arg(VERSION) + '\n';
                str += tr("A simple tool for creating and verifying digital signatures.") + '\n';
                str += '\n';
                str += tr("Using QCA version %1").arg(verstr) + '\n';
                str += '\n';
                str += tr("Icons by Jason Kim") + '\n';

                QCA::ProviderList list = QCA::providers();
                foreach(QCA::Provider *p, list)
                {
                        QString credit = p->credit();
                        if(!credit.isEmpty())
                        {
                                str += '\n';
                                str += credit;
                        }
                }

                QMessageBox::about(this, tr("About CMS Signer"), str);
        }

        void sign_loadError()
        {
                delete op;
                op = 0;

                setEnabled(true);
        }

        void sign_finished(const QString &sig)
        {
                delete op;
                op = 0;

                ui.te_sig->setPlainText(sig);

                setEnabled(true);
        }

        void sign_error(const QString &msg)
        {
                delete op;
                op = 0;

                setEnabled(true);

                QMessageBox::information(this, tr("Error"), msg);
        }

        void verify_finished()
        {
                QCA::SecureMessageSignature signer = ((VerifyOperation *)op)->signer;
                delete op;
                op = 0;

                // import the cert?
                QCA::SecureMessageKey skey = signer.key();
                if(!skey.isNull())
                {
                        QCA::CertificateChain chain = skey.x509CertificateChain();

                        int at = -1;
                        QList<CertItem> items = users->items();
                        for(int n = 0; n < items.count(); ++n)
                        {
                                const CertItem &i = items[n];
                                if(i.certificateChain().primary() == chain.primary())
                                {
                                        at = n;
                                        break;
                                }
                        }

                        // add
                        if(at == -1)
                        {
                                auto_import_req_id = users->addUser(chain);
                                return;
                        }
                        // update
                        else
                        {
                                users->updateChain(users->idFromRow(at), chain);
                        }
                }

                verify_next();
        }

        void verify_next()
        {
                setEnabled(true);

                QMessageBox::information(this, tr("Verify"), tr("Signature verified successfully."));
        }

        void verify_error(const QString &msg)
        {
                QCA::SecureMessageSignature signer = ((VerifyOperation *)op)->signer;
                delete op;
                op = 0;

                QCA::SecureMessageKey skey = signer.key();
                if(signer.keyValidity() == QCA::ErrorSelfSigned && !skey.isNull())
                {
                        QCA::CertificateChain chain = skey.x509CertificateChain();
                        if(chain.count() == 1 && chain.primary().isSelfSigned())
                        {
                                QCA::Certificate cert = chain.primary();

                                int ret = QMessageBox::warning(this, tr("Self-signed certificate"), tr(
                                        "<qt>The signature is made by an unknown user, and the certificate is self-signed.<br>\n"
                                        "<br>\n"
                                        "<nobr>Common Name: %1</nobr><br>\n"
                                        "<nobr>SHA1 Fingerprint: %2</nobr><br>\n"
                                        "<br>\n"
                                        "Trust the certificate?</qt>"
                                        ).arg(cert.commonName(), get_fingerprint(cert)),
                                        QMessageBox::Yes | QMessageBox::No,
                                        QMessageBox::No);

                                if(ret == QMessageBox::Yes)
                                {
                                        self_signed_verify_cert = cert;
                                        do_verify();
                                        return;
                                }
                        }
                }

                setEnabled(true);

                QMessageBox::information(this, tr("Error"), msg);
        }
};

int main(int argc, char **argv)
{
        QCA::Initializer qcaInit;
        QApplication qapp(argc, argv);

        qapp.setApplicationName(MainWin::tr("CMS Signer"));

        if(!QCA::isSupported("cert,crl,cms"))
        {
                QMessageBox::critical(0, qapp.applicationName() + ": " + MainWin::tr("Error"),
                        MainWin::tr("No support for CMS is available.  Please install an appropriate QCA plugin, such as qca-ossl."));
                return 1;
        }

        QCA::KeyStoreManager::start();

        MainWin mainWin;
        mainWin.show();
        return qapp.exec();
}

#include "main.moc"

---