source: qca/trunk/src/qca.h@ 26

Last change on this file since 26 was 24, checked in by dmik, 19 years ago

QCA: Imported original QCA 1.0 sources from Affinix
  • Property svn:keywords set to Id
File size: 10.0 KB
Line 
1/*
2 * qca.h - Qt Cryptographic Architecture
3 * Copyright (C) 2003 Justin Karneges
4 *
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 *
19 */
20
21#ifndef QCA_H
22#define QCA_H
23
24#include<qstring.h>
25#include<qcstring.h>
26#include<qdatetime.h>
27#include<qmap.h>
28#include<qptrlist.h>
29#include<qobject.h>
30
31#ifdef Q_OS_WIN32
32# ifndef QCA_STATIC
33# ifdef QCA_MAKEDLL
34# define QCA_EXPORT __declspec(dllexport)
35# else
36# define QCA_EXPORT __declspec(dllimport)
37# endif
38# endif
39#endif
40#ifndef QCA_EXPORT
41#define QCA_EXPORT
42#endif
43
44#ifdef Q_OS_WIN32
45# ifdef QCA_PLUGIN_DLL
46# define QCA_PLUGIN_EXPORT extern "C" __declspec(dllexport)
47# else
48# define QCA_PLUGIN_EXPORT extern "C" __declspec(dllimport)
49# endif
50#endif
51#ifndef QCA_PLUGIN_EXPORT
52#define QCA_PLUGIN_EXPORT extern "C"
53#endif
54
55class QHostAddress;
56class QStringList;
57
58class QCAProvider;
59class QCA_HashContext;
60class QCA_CipherContext;
61class QCA_CertContext;
62
63namespace QCA
64{
65 enum {
66 CAP_SHA1 = 0x0001,
67 CAP_SHA256 = 0x0002,
68 CAP_MD5 = 0x0004,
69 CAP_BlowFish = 0x0008,
70 CAP_TripleDES = 0x0010,
71 CAP_AES128 = 0x0020,
72 CAP_AES256 = 0x0040,
73 CAP_RSA = 0x0080,
74 CAP_X509 = 0x0100,
75 CAP_TLS = 0x0200,
76 CAP_SASL = 0x0400
77 };
78
79 enum {
80 CBC = 0x0001,
81 CFB = 0x0002
82 };
83
84 enum {
85 Encrypt = 0x0001,
86 Decrypt = 0x0002
87 };
88
89 QCA_EXPORT void init();
90 QCA_EXPORT bool isSupported(int capabilities);
91 QCA_EXPORT void insertProvider(QCAProvider *);
92 QCA_EXPORT void unloadAllPlugins();
93
94 QCA_EXPORT QString arrayToHex(const QByteArray &);
95 QCA_EXPORT QByteArray hexToArray(const QString &);
96
97 class QCA_EXPORT Hash
98 {
99 public:
100 Hash(const Hash &);
101 Hash & operator=(const Hash &);
102 ~Hash();
103
104 void clear();
105 void update(const QByteArray &a);
106 QByteArray final();
107
108 protected:
109 Hash(QCA_HashContext *);
110
111 private:
112 class Private;
113 Private *d;
114 };
115
116 template <class T>
117 class QCA_EXPORT HashStatic
118 {
119 public:
120 HashStatic<T>() {}
121
122 static QByteArray hash(const QByteArray &a)
123 {
124 T obj;
125 obj.update(a);
126 return obj.final();
127 }
128
129 static QByteArray hash(const QCString &cs)
130 {
131 QByteArray a(cs.length());
132 memcpy(a.data(), cs.data(), a.size());
133 return hash(a);
134 }
135
136 static QString hashToString(const QByteArray &a)
137 {
138 return arrayToHex(hash(a));
139 }
140
141 static QString hashToString(const QCString &cs)
142 {
143 return arrayToHex(hash(cs));
144 }
145 };
146
147 class QCA_EXPORT Cipher
148 {
149 public:
150 Cipher(const Cipher &);
151 Cipher & operator=(const Cipher &);
152 ~Cipher();
153
154 QByteArray dyn_generateKey(int size=-1) const;
155 QByteArray dyn_generateIV() const;
156 void reset(int dir, int mode, const QByteArray &key, const QByteArray &iv, bool pad=true);
157 bool update(const QByteArray &a);
158 QByteArray final(bool *ok=0);
159
160 protected:
161 Cipher(QCA_CipherContext *, int dir, int mode, const QByteArray &key, const QByteArray &iv, bool pad);
162
163 private:
164 class Private;
165 Private *d;
166 };
167
168 template <class T>
169 class QCA_EXPORT CipherStatic
170 {
171 public:
172 CipherStatic<T>() {}
173
174 static QByteArray generateKey(int size=-1)
175 {
176 T obj;
177 return obj.dyn_generateKey(size);
178 }
179
180 static QByteArray generateIV()
181 {
182 T obj;
183 return obj.dyn_generateIV();
184 }
185 };
186
187 class QCA_EXPORT SHA1 : public Hash, public HashStatic<SHA1>
188 {
189 public:
190 SHA1();
191 };
192
193 class QCA_EXPORT SHA256 : public Hash, public HashStatic<SHA256>
194 {
195 public:
196 SHA256();
197 };
198
199 class QCA_EXPORT MD5 : public Hash, public HashStatic<MD5>
200 {
201 public:
202 MD5();
203 };
204
205 class QCA_EXPORT BlowFish : public Cipher, public CipherStatic<BlowFish>
206 {
207 public:
208 BlowFish(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
209 };
210
211 class QCA_EXPORT TripleDES : public Cipher, public CipherStatic<TripleDES>
212 {
213 public:
214 TripleDES(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
215 };
216
217 class QCA_EXPORT AES128 : public Cipher, public CipherStatic<AES128>
218 {
219 public:
220 AES128(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
221 };
222
223 class QCA_EXPORT AES256 : public Cipher, public CipherStatic<AES256>
224 {
225 public:
226 AES256(int dir=Encrypt, int mode=CBC, const QByteArray &key=QByteArray(), const QByteArray &iv=QByteArray(), bool pad=true);
227 };
228
229 class RSA;
230 class QCA_EXPORT RSAKey
231 {
232 public:
233 RSAKey();
234 RSAKey(const RSAKey &from);
235 RSAKey & operator=(const RSAKey &from);
236 ~RSAKey();
237
238 bool isNull() const;
239 bool havePublic() const;
240 bool havePrivate() const;
241
242 QByteArray toDER(bool publicOnly=false) const;
243 bool fromDER(const QByteArray &a);
244
245 QString toPEM(bool publicOnly=false) const;
246 bool fromPEM(const QString &);
247
248 // only call if you know what you are doing
249 bool fromNative(void *);
250
251 private:
252 class Private;
253 Private *d;
254
255 friend class RSA;
256 friend class TLS;
257 bool encrypt(const QByteArray &a, QByteArray *out, bool oaep) const;
258 bool decrypt(const QByteArray &a, QByteArray *out, bool oaep) const;
259 bool generate(unsigned int bits);
260 };
261
262 class QCA_EXPORT RSA
263 {
264 public:
265 RSA();
266 ~RSA();
267
268 RSAKey key() const;
269 void setKey(const RSAKey &);
270
271 bool encrypt(const QByteArray &a, QByteArray *out, bool oaep=false) const;
272 bool decrypt(const QByteArray &a, QByteArray *out, bool oaep=false) const;
273
274 static RSAKey generateKey(unsigned int bits);
275
276 private:
277 RSAKey v_key;
278 };
279
280 typedef QMap<QString, QString> CertProperties;
281 class QCA_EXPORT Cert
282 {
283 public:
284 Cert();
285 Cert(const Cert &);
286 Cert & operator=(const Cert &);
287 ~Cert();
288
289 bool isNull() const;
290
291 QString commonName() const;
292 QString serialNumber() const;
293 QString subjectString() const;
294 QString issuerString() const;
295 CertProperties subject() const;
296 CertProperties issuer() const;
297 QDateTime notBefore() const;
298 QDateTime notAfter() const;
299
300 QByteArray toDER() const;
301 bool fromDER(const QByteArray &a);
302
303 QString toPEM() const;
304 bool fromPEM(const QString &);
305
306 private:
307 class Private;
308 Private *d;
309
310 friend class TLS;
311 void fromContext(QCA_CertContext *);
312 };
313
314 class QCA_EXPORT TLS : public QObject
315 {
316 Q_OBJECT
317 public:
318 enum Validity {
319 NoCert,
320 Valid,
321 HostMismatch,
322 Rejected,
323 Untrusted,
324 SignatureFailed,
325 InvalidCA,
326 InvalidPurpose,
327 SelfSigned,
328 Revoked,
329 PathLengthExceeded,
330 Expired,
331 Unknown
332 };
333 enum Error { ErrHandshake, ErrCrypt };
334
335 TLS(QObject *parent=0);
336 ~TLS();
337
338 void setCertificate(const Cert &cert, const RSAKey &key);
339 void setCertificateStore(const QPtrList<Cert> &store); // note: store must persist
340
341 void reset();
342 bool startClient(const QString &host="");
343 bool startServer();
344 void close();
345 bool isHandshaken() const;
346
347 // plain (application side)
348 void write(const QByteArray &a);
349 QByteArray read();
350
351 // encoded (socket side)
352 void writeIncoming(const QByteArray &a);
353 QByteArray readOutgoing();
354 QByteArray readUnprocessed();
355
356 // cert related
357 const Cert & peerCertificate() const;
358 int certificateValidityResult() const;
359
360 signals:
361 void handshaken();
362 void readyRead();
363 void readyReadOutgoing(int plainBytes);
364 void closed();
365 void error(int);
366
367 private slots:
368 void update();
369
370 private:
371 class Private;
372 Private *d;
373 };
374
375 class QCA_EXPORT SASL : public QObject
376 {
377 Q_OBJECT
378 public:
379 enum Error { ErrAuth, ErrCrypt };
380 enum ErrorCond {
381 NoMech,
382 BadProto,
383 BadServ,
384 BadAuth,
385 NoAuthzid,
386 TooWeak,
387 NeedEncrypt,
388 Expired,
389 Disabled,
390 NoUser,
391 RemoteUnavail
392 };
393 SASL(QObject *parent=0);
394 ~SASL();
395
396 static void setAppName(const QString &name);
397
398 void reset();
399 int errorCondition() const;
400
401 // options
402 void setAllowPlain(bool);
403 void setAllowAnonymous(bool);
404 void setAllowActiveVulnerable(bool);
405 void setAllowDictionaryVulnerable(bool);
406 void setRequireForwardSecrecy(bool);
407 void setRequirePassCredentials(bool);
408 void setRequireMutualAuth(bool);
409
410 void setMinimumSSF(int);
411 void setMaximumSSF(int);
412 void setExternalAuthID(const QString &authid);
413 void setExternalSSF(int);
414
415 void setLocalAddr(const QHostAddress &addr, Q_UINT16 port);
416 void setRemoteAddr(const QHostAddress &addr, Q_UINT16 port);
417
418 // initialize
419 bool startClient(const QString &service, const QString &host, const QStringList &mechlist, bool allowClientSendFirst=true);
420 bool startServer(const QString &service, const QString &host, const QString &realm, QStringList *mechlist);
421
422 // authentication
423 void putStep(const QByteArray &stepData);
424 void putServerFirstStep(const QString &mech);
425 void putServerFirstStep(const QString &mech, const QByteArray &clientInit);
426 void setUsername(const QString &user);
427 void setAuthzid(const QString &auth);
428 void setPassword(const QString &pass);
429 void setRealm(const QString &realm);
430 void continueAfterParams();
431 void continueAfterAuthCheck();
432
433 // security layer
434 int ssf() const;
435 void write(const QByteArray &a);
436 QByteArray read();
437 void writeIncoming(const QByteArray &a);
438 QByteArray readOutgoing();
439
440 signals:
441 // for authentication
442 void clientFirstStep(const QString &mech, const QByteArray *clientInit);
443 void nextStep(const QByteArray &stepData);
444 void needParams(bool user, bool authzid, bool pass, bool realm);
445 void authCheck(const QString &user, const QString &authzid);
446 void authenticated();
447
448 // for security layer
449 void readyRead();
450 void readyReadOutgoing(int plainBytes);
451
452 // error
453 void error(int);
454
455 private slots:
456 void tryAgain();
457
458 private:
459 class Private;
460 Private *d;
461
462 void handleServerFirstStep(int r);
463 };
464};
465
466#endif
Note: See TracBrowser for help on using the repository browser.