00001
00030
#ifdef HAVE_CONFIG_H
00031
#include <config.h>
00032
#endif
00033
00034
#include "cryptplugwrapper.h"
00035
#include "cryptplug.h"
00036
00037
#include <backends/qgpgme/qgpgmekeylistjob.h>
00038
#include <backends/qgpgme/qgpgmeencryptjob.h>
00039
#include <backends/qgpgme/qgpgmedecryptjob.h>
00040
#include <backends/qgpgme/qgpgmesignjob.h>
00041
#include <backends/qgpgme/qgpgmeverifydetachedjob.h>
00042
#include <backends/qgpgme/qgpgmeverifyopaquejob.h>
00043
#include <backends/qgpgme/qgpgmekeygenerationjob.h>
00044
#include <backends/qgpgme/qgpgmeimportjob.h>
00045
#include <backends/qgpgme/qgpgmeexportjob.h>
00046
#include <backends/qgpgme/qgpgmesecretkeyexportjob.h>
00047
#include <backends/qgpgme/qgpgmedownloadjob.h>
00048
#include <backends/qgpgme/qgpgmedeletejob.h>
00049
#include <backends/qgpgme/qgpgmesignencryptjob.h>
00050
#include <backends/qgpgme/qgpgmedecryptverifyjob.h>
00051
#include <backends/qgpgme/qgpgmecryptoconfig.h>
00052
#include <backends/qgpgme/qgpgmerefreshkeysjob.h>
00053
00054
00055
#include <qgpgme/dataprovider.h>
00056
00057
00058
#include <gpgmepp/data.h>
00059
#include <gpgmepp/importresult.h>
00060
#include <gpgmepp/keygenerationresult.h>
00061
00062
00063
#include <kdebug.h>
00064
#include <kapplication.h>
00065
#include <klocale.h>
00066
#include <kglobal.h>
00067
#include <kconfig.h>
00068
00069
00070
#include <memory>
00071
00072
#include <assert.h>
00073
#include <stdlib.h>
00074
#include <stdio.h>
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091
00092
00093
00094
00121
00122
class DNBeautifier {
00123
public:
00124
enum UnknownAttrsHandling { unknownAttrsHide,
00125 unknownAttrsPrefix,
00126 unknownAttrsPostfix,
00127 unknownAttrsInfix };
00128
00129
00130 DNBeautifier()
00131 {
00132
00133 _unknownAttrsHandling = unknownAttrsInfix;
00134 _unknownAttrsHandlingChar =
"INFIX";
00135 }
00136 DNBeautifier( KConfig* config,
00137
const QString& cfgGroup,
00138
const QString& cfgAttributeOrderEntry,
00139
const QString& cfgUnknownAttrsEntry,
00140
const QStringList& fallbackAttrOrder =
QStringList(),
00141 UnknownAttrsHandling fallbackUnknowAttrsHandling = unknownAttrsInfix )
00142 {
00143 _unknownAttrsHandling = unknownAttrsInfix;
00144 _unknownAttrsHandlingChar =
"INFIX";
00145
if( config ){
00146
const QString oldGroup( config->group() );
00147 config->setGroup( cfgGroup );
00148 _attrOrder =
00149 config->readListEntry( cfgAttributeOrderEntry );
00150 _unknownAttrsHandlingChar =
00151 config->readEntry( cfgUnknownAttrsEntry ).upper().latin1();
00152 config->setGroup( oldGroup );
00153
if( _unknownAttrsHandlingChar ==
"HIDE" )
00154 _unknownAttrsHandling = unknownAttrsHide;
00155
else if( _unknownAttrsHandlingChar ==
"PREFIX" )
00156 _unknownAttrsHandling = unknownAttrsPrefix;
00157
else if( _unknownAttrsHandlingChar ==
"POSTFIX" )
00158 _unknownAttrsHandling = unknownAttrsPostfix;
00159
else if( _unknownAttrsHandlingChar ==
"INFIX" )
00160 _unknownAttrsHandling = unknownAttrsInfix;
00161
else
00162 _unknownAttrsHandlingChar =
"INFIX";
00163 }
00164
if( _attrOrder.isEmpty() && ! fallbackAttrOrder.isEmpty() )
00165 _attrOrder = fallbackAttrOrder;
00166
00167
if( _attrOrder.isEmpty() ){
00168 _attrOrderChar = 0;
00169 }
else{
00170 _attrOrderChar =
new char*[ _attrOrder.count()+1 ];
00171
int i=0;
00172
for( QStringList::ConstIterator itOrder = _attrOrder.begin();
00173 itOrder != _attrOrder.end();
00174 ++itOrder ){
00175 _attrOrderChar[ i ] = (
char*)malloc( ((*itOrder).length()+1)*
sizeof(
char) );
00176 strcpy( _attrOrderChar[ i ], (*itOrder).latin1() );
00177 ++i;
00178 }
00179 _attrOrderChar[ i ] = NULL;
00180 }
00181 }
00182 ~DNBeautifier()
00183 {
00184
int i=0;
00185
for( QStringList::ConstIterator itOrder = _attrOrder.begin();
00186 itOrder != _attrOrder.end();
00187 ++itOrder ){
00188 free( _attrOrderChar[ i ] );
00189 ++i;
00190 }
00191
delete[] _attrOrderChar;
00192 }
00193
00194
QStringList attrOrder()
const
00195
{
00196
return _attrOrder;
00197 }
00198
char** attrOrderChar()
00199 {
00200
return _attrOrderChar;
00201 }
00202
00203 UnknownAttrsHandling unknownAttrsHandling()
const
00204
{
00205
return _unknownAttrsHandling;
00206 }
00207
const char* unknownAttrsHandlingChar()
const
00208
{
00209
return _unknownAttrsHandlingChar;
00210 }
00211
00212
QValueList< QPair<QString,QString> > reorder(
const QValueList<
QPair<QString,QString> > & dn )
const
00213
{
00214
return reorder( dn, _attrOrder, _unknownAttrsHandling );
00215 }
00216
00217
00218
static QValueList< QPair<QString,QString> > reorder(
00219
const QValueList<
QPair<QString,QString> > & dn,
00220
QStringList attrOrder,
00221 UnknownAttrsHandling unknownAttrsHandling )
00222 {
00223
if( !attrOrder.isEmpty() ){
00224
QPtrList< QPair<QString,QString> > unknownEntries;
00225
QValueList< QPair<QString,QString> > dnNew;
00226
00227
QPair<QString,QString>* unknownEntry;
00228 QStringList::ConstIterator itOrder;
00229
QValueList< QPair<QString,QString> >::ConstIterator itDN;
00230
bool bFound;
00231
00232
if( unknownAttrsHandling != unknownAttrsHide ){
00233
00234
for( itDN = dn.begin(); itDN != dn.end(); ++itDN ){
00235 bFound =
false;
00236
for( itOrder = attrOrder.begin(); itOrder != attrOrder.end(); ++itOrder ){
00237
if( (*itOrder) == (*itDN).first ){
00238 bFound =
true;
00239
break;
00240 }
00241 }
00242
if( !bFound )
00243 unknownEntries.append( &(*itDN) );
00244 }
00245 }
00246
00247
00248
if( unknownAttrsHandling == unknownAttrsPrefix ){
00249
for( unknownEntry = unknownEntries.first(); unknownEntry; unknownEntry = unknownEntries.next() ){
00250 dnNew << *unknownEntry;
00251 }
00252 }
00253
00254
00255
bool b_X_declared =
false;
00256
for( itOrder = attrOrder.begin(); itOrder != attrOrder.end(); ++itOrder ){
00257
if( (*itOrder) ==
"_X_" ){
00258 b_X_declared =
true;
00259
00260
if( unknownAttrsHandling == unknownAttrsInfix ){
00261
for( unknownEntry = unknownEntries.first(); unknownEntry; unknownEntry = unknownEntries.next() ){
00262 dnNew << *unknownEntry;
00263 }
00264 }
00265 }
else{
00266
for( itDN = dn.begin(); itDN != dn.end(); ++itDN ){
00267
if( (*itOrder) == (*itDN).first ){
00268 dnNew << *itDN;
00269
00270 }
00271 }
00272 }
00273 }
00274
00275
00276
if( unknownAttrsHandling == unknownAttrsPostfix ||
00277 ( unknownAttrsHandling == unknownAttrsInfix && ! b_X_declared ) ){
00278
for( unknownEntry = unknownEntries.first(); unknownEntry; unknownEntry = unknownEntries.next() ){
00279 dnNew << *unknownEntry;
00280 }
00281 }
00282
00283
return dnNew;
00284 }
00285
return dn;
00286 }
00287
00288
private:
00289
QStringList _attrOrder;
00290
char** _attrOrderChar;
00291 UnknownAttrsHandling _unknownAttrsHandling;
00292
QCString _unknownAttrsHandlingChar;
00293 };
00294
00295
00296
00297
00298
00299
00300
00301 StructuringInfoWrapper::StructuringInfoWrapper(
CryptPlugWrapper* wrapper )
00302 : _initDone( false ), _wrapper( wrapper )
00303 {
00304 initMe();
00305 }
00306 StructuringInfoWrapper::~StructuringInfoWrapper()
00307 {
00308 freeMe();
00309 }
00310
void StructuringInfoWrapper::reset()
00311 {
00312 freeMe();
00313 initMe();
00314 }
00315
void StructuringInfoWrapper::initMe()
00316 {
00317
if ( _wrapper && _wrapper->
cryptPlug() ) {
00318 _wrapper->
cryptPlug()->init_StructuringInfo( &data );
00319 _initDone =
true;
00320 }
00321 }
00322
void StructuringInfoWrapper::freeMe()
00323 {
00324
if( _wrapper && _wrapper->
cryptPlug() && _initDone ) {
00325 _wrapper->
cryptPlug()->free_StructuringInfo( &data );
00326 _initDone =
false;
00327 }
00328 }
00329
00330
class CryptPlugWrapper::Config {
00331
public:
00332 Config( gpgme_protocol_t proto );
00333 ~Config();
00334
00335
const char* signatureKeyCertificate;
00336 SignatureAlgorithm signatureAlgorithm;
00337 SignatureCompoundMode signatureCompoundMode;
00338 SendCertificates sendCertificates;
00339
bool saveSentSignatures;
00340
bool warnNoCertificate;
00341
bool signatureUseCRLs;
00342 EncryptionAlgorithm encryptionAlgorithm;
00343 EncryptEmail encryptEmail;
00344
bool saveMessagesEncrypted;
00345
bool encryptionUseCRLs;
00346
bool encryptionCRLExpiryNearWarning;
00347
int encryptionCRLNearExpiryInterval;
00348 CertificateSource certificateSource;
00349
bool warnSendUnsigned;
00350
bool signatureCertificateExpiryNearWarning;
00351
int signatureCertificateExpiryNearInterval;
00352
bool cACertificateExpiryNearWarning;
00353
int cACertificateExpiryNearInterval;
00354
bool rootCertificateExpiryNearWarning;
00355
int rootCertificateExpiryNearInterval;
00356
bool warnSendUnencrypted;
00357
bool checkCertificatePath;
00358
bool receiverCertificateExpiryNearWarning;
00359
int receiverCertificateExpiryNearWarningInterval;
00360
bool certificateInChainExpiryNearWarning;
00361
int certificateInChainExpiryNearWarningInterval;
00362
bool receiverEmailAddressNotInCertificateWarning;
00363
const char* libVersion;
00364 };
00365
00366
static const int NEAR_EXPIRY = 14;
00367
00368 CryptPlugWrapper::Config::Config( gpgme_protocol_t proto )
00369 {
00370 signatureAlgorithm = SignAlg_SHA1;
00371
if ( proto == GPGME_PROTOCOL_CMS )
00372 signatureCompoundMode = SignatureCompoundMode_Opaque;
00373
else
00374 signatureCompoundMode = SignatureCompoundMode_Detached;
00375 sendCertificates = SendCert_SendChainWithRoot;
00376 saveSentSignatures =
true;
00377 warnNoCertificate =
true;
00378 signatureUseCRLs =
true;
00379 encryptionAlgorithm = EncryptAlg_RSA;
00380 encryptEmail = EncryptEmail_Ask;
00381 saveMessagesEncrypted =
true;
00382 encryptionUseCRLs =
true;
00383 encryptionCRLExpiryNearWarning =
false;
00384 encryptionCRLNearExpiryInterval = NEAR_EXPIRY;
00385 certificateSource = CertSrc_Server;
00386 warnSendUnsigned =
true;
00387 signatureCertificateExpiryNearWarning =
true;
00388 signatureCertificateExpiryNearInterval = NEAR_EXPIRY;
00389 cACertificateExpiryNearWarning =
true;
00390 cACertificateExpiryNearInterval = NEAR_EXPIRY;
00391 rootCertificateExpiryNearWarning =
true;
00392 rootCertificateExpiryNearInterval = NEAR_EXPIRY;
00393 warnSendUnencrypted =
false;
00394 checkCertificatePath =
true;
00395 receiverCertificateExpiryNearWarning =
true;
00396 receiverCertificateExpiryNearWarningInterval = NEAR_EXPIRY;
00397 certificateInChainExpiryNearWarning =
true;
00398 certificateInChainExpiryNearWarningInterval = NEAR_EXPIRY;
00399 receiverEmailAddressNotInCertificateWarning =
true;
00400 libVersion = gpgme_check_version (NULL);
00401 }
00402
00403 CryptPlugWrapper::Config::~Config() {
00404 }
00405
00406 const char*
CryptPlugWrapper::bugURL(){
return "http://www.gnupg.org/aegypten/"; }
00407
00408
00409 void CryptPlugWrapper::setSignatureAlgorithm( SignatureAlgorithm sigAlg )
00410 {
00411 _config->signatureAlgorithm = sigAlg;
00412 }
00413
00414 SignatureAlgorithm
CryptPlugWrapper::signatureAlgorithm()
00415 {
00416
return _config->signatureAlgorithm;
00417 }
00418
00419
00420
00421
00422 void CryptPlugWrapper::setWarnSendUnsigned(
bool flag )
00423 {
00424 _config->warnSendUnsigned = flag;
00425 }
00426
00427 bool CryptPlugWrapper::warnSendUnsigned()
00428 {
00429
return _config->warnSendUnsigned;
00430 }
00431
00432
00433
00434
00435
00436
00437
00438
00439
00440 void CryptPlugWrapper::setSignatureCertificateExpiryNearWarning(
bool flag )
00441 {
00442 _config->signatureCertificateExpiryNearWarning = flag;
00443 }
00444
00445 bool CryptPlugWrapper::signatureCertificateExpiryNearWarning(
void )
00446 {
00447
return _config->signatureCertificateExpiryNearWarning;
00448 }
00449
00450 void CryptPlugWrapper::setSignatureCertificateExpiryNearInterval(
int interval )
00451 {
00452 _config->signatureCertificateExpiryNearInterval = interval;
00453 }
00454
00455 int CryptPlugWrapper::signatureCertificateExpiryNearInterval(
void )
00456 {
00457
return _config->signatureCertificateExpiryNearInterval;
00458 }
00459
00460 void CryptPlugWrapper::setCACertificateExpiryNearWarning(
bool flag )
00461 {
00462 _config->cACertificateExpiryNearWarning = flag;
00463 }
00464
00465 bool CryptPlugWrapper::caCertificateExpiryNearWarning(
void )
00466 {
00467
return _config->cACertificateExpiryNearWarning;
00468 }
00469
00470 void CryptPlugWrapper::setCACertificateExpiryNearInterval(
int interval )
00471 {
00472 _config->cACertificateExpiryNearInterval = interval;
00473 }
00474
00475 int CryptPlugWrapper::caCertificateExpiryNearInterval(
void )
00476 {
00477
return _config->cACertificateExpiryNearInterval;
00478 }
00479
00480 void CryptPlugWrapper::setRootCertificateExpiryNearWarning(
bool flag )
00481 {
00482 _config->rootCertificateExpiryNearWarning = flag;
00483 }
00484
00485 bool CryptPlugWrapper::rootCertificateExpiryNearWarning(
void )
00486 {
00487
return _config->rootCertificateExpiryNearWarning;
00488 }
00489
00490 void CryptPlugWrapper::setRootCertificateExpiryNearInterval(
int interval )
00491 {
00492 _config->rootCertificateExpiryNearInterval = interval;
00493 }
00494
00495 int CryptPlugWrapper::rootCertificateExpiryNearInterval(
void )
00496 {
00497
return _config->rootCertificateExpiryNearInterval;
00498 }
00499
00500
00501
00502
00503
00504 void CryptPlugWrapper::setEncryptionAlgorithm( EncryptionAlgorithm cryptAlg )
00505 {
00506 _config->encryptionAlgorithm = cryptAlg;
00507 }
00508
00509 EncryptionAlgorithm
CryptPlugWrapper::encryptionAlgorithm()
00510 {
00511
return _config->encryptionAlgorithm;
00512 }
00513
00514 void CryptPlugWrapper::setEncryptEmail( EncryptEmail cryptMode )
00515 {
00516 _config->encryptEmail = cryptMode;
00517 }
00518
00519 EncryptEmail
CryptPlugWrapper::encryptEmail()
00520 {
00521
return _config->encryptEmail;
00522 }
00523
00524
00525
00526
00527
00528
00529 void CryptPlugWrapper::setWarnSendUnencrypted(
bool flag )
00530 {
00531 _config->warnSendUnencrypted = flag;
00532 }
00533
00534 bool CryptPlugWrapper::warnSendUnencrypted()
00535 {
00536
return _config->warnSendUnencrypted;
00537 }
00538
00539
00540
00541
00542
00543
00544
00545
00546
00547 void CryptPlugWrapper::setSaveMessagesEncrypted(
bool flag )
00548 {
00549 _config->saveMessagesEncrypted = flag;
00550 }
00551
00552 bool CryptPlugWrapper::saveMessagesEncrypted()
00553 {
00554
return _config->saveMessagesEncrypted;
00555 }
00556
00557
00558
00559
00560
00561
00562
00563 void CryptPlugWrapper::setCheckCertificatePath(
bool flag )
00564 {
00565 _config->checkCertificatePath = flag;
00566 }
00567
00568 bool CryptPlugWrapper::checkCertificatePath()
00569 {
00570
return _config->checkCertificatePath;
00571 }
00572
00573
00574
00575
00576
00577
00578
00579
00580
00581
00582
00583
00584 void CryptPlugWrapper::setReceiverCertificateExpiryNearWarning(
bool flag )
00585 {
00586 _config->receiverCertificateExpiryNearWarning = flag;
00587 }
00588
00589 bool CryptPlugWrapper::receiverCertificateExpiryNearWarning()
00590 {
00591
return _config->receiverCertificateExpiryNearWarning;
00592 }
00593
00594
00595 void CryptPlugWrapper::setReceiverCertificateExpiryNearWarningInterval(
int interval )
00596 {
00597 _config->receiverCertificateExpiryNearWarningInterval = interval;
00598 }
00599
00600 int CryptPlugWrapper::receiverCertificateExpiryNearWarningInterval()
00601 {
00602
return _config->receiverCertificateExpiryNearWarningInterval;
00603 }
00604
00605 void CryptPlugWrapper::setCertificateInChainExpiryNearWarning(
bool flag )
00606 {
00607 _config->certificateInChainExpiryNearWarning = flag;
00608 }
00609
00610 bool CryptPlugWrapper::certificateInChainExpiryNearWarning()
00611 {
00612
return _config->certificateInChainExpiryNearWarning;
00613 }
00614
00615
00616 void CryptPlugWrapper::setCertificateInChainExpiryNearWarningInterval(
int interval )
00617 {
00618 _config->certificateInChainExpiryNearWarningInterval = interval;
00619 }
00620
00621 int CryptPlugWrapper::certificateInChainExpiryNearWarningInterval()
00622 {
00623
return _config->certificateInChainExpiryNearWarningInterval;
00624 }
00625
00626 void CryptPlugWrapper::setReceiverEmailAddressNotInCertificateWarning(
bool flag )
00627 {
00628 _config->receiverEmailAddressNotInCertificateWarning = flag;
00629 }
00630
00631 bool CryptPlugWrapper::receiverEmailAddressNotInCertificateWarning()
00632 {
00633
return _config->receiverEmailAddressNotInCertificateWarning;
00634 }
00635
00636
00637
00638
00639
00640
00641
00642
00643 void CryptPlugWrapper::setEncryptionUseCRLs(
bool flag )
00644 {
00645 _config->encryptionUseCRLs = flag;
00646
00647
00648
00649
00650
00651 }
00652
00653 bool CryptPlugWrapper::encryptionUseCRLs()
00654 {
00655
return _config->encryptionUseCRLs;
00656 }
00657
00658
00659 void CryptPlugWrapper::setEncryptionCRLExpiryNearWarning(
bool flag )
00660 {
00661 _config->encryptionCRLExpiryNearWarning = flag;
00662 }
00663
00664 bool CryptPlugWrapper::encryptionCRLExpiryNearWarning()
00665 {
00666
return _config->encryptionCRLExpiryNearWarning;
00667 }
00668
00669 void CryptPlugWrapper::setEncryptionCRLNearExpiryInterval(
int interval )
00670 {
00671 _config->encryptionCRLNearExpiryInterval = interval;
00672 }
00673
00674 int CryptPlugWrapper::encryptionCRLNearExpiryInterval()
00675 {
00676
return _config->encryptionCRLNearExpiryInterval;
00677 }
00678
00679
00680 void CryptPlugWrapper::setCertificateSource( CertificateSource source )
00681 {
00682 _config->certificateSource = source;
00683 }
00684
00685 CertificateSource
CryptPlugWrapper::certificateSource()
00686 {
00687
return _config->certificateSource;
00688 }
00689
00690
00691
00692
00693
00694 QString CryptPlugWrapper::libVersion()
const {
00695
return _config && _config->libVersion ? QString::fromUtf8( _config->libVersion ) : QString::null ;
00696 }
00697
00698
00699
00700
QString CryptPlugWrapper::errorIdToText(
int errId,
bool & isPassphraseError ) {
00701
const GpgME::Error err( errId );
00702 isPassphraseError = err.isCanceled()
00703 || gpgme_err_code( errId ) == GPG_ERR_NO_SECKEY ;
00704
return QString::fromLocal8Bit( err.asString() );
00705
#if 0
00706
switch( errId ){
00707
case -1:
00708
return(i18n(
"End of File reached during operation."));
00709
case 0:
00710
return(i18n(
"No error."));
00711
case 1:
00712
return(i18n(
"General error."));
00713
case 2:
00714
return(i18n(
"Out of core."));
00715
case 3:
00716
return(i18n(
"Invalid value."));
00717
case 4:
00718
return(i18n(
"Engine is busy."));
00719
case 5:
00720
return(i18n(
"No request."));
00721
case 6:
00722
return(i18n(
"Execution error."));
00723
case 7:
00724
return(i18n(
"Too many processes."));
00725
case 8:
00726
return(i18n(
"Pipe error."));
00727
case 9:
00728
return(i18n(
"No recipients."));
00729
case 10:
00730
return(i18n(
"No data."));
00731
case 11:
00732
return(i18n(
"Conflict."));
00733
case 12:
00734
return(i18n(
"Not implemented."));
00735
case 13:
00736
return(i18n(
"Read error."));
00737
case 14:
00738
return(i18n(
"Write error."));
00739
case 15:
00740
return(i18n(
"Invalid type."));
00741
case 16:
00742
return(i18n(
"Invalid mode."));
00743
case 17:
00744
return(i18n(
"File error."));
00745
case 18:
00746
return(i18n(
"Decryption failed."));
00747
case 19:
00748 isPassphraseError =
true;
00749
return(i18n(
"No passphrase."));
00750
case 20:
00751 isPassphraseError =
true;
00752
return(i18n(
"Canceled."));
00753
case 21:
00754 isPassphraseError =
true;
00755
return(i18n(
"Invalid key."));
00756
case 22:
00757
return(i18n(
"Invalid engine."));
00758
case 23:
00759
return(i18n(
"Invalid recipients."));
00760
default:
00761
return(i18n(
"Unknown error."));
00762 }
00763
#endif
00764
}
00765
00766
00767
00768
00769 CryptPlugWrapper::CryptPlugWrapper(
const QString& name,
00770
const QString& libName,
00771
const QString& update,
00772
bool active )
00773 : Kleo::CryptoBackend::Protocol(),
00774 _name( name ),
00775 _libName( libName ),
00776 _updateURL( update ),
00777 _active( active ),
00778 _initStatus( InitStatus_undef ),
00779 _cp( 0 ),
00780 _config( 0 ),
00781 _cryptoConfig( 0 )
00782 {
00783
const bool ok = initialize( 0, 0 );
00784 assert( ok );
00785 }
00786
00787
00788 CryptPlugWrapper::~CryptPlugWrapper()
00789 {
00790
deinitialize();
00791 }
00792
00793
00794 void CryptPlugWrapper::setActive(
bool active )
00795 {
00796 _active = active;
00797 }
00798
00799
00800 bool CryptPlugWrapper::active()
const
00801
{
00802
return _active;
00803 }
00804
00805
00806
00807 bool CryptPlugWrapper::setLibName(
const QString& libName )
00808 {
00809
bool bOk = ! _cp;
00810
if( bOk )
00811 _libName = libName;
00812
return bOk;
00813 }
00814
00815 QString CryptPlugWrapper::libName()
const
00816
{
00817
return _libName;
00818 }
00819
00820
QString CryptPlugWrapper::protocol()
const
00821
{
00822
if ( _libName.contains(
"smime" ) )
00823
return "smime";
00824
if ( _libName.contains(
"openpgp" ) )
00825
return "openpgp";
00826
return QString::null;
00827 }
00828
00829 void CryptPlugWrapper::setDisplayName(
const QString& name )
00830 {
00831 _name = name;
00832 }
00833
00834
00835 QString CryptPlugWrapper::displayName()
const
00836
{
00837
if ( !_name.isEmpty() )
00838
return _name;
00839
if ( _libName.contains(
"smime" ) )
00840
return "gpgsm";
00841
if ( _libName.contains(
"openpgp" ) )
00842
return "gpg";
00843
return i18n(
"(Unknown Protocol)");
00844 }
00845
00846
00847 void CryptPlugWrapper::setUpdateURL(
const QString& url )
00848 {
00849 _updateURL = url;
00850 }
00851
00852
00853 QString CryptPlugWrapper::updateURL()
const
00854
{
00855
return _updateURL;
00856 }
00857
00858 bool CryptPlugWrapper::alwaysEncryptToSelf() {
00859
return true;
00860 }
00861
00862
00863 void CryptPlugWrapper::setAlwaysEncryptToSelf(
bool enc ) {
00864 mAlwaysEncryptToSelf = enc;
00865 }
00866
00867
bool CryptPlugWrapper::initialize( InitStatus* initStatus,
QString* errorMsg )
00868 {
00869
if ( _cp )
00870
return true;
00871
00872 _initStatus = InitStatus_undef;
00873
00874
if ( _libName.isEmpty() ) {
00875 _initStatus = InitStatus_NoLibName;
00876 kdDebug(5150) <<
"No library name was given.\n" << endl;
00877 }
else {
00878
if ( _libName.contains(
"smime" ) ) {
00879 _cp =
new SMIMECryptPlug();
00880 _config =
new Config( GPGME_PROTOCOL_CMS );
00881 }
else if ( _libName.contains(
"openpgp" ) ) {
00882 _cp =
new OpenPGPCryptPlug();
00883 _config =
new Config( GPGME_PROTOCOL_OpenPGP );
00884 }
else {
00885 _cp = 0;
00886 _config = 0;
00887 }
00888
00889
if ( !_cp ) {
00890 _initStatus = InitStatus_LoadError;
00891 kdDebug(5150) <<
"Couldn't create '" << _libName.latin1() <<
"'" << endl;
00892 }
else {
00893
00894
if( !_cp->initialize() ) {
00895 _initStatus = InitStatus_InitError;
00896 kdDebug(5150) <<
"Error while executing function 'initialize' on plugin " << _libName << endl;
00897 _lastError = i18n(
"Error while initializing plugin \"%1\"").arg( _libName );
00898
if ( errorMsg )
00899 *errorMsg = _lastError;
00900
delete _cp; _cp = 0;
00901
delete _config; _config = 0;
00902 }
else {
00903 _initStatus = InitStatus_Ok;
00904 }
00905 }
00906 }
00907
if( initStatus )
00908 *initStatus = _initStatus;
00909
return _initStatus == InitStatus_Ok;
00910 }
00911
00912
00913
00914 void CryptPlugWrapper::deinitialize()
00915 {
00916
delete _cp; _cp = 0;
00917
delete _config; _config = 0;
00918
delete _cryptoConfig; _cryptoConfig = 0;
00919 }
00920
00921
00922 CryptPlugWrapper::InitStatus CryptPlugWrapper::initStatus(
QString* errorMsg )
const
00923
{
00924
if( errorMsg )
00925 *errorMsg = _lastError;
00926
return _initStatus;
00927 }
00928
00929
00930 bool CryptPlugWrapper::hasFeature( Feature flag )
00931 {
00932
return _cp && _cp->hasFeature( flag );
00933 }
00934
00935
00936
00937
00938
00939 bool CryptPlugWrapper::signMessage(
const char* cleartext,
00940
char** ciphertext,
00941
const size_t* cipherLen,
00942
const char* certificate,
00943
StructuringInfoWrapper& structuring,
00944
int* errId,
00945
char** errTxt )
00946 {
00947
return _cp && _cp->signMessage( cleartext, ciphertext, cipherLen, certificate,
00948 &structuring.
data, errId, errTxt,
00949 _config->sendCertificates, _config->signatureCompoundMode );
00950 }
00951
00952
00953 bool CryptPlugWrapper::checkMessageSignature(
char** cleartext,
00954
const char* signaturetext,
00955
bool signatureIsBinary,
00956
int signatureLen,
00957 CryptPlug::SignatureMetaData* sigmeta )
00958 {
00959 DNBeautifier dnBeautifier( kapp->config(),
00960
"DN",
00961
"AttributeOrder",
00962
"UnknownAttributes" );
00963
return _cp && _cp->checkMessageSignature( cleartext,
00964 signaturetext,
00965 signatureIsBinary,
00966 signatureLen,
00967 sigmeta,
00968 dnBeautifier.attrOrderChar(),
00969 dnBeautifier.unknownAttrsHandlingChar() );
00970 }
00971
00972
00973 bool CryptPlugWrapper::storeCertificatesFromMessage(
const char* ciphertext )
00974 {
00975
return _cp && _cp->storeCertificatesFromMessage( ciphertext );
00976 }
00977
00978
00979 bool CryptPlugWrapper::findCertificates(
const char* addressee,
00980
char** certificates,
00981
int* newSize,
00982
bool secretOnly )
00983 {
00984 DNBeautifier dnBeautifier( kapp->config(),
00985
"DN",
00986
"AttributeOrder",
00987
"UnknownAttributes" );
00988
return _cp && _cp->findCertificates( addressee,
00989 certificates,
00990 newSize,
00991 secretOnly,
00992 dnBeautifier.attrOrderChar(),
00993 dnBeautifier.unknownAttrsHandlingChar() );
00994 }
00995
00996 bool CryptPlugWrapper::encryptMessage(
const char* cleartext,
00997
const char** ciphertext,
00998
const size_t* cipherLen,
00999
const char* addressee,
01000
StructuringInfoWrapper& structuring,
01001
int* errId,
01002
char** errTxt )
01003 {
01004
return _cp && _cp->encryptMessage( cleartext, ciphertext, cipherLen, addressee,
01005 &structuring.
data, errId, errTxt );
01006 }
01007
01008
01009 bool CryptPlugWrapper::encryptAndSignMessage(
const char* cleartext,
01010
const char** ciphertext,
01011
const char* certificate,
01012
StructuringInfoWrapper& structuring )
01013 {
01014
return _cp && _cp->encryptAndSignMessage( cleartext, ciphertext, certificate,
01015 &structuring.
data );
01016 }
01017
01018
01019 bool CryptPlugWrapper::decryptMessage(
const char* ciphertext,
01020
bool cipherIsBinary,
01021
int cipherLen,
01022
char** cleartext,
01023
const char* certificate,
01024
int* errId,
01025
char** errTxt )
01026 {
01027
return _cp && _cp->decryptMessage( ciphertext, cipherIsBinary, cipherLen,
01028 (
const char**)cleartext, certificate, errId, errTxt );
01029 }
01030
01031
01032 bool CryptPlugWrapper::decryptAndCheckMessage(
01033
const char* ciphertext,
01034
bool cipherIsBinary,
01035
int cipherLen,
01036
char** cleartext,
01037
const char* certificate,
01038
bool* signatureFound,
01039 CryptPlug::SignatureMetaData* sigmeta,
01040
int* errId,
01041
char** errTxt )
01042 {
01043 DNBeautifier dnBeautifier( kapp->config(),
01044
"DN",
01045
"AttributeOrder",
01046
"UnknownAttributes" );
01047
return _cp && _cp->decryptAndCheckMessage( ciphertext,
01048 cipherIsBinary,
01049 cipherLen,
01050 (
const char**)cleartext,
01051 certificate,
01052 signatureFound,
01053 sigmeta,
01054 errId,
01055 errTxt,
01056 dnBeautifier.attrOrderChar(),
01057 dnBeautifier.unknownAttrsHandlingChar() );
01058 }
01059
01060
01061
01062
01063
void CryptPlugWrapper::freeSignatureMetaData( CryptPlug::SignatureMetaData* sigmeta )
01064 {
01065
if ( !sigmeta )
01066
return;
01067 free( sigmeta->status );
01068
for(
int i = 0; i < sigmeta->extended_info_count; ++i ) {
01069 free( sigmeta->extended_info[i].creation_time );
01070 free( (
void*)sigmeta->extended_info[i].status_text );
01071 free( (
void*)sigmeta->extended_info[i].keyid );
01072 free( (
void*)sigmeta->extended_info[i].fingerprint );
01073 free( (
void*)sigmeta->extended_info[i].algo );
01074 free( (
void*)sigmeta->extended_info[i].userid );
01075 free( (
void*)sigmeta->extended_info[i].name );
01076 free( (
void*)sigmeta->extended_info[i].comment );
01077
if( sigmeta->extended_info[i].emailCount ){
01078
for(
int j=0; j < sigmeta->extended_info[i].emailCount; ++j)
01079
if( sigmeta->extended_info[i].emailList[j] )
01080 free( (
void*)sigmeta->extended_info[i].emailList[j] );
01081 free( (
void*)sigmeta->extended_info[i].emailList );
01082 }
01083 }
01084 free( sigmeta->extended_info );
01085 }
01086
01087
CryptPlugWrapper::CertificateInfoList CryptPlugWrapper::listKeys(
const QString& pattern,
01088
bool remote,
01089
bool* truncated )
01090 {
01091 CertificateInfoList result;
01092
if ( truncated ) *truncated =
false;
01093
if ( !_cp )
01094
return result;
01095
01096 CryptPlug::CertIterator * it = _cp->startListCertificates( pattern.utf8().data(), remote );
01097
if ( !it )
01098
return result;
01099
01100 DNBeautifier dnBeautifier( kapp->config(),
01101
"DN",
01102
"AttributeOrder",
01103
"UnknownAttributes" );
01104
01105
while (
true ) {
01106 CryptPlug::CertificateInfo* info = 0;
01107
if ( _cp->nextCertificate( it,
01108 &info,
01109 dnBeautifier.attrOrderChar(),
01110 dnBeautifier.unknownAttrsHandlingChar() ) != 0 ) {
01111 kdDebug(5150) <<
"error" << endl;
01112
break;
01113 }
01114
if ( !info )
01115
break;
01116
01117 CryptPlugWrapper::CertificateInfo cpwinfo;
01118
for (
char** ptr = info->userid; *ptr; ++ptr )
01119 cpwinfo.userid << QString::fromUtf8( *ptr );
01120 cpwinfo.userid_0_org = QString::fromUtf8( info->userid_0_org );
01121
01122 kdDebug(5150) <<
"CryptPlugWrapper got " << cpwinfo.userid[0] << endl;
01123 cpwinfo.serial = QString::fromUtf8( info->serial );
01124 kdDebug(5150) <<
"fpr=" << info->fingerprint << endl;
01125 cpwinfo.fingerprint = QString::fromUtf8( info->fingerprint );
01126 kdDebug(5150) <<
"Done getting fpr" << endl;
01127
01128 cpwinfo.issuer_org = QString::fromUtf8( info->issuer_org );
01129 cpwinfo.issuer_reord = QString::fromUtf8( info->issuer_reord );
01130 cpwinfo.chainid = QString::fromUtf8( info->chainid );
01131
QString caps = QString::fromUtf8( info->caps );
01132
01133 cpwinfo.sign = caps.contains(
's');
01134 cpwinfo.encrypt = caps.contains(
'e');
01135 cpwinfo.certify = caps.contains(
'c');
01136
01137 cpwinfo.created.setTime_t(info->created );
01138 cpwinfo.expire.setTime_t( info->expire );
01139
01140 cpwinfo.secret = info->secret;
01141 cpwinfo.invalid = info->invalid;
01142 cpwinfo.expired = info->expired;
01143 cpwinfo.disabled = info->disabled;
01144
01145
for ( CryptPlug::DnPair * a = info->dnarray ; a && a->key&& a->value ; ++a )
01146
01147 cpwinfo.dn.push_back( qMakePair( QString::fromUtf8( a->key ), QString::fromUtf8( a->value ) ) );
01148
01149
01150
01151 result.push_back( cpwinfo );
01152 }
01153
01154
if ( _cp->endListCertificates( it ) != 0 )
01155
if ( truncated ) *truncated =
true;
01156
01157
return result;
01158 }
01159
01160 GpgME::ImportResult CryptPlugWrapper::importCertificate(
const char* data, size_t length )
01161 {
01162
if ( !_cp )
01163
return GpgME::ImportResult();
01164
01165
01166
return _cp->importCertificateFromMem( data, length );
01167 }
01168
01169
Kleo::KeyListJob * CryptPlugWrapper::keyListJob(
bool remote,
bool includeSigs,
bool validate )
const {
01170
if ( !_cp )
01171
return 0;
01172
01173 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01174
if ( !context )
01175
return 0;
01176
01177
unsigned int mode = context->keyListMode();
01178
if ( remote ) {
01179 mode |= GpgME::Context::Extern;
01180 mode &= ~GpgME::Context::Local;
01181 }
else {
01182 mode |= GpgME::Context::Local;
01183 mode &= ~GpgME::Context::Extern;
01184 }
01185
if ( includeSigs ) mode |= GpgME::Context::Signatures;
01186
if ( validate ) mode |= GpgME::Context::Validate;
01187 context->setKeyListMode( mode );
01188
return new Kleo::QGpgMEKeyListJob( context );
01189 }
01190
01191
Kleo::EncryptJob * CryptPlugWrapper::encryptJob(
bool armor,
bool textmode )
const {
01192
if ( !_cp )
01193
return 0;
01194
01195 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01196
if ( !context )
01197
return 0;
01198
01199 context->setArmor( armor );
01200 context->setTextMode( textmode );
01201
return new Kleo::QGpgMEEncryptJob( context );
01202 }
01203
01204
Kleo::DecryptJob * CryptPlugWrapper::decryptJob()
const {
01205
if ( !_cp )
01206
return 0;
01207
01208 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01209
if ( !context )
01210
return 0;
01211
01212
return new Kleo::QGpgMEDecryptJob( context );
01213 }
01214
01215
Kleo::SignJob * CryptPlugWrapper::signJob(
bool armor,
bool textMode )
const {
01216
if ( !_cp )
01217
return 0;
01218
01219 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01220
if ( !context )
01221
return 0;
01222
01223 context->setArmor( armor );
01224 context->setTextMode( textMode );
01225
01226
return new Kleo::QGpgMESignJob( context );
01227 }
01228
01229
Kleo::VerifyDetachedJob * CryptPlugWrapper::verifyDetachedJob(
bool textMode )
const {
01230
if ( !_cp )
01231
return 0;
01232
01233 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01234
if ( !context )
01235
return 0;
01236
01237 context->setTextMode( textMode );
01238
01239
return new Kleo::QGpgMEVerifyDetachedJob( context );
01240 }
01241
01242
Kleo::VerifyOpaqueJob * CryptPlugWrapper::verifyOpaqueJob(
bool textMode )
const {
01243
if ( !_cp )
01244
return 0;
01245
01246 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01247
if ( !context )
01248
return 0;
01249
01250 context->setTextMode( textMode );
01251
01252
return new Kleo::QGpgMEVerifyOpaqueJob( context );
01253 }
01254
01255
Kleo::KeyGenerationJob * CryptPlugWrapper::keyGenerationJob()
const {
01256
if ( !_cp )
01257
return 0;
01258
01259 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01260
if ( !context )
01261
return 0;
01262
01263
return new Kleo::QGpgMEKeyGenerationJob( context );
01264 }
01265
01266
Kleo::ImportJob * CryptPlugWrapper::importJob()
const {
01267
if ( !_cp )
01268
return 0;
01269
01270 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01271
if ( !context )
01272
return 0;
01273
01274
return new Kleo::QGpgMEImportJob( context );
01275 }
01276
01277
Kleo::ExportJob * CryptPlugWrapper::publicKeyExportJob(
bool armor )
const {
01278
if ( !_cp )
01279
return 0;
01280
01281 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01282
if ( !context )
01283
return 0;
01284
01285 context->setArmor( armor );
01286
return new Kleo::QGpgMEExportJob( context );
01287 }
01288
01289
Kleo::ExportJob * CryptPlugWrapper::secretKeyExportJob(
bool armor )
const {
01290
if ( !_cp || _cp->mProtocol != GpgME::Context::CMS )
01291
return 0;
01292
01293
01294
return new Kleo::QGpgMESecretKeyExportJob( armor );
01295 }
01296
01297
Kleo::RefreshKeysJob * CryptPlugWrapper::refreshKeysJob()
const {
01298
if ( !_cp || _cp->mProtocol != GpgME::Context::CMS )
01299
return 0;
01300
01301
01302
return new Kleo::QGpgMERefreshKeysJob();
01303 }
01304
01305
Kleo::DownloadJob * CryptPlugWrapper::downloadJob(
bool armor )
const {
01306
if ( !_cp )
01307
return 0;
01308
01309 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01310
if ( !context )
01311
return 0;
01312
01313 context->setArmor( armor );
01314
01315 context->setKeyListMode( GpgME::Context::Extern );
01316
01317
return new Kleo::QGpgMEDownloadJob( context );
01318 }
01319
01320
Kleo::DeleteJob * CryptPlugWrapper::deleteJob()
const {
01321
if ( !_cp )
01322
return 0;
01323
01324 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01325
if ( !context )
01326
return 0;
01327
01328
return new Kleo::QGpgMEDeleteJob( context );
01329 }
01330
01331
Kleo::SignEncryptJob * CryptPlugWrapper::signEncryptJob(
bool armor,
bool textMode )
const {
01332
if ( !_cp )
01333
return 0;
01334
01335 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01336
if ( !context )
01337
return 0;
01338
01339 context->setArmor( armor );
01340 context->setTextMode( textMode );
01341
01342
return new Kleo::QGpgMESignEncryptJob( context );
01343 }
01344
01345
Kleo::DecryptVerifyJob * CryptPlugWrapper::decryptVerifyJob(
bool textMode )
const {
01346
if ( !_cp )
01347
return 0;
01348
01349 GpgME::Context * context = GpgME::Context::createForProtocol( _cp->mProtocol );
01350
if ( !context )
01351
return 0;
01352
01353 context->setTextMode( textMode );
01354
01355
return new Kleo::QGpgMEDecryptVerifyJob( context );
01356 }