/Users/baford/proj/netsteria/sst/lib/ident.h

#ifndef SST_IDENT_H
#define SST_IDENT_H

#include <QByteArray>
#include <QSharedData>

#include <openssl/dsa.h>
#include <openssl/rsa.h>

#include "sign.h"

class QHostAddress;
class QSettings;


namespace SST {

class SecureHash;
class Ident;


class IdentData : public QSharedData
{
        friend class Ident;

        QByteArray id;
        SignKey *k;

public:
        inline IdentData(const QByteArray id) : id(id), k(NULL) { }
        IdentData(const IdentData &other);
        ~IdentData();

        bool setKey(const QByteArray &key);
        void clearKey();
};

class Ident
{
        QSharedDataPointer<IdentData> d;

public:
        enum Scheme {
                NoScheme = 0,   

                // Non-cryptographic legacy address schemes
                MAC     = 1,    
                IP      = 2,    

                // Cryptographic identity schemes
                DSA160  = 10,   
                RSA160  = 11,   
        };

        Ident();

        Ident(const QByteArray &id);

        Ident(const QByteArray &id, const QByteArray &key);


        inline QByteArray id() const { return d->id; }

        void setID(const QByteArray &id);

        inline bool isNull() { return d->id.isEmpty(); }

        inline Scheme scheme() const {
                return d->id.isEmpty() ? NoScheme
                        : (Scheme)(d->id.at(0) >> 2); }

        inline bool haveKey() const
                { return d->k && d->k->type() != SignKey::Invalid; }

        inline bool havePrivateKey() const
                { return d->k && d->k->type() == SignKey::Private; }

        inline QByteArray key(bool getPrivateKey = false) const
                { return d->k->key(getPrivateKey); }

        bool setKey(const QByteArray &key);

        inline SecureHash *newHash(QObject *parent = NULL) const
                { return d->k->newHash(parent); }

        QByteArray hash(const void *data, int len) const;

        inline QByteArray hash(const QByteArray &data) const
                { return hash(data.constData(), data.size()); }

        inline QByteArray sign(const QByteArray &digest) const
                { return d->k->sign(digest); }

        inline bool verify(const QByteArray &digest,
                                const QByteArray &sig) const
                { return d->k->verify(digest, sig); }

        static Ident generate(Scheme sch = RSA160, int bits = 0);


        static Ident fromMacAddress(const QByteArray &addr);

        QByteArray macAddress();


        static Ident fromIpAddress(const QHostAddress &addr, quint16 port = 0);

        QHostAddress ipAddress(quint16 *out_port = NULL);

        quint16 ipPort();
};


class IdentHostState
{
        Ident hid;


public:
        Ident hostIdent(bool create = true);

        void setHostIdent(const Ident &ident);

        void initHostIdent(QSettings *settings);
};


} // namespace SST

#endif  // SST_IDENT_H

---