Page MenuHome GnuPG
Files F25703415

No OneTemporary
Actions

View Options

diff --git a/lang/cpp/src/verificationresult.cpp b/lang/cpp/src/verificationresult.cpp
index c32c8964..c62625d1 100644
--- a/lang/cpp/src/verificationresult.cpp
+++ b/lang/cpp/src/verificationresult.cpp
@@ -1,561 +1,575 @@
/*
verificationresult.cpp - wraps a gpgme verify result
Copyright (C) 2004 Klarälvdalens Datakonsult AB
This file is part of GPGME++.
GPGME++ is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
GPGME++ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with GPGME++; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#include <verificationresult.h>
#include <notation.h>
#include "result_p.h"
#include "util.h"
+#include "key.h"
#include <gpgme.h>
#include <istream>
#include <algorithm>
#include <iterator>
#include <string>
#include <cstring>
#include <cstdlib>
#include <string.h>
class GpgME::VerificationResult::Private
{
public:
explicit Private(const gpgme_verify_result_t r)
{
if (!r) {
return;
}
if (r->file_name) {
file_name = r->file_name;
}
// copy recursively, using compiler-generated copy ctor.
// We just need to handle the pointers in the structs:
for (gpgme_signature_t is = r->signatures ; is ; is = is->next) {
gpgme_signature_t scopy = new _gpgme_signature(*is);
if (is->fpr) {
scopy->fpr = strdup(is->fpr);
}
// PENDING(marc) why does this crash on Windows in strdup()?
# ifndef _WIN32
if (is->pka_address) {
scopy->pka_address = strdup(is->pka_address);
}
# else
scopy->pka_address = 0;
# endif
scopy->next = 0;
sigs.push_back(scopy);
+ // copy keys
+ if (scopy->key) {
+ keys.push_back(Key(scopy->key, true));
+ }
// copy notations:
nota.push_back(std::vector<Nota>());
purls.push_back(0);
for (gpgme_sig_notation_t in = is->notations ; in ; in = in->next) {
if (!in->name) {
if (in->value) {
purls.back() = strdup(in->value); // policy url
}
continue;
}
Nota n = { 0, 0, in->flags };
n.name = strdup(in->name);
if (in->value) {
n.value = strdup(in->value);
}
nota.back().push_back(n);
}
}
}
~Private()
{
for (std::vector<gpgme_signature_t>::iterator it = sigs.begin() ; it != sigs.end() ; ++it) {
std::free((*it)->fpr);
std::free((*it)->pka_address);
delete *it; *it = 0;
}
for (std::vector< std::vector<Nota> >::iterator it = nota.begin() ; it != nota.end() ; ++it) {
for (std::vector<Nota>::iterator jt = it->begin() ; jt != it->end() ; ++jt) {
std::free(jt->name); jt->name = 0;
std::free(jt->value); jt->value = 0;
}
}
std::for_each(purls.begin(), purls.end(), &std::free);
}
struct Nota {
char *name;
char *value;
gpgme_sig_notation_flags_t flags;
};
std::vector<gpgme_signature_t> sigs;
std::vector< std::vector<Nota> > nota;
+ std::vector<GpgME::Key> keys;
std::vector<char *> purls;
std::string file_name;
};
GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, int error)
: GpgME::Result(error), d()
{
init(ctx);
}
GpgME::VerificationResult::VerificationResult(gpgme_ctx_t ctx, const Error &error)
: GpgME::Result(error), d()
{
init(ctx);
}
void GpgME::VerificationResult::init(gpgme_ctx_t ctx)
{
if (!ctx) {
return;
}
gpgme_verify_result_t res = gpgme_op_verify_result(ctx);
if (!res) {
return;
}
d.reset(new Private(res));
}
make_standard_stuff(VerificationResult)
const char *GpgME::VerificationResult::fileName() const
{
return d ? d->file_name.c_str() : 0 ;
}
unsigned int GpgME::VerificationResult::numSignatures() const
{
return d ? d->sigs.size() : 0 ;
}
GpgME::Signature GpgME::VerificationResult::signature(unsigned int idx) const
{
return Signature(d, idx);
}
std::vector<GpgME::Signature> GpgME::VerificationResult::signatures() const
{
if (!d) {
return std::vector<Signature>();
}
std::vector<Signature> result;
result.reserve(d->sigs.size());
for (unsigned int i = 0 ; i < d->sigs.size() ; ++i) {
result.push_back(Signature(d, i));
}
return result;
}
GpgME::Signature::Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int i)
: d(parent), idx(i)
{
}
GpgME::Signature::Signature() : d(), idx(0) {}
bool GpgME::Signature::isNull() const
{
return !d || idx >= d->sigs.size() ;
}
GpgME::Signature::Summary GpgME::Signature::summary() const
{
if (isNull()) {
return None;
}
gpgme_sigsum_t sigsum = d->sigs[idx]->summary;
unsigned int result = 0;
if (sigsum & GPGME_SIGSUM_VALID) {
result |= Valid;
}
if (sigsum & GPGME_SIGSUM_GREEN) {
result |= Green;
}
if (sigsum & GPGME_SIGSUM_RED) {
result |= Red;
}
if (sigsum & GPGME_SIGSUM_KEY_REVOKED) {
result |= KeyRevoked;
}
if (sigsum & GPGME_SIGSUM_KEY_EXPIRED) {
result |= KeyExpired;
}
if (sigsum & GPGME_SIGSUM_SIG_EXPIRED) {
result |= SigExpired;
}
if (sigsum & GPGME_SIGSUM_KEY_MISSING) {
result |= KeyMissing;
}
if (sigsum & GPGME_SIGSUM_CRL_MISSING) {
result |= CrlMissing;
}
if (sigsum & GPGME_SIGSUM_CRL_TOO_OLD) {
result |= CrlTooOld;
}
if (sigsum & GPGME_SIGSUM_BAD_POLICY) {
result |= BadPolicy;
}
if (sigsum & GPGME_SIGSUM_SYS_ERROR) {
result |= SysError;
}
if (sigsum & GPGME_SIGSUM_TOFU_CONFLICT) {
result |= TofuConflict;
}
return static_cast<Summary>(result);
}
const char *GpgME::Signature::fingerprint() const
{
return isNull() ? 0 : d->sigs[idx]->fpr ;
}
GpgME::Error GpgME::Signature::status() const
{
return Error(isNull() ? 0 : d->sigs[idx]->status);
}
time_t GpgME::Signature::creationTime() const
{
return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->timestamp);
}
time_t GpgME::Signature::expirationTime() const
{
return static_cast<time_t>(isNull() ? 0 : d->sigs[idx]->exp_timestamp);
}
bool GpgME::Signature::neverExpires() const
{
return expirationTime() == (time_t)0;
}
bool GpgME::Signature::isWrongKeyUsage() const
{
return !isNull() && d->sigs[idx]->wrong_key_usage;
}
bool GpgME::Signature::isVerifiedUsingChainModel() const
{
return !isNull() && d->sigs[idx]->chain_model;
}
GpgME::Signature::PKAStatus GpgME::Signature::pkaStatus() const
{
if (!isNull()) {
return static_cast<PKAStatus>(d->sigs[idx]->pka_trust);
}
return UnknownPKAStatus;
}
const char *GpgME::Signature::pkaAddress() const
{
if (!isNull()) {
return d->sigs[idx]->pka_address;
}
return 0;
}
GpgME::Signature::Validity GpgME::Signature::validity() const
{
if (isNull()) {
return Unknown;
}
switch (d->sigs[idx]->validity) {
default:
case GPGME_VALIDITY_UNKNOWN: return Unknown;
case GPGME_VALIDITY_UNDEFINED: return Undefined;
case GPGME_VALIDITY_NEVER: return Never;
case GPGME_VALIDITY_MARGINAL: return Marginal;
case GPGME_VALIDITY_FULL: return Full;
case GPGME_VALIDITY_ULTIMATE: return Ultimate;
}
}
char GpgME::Signature::validityAsString() const
{
if (isNull()) {
return '?';
}
switch (d->sigs[idx]->validity) {
default:
case GPGME_VALIDITY_UNKNOWN: return '?';
case GPGME_VALIDITY_UNDEFINED: return 'q';
case GPGME_VALIDITY_NEVER: return 'n';
case GPGME_VALIDITY_MARGINAL: return 'm';
case GPGME_VALIDITY_FULL: return 'f';
case GPGME_VALIDITY_ULTIMATE: return 'u';
}
}
GpgME::Error GpgME::Signature::nonValidityReason() const
{
return Error(isNull() ? 0 : d->sigs[idx]->validity_reason);
}
unsigned int GpgME::Signature::publicKeyAlgorithm() const
{
if (!isNull()) {
return d->sigs[idx]->pubkey_algo;
}
return 0;
}
const char *GpgME::Signature::publicKeyAlgorithmAsString() const
{
if (!isNull()) {
return gpgme_pubkey_algo_name(d->sigs[idx]->pubkey_algo);
}
return 0;
}
unsigned int GpgME::Signature::hashAlgorithm() const
{
if (!isNull()) {
return d->sigs[idx]->hash_algo;
}
return 0;
}
const char *GpgME::Signature::hashAlgorithmAsString() const
{
if (!isNull()) {
return gpgme_hash_algo_name(d->sigs[idx]->hash_algo);
}
return 0;
}
const char *GpgME::Signature::policyURL() const
{
return isNull() ? 0 : d->purls[idx] ;
}
GpgME::Notation GpgME::Signature::notation(unsigned int nidx) const
{
return GpgME::Notation(d, idx, nidx);
}
std::vector<GpgME::Notation> GpgME::Signature::notations() const
{
if (isNull()) {
return std::vector<GpgME::Notation>();
}
std::vector<GpgME::Notation> result;
result.reserve(d->nota[idx].size());
for (unsigned int i = 0 ; i < d->nota[idx].size() ; ++i) {
result.push_back(GpgME::Notation(d, idx, i));
}
return result;
}
+GpgME::Key GpgME::Signature::key() const
+{
+ if (isNull()) {
+ return Key();
+ }
+ return d->keys[idx];
+}
+
class GpgME::Notation::Private
{
public:
Private() : d(), sidx(0), nidx(0), nota(0) {}
Private(const std::shared_ptr<VerificationResult::Private> &priv, unsigned int sindex, unsigned int nindex)
: d(priv), sidx(sindex), nidx(nindex), nota(0)
{
}
Private(gpgme_sig_notation_t n)
: d(), sidx(0), nidx(0), nota(n ? new _gpgme_sig_notation(*n) : 0)
{
if (nota && nota->name) {
nota->name = strdup(nota->name);
}
if (nota && nota->value) {
nota->value = strdup(nota->value);
}
}
Private(const Private &other)
: d(other.d), sidx(other.sidx), nidx(other.nidx), nota(other.nota)
{
if (nota) {
nota->name = strdup(nota->name);
nota->value = strdup(nota->value);
}
}
~Private()
{
if (nota) {
std::free(nota->name); nota->name = 0;
std::free(nota->value); nota->value = 0;
delete nota;
}
}
std::shared_ptr<VerificationResult::Private> d;
unsigned int sidx, nidx;
gpgme_sig_notation_t nota;
};
GpgME::Notation::Notation(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int sindex, unsigned int nindex)
: d(new Private(parent, sindex, nindex))
{
}
GpgME::Notation::Notation(gpgme_sig_notation_t nota)
: d(new Private(nota))
{
}
GpgME::Notation::Notation() : d() {}
bool GpgME::Notation::isNull() const
{
if (!d) {
return true;
}
if (d->d) {
return d->sidx >= d->d->nota.size() || d->nidx >= d->d->nota[d->sidx].size() ;
}
return !d->nota;
}
const char *GpgME::Notation::name() const
{
return
isNull() ? 0 :
d->d ? d->d->nota[d->sidx][d->nidx].name :
d->nota ? d->nota->name : 0 ;
}
const char *GpgME::Notation::value() const
{
return
isNull() ? 0 :
d->d ? d->d->nota[d->sidx][d->nidx].value :
d->nota ? d->nota->value : 0 ;
}
GpgME::Notation::Flags GpgME::Notation::flags() const
{
return
convert_from_gpgme_sig_notation_flags_t(
isNull() ? 0 :
d->d ? d->d->nota[d->sidx][d->nidx].flags :
d->nota ? d->nota->flags : 0);
}
bool GpgME::Notation::isHumanReadable() const
{
return flags() & HumanReadable;
}
bool GpgME::Notation::isCritical() const
{
return flags() & Critical;
}
std::ostream &GpgME::operator<<(std::ostream &os, const VerificationResult &result)
{
os << "GpgME::VerificationResult(";
if (!result.isNull()) {
os << "\n error: " << result.error()
<< "\n fileName: " << protect(result.fileName())
<< "\n signatures:\n";
const std::vector<Signature> sigs = result.signatures();
std::copy(sigs.begin(), sigs.end(),
std::ostream_iterator<Signature>(os, "\n"));
}
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, Signature::PKAStatus pkaStatus)
{
#define OUTPUT( x ) if ( !(pkaStatus & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0)
os << "GpgME::Signature::PKAStatus(";
OUTPUT(UnknownPKAStatus);
OUTPUT(PKAVerificationFailed);
OUTPUT(PKAVerificationSucceeded);
#undef OUTPUT
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, Signature::Summary summary)
{
#define OUTPUT( x ) if ( !(summary & (GpgME::Signature:: x)) ) {} else do { os << #x " "; } while(0)
os << "GpgME::Signature::Summary(";
OUTPUT(Valid);
OUTPUT(Green);
OUTPUT(Red);
OUTPUT(KeyRevoked);
OUTPUT(KeyExpired);
OUTPUT(SigExpired);
OUTPUT(KeyMissing);
OUTPUT(CrlMissing);
OUTPUT(CrlTooOld);
OUTPUT(BadPolicy);
OUTPUT(SysError);
OUTPUT(TofuConflict);
#undef OUTPUT
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, const Signature &sig)
{
os << "GpgME::Signature(";
if (!sig.isNull()) {
os << "\n Summary: " << sig.summary()
<< "\n Fingerprint: " << protect(sig.fingerprint())
<< "\n Status: " << sig.status()
<< "\n creationTime: " << sig.creationTime()
<< "\n expirationTime: " << sig.expirationTime()
<< "\n isWrongKeyUsage: " << sig.isWrongKeyUsage()
<< "\n isVerifiedUsingChainModel: " << sig.isVerifiedUsingChainModel()
<< "\n pkaStatus: " << sig.pkaStatus()
<< "\n pkaAddress: " << protect(sig.pkaAddress())
<< "\n validity: " << sig.validityAsString()
<< "\n nonValidityReason: " << sig.nonValidityReason()
<< "\n publicKeyAlgorithm: " << protect(sig.publicKeyAlgorithmAsString())
<< "\n hashAlgorithm: " << protect(sig.hashAlgorithmAsString())
<< "\n policyURL: " << protect(sig.policyURL())
<< "\n notations:\n";
const std::vector<Notation> nota = sig.notations();
std::copy(nota.begin(), nota.end(),
std::ostream_iterator<Notation>(os, "\n"));
}
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, Notation::Flags flags)
{
os << "GpgME::Notation::Flags(";
#define OUTPUT( x ) if ( !(flags & (GpgME::Notation:: x)) ) {} else do { os << #x " "; } while(0)
OUTPUT(HumanReadable);
OUTPUT(Critical);
#undef OUTPUT
return os << ')';
}
std::ostream &GpgME::operator<<(std::ostream &os, const Notation &nota)
{
os << "GpgME::Signature::Notation(";
if (!nota.isNull()) {
os << "\n name: " << protect(nota.name())
<< "\n value: " << protect(nota.value())
<< "\n flags: " << nota.flags()
<< '\n';
}
return os << ")";
}
diff --git a/lang/cpp/src/verificationresult.h b/lang/cpp/src/verificationresult.h
index 3394a474..93288af2 100644
--- a/lang/cpp/src/verificationresult.h
+++ b/lang/cpp/src/verificationresult.h
@@ -1,174 +1,180 @@
/*
verificationresult.h - wraps a gpgme verify result
Copyright (C) 2004 Klarälvdalens Datakonsult AB
This file is part of GPGME++.
GPGME++ is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
GPGME++ is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with GPGME++; see the file COPYING.LIB. If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifndef __GPGMEPP_VERIFICATIONRESULT_H__
#define __GPGMEPP_VERIFICATIONRESULT_H__
#include "gpgmefw.h"
#include "result.h"
#include "gpgmepp_export.h"
#include <time.h>
#include <memory>
#include <vector>
#include <iosfwd>
namespace GpgME
{
class Error;
class Signature;
class Notation;
+class Key;
class GPGMEPP_EXPORT VerificationResult : public Result
{
public:
VerificationResult();
VerificationResult(gpgme_ctx_t ctx, int error);
VerificationResult(gpgme_ctx_t ctx, const Error &error);
explicit VerificationResult(const Error &err);
const VerificationResult &operator=(VerificationResult other)
{
swap(other);
return *this;
}
void swap(VerificationResult &other)
{
Result::swap(other);
using std::swap;
swap(this->d, other.d);
}
bool isNull() const;
const char *fileName() const;
unsigned int numSignatures() const;
Signature signature(unsigned int index) const;
std::vector<Signature> signatures() const;
class Private;
private:
void init(gpgme_ctx_t ctx);
std::shared_ptr<Private> d;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const VerificationResult &result);
class GPGMEPP_EXPORT Signature
{
friend class ::GpgME::VerificationResult;
Signature(const std::shared_ptr<VerificationResult::Private> &parent, unsigned int index);
public:
typedef GPGMEPP_DEPRECATED GpgME::Notation Notation;
Signature();
const Signature &operator=(Signature other)
{
swap(other);
return *this;
}
void swap(Signature &other)
{
using std::swap;
swap(this->d, other.d);
swap(this->idx, other.idx);
}
bool isNull() const;
enum Summary {
None = 0x000,
Valid = 0x001,
Green = 0x002,
Red = 0x004,
KeyRevoked = 0x008,
KeyExpired = 0x010,
SigExpired = 0x020,
KeyMissing = 0x040,
CrlMissing = 0x080,
CrlTooOld = 0x100,
BadPolicy = 0x200,
SysError = 0x400,
TofuConflict= 0x800
};
Summary summary() const;
const char *fingerprint() const;
Error status() const;
time_t creationTime() const;
time_t expirationTime() const;
bool neverExpires() const;
GPGMEPP_DEPRECATED bool wrongKeyUsage() const
{
return isWrongKeyUsage();
}
bool isWrongKeyUsage() const;
bool isVerifiedUsingChainModel() const;
enum PKAStatus {
UnknownPKAStatus, PKAVerificationFailed, PKAVerificationSucceeded
};
PKAStatus pkaStatus() const;
const char *pkaAddress() const;
enum Validity {
Unknown, Undefined, Never, Marginal, Full, Ultimate
};
Validity validity() const;
char validityAsString() const;
Error nonValidityReason() const;
unsigned int publicKeyAlgorithm() const;
const char *publicKeyAlgorithmAsString() const;
unsigned int hashAlgorithm() const;
const char *hashAlgorithmAsString() const;
const char *policyURL() const;
GpgME::Notation notation(unsigned int index) const;
std::vector<GpgME::Notation> notations() const;
+ /** Returns the key object associated with this signature.
+ * May be incomplete but will have at least the fingerprint
+ * set or the associated TOFU Information if applicable. */
+ GpgME::Key key() const;
+
private:
std::shared_ptr<VerificationResult::Private> d;
unsigned int idx;
};
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, const Signature &sig);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::PKAStatus pkaStatus);
GPGMEPP_EXPORT std::ostream &operator<<(std::ostream &os, Signature::Summary summary);
}
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(VerificationResult)
GPGMEPP_MAKE_STD_SWAP_SPECIALIZATION(Signature)
#endif // __GPGMEPP_VERIFICATIONRESULT_H__

File Metadata

Mime Type
text/x-diff
Expires
Tue, Jul 8, 12:16 PM (11 h, 31 m)
Storage Engine
local-disk
Storage Format
Raw Data
Storage Handle
46/08/a6a82f38bed5c9b995b06a7d46f2

Event Timeline