41 #ifndef _UCOMMON_SECURE_H_
42 #define _UCOMMON_SECURE_H_
44 #ifndef _UCOMMON_CONFIG_H_
48 #ifndef _UCOMMON_UCOMMON_H_
52 #define MAX_CIPHER_KEYSIZE 512
53 #define MAX_DIGEST_HASHSIZE 512
68 typedef enum {OK=0, INVALID, MISSING_CERTIFICATE, MISSING_PRIVATEKEY, INVALID_CERTIFICATE, INVALID_AUTHORITY, INVALID_PEERNAME, INVALID_CIPHER} error_t;
76 inline secure() {error = OK;};
107 static bool init(
void);
115 static bool fips(
void);
122 static int oscerts(
const char *path);
128 static const char *oscerts(
void);
150 static server_t server(
const char *
keyfile = NULL,
const char *authority = NULL);
158 static client_t client(
const char *authority = NULL);
166 static client_t user(
const char *authority);
173 static void cipher(
secure *context,
const char *ciphers);
180 {
return error == OK;};
193 static void uuid(
char *
string);
197 template <
typename T>
198 inline static void erase(T *
object)
199 {memset(
object, 0,
sizeof(
object));
delete object;}
201 inline operator bool()
204 inline bool operator!()
205 {
return !is_valid();}
236 void open(
const char *host,
const char *service,
size_t size = 536);
244 size_t _pull(
char *address,
size_t size);
250 inline bool is_secure(
void)
251 {
return bio != NULL;};
266 typedef enum {ENCRYPT = 1, DECRYPT = 0} mode_t;
281 const void *algotype;
286 const void *hashtype;
293 unsigned char keybuf[MAX_CIPHER_KEYSIZE / 8], ivbuf[MAX_CIPHER_KEYSIZE / 8];
296 size_t keysize, blksize;
298 Key(
const char *cipher);
301 void set(
const char *cipher);
303 void set(
const char *cipher,
const char *digest);
305 void assign(
const char *key,
size_t size,
const unsigned char *salt,
unsigned rounds);
308 Key(
const char *cipher,
const char *digest,
const char *text,
size_t size = 0,
const unsigned char *salt = NULL,
unsigned rounds = 1);
310 Key(
const char *cipher,
const char *digest);
314 void assign(
const char *key,
size_t size = 0);
318 inline size_t size(
void)
321 inline size_t iosize(
void)
324 inline operator bool()
325 {
return keysize > 0;};
327 inline bool operator!()
328 {
return keysize == 0;};
330 inline Key& operator=(
const char *pass)
331 {assign(pass);
return *
this;};
333 static void options(
const unsigned char *salt = NULL,
unsigned rounds = 1);
340 size_t bufsize, bufpos;
342 unsigned char *bufaddr;
346 virtual void push(
unsigned char *address,
size_t size);
353 Cipher(
key_t key, mode_t mode,
unsigned char *address = NULL,
size_t size = 0);
357 void set(
unsigned char *address,
size_t size = 0);
359 void set(
key_t key, mode_t mode,
unsigned char *address,
size_t size = 0);
375 size_t put(
const unsigned char *data,
size_t size);
383 size_t puts(
const char *
string);
396 size_t pad(
const unsigned char *address,
size_t size);
406 size_t process(
unsigned char *address,
size_t size,
bool flag =
false);
408 inline size_t size(
void)
411 inline size_t pos(
void)
414 inline size_t align(
void)
415 {
return keys.iosize();};
422 static bool has(
const char *name);
437 const void *hashtype;
442 unsigned char buffer[MAX_DIGEST_HASHSIZE / 8];
443 char textbuf[MAX_DIGEST_HASHSIZE / 8 + 1];
455 inline bool puts(
const char *str)
456 {
return put(str, strlen(str));};
458 inline Digest &operator<<(
const char *str)
459 {puts(str);
return *
this;}
461 inline Digest &operator<<(int16_t value)
462 {int16_t v = htons(value); put(&v, 2);
return *
this;}
464 inline Digest &operator<<(int32_t value)
465 {int32_t v = htonl(value); put(&v, 4);
return *
this;}
468 {
const char *cp = p.
_print();
if(cp) puts(cp);
return *
this;}
470 bool put(
const void *memory,
size_t size);
472 inline unsigned size()
const
475 const unsigned char *
get(void);
477 const char *c_str(
void);
480 {
return String(c_str());};
483 {
return String(c_str());};
485 void set(
const char *
id);
487 inline void operator=(
const char *
id)
490 inline bool operator *=(
const char *text)
491 {
return puts(text);};
493 inline bool operator +=(
const char *text)
494 {
return puts(text);};
496 inline const char *operator*()
499 inline bool operator!()
const
500 {
return !bufsize && context == NULL;};
502 inline operator bool()
const
503 {
return bufsize > 0 || context != NULL;};
510 void recycle(
bool binary =
false);
522 static bool has(
const char *name);
524 static void uuid(
char *
string,
const char *name,
const unsigned char *ns = NULL);
526 static String uuid(
const char *name,
const unsigned char *ns = NULL);
541 const void *hmactype;
546 unsigned char buffer[MAX_DIGEST_HASHSIZE / 8];
547 char textbuf[MAX_DIGEST_HASHSIZE / 8 + 1];
553 HMAC(
const char *digest,
const char *key,
size_t keylen = 0);
559 inline bool puts(
const char *str)
560 {
return put(str, strlen(str));};
562 inline HMAC &operator<<(
const char *str)
563 {puts(str);
return *
this;}
565 inline HMAC &operator<<(int16_t value)
566 {int16_t v = htons(value); put(&v, 2);
return *
this;}
568 inline HMAC &operator<<(int32_t value)
569 {int32_t v = htonl(value); put(&v, 4);
return *
this;}
572 {
const char *cp = p.
_print();
if(cp) puts(cp);
return *
this;}
574 bool put(
const void *memory,
size_t size);
576 inline unsigned size()
const
579 const unsigned char *
get(void);
581 const char *c_str(
void);
584 {
return String(c_str());};
587 {
return String(c_str());};
589 void set(
const char *digest,
const char *key,
size_t len);
591 inline bool operator *=(
const char *text)
592 {
return puts(text);};
594 inline bool operator +=(
const char *text)
595 {
return puts(text);};
597 inline const char *operator*()
600 inline bool operator!()
const
601 {
return !bufsize && context == NULL;};
603 inline operator bool()
const
604 {
return bufsize > 0 || context != NULL;};
611 static bool has(
const char *name);
628 static bool seed(
const unsigned char *buffer,
size_t size);
633 static void seed(
void);
643 static size_t key(
unsigned char *memory,
size_t size);
653 static size_t fill(
unsigned char *memory,
size_t size);
659 static int get(void);
667 static int get(
int min,
int max);
673 static double real(
void);
681 static double real(
double min,
double max);
688 static bool status(
void);
694 static void uuid(
char *
string);
724 inline void zerofill(
void *
addr,
size_t size)
726 ::memset(addr, 0, size);
729 #if defined(OLD_STDCPP) || defined(NEW_STDCPP)
756 void open(
const char *host,
const char *service,
size_t size = 536);
764 ssize_t _write(
const char *address,
size_t size);
766 ssize_t _read(
char *address,
size_t size);
770 inline void flush(
void)
773 inline bool is_secure(
void)
774 {
return bio != NULL;}
809 {String::set(buffer, S, text);}
815 {memset(buffer, 0, S);}
821 {memset(buffer, 0, S);}
828 {String::set(buffer, S, text);}
836 {String::add(buffer, S, text);}
842 inline operator bool()
const
850 {
return buffer[0] == 0;}
856 inline operator char *()
872 {
return buffer[offset];}
880 {
return buffer + offset;}
893 inline size_t len(
void)
const
894 {
return strlen(buffer);}
906 unsigned char buffer[S];
918 {Random::key(buffer, S);}
924 {memset(buffer, 0, S);}
930 {Random::key(buffer, S);}
936 {memset(buffer, 0, S);}
942 inline operator unsigned char *()
void release(void)
Release (free) buffer memory.
error_t error
Last error flagged for this context.
void open(Socket::address &address, unsigned segment=536)
Open a stream connection to a tcp service.
HMAC hmac_t
Convenience type for generic digests.
void clear(void)
Clear current key memory.
virtual const char * _print(void) const =0
Extract formatted string for object.
void * session_t
Convenience type to represent a secure socket session.
size_t len(void) const
Get current length of string.
~keystring()
Clear memory when destroyed.
A cryptographic digest class.
A copy-on-write string class that operates by reference count.
T &() min(T &o1, T &o2)
Convenience function to return min of two objects.
A generic data ciphering class.
char * operator*()
Get text by object pointer reference.
T * init(T *memory)
Template function to initialize memory by invoking default constructor.
A generic tcp server class.
Cipher::Key skey_t
Convenience type for generic cipher key.
Digest digest_t
Convenience type for generic digests.
A template to create a random generated key of specified size.
virtual size_t _pull(char *address, size_t size)
Method to pull buffer from physical i/o (read).
Secure socket using std::iostream.
keystring(const char *text)
Create a character buffer with assigned text.
size_t size(void) const
Get allocated size of the object.
secure * client_t
Convenience type to represent a security context.
void release(SharedAccess &object)
Convenience function to unlock shared object through it's protocol.
Traditional keypair config file parsing class.
void operator=(const char *text)
Assign null terminated text to the object.
A generic tcp socket class that offers i/o buffering.
~keyrandom()
Clear memory when destroyed.
Various miscellaneous platform specific headers and defines.
virtual bool _pending(void)
Check for pending tcp or ssl data.
error_t err(void)
Get last error code associated with the security context.
Cipher cipher_t
Convenience type for generic ciphers.
void operator+=(const char *text)
Concatenate text into the object.
void close(void)
Close an active stream connection.
int sync(void)
Flush the stream input and output buffers, writes pending output.
Cryptographically relevant random numbers.
keystring()
Create a new character buffer with an empty string.
void release(void)
Release the tcp stream and destroy the underlying socket.
char & operator[](size_t offset) const
Array operator to get a character from the object.
char * operator()(size_t offset)
Get a pointer to an offset in the object by expression operator.
A generic socket address class.
bool operator!() const
Test if the object is empty.
Common secure socket support.
A cryptographic message authentication code class.
struct sockaddr * addr(Socket::address &address)
A convenience function to convert a socket address list into a socket address.
virtual size_t _push(const char *address, size_t size)
Method to push buffer into physical i/o (write).
T &() max(T &o1, T &o2)
Convenience function to return max of two objects.
error_t
Different error states of the security context.
void update(void)
Update with new random key.
Used for forming stream output.
bool is_valid(void) const
Determine if the current security context is valid.
size_t size(void) const
Get allocated size of the object.
keyrandom()
Create a new character buffer with an empty string.
SSLBuffer ssl_t
Convenience type for secure socket.
Streamable tcp connection between client and server.
void * bufio_t
Convenience type to represent a secure socket buf i/o stream.
virtual bool _flush(void)
Flush buffer to physical i/o.
A template to create a string array that automatically erases.
unsigned char * operator*()
Get text by object pointer reference.
ObjectProtocol * copy(ObjectProtocol *object)
Convenience function to access object copy.
void open(const TCPServer *server, size_t size=536)
Connect a tcp socket to a client from a listener.
void close(void)
Close active connection.
Cipher key formed by hash algorithm.
void clear(void)
Clear current key memory.
Top level include file for the GNU uCommon C++ core library.