GPGME Plug-In initial checkin. Saving/restoring of configuration is working.
[gpgme.git] / gpgmeplug / gpgmeplug.c
1 /* -*- Mode: C -*-
2
3   $Id$
4
5   GPGMEPLUG - an GPGME based cryptography plug-in following
6               the common CRYPTPLUG specification.
7
8   Copyright (C) 2001 by Klarälvdalens Datakonsult AB
9
10   GPGMEPLUG is free software; you can redistribute it and/or modify
11   it under the terms of GNU General Public License as published by
12   the Free Software Foundation; version 2 of the License.
13
14   GPGMEPLUG is distributed in the hope that it will be useful,
15   it under the terms of GNU General Public License as published by
16   the Free Software Foundation; version 2 of the License
17   but WITHOUT ANY WARRANTY; without even the implied warranty of
18   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19   GNU General Public License for more details.
20
21   You should have received a copy of the GNU General Public License
22   along with this program; if not, write to the Free Software
23   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
24 */
25
26
27
28 /*! \file gpgmeplug.c
29     \brief GPGME implementation of CRYPTPLUG following the
30     specification located in common API header cryptplug.h.
31
32     CRYPTPLUG is an independent cryptography plug-in API
33     developed for Sphinx-enabeling KMail and Mutt.
34
35     CRYPTPLUG was designed for the Aegypten project, but it may
36     be used by 3rd party developers as well to design pluggable
37     crypto backends for the above mentioned MUAs.
38
39     \note All string parameters appearing in this API are to be
40     interpreted as UTF-8 encoded.
41
42     \see cryptplug.h
43 */
44
45 #include <config.h>
46 #include <stdio.h>
47 #include <stdlib.h>
48 #include <string.h>
49 #include <assert.h>
50 #include <errno.h>
51
52 #include <gpgme.h>
53 #include <util.h>
54
55 #include "cryptplug.h"
56
57
58 typedef struct {
59   const char*             signatureKeyCertificate;
60   SignatureAlgorithm      signatureAlgorithm;
61   SendCertificates        sendCertificates;
62   SignEmail               signEmail;
63   bool                    saveSentSignatures;
64   bool                    certificateExpiryNearWarning;
65   bool                    warnNoCertificate;
66   PinRequests             numPINRequests;
67   bool                    checkSignatureCertificatePathToRoot;
68   bool                    signatureUseCRLs;
69   bool                    signatureCRLExpiryNearWarning;
70   int                     signatureCRLNearExpiryInterval;
71   EncryptionAlgorithm     encryptionAlgorithm;
72   EncryptEmail            encryptEmail;
73   bool                    saveMessagesEncrypted;
74   bool                    checkEncryptionCertificatePathToRoot;
75   bool                    encryptionUseCRLs;
76   bool                    encryptionCRLExpiryNearWarning;
77   int                     encryptionCRLNearExpiryInterval;
78   struct DirectoryServer *directoryServers;
79   unsigned int            numDirectoryServers;
80   CertificateSource       certificateSource;
81   CertificateSource       cRLSource;
82 } Config;
83
84
85 Config config;
86
87
88 #define NEAR_EXPIRY 21
89
90 bool initialize()
91 {
92   config.signatureKeyCertificate              = "";
93   config.signatureAlgorithm                   = SignAlg_SHA1;
94   config.sendCertificates                     = SendCert_SendChainWithRoot;
95   config.signEmail                            = SignEmail_SignAll;
96   config.saveSentSignatures                   = true;
97   config.certificateExpiryNearWarning         = true;
98   config.warnNoCertificate                    = true;
99   config.numPINRequests                       = PinRequest_Always;
100   config.checkSignatureCertificatePathToRoot  = true;
101   config.signatureUseCRLs                     = true;
102   config.signatureCRLExpiryNearWarning        = true;
103   config.signatureCRLNearExpiryInterval       = NEAR_EXPIRY;
104   config.encryptionAlgorithm                  = EncryptAlg_RSA;
105   config.encryptEmail                         = EncryptEmail_Ask;
106   config.saveMessagesEncrypted                = true;
107   config.checkEncryptionCertificatePathToRoot = true;
108   config.encryptionUseCRLs                    = true;
109   config.encryptionCRLExpiryNearWarning       = true;
110   config.encryptionCRLNearExpiryInterval      = NEAR_EXPIRY;
111   config.directoryServers                     = NULL;
112   config.numDirectoryServers                  = 0;
113   config.certificateSource                    = CertSrc_Server;
114   config.cRLSource                            = CertSrc_Server;
115   return true;
116 };
117
118
119 void deinitialize()
120 {
121   _gpgme_free( config.directoryServers );
122 }
123
124
125 bool hasFeature( Feature flag )
126 {
127   switch ( flag ) {
128     case CryptPlugFeat_SignMessages:              return true;
129     case CryptPlugFeat_VerifySignatures:          return true;
130     case CryptPlugFeat_EncryptMessages:           return true;
131     case CryptPlugFeat_DecryptMessages:           return true;
132     // undefined or not yet implemented:
133     case CryptPlugFeat_undef:                     return false;
134     default:                                      return false;
135   }
136 }
137
138
139 void unsafeStationery( void** pixmap, const char** menutext, char* accel,
140           const char** tooltip, const char** statusbartext ){}
141
142 void signedStationery( void** pixmap, const char** menutext, char* accel,
143           const char** tooltip, const char** statusbartext ){}
144
145 void encryptedStationery( void** pixmap, const char**
146           menutext, char* accel,
147           const char** tooltip, const char** statusbartext ){}
148
149 void signedEncryptedStationery( void** pixmap, const char**
150           menutext, char* accel,
151           const char** tooltip, const char** statusbartext ){}
152
153 const char* signatureConfigurationDialog(){ return 0; }
154
155 const char* signatureKeySelectionDialog(){ return 0; }
156
157 const char* signatureAlgorithmDialog(){ return 0; }
158
159 const char* signatureHandlingDialog(){ return 0; }
160
161 void setSignatureKeyCertificate( const char* certificate )
162 {
163   config.signatureKeyCertificate = certificate;
164 }
165
166 const char* signatureKeyCertificate()
167 {
168   return config.signatureKeyCertificate;
169 }
170
171 void setSignatureAlgorithm( SignatureAlgorithm sigAlg )
172 {
173   config.signatureAlgorithm = sigAlg;
174 }
175
176 SignatureAlgorithm signatureAlgorithm()
177 {
178   return config.signatureAlgorithm;
179 }
180
181 void setSendCertificates( SendCertificates sendCert )
182 {
183   config.sendCertificates = sendCert;
184 }
185
186 SendCertificates sendCertificates()
187 {
188   return config.sendCertificates;
189 }
190
191 void setSignEmail( SignEmail signMail )
192 {
193   config.signEmail = signMail;
194 }
195
196 SignEmail signEmail()
197 {
198   return config.signEmail;
199 }
200
201 void setSaveSentSignatures( bool flag )
202 {
203   config.saveSentSignatures = flag;
204 }
205
206 bool saveSentSignatures()
207 {
208   return config.saveSentSignatures;
209 }
210
211 void setCertificateExpiryNearWarning( bool flag )
212 {
213   config.certificateExpiryNearWarning = flag;
214 }
215
216 bool certificateExpiryNearWarning()
217 {
218   return config.certificateExpiryNearWarning;
219 }
220
221 void setWarnNoCertificate( bool flag )
222 {
223   config.warnNoCertificate = flag;
224 }
225
226 bool warnNoCertificate()
227 {
228   return config.warnNoCertificate;
229 }
230
231 void setNumPINRequests( PinRequests reqMode )
232 {
233   config.numPINRequests = reqMode;
234 }
235
236 PinRequests numPINRequests()
237 {
238   return config.numPINRequests;
239 }
240
241 void setCheckSignatureCertificatePathToRoot( bool flag )
242 {
243   config.checkSignatureCertificatePathToRoot = flag;
244 }
245
246 bool checkSignatureCertificatePathToRoot()
247 {
248   return config.checkSignatureCertificatePathToRoot;
249 }
250
251 void setSignatureUseCRLs( bool flag )
252 {
253   config.signatureUseCRLs = flag;
254 }
255
256 bool signatureUseCRLs()
257 {
258   return config.signatureUseCRLs;
259 }
260
261 void setSignatureCRLExpiryNearWarning( bool flag )
262 {
263   config.signatureCRLExpiryNearWarning = flag;
264 }
265
266 bool signatureCRLExpiryNearWarning()
267 {
268   return config.signatureCRLExpiryNearWarning;
269 }
270
271 void setSignatureCRLNearExpiryInterval( int interval )
272 {
273   config.signatureCRLNearExpiryInterval = interval;
274 }
275
276 int signatureCRLNearExpiryInterval()
277 {
278   return config.signatureCRLNearExpiryInterval;
279 }
280
281
282 const char* encryptionConfigurationDialog(){ return 0; }
283
284 const char* encryptionAlgorithmDialog(){ return 0; }
285
286 const char* encryptionHandlingDialog(){ return 0; }
287
288 const char* encryptionReceiverDialog(){ return 0; }
289
290 void setEncryptionAlgorithm( EncryptionAlgorithm cryptAlg )
291 {
292   config.encryptionAlgorithm = cryptAlg;
293 }
294
295 EncryptionAlgorithm encryptionAlgorithm()
296 {
297   return config.encryptionAlgorithm;
298 }
299
300 void setEncryptEmail( EncryptEmail cryptMode )
301 {
302   config.encryptEmail = cryptMode;
303 }
304
305 EncryptEmail encryptEmail()
306 {
307   return config.encryptEmail;
308 }
309
310 void setSaveMessagesEncrypted( bool flag )
311 {
312   config.saveMessagesEncrypted = flag;
313 }
314
315 bool saveMessagesEncrypted()
316 {
317   return config.saveMessagesEncrypted;
318 }
319
320 void setCheckEncryptionCertificatePathToRoot( bool flag )
321 {
322   config.checkEncryptionCertificatePathToRoot = flag;
323 }
324
325 bool checkEncryptionCertificatePathToRoot()
326 {
327   return config.checkEncryptionCertificatePathToRoot;
328 }
329
330 void setEncryptionUseCRLs( bool flag )
331 {
332   config.encryptionUseCRLs = flag;
333 }
334
335 bool encryptionUseCRLs()
336 {
337   return config.encryptionUseCRLs;
338 }
339
340 void setEncryptionCRLExpiryNearWarning( bool flag )
341 {
342   config.encryptionCRLExpiryNearWarning = flag;
343 }
344
345 bool encryptionCRLExpiryNearWarning()
346 {
347   return config.encryptionCRLExpiryNearWarning;
348 }
349
350 void setEncryptionCRLNearExpiryInterval( int interval )
351 {
352   config.encryptionCRLNearExpiryInterval = interval;
353 }
354
355 int encryptionCRLNearExpiryInterval()
356 {
357   return config.encryptionCRLNearExpiryInterval;
358 }
359
360
361 const char* directoryServiceConfigurationDialog(){ return 0; }
362
363 void appendDirectoryServer( const char* servername, int port,
364                             const char* description )
365 {
366   struct DirectoryServer *servers = NULL;
367   servers = xtryrealloc( config.directoryServers,
368                          (1+config.numDirectoryServers) * sizeof *servers );
369   if( servers ) {
370     config.directoryServers = servers;
371     servers[ config.numDirectoryServers ].servername  = servername;
372     servers[ config.numDirectoryServers ].port        = port;
373     servers[ config.numDirectoryServers ].description = description;
374     config.numDirectoryServers += 1;
375   }
376 }
377
378 void setDirectoryServers( struct DirectoryServer server[], unsigned int size )
379 {
380   struct DirectoryServer *servers = NULL;
381   servers = xtrycalloc ( size, sizeof *servers );
382   if( servers ) {
383     _gpgme_free( config.directoryServers );
384     config.directoryServers = servers;
385     config.numDirectoryServers = size;
386   }
387 }
388
389 struct DirectoryServer * directoryServers( int* numServers )
390 {
391   if( numServers )
392     *numServers = config.numDirectoryServers;
393   return config.directoryServers;
394 };
395
396 void setCertificateSource( CertificateSource source )
397 {
398   config.certificateSource = source;
399 }
400
401 CertificateSource certificateSource()
402 {
403   return config.certificateSource;
404 }
405
406 void setCRLSource( CertificateSource source )
407 {
408   config.cRLSource = source;
409 }
410
411 CertificateSource crlSource()
412 {
413   return config.cRLSource;
414 }
415
416
417 bool certificateValidity( const char* certificate,
418                           int* level ){ return true; }
419
420
421 bool signMessage( const char*  cleartext,
422                   const char** ciphertext,
423                   const char*  certificate )
424 {
425 /*
426   GpgmeCtx ctx;
427   GpgmeData data, sig;
428
429   gpgme_new (&ctx);
430   gpgme_set_armor (ctx, 1);
431   gpgme_set_textmode (ctx, 1);
432
433   gpgme_data_new_from_mem (&data, mime_object,
434                             mime_object_len, TRUE );
435   gpgme_data_new ( &sig );
436   gpgme_op_sign (ctx, data, sig, GPGME_SIG_MODE_DETACH );
437
438   fputs ( "Content-Type: multipart/signed;\r\n"
439           "              protocol=\"application/pgp-signature\";\r\n"
440           "              boundary=\"42=.42=.42=.42\"\r\n"
441           "\r\n--42=.42=.42=.42\r\n", stdout );
442
443   gpgme_data_rewind (data);
444   while ( !gpgme_data_read (data, buf, sizeof buf, &nread ) ) {
445         fwrite (buf, nread, 1, stdout );
446   }
447   fputs ( "\r\n--42=.42=.42=.42--\r\n"
448           "Content-Type: application/pgp-signature\r\n\r\n", stdout);
449
450   gpgme_data_rewind (sig);
451   while ( !gpgme_data_read (sig, buf, sizeof buf, &nread ) ) {
452         fwrite (buf, nread, 1, stdout );
453   }
454   fputs ( "\r\n--42=.42=.42=.42--\r\n", stdout );
455
456   gpgme_release (ctx);
457   gpgme_data_release(data);
458   gpgme_data_release(sig);
459 */
460   return true;
461 }
462
463 bool checkMessageSignature( const char* ciphertext, const char**
464         cleartext, struct SignatureMetaData* sigmeta ){ return true; }
465
466 bool storeCertificatesFromMessage(
467         const char* ciphertext ){ return true; }
468
469
470 bool encryptMessage( const char* cleartext,
471                      const char** ciphertext ){ return true; }
472
473 bool encryptAndSignMessage( const char* cleartext,
474           const char** ciphertext, const char* certificate,
475           struct SignatureMetaData* sigmeta ){ return true; }
476
477 bool decryptMessage( const char* ciphertext, const
478           char** cleartext, const char* certificate ){ return true; }
479
480 bool decryptAndCheckMessage( const char* ciphertext,
481           const char** cleartext, const char* certificate,
482           struct SignatureMetaData* sigmeta ){ return true; }
483
484
485 const char* requestCertificateDialog(){ return 0; }
486
487 bool requestDecentralCertificate( const char* name, const char*
488           email, const char* organization, const char* department,
489           const char* ca_address ){ return true; }
490
491 bool requestCentralCertificateAndPSE( const char* name,
492           const char* email, const char* organization, const char* department,
493           const char* ca_address ){ return true; }
494
495 bool createPSE(){ return true; }
496
497 bool registerCertificate( const char* certificate ){ return true; }
498
499 bool requestCertificateProlongation( const char* certificate,
500                                      const char* ca_address ){ return true; }
501
502 const char* certificateChain(){ return 0; }
503
504 bool deleteCertificate( const char* certificate ){ return true; }
505
506 bool archiveCertificate( const char* certificate ){ return true; }
507
508
509 const char* displayCRL(){ return 0; }
510
511 void updateCRL(){}