File indexing completed on 2024-04-07 14:43:23

0001 /*
0002  * Copyright (C) 2003-2007  Justin Karneges <justin@affinix.com>
0003  * Copyright (C) 2004,2005  Brad Hards <bradh@frogmouth.net>
0004  *
0005  * This library is free software; you can redistribute it and/or
0006  * modify it under the terms of the GNU Lesser General Public
0007  * License as published by the Free Software Foundation; either
0008  * version 2.1 of the License, or (at your option) any later version.
0009  *
0010  * This library is distributed in the hope that it will be useful,
0011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
0013  * Lesser General Public License for more details.
0014  *
0015  * You should have received a copy of the GNU Lesser General Public
0016  * License along with this library; if not, write to the Free Software
0017  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
0018  * 02110-1301  USA
0019  *
0020  */
0021 
0022 #include "qca_securemessage.h"
0023 
0024 #include "qca_safeobj.h"
0025 #include "qca_safetimer.h"
0026 #include "qcaprovider.h"
0027 
0028 namespace QCA {
0029 
0030 Provider::Context *getContext(const QString &type, const QString &provider);
0031 
0032 //----------------------------------------------------------------------------
0033 // SecureMessageKey
0034 //----------------------------------------------------------------------------
0035 class SecureMessageKey::Private : public QSharedData
0036 {
0037 public:
0038     SecureMessageKey::Type type;
0039     PGPKey                 pgp_pub, pgp_sec;
0040     CertificateChain       cert_pub;
0041     PrivateKey             cert_sec;
0042 
0043     Private()
0044     {
0045         type = SecureMessageKey::None;
0046     }
0047 
0048     // set the proper type, and reset the opposite data structures if needed
0049     void ensureType(SecureMessageKey::Type t)
0050     {
0051         // if we were non-null and changed, we may need to reset some things
0052         if (type != SecureMessageKey::None && t != type) {
0053             if (type == SecureMessageKey::X509) {
0054                 cert_pub = CertificateChain();
0055                 cert_sec = PrivateKey();
0056             } else if (type == SecureMessageKey::PGP) {
0057                 pgp_pub = PGPKey();
0058                 pgp_sec = PGPKey();
0059             }
0060         }
0061         type = t;
0062     }
0063 };
0064 
0065 SecureMessageKey::SecureMessageKey()
0066     : d(new Private)
0067 {
0068 }
0069 
0070 SecureMessageKey::SecureMessageKey(const SecureMessageKey &from)
0071     : d(from.d)
0072 {
0073 }
0074 
0075 SecureMessageKey::~SecureMessageKey()
0076 {
0077 }
0078 
0079 SecureMessageKey &SecureMessageKey::operator=(const SecureMessageKey &from)
0080 {
0081     d = from.d;
0082     return *this;
0083 }
0084 
0085 bool SecureMessageKey::isNull() const
0086 {
0087     return (d->type == None);
0088 }
0089 
0090 SecureMessageKey::Type SecureMessageKey::type() const
0091 {
0092     return d->type;
0093 }
0094 
0095 PGPKey SecureMessageKey::pgpPublicKey() const
0096 {
0097     return d->pgp_pub;
0098 }
0099 
0100 PGPKey SecureMessageKey::pgpSecretKey() const
0101 {
0102     return d->pgp_sec;
0103 }
0104 
0105 void SecureMessageKey::setPGPPublicKey(const PGPKey &pub)
0106 {
0107     d->ensureType(SecureMessageKey::PGP);
0108     d->pgp_pub = pub;
0109 }
0110 
0111 void SecureMessageKey::setPGPSecretKey(const PGPKey &sec)
0112 {
0113     d->ensureType(SecureMessageKey::PGP);
0114     Q_ASSERT(sec.isSecret());
0115     d->pgp_sec = sec;
0116 }
0117 
0118 CertificateChain SecureMessageKey::x509CertificateChain() const
0119 {
0120     return d->cert_pub;
0121 }
0122 
0123 PrivateKey SecureMessageKey::x509PrivateKey() const
0124 {
0125     return d->cert_sec;
0126 }
0127 
0128 void SecureMessageKey::setX509CertificateChain(const CertificateChain &c)
0129 {
0130     d->ensureType(SecureMessageKey::X509);
0131     d->cert_pub = c;
0132 }
0133 
0134 void SecureMessageKey::setX509PrivateKey(const PrivateKey &k)
0135 {
0136     d->ensureType(SecureMessageKey::X509);
0137     d->cert_sec = k;
0138 }
0139 
0140 void SecureMessageKey::setX509KeyBundle(const KeyBundle &kb)
0141 {
0142     setX509CertificateChain(kb.certificateChain());
0143     setX509PrivateKey(kb.privateKey());
0144 }
0145 
0146 bool SecureMessageKey::havePrivate() const
0147 {
0148     if (d->type == SecureMessageKey::PGP && !d->pgp_sec.isNull())
0149         return true;
0150     else if (d->type == SecureMessageKey::X509 && !d->cert_sec.isNull())
0151         return true;
0152     return false;
0153 }
0154 
0155 QString SecureMessageKey::name() const
0156 {
0157     if (d->type == SecureMessageKey::PGP && !d->pgp_pub.isNull())
0158         return d->pgp_pub.primaryUserId();
0159     else if (d->type == SecureMessageKey::X509 && !d->cert_pub.isEmpty())
0160         return d->cert_pub.primary().commonName();
0161     else
0162         return QString();
0163 }
0164 
0165 //----------------------------------------------------------------------------
0166 // SecureMessageSignature
0167 //----------------------------------------------------------------------------
0168 class SecureMessageSignature::Private : public QSharedData
0169 {
0170 public:
0171     SecureMessageSignature::IdentityResult r;
0172     Validity                               v;
0173     SecureMessageKey                       key;
0174     QDateTime                              ts;
0175 
0176     Private()
0177     {
0178         r = SecureMessageSignature::NoKey;
0179         v = ErrorValidityUnknown;
0180     }
0181 };
0182 
0183 SecureMessageSignature::SecureMessageSignature()
0184     : d(new Private)
0185 {
0186 }
0187 
0188 SecureMessageSignature::SecureMessageSignature(IdentityResult          r,
0189                                                Validity                v,
0190                                                const SecureMessageKey &key,
0191                                                const QDateTime        &ts)
0192     : d(new Private)
0193 {
0194     d->r   = r;
0195     d->v   = v;
0196     d->key = key;
0197     d->ts  = ts;
0198 }
0199 
0200 SecureMessageSignature::SecureMessageSignature(const SecureMessageSignature &from)
0201     : d(from.d)
0202 {
0203 }
0204 
0205 SecureMessageSignature::~SecureMessageSignature()
0206 {
0207 }
0208 
0209 SecureMessageSignature &SecureMessageSignature::operator=(const SecureMessageSignature &from)
0210 {
0211     d = from.d;
0212     return *this;
0213 }
0214 
0215 SecureMessageSignature::IdentityResult SecureMessageSignature::identityResult() const
0216 {
0217     return d->r;
0218 }
0219 
0220 Validity SecureMessageSignature::keyValidity() const
0221 {
0222     return d->v;
0223 }
0224 
0225 SecureMessageKey SecureMessageSignature::key() const
0226 {
0227     return d->key;
0228 }
0229 
0230 QDateTime SecureMessageSignature::timestamp() const
0231 {
0232     return d->ts;
0233 }
0234 
0235 //----------------------------------------------------------------------------
0236 // SecureMessage
0237 //----------------------------------------------------------------------------
0238 enum ResetMode
0239 {
0240     ResetSession        = 0,
0241     ResetSessionAndData = 1,
0242     ResetAll            = 2
0243 };
0244 
0245 class SecureMessage::Private : public QObject
0246 {
0247     Q_OBJECT
0248 public:
0249     SecureMessage       *q;
0250     MessageContext      *c;
0251     SecureMessageSystem *system;
0252 
0253     bool                  bundleSigner, smime;
0254     SecureMessage::Format format;
0255     SecureMessageKeyList  to;
0256     SecureMessageKeyList  from;
0257 
0258     QByteArray                 in;
0259     bool                       success;
0260     SecureMessage::Error       errorCode;
0261     QByteArray                 detachedSig;
0262     QString                    hashName;
0263     SecureMessageSignatureList signers;
0264     QString                    dtext;
0265 
0266     QList<int> bytesWrittenArgs;
0267     SafeTimer  readyReadTrigger, bytesWrittenTrigger, finishedTrigger;
0268 
0269     Private(SecureMessage *_q)
0270         : readyReadTrigger(this)
0271         , bytesWrittenTrigger(this)
0272         , finishedTrigger(this)
0273     {
0274         q      = _q;
0275         c      = nullptr;
0276         system = nullptr;
0277 
0278         readyReadTrigger.setSingleShot(true);
0279         bytesWrittenTrigger.setSingleShot(true);
0280         finishedTrigger.setSingleShot(true);
0281         connect(&readyReadTrigger, &SafeTimer::timeout, this, &Private::t_readyRead);
0282         connect(&bytesWrittenTrigger, &SafeTimer::timeout, this, &Private::t_bytesWritten);
0283         connect(&finishedTrigger, &SafeTimer::timeout, this, &Private::t_finished);
0284 
0285         reset(ResetAll);
0286     }
0287 
0288     void init()
0289     {
0290         connect(c, &MessageContext::updated, this, &Private::updated);
0291     }
0292 
0293     void reset(ResetMode mode)
0294     {
0295         if (c)
0296             c->reset();
0297 
0298         bytesWrittenArgs.clear();
0299         readyReadTrigger.stop();
0300         bytesWrittenTrigger.stop();
0301         finishedTrigger.stop();
0302 
0303         if (mode >= ResetSessionAndData) {
0304             in.clear();
0305             success   = false;
0306             errorCode = SecureMessage::ErrorUnknown;
0307             detachedSig.clear();
0308             hashName = QString();
0309             signers.clear();
0310         }
0311 
0312         if (mode >= ResetAll) {
0313             bundleSigner = true;
0314             format       = SecureMessage::Binary;
0315             to.clear();
0316             from.clear();
0317         }
0318     }
0319 
0320 public Q_SLOTS:
0321     void updated()
0322     {
0323         bool sig_read    = false;
0324         bool sig_written = false;
0325         bool sig_done    = false;
0326         int  written     = 0;
0327         {
0328             const QByteArray a = c->read();
0329             if (!a.isEmpty()) {
0330                 sig_read = true;
0331                 in.append(a);
0332             }
0333 
0334             const int x = c->written();
0335             if (x > 0) {
0336                 sig_written = true;
0337                 written     = x;
0338             }
0339         }
0340 
0341         if (c->finished()) {
0342             sig_done = true;
0343 
0344             success   = c->success();
0345             errorCode = c->errorCode();
0346             dtext     = c->diagnosticText();
0347             if (success) {
0348                 detachedSig = c->signature();
0349                 hashName    = c->hashName();
0350                 signers     = c->signers();
0351             }
0352             reset(ResetSession);
0353         }
0354 
0355         if (sig_read)
0356             readyReadTrigger.start();
0357         if (sig_written) {
0358             bytesWrittenArgs += written;
0359             bytesWrittenTrigger.start();
0360         }
0361         if (sig_done)
0362             finishedTrigger.start();
0363     }
0364 
0365     void t_readyRead()
0366     {
0367         emit q->readyRead();
0368     }
0369 
0370     void t_bytesWritten()
0371     {
0372         emit q->bytesWritten(bytesWrittenArgs.takeFirst());
0373     }
0374 
0375     void t_finished()
0376     {
0377         emit q->finished();
0378     }
0379 };
0380 
0381 SecureMessage::SecureMessage(SecureMessageSystem *system)
0382 {
0383     d         = new Private(this);
0384     d->system = system;
0385     d->c      = static_cast<SMSContext *>(d->system->context())->createMessage();
0386     change(d->c);
0387     d->init();
0388 }
0389 
0390 SecureMessage::~SecureMessage()
0391 {
0392     delete d;
0393 }
0394 
0395 SecureMessage::Type SecureMessage::type() const
0396 {
0397     return d->c->type();
0398 }
0399 
0400 bool SecureMessage::canSignMultiple() const
0401 {
0402     return d->c->canSignMultiple();
0403 }
0404 
0405 bool SecureMessage::canClearsign() const
0406 {
0407     return (type() == OpenPGP);
0408 }
0409 
0410 bool SecureMessage::canSignAndEncrypt() const
0411 {
0412     return (type() == OpenPGP);
0413 }
0414 
0415 void SecureMessage::reset()
0416 {
0417     d->reset(ResetAll);
0418 }
0419 
0420 bool SecureMessage::bundleSignerEnabled() const
0421 {
0422     return d->bundleSigner;
0423 }
0424 
0425 bool SecureMessage::smimeAttributesEnabled() const
0426 {
0427     return d->smime;
0428 }
0429 
0430 SecureMessage::Format SecureMessage::format() const
0431 {
0432     return d->format;
0433 }
0434 
0435 SecureMessageKeyList SecureMessage::recipientKeys() const
0436 {
0437     return d->to;
0438 }
0439 
0440 SecureMessageKeyList SecureMessage::signerKeys() const
0441 {
0442     return d->from;
0443 }
0444 
0445 void SecureMessage::setBundleSignerEnabled(bool b)
0446 {
0447     d->bundleSigner = b;
0448 }
0449 
0450 void SecureMessage::setSMIMEAttributesEnabled(bool b)
0451 {
0452     d->smime = b;
0453 }
0454 
0455 void SecureMessage::setFormat(Format f)
0456 {
0457     d->format = f;
0458 }
0459 
0460 void SecureMessage::setRecipient(const SecureMessageKey &key)
0461 {
0462     d->to = SecureMessageKeyList() << key;
0463 }
0464 
0465 void SecureMessage::setRecipients(const SecureMessageKeyList &keys)
0466 {
0467     d->to = keys;
0468 }
0469 
0470 void SecureMessage::setSigner(const SecureMessageKey &key)
0471 {
0472     d->from = SecureMessageKeyList() << key;
0473 }
0474 
0475 void SecureMessage::setSigners(const SecureMessageKeyList &keys)
0476 {
0477     d->from = keys;
0478 }
0479 
0480 void SecureMessage::startEncrypt()
0481 {
0482     d->reset(ResetSessionAndData);
0483     d->c->setupEncrypt(d->to);
0484     d->c->start(d->format, MessageContext::Encrypt);
0485 }
0486 
0487 void SecureMessage::startDecrypt()
0488 {
0489     d->reset(ResetSessionAndData);
0490     d->c->start(d->format, MessageContext::Decrypt);
0491 }
0492 
0493 void SecureMessage::startSign(SignMode m)
0494 {
0495     d->reset(ResetSessionAndData);
0496     d->c->setupSign(d->from, m, d->bundleSigner, d->smime);
0497     d->c->start(d->format, MessageContext::Sign);
0498 }
0499 
0500 void SecureMessage::startVerify(const QByteArray &sig)
0501 {
0502     d->reset(ResetSessionAndData);
0503     if (!sig.isEmpty())
0504         d->c->setupVerify(sig);
0505     d->c->start(d->format, MessageContext::Verify);
0506 }
0507 
0508 void SecureMessage::startSignAndEncrypt()
0509 {
0510     d->reset(ResetSessionAndData);
0511     d->c->setupEncrypt(d->to);
0512     d->c->setupSign(d->from, Message, d->bundleSigner, d->smime);
0513     d->c->start(d->format, MessageContext::SignAndEncrypt);
0514 }
0515 
0516 void SecureMessage::update(const QByteArray &in)
0517 {
0518     d->c->update(in);
0519 }
0520 
0521 QByteArray SecureMessage::read()
0522 {
0523     const QByteArray a = d->in;
0524     d->in.clear();
0525     return a;
0526 }
0527 
0528 int SecureMessage::bytesAvailable() const
0529 {
0530     return d->in.size();
0531 }
0532 
0533 void SecureMessage::end()
0534 {
0535     d->c->end();
0536 }
0537 
0538 bool SecureMessage::waitForFinished(int msecs)
0539 {
0540     d->c->waitForFinished(msecs);
0541     d->updated();
0542     return d->success;
0543 }
0544 
0545 bool SecureMessage::success() const
0546 {
0547     return d->success;
0548 }
0549 
0550 SecureMessage::Error SecureMessage::errorCode() const
0551 {
0552     return d->errorCode;
0553 }
0554 
0555 QByteArray SecureMessage::signature() const
0556 {
0557     return d->detachedSig;
0558 }
0559 
0560 QString SecureMessage::hashName() const
0561 {
0562     return d->hashName;
0563 }
0564 
0565 bool SecureMessage::wasSigned() const
0566 {
0567     return !d->signers.isEmpty();
0568 }
0569 
0570 bool SecureMessage::verifySuccess() const
0571 {
0572     // if we're not done or there were no signers, then return false
0573     if (!d->success || d->signers.isEmpty())
0574         return false;
0575 
0576     // make sure all signers have a valid signature
0577     for (int n = 0; n < d->signers.count(); ++n) {
0578         if (d->signers[n].identityResult() != SecureMessageSignature::Valid)
0579             return false;
0580     }
0581     return true;
0582 }
0583 
0584 SecureMessageSignature SecureMessage::signer() const
0585 {
0586     if (d->signers.isEmpty())
0587         return SecureMessageSignature();
0588 
0589     return d->signers.first();
0590 }
0591 
0592 SecureMessageSignatureList SecureMessage::signers() const
0593 {
0594     return d->signers;
0595 }
0596 
0597 QString SecureMessage::diagnosticText() const
0598 {
0599     return d->dtext;
0600 }
0601 
0602 //----------------------------------------------------------------------------
0603 // SecureMessageSystem
0604 //----------------------------------------------------------------------------
0605 SecureMessageSystem::SecureMessageSystem(QObject *parent, const QString &type, const QString &provider)
0606     : QObject(parent)
0607     , Algorithm(type, provider)
0608 {
0609 }
0610 
0611 SecureMessageSystem::~SecureMessageSystem()
0612 {
0613 }
0614 
0615 //----------------------------------------------------------------------------
0616 // OpenPGP
0617 //----------------------------------------------------------------------------
0618 OpenPGP::OpenPGP(QObject *parent, const QString &provider)
0619     : SecureMessageSystem(parent, QStringLiteral("openpgp"), provider)
0620 {
0621 }
0622 
0623 OpenPGP::~OpenPGP()
0624 {
0625 }
0626 
0627 //----------------------------------------------------------------------------
0628 // CMS
0629 //----------------------------------------------------------------------------
0630 class CMS::Private
0631 {
0632 public:
0633     CertificateCollection trusted, untrusted;
0634     SecureMessageKeyList  privateKeys;
0635 };
0636 
0637 CMS::CMS(QObject *parent, const QString &provider)
0638     : SecureMessageSystem(parent, QStringLiteral("cms"), provider)
0639 {
0640     d = new Private;
0641 }
0642 
0643 CMS::~CMS()
0644 {
0645     delete d;
0646 }
0647 
0648 CertificateCollection CMS::trustedCertificates() const
0649 {
0650     return d->trusted;
0651 }
0652 
0653 CertificateCollection CMS::untrustedCertificates() const
0654 {
0655     return d->untrusted;
0656 }
0657 
0658 SecureMessageKeyList CMS::privateKeys() const
0659 {
0660     return d->privateKeys;
0661 }
0662 
0663 void CMS::setTrustedCertificates(const CertificateCollection &trusted)
0664 {
0665     d->trusted = trusted;
0666     static_cast<SMSContext *>(context())->setTrustedCertificates(trusted);
0667 }
0668 
0669 void CMS::setUntrustedCertificates(const CertificateCollection &untrusted)
0670 {
0671     d->untrusted = untrusted;
0672     static_cast<SMSContext *>(context())->setUntrustedCertificates(untrusted);
0673 }
0674 
0675 void CMS::setPrivateKeys(const SecureMessageKeyList &keys)
0676 {
0677     d->privateKeys = keys;
0678     static_cast<SMSContext *>(context())->setPrivateKeys(keys);
0679 }
0680 
0681 }
0682 
0683 #include "qca_securemessage.moc"