UCommon

ucommon/secure.h

Go to the documentation of this file.
00001 // Copyright (C) 2010 David Sugar, Tycho Softworks.
00002 //
00003 // This file is part of GNU uCommon C++.
00004 //
00005 // GNU uCommon C++ is free software: you can redistribute it and/or modify
00006 // it under the terms of the GNU Lesser General Public License as published 
00007 // by the Free Software Foundation, either version 3 of the License, or
00008 // (at your option) any later version.
00009 //
00010 // GNU uCommon C++ is distributed in the hope that it will be useful,
00011 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00012 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013 // GNU Lesser General Public License for more details.
00014 //
00015 // You should have received a copy of the GNU Lesser General Public License
00016 // along with GNU uCommon C++.  If not, see <http://www.gnu.org/licenses/>.
00017 
00041 #ifndef _UCOMMON_SECURE_H_
00042 #define _UCOMMON_SECURE_H_
00043 
00044 #ifndef _UCOMMON_CONFIG_H_
00045 #include <ucommon/platform.h>
00046 #endif
00047 
00048 #ifndef _UCOMMON_UCOMMON_H_
00049 #include <ucommon/ucommon.h>
00050 #endif
00051 
00052 #define MAX_CIPHER_KEYSIZE  512
00053 #define MAX_DIGEST_HASHSIZE 512
00054 
00055 NAMESPACE_UCOMMON
00056 
00062 class __EXPORT secure
00063 {
00064 public:
00068     typedef enum {OK=0, INVALID, MISSING_CERTIFICATE, MISSING_PRIVATEKEY, INVALID_CERTIFICATE, INVALID_AUTHORITY, INVALID_PEERNAME, INVALID_CIPHER} error_t;
00069 
00070 protected:
00074     error_t error;
00075 
00076     inline secure() {error = OK;};
00077 
00078 public:
00083     virtual ~secure();
00084 
00088     typedef secure *client_t;
00089 
00090     typedef secure *server_t;
00091 
00095     typedef void *session_t;
00096 
00100     typedef void *bufio_t;
00101 
00109     static bool init(const char *program = NULL);
00110 
00120     static error_t verify(session_t session, const char *peername = NULL);
00121 
00131     static server_t server(const char *authority = NULL);
00132 
00139     static client_t client(const char *authority = NULL);
00140 
00147     static client_t user(const char *authority);
00148 
00154     static void cipher(secure *context, const char *ciphers);
00155 
00160     inline bool is(void)
00161         {return error == OK;};
00162 
00167     inline error_t err(void)
00168         {return error;};
00169 
00174     static void uuid(char *string);
00175 
00176     static String uuid(void);
00177 };
00178 
00186 class __EXPORT SSLBuffer : public TCPBuffer
00187 {
00188 protected:
00189     secure::session_t ssl;
00190     secure::bufio_t bio;
00191     bool server;
00192     bool verify;
00193 
00194 public:
00195     SSLBuffer(secure::client_t context);
00196     SSLBuffer(const TCPServer *server, secure::server_t context, size_t size = 536);
00197     ~SSLBuffer();
00198 
00206     void open(const char *host, const char *service, size_t size = 536);
00207 
00208     void close(void);
00209 
00210     void release(void);
00211 
00212     size_t _push(const char *address, size_t size);
00213 
00214     size_t _pull(char *address, size_t size);
00215 
00216     bool _flush(void);
00217 
00218     bool _pending(void);
00219 
00220     inline bool is_secure(void)
00221         {return bio != NULL;};
00222 };
00223 
00233 class __EXPORT Cipher
00234 {
00235 public:
00236     typedef enum {ENCRYPT = 1, DECRYPT = 0} mode_t;
00237 
00245     class __EXPORT Key
00246     {
00247     private:
00248         friend class Cipher;
00249     
00250         union {
00251             const void *algotype;
00252             int algoid;
00253         };
00254 
00255         union {
00256             const void *hashtype;
00257             int hashid;
00258         };
00259 
00260         int modeid;
00261         
00262         // assume 512 bit cipher keys possible...
00263         unsigned char keybuf[MAX_CIPHER_KEYSIZE / 8], ivbuf[MAX_CIPHER_KEYSIZE / 8];
00264 
00265         // generated keysize
00266         size_t keysize, blksize;
00267 
00268     public:
00269         Key(const char *cipher, const char *digest, const char *text, size_t size = 0, const unsigned char *salt = NULL, unsigned rounds = 1);
00270         Key();
00271         ~Key();
00272 
00273         void clear(void);
00274 
00275         inline size_t size(void)
00276             {return keysize;};
00277 
00278         inline size_t iosize(void)
00279             {return blksize;};
00280     };
00281 
00282     typedef Key *key_t;
00283 
00284 private:
00285     Key keys;
00286     size_t bufsize, bufpos;
00287     mode_t bufmode;
00288     unsigned char *bufaddr;
00289     void *context;
00290     
00291 protected:
00292     virtual void push(unsigned char *address, size_t size);
00293 
00294     void release(void);
00295 
00296 public:
00297     Cipher();
00298 
00299     Cipher(key_t key, mode_t mode, unsigned char *address = NULL, size_t size = 0);
00300 
00301     ~Cipher();
00302 
00303     void set(unsigned char *address, size_t size = 0);
00304 
00305     void set(key_t key, mode_t mode, unsigned char *address, size_t size = 0);
00306 
00311     size_t flush(void);
00312 
00321     size_t put(const unsigned char *data, size_t size);
00322 
00329     size_t puts(const char *string);
00330 
00342     size_t pad(const unsigned char *address, size_t size);
00343 
00352     size_t process(unsigned char *address, size_t size, bool flag = false);
00353         
00354     inline size_t size(void)
00355         {return bufsize;};
00356 
00357     inline size_t pos(void)
00358         {return bufpos;};
00359 
00360     inline size_t align(void)
00361         {return keys.iosize();};
00362 
00368     static bool is(const char *name);
00369 };
00370 
00377 class __EXPORT Digest
00378 {
00379 private:
00380     void *context;
00381 
00382     union {
00383         const void *hashtype;
00384         int hashid;
00385     };
00386 
00387     unsigned bufsize;
00388     unsigned char buffer[MAX_DIGEST_HASHSIZE / 8];
00389     char textbuf[MAX_DIGEST_HASHSIZE / 8 + 1];
00390     
00391 protected:
00392     void release(void);
00393 
00394 public:
00395     Digest(const char *type);
00396 
00397     Digest();
00398 
00399     ~Digest();
00400 
00401     inline bool puts(const char *str)
00402         {return put(str, strlen(str));};
00403 
00404     bool put(const void *memory, size_t size);
00405     
00406     inline unsigned size() const
00407         {return bufsize;};
00408     
00409     const unsigned char *get(void);
00410 
00411     const char *c_str(void);
00412 
00413     inline String str(void)
00414         {return String(c_str());};
00415 
00416     inline operator String()
00417         {return String(c_str());};
00418 
00419     void set(const char *id);
00420 
00421     inline void operator=(const char *id)
00422         {set(id);};
00423 
00424     inline bool operator *=(const char *text)
00425         {return puts(text);};
00426 
00427     inline bool operator +=(const char *text)
00428         {return puts(text);};
00429 
00430     inline const char *operator*()
00431         {return c_str();};
00432 
00433     inline bool operator!() const
00434         {return !bufsize && context == NULL;};
00435 
00436     inline operator bool() const
00437         {return bufsize > 0 || context != NULL;};
00438 
00444     void recycle(bool binary = false);
00445 
00449     void reset(void);
00450 
00456     static bool is(const char *name);
00457 
00458     static void uuid(char *string, const char *name, const unsigned char *ns = NULL);
00459 
00460     static String uuid(const char *name, const unsigned char *ns = NULL);
00461 };
00462 
00468 class __EXPORT Random
00469 {
00470 public:
00477     static bool seed(const unsigned char *buffer, size_t size);
00478 
00482     static void seed(void);
00483 
00492     static size_t key(unsigned char *memory, size_t size);
00493 
00502     static size_t fill(unsigned char *memory, size_t size);
00503 
00508     static int get(void);
00509 
00516     static int get(int min, int max);
00517 
00522     static double real(void);
00523 
00530     static double real(double min, double max);
00531 
00537     static bool status(void);
00538 
00543     static void uuid(char *string);
00544 
00545     static String uuid(void);
00546 };
00547 
00551 typedef SSLBuffer ssl_t;
00552 
00556 typedef Digest digest_t;
00557 
00561 typedef Cipher cipher_t;
00562 
00566 typedef Cipher::Key skey_t;
00567 
00568 inline void zerofill(void *addr, size_t size)
00569 {
00570     ::memset(addr, 0, size);
00571 }
00572 
00573 #if defined(OLD_STDCPP) || defined(NEW_STDCPP)
00574 
00583 class __EXPORT sstream : public tcpstream
00584 {
00585 protected:
00586     secure::session_t ssl;
00587     secure::bufio_t bio;
00588     bool server;
00589     bool verify;
00590 
00591 public:
00592     sstream(secure::client_t context);
00593     sstream(const TCPServer *server, secure::server_t context, size_t size = 536);
00594     ~sstream();
00595 
00596     void open(const char *host, const char *service, size_t size = 536);
00597 
00598     void close(void);
00599 
00600     int sync();
00601 
00602     void release(void);
00603 
00604     ssize_t _write(const char *address, size_t size);
00605 
00606     ssize_t _read(char *address, size_t size);
00607 
00608     bool _wait(void);
00609 
00610     inline void flush(void)
00611         {sync();}
00612 
00613     inline bool is_secure(void)
00614         {return bio != NULL;}
00615 };
00616 
00617 #endif
00618 
00619 END_NAMESPACE
00620 
00621 #endif