00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
#ifdef HAVE_CONFIG_H
00024
#include <config.h>
00025
#endif
00026
00027
#include <qtimer.h>
00028
00029
#include "kssld.h"
00030
#include <kconfig.h>
00031
#include <ksimpleconfig.h>
00032
#include <ksslcertchain.h>
00033
#include <ksslcertificate.h>
00034
#include <ksslcertificatehome.h>
00035
#include <ksslpkcs12.h>
00036
#include <ksslx509map.h>
00037
#include <qptrlist.h>
00038
#include <sys/types.h>
00039
#include <sys/stat.h>
00040
#include <stdlib.h>
00041
#include <pwd.h>
00042
#include <unistd.h>
00043
#include <qfile.h>
00044
#include <qsortedlist.h>
00045
#include <kglobal.h>
00046
#include <kstandarddirs.h>
00047
#include <kdebug.h>
00048
#include <qdatetime.h>
00049
00050
#include <kmdcodec.h>
00051
#include <kopenssl.h>
00052
00053
00054
00055
extern "C" {
00056 KDE_EXPORT KDEDModule *create_kssld(
const QCString &name) {
00057
return new KSSLD(name);
00058 }
00059
00060 KDE_EXPORT
void *__kde_do_unload;
00061 }
00062
00063
00064 KSSLD::KSSLD(
const QCString &name) : KDEDModule(
name)
00065 {
00066
00067 cfg =
new KSimpleConfig(
"ksslpolicies",
false);
00068
KGlobal::dirs()->
addResourceType(
"kssl", KStandardDirs::kde_default(
"data") +
"kssl");
00069 caVerifyUpdate();
00070 cacheLoadDefaultPolicies();
00071 certList.setAutoDelete(
false);
00072 kossl = KOSSL::self();
00073
00074
00075 }
00076
00077
00078 KSSLD::~KSSLD()
00079 {
00080
00081 cacheClearList();
00082
delete cfg;
00083
00084
00085 }
00086
00087
00088
00089
00090
00091
class KSSLCNode {
00092
public:
00093
KSSLCertificate *cert;
00094 KSSLCertificateCache::KSSLCertificatePolicy policy;
00095
bool permanent;
00096
QDateTime expires;
00097
QStringList hosts;
00098 KSSLCNode() { cert = 0L;
00099 policy = KSSLCertificateCache::Unknown;
00100 permanent =
true;
00101 }
00102 ~KSSLCNode() {
delete cert; }
00103 };
00104
00105
00106
00107
void KSSLD::cacheSaveToDisk() {
00108 KSSLCNode *node;
00109
00110
for (node = certList.first(); node; node = certList.next()) {
00111
if (node->permanent ||
00112 node->expires > QDateTime::currentDateTime()) {
00113
00114
00115
00116 cfg->setGroup(node->cert->getSubject());
00117 cfg->writeEntry(
"Certificate", node->cert->toString());
00118 cfg->writeEntry(
"Policy", node->policy);
00119 cfg->writeEntry(
"Expires", node->expires);
00120 cfg->writeEntry(
"Permanent", node->permanent);
00121 cfg->writeEntry(
"Hosts", node->hosts);
00122
00123
00124
QStringList qsl;
00125
QPtrList<KSSLCertificate> cl =
00126 node->cert->chain().getChain();
00127
for (
KSSLCertificate *c = cl.first();
00128 c != 0;
00129 c = cl.next()) {
00130
00131
00132 qsl << c->
toString();
00133 }
00134
00135 cl.setAutoDelete(
true);
00136 cfg->writeEntry(
"Chain", qsl);
00137 }
00138 }
00139
00140 cfg->sync();
00141
00142
00143
QString cfgName(KGlobal::dirs()->findResource(
"config",
"ksslpolicies"));
00144
00145
if (!cfgName.isEmpty()) {
00146 ::chmod(QFile::encodeName(cfgName), 0600);
00147 }
00148 }
00149
00150
00151
void KSSLD::cacheReload() {
00152 cacheClearList();
00153
delete cfg;
00154 cfg =
new KSimpleConfig(
"ksslpolicies",
false);
00155 cacheLoadDefaultPolicies();
00156 }
00157
00158
00159
void KSSLD::cacheClearList() {
00160 KSSLCNode *node;
00161
00162
for (node = certList.first(); node; node = certList.next()) {
00163 certList.remove(node);
00164
delete node;
00165 }
00166
00167 skEmail.clear();
00168 skMD5Digest.clear();
00169 }
00170
00171
00172
void KSSLD::cacheLoadDefaultPolicies() {
00173
QStringList groups = cfg->groupList();
00174
00175
for (QStringList::Iterator i = groups.begin();
00176 i != groups.end();
00177 ++i) {
00178
if ((*i).length() == 0) {
00179
continue;
00180 }
00181
00182 cfg->setGroup(*i);
00183
00184
00185
if (!cfg->readBoolEntry(
"Permanent") &&
00186 cfg->readDateTimeEntry(
"Expires") <
00187 QDateTime::currentDateTime()) {
00188 cfg->deleteGroup(*i);
00189
continue;
00190 }
00191
00192
QCString encodedCert;
00193
KSSLCertificate *newCert;
00194
00195 encodedCert = cfg->readEntry(
"Certificate").local8Bit();
00196 newCert =
KSSLCertificate::fromString(encodedCert);
00197
00198
if (!newCert) {
00199
continue;
00200 }
00201
00202 KSSLCNode *n =
new KSSLCNode;
00203 n->cert = newCert;
00204 n->policy = (KSSLCertificateCache::KSSLCertificatePolicy) cfg->readNumEntry(
"Policy");
00205 n->permanent = cfg->readBoolEntry(
"Permanent");
00206 n->expires = cfg->readDateTimeEntry(
"Expires");
00207 n->hosts = cfg->readListEntry(
"Hosts");
00208 newCert->
chain().
setCertChain(cfg->readListEntry(
"Chain"));
00209 certList.append(n);
00210 searchAddCert(newCert);
00211 }
00212 }
00213
00214
00215
void KSSLD::cacheAddCertificate(
KSSLCertificate cert,
00216 KSSLCertificateCache::KSSLCertificatePolicy policy,
00217
bool permanent) {
00218 KSSLCNode *node;
00219
00220
for (node = certList.first(); node; node = certList.next()) {
00221
if (cert == *(node->cert)) {
00222 node->policy = policy;
00223 node->permanent = permanent;
00224
00225
if (!permanent) {
00226 node->expires = QDateTime::currentDateTime();
00227
00228 node->expires = node->expires.addSecs(3600);
00229 }
00230
00231 cacheSaveToDisk();
00232
return;
00233 }
00234 }
00235
00236 KSSLCNode *n =
new KSSLCNode;
00237 n->cert = cert.
replicate();
00238 n->policy = policy;
00239 n->permanent = permanent;
00240
00241 cacheRemoveBySubject(n->cert->getSubject());
00242 certList.prepend(n);
00243
00244
if (!permanent) {
00245 n->expires = QDateTime::currentDateTime();
00246 n->expires = n->expires.addSecs(3600);
00247 }
00248
00249 searchAddCert(n->cert);
00250 cacheSaveToDisk();
00251 }
00252
00253
00254 KSSLCertificateCache::KSSLCertificatePolicy KSSLD::cacheGetPolicyByCN(
QString cn) {
00255 KSSLCNode *node;
00256
00257
for (node = certList.first(); node; node = certList.next()) {
00258
if (
KSSLX509Map(node->cert->getSubject()).getValue(
"CN") == cn) {
00259
if (!node->permanent &&
00260 node->expires < QDateTime::currentDateTime()) {
00261 certList.remove(node);
00262 cfg->deleteGroup(node->cert->getSubject());
00263
delete node;
00264
continue;
00265 }
00266
00267 certList.remove(node);
00268 certList.prepend(node);
00269 cacheSaveToDisk();
00270
return node->policy;
00271 }
00272 }
00273
00274 cacheSaveToDisk();
00275
00276
return KSSLCertificateCache::Unknown;
00277 }
00278
00279
00280 KSSLCertificateCache::KSSLCertificatePolicy KSSLD::cacheGetPolicyByCertificate(
KSSLCertificate cert) {
00281 KSSLCNode *node;
00282
00283
for (node = certList.first(); node; node = certList.next()) {
00284
if (cert == *(node->cert)) {
00285
if (!node->permanent &&
00286 node->expires < QDateTime::currentDateTime()) {
00287 certList.remove(node);
00288 cfg->deleteGroup(node->cert->getSubject());
00289
delete node;
00290 cacheSaveToDisk();
00291
return KSSLCertificateCache::Unknown;
00292 }
00293
00294 certList.remove(node);
00295 certList.prepend(node);
00296
return node->policy;
00297 }
00298 }
00299
00300
return KSSLCertificateCache::Unknown;
00301 }
00302
00303
00304
bool KSSLD::cacheSeenCN(
QString cn) {
00305 KSSLCNode *node;
00306
00307
for (node = certList.first(); node; node = certList.next()) {
00308
if (
KSSLX509Map(node->cert->getSubject()).getValue(
"CN") == cn) {
00309
if (!node->permanent &&
00310 node->expires < QDateTime::currentDateTime()) {
00311 certList.remove(node);
00312 cfg->deleteGroup(node->cert->getSubject());
00313
delete node;
00314 cacheSaveToDisk();
00315
continue;
00316 }
00317
00318 certList.remove(node);
00319 certList.prepend(node);
00320
return true;
00321 }
00322 }
00323
00324
return false;
00325 }
00326
00327
00328
bool KSSLD::cacheSeenCertificate(
KSSLCertificate cert) {
00329 KSSLCNode *node;
00330
00331
for (node = certList.first(); node; node = certList.next()) {
00332
if (cert == *(node->cert)) {
00333
if (!node->permanent &&
00334 node->expires < QDateTime::currentDateTime()) {
00335 certList.remove(node);
00336 cfg->deleteGroup(node->cert->getSubject());
00337
delete node;
00338 cacheSaveToDisk();
00339
return false;
00340 }
00341
00342 certList.remove(node);
00343 certList.prepend(node);
00344
return true;
00345 }
00346 }
00347
00348
return false;
00349 }
00350
00351
00352
bool KSSLD::cacheIsPermanent(
KSSLCertificate cert) {
00353 KSSLCNode *node;
00354
00355
for (node = certList.first(); node; node = certList.next()) {
00356
if (cert == *(node->cert)) {
00357
if (!node->permanent && node->expires <
00358 QDateTime::currentDateTime()) {
00359 certList.remove(node);
00360 cfg->deleteGroup(node->cert->getSubject());
00361
delete node;
00362 cacheSaveToDisk();
00363
return false;
00364 }
00365
00366 certList.remove(node);
00367 certList.prepend(node);
00368
return node->permanent;
00369 }
00370 }
00371
00372
return false;
00373 }
00374
00375
00376
bool KSSLD::cacheRemoveBySubject(
QString subject) {
00377 KSSLCNode *node;
00378
bool gotOne =
false;
00379
00380
for (node = certList.first(); node; node = certList.next()) {
00381
if (node->cert->getSubject() == subject) {
00382 certList.remove(node);
00383 cfg->deleteGroup(node->cert->getSubject());
00384 searchRemoveCert(node->cert);
00385
delete node;
00386 gotOne =
true;
00387 }
00388 }
00389
00390 cacheSaveToDisk();
00391
00392
return gotOne;
00393 }
00394
00395
00396
bool KSSLD::cacheRemoveByCN(
QString cn) {
00397 KSSLCNode *node;
00398
bool gotOne =
false;
00399
00400
for (node = certList.first(); node; node = certList.next()) {
00401
if (
KSSLX509Map(node->cert->getSubject()).getValue(
"CN") == cn) {
00402 certList.remove(node);
00403 cfg->deleteGroup(node->cert->getSubject());
00404 searchRemoveCert(node->cert);
00405
delete node;
00406 gotOne =
true;
00407 }
00408 }
00409
00410 cacheSaveToDisk();
00411
00412
return gotOne;
00413 }
00414
00415
00416
bool KSSLD::cacheRemoveByCertificate(
KSSLCertificate cert) {
00417 KSSLCNode *node;
00418
00419
for (node = certList.first(); node; node = certList.next()) {
00420
if (cert == *(node->cert)) {
00421 certList.remove(node);
00422 cfg->deleteGroup(node->cert->getSubject());
00423 searchRemoveCert(node->cert);
00424
delete node;
00425 cacheSaveToDisk();
00426
return true;
00427 }
00428 }
00429
00430
return false;
00431 }
00432
00433
00434
bool KSSLD::cacheModifyByCN(
QString cn,
00435 KSSLCertificateCache::KSSLCertificatePolicy policy,
bool permanent,
00436
QDateTime expires) {
00437 KSSLCNode *node;
00438
00439
for (node = certList.first(); node; node = certList.next()) {
00440
if (
KSSLX509Map(node->cert->getSubject()).getValue(
"CN") == cn) {
00441 node->permanent = permanent;
00442 node->expires = expires;
00443 node->policy = policy;
00444 certList.remove(node);
00445 certList.prepend(node);
00446 cacheSaveToDisk();
00447
return true;
00448 }
00449 }
00450
00451
return false;
00452 }
00453
00454
00455
bool KSSLD::cacheModifyByCertificate(
KSSLCertificate cert,
00456 KSSLCertificateCache::KSSLCertificatePolicy policy,
00457
bool permanent,
00458
QDateTime expires) {
00459 KSSLCNode *node;
00460
00461
for (node = certList.first(); node; node = certList.next()) {
00462
if (cert == *(node->cert)) {
00463 node->permanent = permanent;
00464 node->expires = expires;
00465 node->policy = policy;
00466 certList.remove(node);
00467 certList.prepend(node);
00468 cacheSaveToDisk();
00469
return true;
00470 }
00471 }
00472
00473
return false;
00474 }
00475
00476
00477
QStringList KSSLD::cacheGetHostList(
KSSLCertificate cert) {
00478 KSSLCNode *node;
00479
00480
for (node = certList.first(); node; node = certList.next()) {
00481
if (cert == *(node->cert)) {
00482
if (!node->permanent && node->expires <
00483 QDateTime::currentDateTime()) {
00484 certList.remove(node);
00485 cfg->deleteGroup(node->cert->getSubject());
00486 searchRemoveCert(node->cert);
00487
delete node;
00488 cacheSaveToDisk();
00489
return QStringList();
00490 }
00491
00492 certList.remove(node);
00493 certList.prepend(node);
00494
return node->hosts;
00495 }
00496 }
00497
00498
return QStringList();
00499 }
00500
00501
00502
bool KSSLD::cacheAddHost(
KSSLCertificate cert,
QString host) {
00503 KSSLCNode *node;
00504
00505
if (host.isEmpty())
00506
return true;
00507
00508
for (node = certList.first(); node; node = certList.next()) {
00509
if (cert == *(node->cert)) {
00510
if (!node->permanent && node->expires <
00511 QDateTime::currentDateTime()) {
00512 certList.remove(node);
00513 cfg->deleteGroup(node->cert->getSubject());
00514 searchRemoveCert(node->cert);
00515
delete node;
00516 cacheSaveToDisk();
00517
return false;
00518 }
00519
00520
if (!node->hosts.contains(host)) {
00521 node->hosts << host;
00522 }
00523
00524 certList.remove(node);
00525 certList.prepend(node);
00526 cacheSaveToDisk();
00527
return true;
00528 }
00529 }
00530
00531
return false;
00532 }
00533
00534
00535
bool KSSLD::cacheRemoveHost(
KSSLCertificate cert,
QString host) {
00536 KSSLCNode *node;
00537
00538
for (node = certList.first(); node; node = certList.next()) {
00539
if (cert == *(node->cert)) {
00540
if (!node->permanent && node->expires <
00541 QDateTime::currentDateTime()) {
00542 certList.remove(node);
00543 cfg->deleteGroup(node->cert->getSubject());
00544 searchRemoveCert(node->cert);
00545
delete node;
00546 cacheSaveToDisk();
00547
return false;
00548 }
00549 node->hosts.remove(host);
00550 certList.remove(node);
00551 certList.prepend(node);
00552 cacheSaveToDisk();
00553
return true;
00554 }
00555 }
00556
00557
return false;
00558 }
00559
00560
00561
00562
00564
00565
void KSSLD::caVerifyUpdate() {
00566
QString path =
KGlobal::dirs()->
saveLocation(
"kssl") +
"/ca-bundle.crt";
00567
if (!QFile::exists(path))
00568
return;
00569
00570 cfg->setGroup(QString::null);
00571 Q_UINT32 newStamp =
KGlobal::dirs()->
calcResourceHash(
"config",
"ksslcalist",
true);
00572 Q_UINT32 oldStamp = cfg->readUnsignedNumEntry(
"ksslcalistStamp");
00573
if (oldStamp != newStamp)
00574 {
00575 caRegenerate();
00576 cfg->writeEntry(
"ksslcalistStamp", newStamp);
00577 cfg->sync();
00578 }
00579 }
00580
00581
bool KSSLD::caRegenerate() {
00582
QString path =
KGlobal::dirs()->
saveLocation(
"kssl") +
"/ca-bundle.crt";
00583
00584
QFile out(path);
00585
00586
if (!out.open(IO_WriteOnly))
00587
return false;
00588
00589
KConfig cfg(
"ksslcalist",
true,
false);
00590
00591
QStringList x = cfg.
groupList();
00592
00593
for (QStringList::Iterator i = x.begin();
00594 i != x.end();
00595 ++i) {
00596
if ((*i).isEmpty() || *i ==
"<default>")
continue;
00597
00598 cfg.
setGroup(*i);
00599
00600
if (!cfg.
readBoolEntry(
"site",
false))
continue;
00601
00602
QString cert = cfg.
readEntry(
"x509",
"");
00603
if (cert.length() <= 0)
continue;
00604
00605
unsigned int xx = cert.length() - 1;
00606
for (
unsigned int j = 0; j < xx/64; j++) {
00607 cert.insert(64*(j+1)+j,
'\n');
00608 }
00609 out.writeBlock(
"-----BEGIN CERTIFICATE-----\n", 28);
00610 out.writeBlock(cert.latin1(), cert.length());
00611 out.writeBlock(
"\n-----END CERTIFICATE-----\n\n", 28);
00612 out.flush();
00613 }
00614
00615
return true;
00616 }
00617
00618
00619
00620
bool KSSLD::caAdd(
QString certificate,
bool ssl,
bool email,
bool code) {
00621
KSSLCertificate *x =
KSSLCertificate::fromString(certificate.local8Bit());
00622
00623
if (!x)
return false;
00624
00625
KConfig cfg(
"ksslcalist",
false,
false);
00626
00627 cfg.
setGroup(x->
getSubject());
00628 cfg.
writeEntry(
"x509", certificate);
00629 cfg.
writeEntry(
"site", ssl);
00630 cfg.
writeEntry(
"email", email);
00631 cfg.
writeEntry(
"code", code);
00632
00633 cfg.
sync();
00634
delete x;
00635
00636
return true;
00637 }
00638
00639
00644
static QStringList caReadCerticatesFromFile(
QString filename) {
00645
00646
QStringList certificates;
00647
QString certificate, temp;
00648
QFile file(filename);
00649
00650
if (!file.open(IO_ReadOnly))
00651
return certificates;
00652
00653
while (!file.atEnd()) {
00654 file.readLine(temp, 999);
00655
if (temp.startsWith(
"-----BEGIN CERTIFICATE-----")) {
00656 certificate = QString::null;
00657
continue;
00658 }
00659
00660
if (temp.startsWith(
"-----END CERTIFICATE-----")) {
00661 certificates.append(certificate);
00662 certificate = QString::null;
00663
continue;
00664 }
00665
00666 certificate += temp.stripWhiteSpace();
00667 }
00668
00669 file.close();
00670
00671
return certificates;
00672 }
00673
00674
bool KSSLD::caAddFromFile(
QString filename,
bool ssl,
bool email,
bool code) {
00675
00676
QStringList certificates;
00677 certificates = caReadCerticatesFromFile(filename);
00678
if (certificates.isEmpty())
00679
return false;
00680
00681
bool ok =
true;
00682
00683
for (QStringList::Iterator it = certificates.begin();
00684 it != certificates.end(); ++it ) {
00685 ok &= caAdd(*it, ssl, email, code);
00686 }
00687
00688
return ok;
00689 }
00690
00691
bool KSSLD::caRemoveFromFile(
QString filename) {
00692
00693
QStringList certificates;
00694 certificates = caReadCerticatesFromFile(filename);
00695
if (certificates.isEmpty())
00696
return false;
00697
00698
bool ok =
true;
00699
00700
for (QStringList::Iterator it = certificates.begin();
00701 it != certificates.end(); ++it ) {
00702
QString certificate = *it;
00703
KSSLCertificate *x =
KSSLCertificate::fromString(certificate.local8Bit());
00704 ok &= x && caRemove(x->
getSubject());
00705
delete x;
00706 }
00707
00708
return ok;
00709 }
00710
00711
00712
QStringList KSSLD::caList() {
00713
QStringList x;
00714
KConfig cfg(
"ksslcalist",
true,
false);
00715
00716 x = cfg.
groupList();
00717 x.remove(
"<default>");
00718
00719
return x;
00720 }
00721
00722
00723
bool KSSLD::caUseForSSL(
QString subject) {
00724
KConfig cfg(
"ksslcalist",
true,
false);
00725
00726
if (!cfg.
hasGroup(subject))
00727
return false;
00728
00729 cfg.
setGroup(subject);
00730
return cfg.
readBoolEntry(
"site",
false);
00731 }
00732
00733
00734
00735
bool KSSLD::caUseForEmail(
QString subject) {
00736
KConfig cfg(
"ksslcalist",
true,
false);
00737
00738
if (!cfg.
hasGroup(subject))
00739
return false;
00740
00741 cfg.
setGroup(subject);
00742
return cfg.
readBoolEntry(
"email",
false);
00743 }
00744
00745
00746
00747
bool KSSLD::caUseForCode(
QString subject) {
00748
KConfig cfg(
"ksslcalist",
true,
false);
00749
00750
if (!cfg.
hasGroup(subject))
00751
return false;
00752
00753 cfg.
setGroup(subject);
00754
return cfg.
readBoolEntry(
"code",
false);
00755 }
00756
00757
00758
bool KSSLD::caRemove(
QString subject) {
00759
KConfig cfg(
"ksslcalist",
false,
false);
00760
if (!cfg.
hasGroup(subject))
00761
return false;
00762
00763 cfg.
deleteGroup(subject);
00764 cfg.
sync();
00765
00766
return true;
00767 }
00768
00769
00770
QString KSSLD::caGetCert(
QString subject) {
00771
KConfig cfg(
"ksslcalist",
true,
false);
00772
if (!cfg.
hasGroup(subject))
00773
return QString::null;
00774
00775 cfg.
setGroup(subject);
00776
00777
return cfg.
readEntry(
"x509", QString::null);
00778 }
00779
00780
00781
bool KSSLD::caSetUse(
QString subject,
bool ssl,
bool email,
bool code) {
00782
KConfig cfg(
"ksslcalist",
false,
false);
00783
if (!cfg.
hasGroup(subject))
00784
return false;
00785
00786 cfg.
setGroup(subject);
00787
00788 cfg.
writeEntry(
"site", ssl);
00789 cfg.
writeEntry(
"email", email);
00790 cfg.
writeEntry(
"code", code);
00791 cfg.
sync();
00792
00793
return true;
00794 }
00795
00797
00798
void KSSLD::searchAddCert(
KSSLCertificate *cert) {
00799 skMD5Digest.insert(cert->
getMD5DigestText(), cert,
true);
00800
00801
QStringList mails;
00802 cert->
getEmails(mails);
00803
for(QStringList::const_iterator iter = mails.begin(); iter != mails.end(); iter++) {
00804
QString email = static_cast<const QString &>(*iter).lower();
00805
QMap<QString, QPtrVector<KSSLCertificate> >::iterator it = skEmail.find(email);
00806
00807
if (it == skEmail.end())
00808 it = skEmail.insert(email,
QPtrVector<KSSLCertificate>());
00809
00810
QPtrVector<KSSLCertificate> &elem = *it;
00811
00812
if (elem.findRef(cert) == -1) {
00813
unsigned int n = 0;
00814
for(; n < elem.size(); n++) {
00815
if (!elem.at(n)) {
00816 elem.insert(n, cert);
00817
break;
00818 }
00819 }
00820
if (n == elem.size()) {
00821 elem.resize(n+1);
00822 elem.insert(n, cert);
00823 }
00824 }
00825 }
00826 }
00827
00828
00829
void KSSLD::searchRemoveCert(
KSSLCertificate *cert) {
00830 skMD5Digest.remove(cert->
getMD5DigestText());
00831
00832
QStringList mails;
00833 cert->
getEmails(mails);
00834
for(QStringList::const_iterator iter = mails.begin(); iter != mails.end(); iter++) {
00835
QMap<QString, QPtrVector<KSSLCertificate> >::iterator it = skEmail.find(static_cast<const QString &>(*iter).lower());
00836
00837
if (it == skEmail.end())
00838
break;
00839
00840
QPtrVector<KSSLCertificate> &elem = *it;
00841
00842
int n = elem.findRef(cert);
00843
if (n != -1)
00844 elem.remove(n);
00845 }
00846 }
00847
00848
00849
QStringList KSSLD::getKDEKeyByEmail(
const QString &email) {
00850
QStringList rc;
00851
QMap<QString, QPtrVector<KSSLCertificate> >::iterator it = skEmail.find(email.lower());
00852
00853
kdDebug() <<
"GETKDEKey " << email.latin1() <<
endl;
00854
00855
if (it == skEmail.end())
00856
return rc;
00857
00858
QPtrVector<KSSLCertificate> &elem = *it;
00859
for (
unsigned int n = 0; n < elem.size(); n++) {
00860
KSSLCertificate *cert = elem.at(n);
00861
if (cert) {
00862 rc.append(cert->
getKDEKey());
00863 }
00864 }
00865
00866
kdDebug() <<
"ergebnisse: " << rc.size() <<
" " << elem.size() <<
endl;
00867
return rc;
00868 }
00869
00870
00871
KSSLCertificate KSSLD::getCertByMD5Digest(
const QString &key) {
00872
QMap<QString, KSSLCertificate *>::iterator iter = skMD5Digest.find(key);
00873
00874
kdDebug() <<
"Searching cert for " <<
key.latin1() <<
endl;
00875
00876
if (iter != skMD5Digest.end())
00877
return **iter;
00878
00879
KSSLCertificate rc;
00880
kdDebug() <<
"Not found: " << rc.
toString().latin1() <<
endl;
00881
return rc;
00882 }
00883
00884
00886
00887
00888
00889
00890
00891
QStringList KSSLD::getHomeCertificateList() {
00892
return KSSLCertificateHome::getCertificateList();
00893 }
00894
00895
bool KSSLD::addHomeCertificateFile(
QString filename,
QString password,
bool storePass) {
00896
return KSSLCertificateHome::addCertificate(filename, password, storePass);
00897 }
00898
00899
bool KSSLD::addHomeCertificatePKCS12(
QString base64cert,
QString passToStore) {
00900
bool ok;
00901
KSSLPKCS12 *pkcs12 =
KSSLPKCS12::fromString(base64cert, passToStore);
00902 ok = KSSLCertificateHome::addCertificate(pkcs12, passToStore);
00903
delete pkcs12;
00904
return ok;
00905 }
00906
00907
bool KSSLD::deleteHomeCertificateByFile(
QString filename,
QString password) {
00908
return KSSLCertificateHome::deleteCertificate(filename, password);
00909 }
00910
00911
bool KSSLD::deleteHomeCertificateByPKCS12(
QString base64cert,
QString password) {
00912
bool ok;
00913
KSSLPKCS12 *pkcs12 =
KSSLPKCS12::fromString(base64cert, password);
00914 ok = KSSLCertificateHome::deleteCertificate(pkcs12);
00915
delete pkcs12;
00916
return ok;
00917 }
00918
00919
bool KSSLD::deleteHomeCertificateByName(
QString name) {
00920
return KSSLCertificateHome::deleteCertificateByName(name);
00921 }
00922
00923
00924
00926
00927
#include "kssld.moc"
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948
00949
00950
00951
00952
00953
00954
00955
00956
00957
00958
00959
00960
00961
00962
00963
00964
00965
00966
00967
00968
00969
00970
00971
00972