diff --git a/generators/poppler/CMakeLists.txt b/generators/poppler/CMakeLists.txt --- a/generators/poppler/CMakeLists.txt +++ b/generators/poppler/CMakeLists.txt @@ -111,6 +111,7 @@ generator_pdf.cpp formfields.cpp annots.cpp + pdfsignatureutils.cpp ) ki18n_wrap_ui(okularGenerator_poppler_PART_SRCS diff --git a/generators/poppler/formfields.h b/generators/poppler/formfields.h --- a/generators/poppler/formfields.h +++ b/generators/poppler/formfields.h @@ -111,4 +111,30 @@ }; +class PopplerSignatureInfo; +class PopplerFormFieldSignature : public Okular::FormFieldSignature +{ + public: + PopplerFormFieldSignature( Poppler::FormFieldSignature * field ); + virtual ~PopplerFormFieldSignature(); + + // inherited from Okular::FormField + Okular::NormalizedRect rect() const override; + int id() const override; + QString name() const override; + QString uiName() const override; + bool isReadOnly() const override; + bool isVisible() const override; + + // inherited from Okular::FormFieldSignature + SignatureType signatureType() const override; + Okular::SignatureInfo *validate() const override; + + private: + Poppler::FormFieldSignature * m_field; + mutable PopplerSignatureInfo *m_info; + Okular::NormalizedRect m_rect; + int m_id; +}; + #endif diff --git a/generators/poppler/formfields.cpp b/generators/poppler/formfields.cpp --- a/generators/poppler/formfields.cpp +++ b/generators/poppler/formfields.cpp @@ -12,6 +12,8 @@ #include "core/action.h" +#include "pdfsignatureutils.h" + #include #include @@ -367,4 +369,67 @@ return m_field->canBeSpellChecked(); } +PopplerFormFieldSignature::PopplerFormFieldSignature( Poppler::FormFieldSignature * field ) + : Okular::FormFieldSignature(), m_field( field ), m_info( nullptr ) +{ + m_rect = Okular::NormalizedRect::fromQRectF( m_field->rect() ); + m_id = m_field->id(); + m_info = new PopplerSignatureInfo( m_field->validate( Poppler::FormFieldSignature::ValidateVerifyCertificate ) ); + SET_ACTIONS +} +PopplerFormFieldSignature::~PopplerFormFieldSignature() +{ + delete m_field; + delete m_info; +} + +Okular::NormalizedRect PopplerFormFieldSignature::rect() const +{ + return m_rect; +} + +int PopplerFormFieldSignature::id() const +{ + return m_id; +} + +QString PopplerFormFieldSignature::name() const +{ + return m_field->name(); +} + +QString PopplerFormFieldSignature::uiName() const +{ + return m_field->uiName(); +} + +bool PopplerFormFieldSignature::isReadOnly() const +{ + return m_field->isReadOnly(); +} + +bool PopplerFormFieldSignature::isVisible() const +{ + return m_field->isVisible(); +} + +PopplerFormFieldSignature::SignatureType PopplerFormFieldSignature::signatureType() const +{ + switch ( m_field->signatureType() ) + { + case Poppler::FormFieldSignature::AdbePkcs7sha1: + return Okular::FormFieldSignature::AdbePkcs7sha1; + case Poppler::FormFieldSignature::AdbePkcs7detached: + return Okular::FormFieldSignature::AdbePkcs7detached; + case Poppler::FormFieldSignature::EtsiCAdESdetached: + return Okular::FormFieldSignature::EtsiCAdESdetached; + default: + return Okular::FormFieldSignature::UnknownType; + } +} + +Okular::SignatureInfo *PopplerFormFieldSignature::validate() const +{ + return m_info; +} diff --git a/generators/poppler/generator_pdf.cpp b/generators/poppler/generator_pdf.cpp --- a/generators/poppler/generator_pdf.cpp +++ b/generators/poppler/generator_pdf.cpp @@ -1857,6 +1857,10 @@ case Poppler::FormField::FormChoice: of = new PopplerFormFieldChoice( static_cast( f ) ); break; + case Poppler::FormField::FormSignature: { + of = new PopplerFormFieldSignature( static_cast( f ) ); + break; + } default: ; } if ( of ) diff --git a/generators/poppler/pdfsignatureutils.h b/generators/poppler/pdfsignatureutils.h new file mode 100644 --- /dev/null +++ b/generators/poppler/pdfsignatureutils.h @@ -0,0 +1,64 @@ +/*************************************************************************** + * Copyright (C) 2018 by Chinmoy Ranjan Pradhan * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#ifndef _OKULAR_GENERATOR_PDF_SIGNATUREINFO_H_ +#define _OKULAR_GENERATOR_PDF_SIGNATUREINFO_H_ + +#include + +#include "core/signatureutils.h" + +class PopplerCertificateInfo : public Okular::CertificateInfo +{ + public: + PopplerCertificateInfo(const Poppler::CertificateInfo &info); + ~PopplerCertificateInfo(); + + bool isNull() const override; + int version() const override; + QByteArray serialNumber() const override; + QString issuerInfo(EntityInfoKey) const override; + QString subjectInfo(EntityInfoKey) const override; + QDateTime validityStart() const override; + QDateTime validityEnd() const override; + KeyUsageExtensions keyUsageExtensions() const override; + QByteArray publicKey() const override; + PublicKeyType publicKeyType() const override; + int publicKeyStrength() const override; + bool isSelfSigned() const override; + QByteArray certificateData() const override; + + private: + Poppler::CertificateInfo *m_info; +}; + +class PopplerSignatureInfo : public Okular::SignatureInfo +{ + public: + PopplerSignatureInfo( const Poppler::SignatureValidationInfo &info ); + ~PopplerSignatureInfo(); + + SignatureStatus signatureStatus() const override; + CertificateStatus certificateStatus() const override; + QString signerName() const override; + QString signerSubjectDN() const override; + QString location() const override; + QString reason() const override; + HashAlgorithm hashAlgorithm() const override; + QDateTime signingTime() const override; + QByteArray signature() const override; + QList signedRangeBounds() const override; + bool signsTotalDocument() const override; + Okular::CertificateInfo *certificateInfo() const override; + + private: + Poppler::SignatureValidationInfo *m_info; +}; + +#endif diff --git a/generators/poppler/pdfsignatureutils.cpp b/generators/poppler/pdfsignatureutils.cpp new file mode 100644 --- /dev/null +++ b/generators/poppler/pdfsignatureutils.cpp @@ -0,0 +1,245 @@ +/*************************************************************************** + * Copyright (C) 2018 by Chinmoy Ranjan Pradhan * + * * + * This program is free software; you can redistribute it and/or modify * + * it under the terms of the GNU General Public License as published by * + * the Free Software Foundation; either version 2 of the License, or * + * (at your option) any later version. * + ***************************************************************************/ + +#include "pdfsignatureutils.h" + +#include +#include + +PopplerCertificateInfo::PopplerCertificateInfo( const Poppler::CertificateInfo &info ) + : m_info( new Poppler::CertificateInfo( nullptr ) ) +{ + *m_info = info; +} + +PopplerCertificateInfo::~PopplerCertificateInfo() +{ + delete m_info; +} + +bool PopplerCertificateInfo::isNull() const +{ + return m_info->isNull(); +} + +int PopplerCertificateInfo::version() const +{ + return m_info->version(); +} + +QByteArray PopplerCertificateInfo::serialNumber() const +{ + return m_info->serialNumber(); +} + +QString PopplerCertificateInfo::issuerInfo( PopplerCertificateInfo::EntityInfoKey key ) const +{ + QString str = m_info->issuerInfo(static_cast( key )); + return !str.isEmpty() ? str : i18n("Not Available"); +} + +QString PopplerCertificateInfo::subjectInfo( PopplerCertificateInfo::EntityInfoKey key ) const +{ + QString str = m_info->subjectInfo(static_cast( key )); + return !str.isEmpty() ? str : i18n("Not Available"); +} + +QDateTime PopplerCertificateInfo::validityStart() const +{ + return m_info->validityStart(); +} + +QDateTime PopplerCertificateInfo::validityEnd() const +{ + return m_info->validityEnd(); +} + +PopplerCertificateInfo::KeyUsageExtensions PopplerCertificateInfo::keyUsageExtensions() const +{ + Poppler::CertificateInfo::KeyUsageExtensions popplerKu = m_info->keyUsageExtensions(); + KeyUsageExtensions ku = KuNone; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuDigitalSignature ) ) + ku |= KuDigitalSignature; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuNonRepudiation ) ) + ku |= KuNonRepudiation; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuKeyEncipherment ) ) + ku |= KuKeyEncipherment; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuDataEncipherment ) ) + ku |= KuDataEncipherment; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuKeyAgreement ) ) + ku |= KuKeyAgreement; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuKeyCertSign ) ) + ku |= KuKeyCertSign; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuClrSign ) ) + ku |= KuClrSign; + if ( popplerKu.testFlag( Poppler::CertificateInfo::KuEncipherOnly ) ) + ku |= KuEncipherOnly; + return ku; +} + +QByteArray PopplerCertificateInfo::publicKey() const +{ + return m_info->publicKey(); +} + +PopplerCertificateInfo::PublicKeyType PopplerCertificateInfo::publicKeyType() const +{ + switch ( m_info->publicKeyType() ) + { + case Poppler::CertificateInfo::RsaKey: + return RsaKey; + case Poppler::CertificateInfo::DsaKey: + return DsaKey; + case Poppler::CertificateInfo::EcKey: + return EcKey; + case Poppler::CertificateInfo::OtherKey: + return OtherKey; + } +} + +int PopplerCertificateInfo::publicKeyStrength() const +{ + return m_info->publicKeyStrength(); +} + +bool PopplerCertificateInfo::isSelfSigned() const +{ + return m_info->isSelfSigned(); +} + +QByteArray PopplerCertificateInfo::certificateData() const +{ + return m_info->certificateData(); +} + + +PopplerSignatureInfo::PopplerSignatureInfo( const Poppler::SignatureValidationInfo &info ) + : m_info( new Poppler::SignatureValidationInfo( nullptr ) ) +{ + *m_info = info; +} + +PopplerSignatureInfo::~PopplerSignatureInfo() +{ + delete m_info; +} + +PopplerSignatureInfo::SignatureStatus PopplerSignatureInfo::signatureStatus() const +{ + switch ( m_info->signatureStatus() ) + { + case Poppler::SignatureValidationInfo::SignatureValid: + return SignatureValid; + case Poppler::SignatureValidationInfo::SignatureInvalid: + return SignatureInvalid; + case Poppler::SignatureValidationInfo::SignatureDigestMismatch: + return SignatureDigestMismatch; + case Poppler::SignatureValidationInfo::SignatureDecodingError: + return SignatureDecodingError; + case Poppler::SignatureValidationInfo::SignatureGenericError: + return SignatureGenericError; + case Poppler::SignatureValidationInfo::SignatureNotFound: + return SignatureNotFound; + case Poppler::SignatureValidationInfo::SignatureNotVerified: + return SignatureNotVerified; + default: + return SignatureStatusUnknown; + } +} + +PopplerSignatureInfo::CertificateStatus PopplerSignatureInfo::certificateStatus() const +{ + switch ( m_info->certificateStatus() ) + { + case Poppler::SignatureValidationInfo::CertificateTrusted: + return CertificateTrusted; + case Poppler::SignatureValidationInfo::CertificateUntrustedIssuer: + return CertificateUntrustedIssuer; + case Poppler::SignatureValidationInfo::CertificateUnknownIssuer: + return CertificateUnknownIssuer; + case Poppler::SignatureValidationInfo::CertificateRevoked: + return CertificateRevoked; + case Poppler::SignatureValidationInfo::CertificateExpired: + return CertificateExpired; + case Poppler::SignatureValidationInfo::CertificateGenericError: + return CertificateGenericError; + case Poppler::SignatureValidationInfo::CertificateNotVerified: + return CertificateNotVerified; + default: + return CertificateStatusUnknown; + } +} + +PopplerSignatureInfo::HashAlgorithm PopplerSignatureInfo::hashAlgorithm() const +{ + switch ( m_info->hashAlgorithm() ) + { + case Poppler::SignatureValidationInfo::HashAlgorithmMd2: + return HashAlgorithmMd2; + case Poppler::SignatureValidationInfo::HashAlgorithmMd5: + return HashAlgorithmMd5; + case Poppler::SignatureValidationInfo::HashAlgorithmSha1: + return HashAlgorithmSha1; + case Poppler::SignatureValidationInfo::HashAlgorithmSha256: + return HashAlgorithmSha256; + case Poppler::SignatureValidationInfo::HashAlgorithmSha384: + return HashAlgorithmSha384; + case Poppler::SignatureValidationInfo::HashAlgorithmSha512: + return HashAlgorithmSha512; + case Poppler::SignatureValidationInfo::HashAlgorithmSha224: + return HashAlgorithmSha224; + default: + return HashAlgorithmUnknown; + } +} + +QString PopplerSignatureInfo::signerName() const +{ + return m_info->signerName(); +} + +QString PopplerSignatureInfo::signerSubjectDN() const +{ + return m_info->signerSubjectDN(); +} + +QString PopplerSignatureInfo::location() const +{ + return m_info->location(); +} + +QString PopplerSignatureInfo::reason() const +{ + return m_info->reason(); +} + +QDateTime PopplerSignatureInfo::signingTime() const +{ + return QDateTime::fromTime_t( m_info->signingTime() ); +} + +QByteArray PopplerSignatureInfo::signature() const +{ + return m_info->signature(); +} + +QList PopplerSignatureInfo::signedRangeBounds() const +{ + return m_info->signedRangeBounds(); +} + +bool PopplerSignatureInfo::signsTotalDocument() const +{ + return m_info->signsTotalDocument(); +} + +Okular::CertificateInfo *PopplerSignatureInfo::certificateInfo() const +{ + return ( new PopplerCertificateInfo( m_info->certificateInfo() ) ); +}