* Changed binary data encryption to not be viewable under 'strings'.

svn: 2237

doc/UPDATES

@@ -29,6 +29,7 @@ Lines prefixed with '-' were disabled before release and are not finished, or ar
 * Removed '+/-manop' from 'chanset' var and added to ignore list for chanset.
 * Fixed a segfault with 'set +' (#117)
 * List functions now only work on variables marked as list variables.
+* Changed binary data encryption to not be viewable under 'strings'.
 
 1.2.3
 

src/binary.c

@@ -19,20 +19,8 @@
 #include <sys/types.h>
 #include <signal.h>
 
-/*
-typedef struct encdata_struct {
-  char prefix[PREFIXLEN];
-  char data[65];
-} encdata_t;
-
-static encdata_t encdata = {
-  "AAAAAAAAAAAAAAAA",
-  ""
-};
-*/
-
 settings_t settings = {
-  "AAAAAAAAAAAAAAA",
+  "\200\200\200\200\200\200\200\200\200\200\200\200\200\200\200",
   /* -- STATIC -- */
   "", "", "", "", "", "", "", "", "", "",
   /* -- DYNAMIC -- */
@@ -306,21 +294,31 @@ readcfg(const char *cfgfile)
 static void edpack(settings_t *incfg, const char *hash, int what)
 {
   char *tmp = NULL;
-  char *(*enc_dec_string)(const char *, char *);
-  
+  unsigned char *(*enc_dec_string)(const char *, unsigned char *, size_t *);
+  size_t len = 0;
+
   if (what == PACK_ENC)
-    enc_dec_string = encrypt_string;
+    enc_dec_string = encrypt_binary;
   else
-    enc_dec_string = decrypt_string;
-
-#define dofield(_field) 		do {				\
-	if (_field && _field[0]) {					\
-		tmp = enc_dec_string(hash, _field);			\
-		simple_snprintf(_field, sizeof(_field), "%s", tmp);	\
-		free(tmp);						\
-	}								\
+    enc_dec_string = decrypt_binary;
+
+#define dofield(_field) 		do {							\
+	if (_field && _field[0]) {								\
+		len = sizeof(_field) - 1;							\
+		tmp = (char *) enc_dec_string(hash, (unsigned char *) _field, &len);		\
+		if (what == PACK_ENC) 								\
+		  egg_memcpy(_field, tmp, len);							\
+		else 										\
+		  simple_snprintf(_field, sizeof(_field), "%s", tmp);				\
+		free(tmp);									\
+	}											\
 } while (0)
 
+#ifdef no
+		  egg_memcpy(_field, tmp, len);							\
+
+#endif
+
   /* -- STATIC -- */
   dofield(incfg->hash);
   dofield(incfg->packname);
@@ -330,12 +328,10 @@ static void edpack(settings_t *incfg, const char *hash, int what)
   dofield(incfg->owners);
   dofield(incfg->owneremail);
   dofield(incfg->hubs);
-//  dofield(incfg->salt1);
-//  dofield(incfg->salt2);
+  dofield(incfg->salt1);
+  dofield(incfg->salt2);
   /* -- DYNAMIC -- */
-//printf("BOTS: %s\n", incfg->bots);
   dofield(incfg->bots);
-//printf("EBOTS: %s\n", incfg->bots);
   dofield(incfg->uid);
   dofield(incfg->autouname);
   dofield(incfg->pscloak);
@@ -366,6 +362,8 @@ tellconfig(settings_t *incfg)
   dofield(incfg->owners);
   dofield(incfg->owneremail);
   dofield(incfg->hubs);
+  dofield(incfg->salt1);
+  dofield(incfg->salt2);
   // -- DYNAMIC --
   dofield(incfg->bots);
   dofield(incfg->uid);

src/compat/compat.h

@@ -29,6 +29,7 @@
 #define egg_isspace(x)  isspace((int)  (unsigned char) (x))
 #define egg_islower(x)  islower((int)  (unsigned char) (x))
 #define egg_isupper(x)  isupper((int)  (unsigned char) (x))
+#define egg_isprint(x)  isprint((int)  (unsigned char) (x))
 
 
 #endif /* !__EGG_COMPAT_COMPAT_H */

src/crypt.c

@@ -20,8 +20,8 @@
 
 AES_KEY e_key, d_key;
 
-static unsigned char *
-encrypt_binary(const char *keydata, const unsigned char *in, size_t *inlen)
+unsigned char *
+encrypt_binary(const char *keydata, unsigned char *in, size_t *inlen)
 {
   size_t len = *inlen;
   int blocks = 0, block = 0;
@@ -52,15 +52,15 @@ encrypt_binary(const char *keydata, const unsigned char *in, size_t *inlen)
   return out;
 }
 
-static unsigned char *
-decrypt_binary(const char *keydata, unsigned char *in, size_t len)
+unsigned char *
+decrypt_binary(const char *keydata, unsigned char *in, size_t *len)
 {
   int blocks = 0, block = 0;
   unsigned char *out = NULL;
 
-  len -= len % CRYPT_BLOCKSIZE;
-  out = (unsigned char *) my_calloc(1, len + 1);
-  egg_memcpy(out, in, len);
+  *len -= *len % CRYPT_BLOCKSIZE;
+  out = (unsigned char *) my_calloc(1, *len + 1);
+  egg_memcpy(out, in, *len);
 
   if (!keydata || !*keydata) {
     /* No key, no decryption */
@@ -71,7 +71,7 @@ decrypt_binary(const char *keydata, unsigned char *in, size_t len)
     strlcpy(key, keydata, sizeof(key));
     AES_set_decrypt_key((const unsigned char *) key, CRYPT_KEYBITS, &d_key);
     /* Now loop through the blocks and crypt them */
-    blocks = len / CRYPT_BLOCKSIZE;
+    blocks = *len / CRYPT_BLOCKSIZE;
 
     for (block = blocks - 1; block >= 0; block--)
       AES_decrypt(&out[block * CRYPT_BLOCKSIZE], &out[block * CRYPT_BLOCKSIZE], &d_key);
@@ -86,7 +86,7 @@ char *encrypt_string(const char *keydata, char *in)
   unsigned char *bdata = NULL;
   char *res = NULL;
 
-  len = strlen(in) + 1;
+  len = strlen(in);
   bdata = encrypt_binary(keydata, (unsigned char *) in, &len);
   if (keydata && *keydata) {
     res = b64enc(bdata, len);
@@ -104,7 +104,7 @@ char *decrypt_string(const char *keydata, char *in)
 
   if (keydata && *keydata) {
     buf = b64dec((const unsigned char *) in, &len);
-    res = (char *) decrypt_binary(keydata, (unsigned char *) buf, len);
+    res = (char *) decrypt_binary(keydata, (unsigned char *) buf, &len);
     free(buf);
     return res;
   } else {

src/crypt.h

@@ -18,6 +18,9 @@
 char *MD5(const char *);
 char *MD5FILE(const char *);
 char *SHA1(const char *);
+
+unsigned char *encrypt_binary(const char *, unsigned char *, size_t *);
+unsigned char *decrypt_binary(const char *, unsigned char *, size_t *);
 char *encrypt_string(const char *, char *);
 char *decrypt_string(const char *, char *);
 void encrypt_cmd_pass(char *, char *);

src/debug.c

@@ -105,6 +105,93 @@ void sdprintf (const char *format, ...)
   }
 }
 
+void printstr(unsigned char *str, int len)
+{
+#ifdef no
+        static char *outstr;
+        int i, n, c, usehex;
+        char *s, *outend;
+	int max_strlen = 64;
+        int xflag = 0;
+
+        outstr = (char *) calloc(1, 2 * max_strlen);
+        outend = outstr + max_strlen * 2 - 10;
+
+        n = (((max_strlen) < (len)) ? (max_strlen) : (len));
+        usehex = 0;
+        if (xflag > 1)
+                usehex = 1;
+        else if (xflag) {
+                for (i = 0; i < n; i++) {
+                        c = str[i];
+                        if (len < 0 && c == '\0')
+                                break;
+                        if (!isprint(c) && !egg_isspace(c)) {
+                                usehex = 1;
+                                break;
+                        }
+                }
+        }
+
+        s = outstr;
+        *s++ = '\"';
+
+        if (usehex) {
+                for (i = 0; i < n; i++) {
+                        c = str[i];
+                        if (len < 0 && c == '\0')
+                                break;
+                        sprintf(s, "\\x%02x", c);
+                        s += 4;
+                        if (s > outend)
+                                break;
+                }
+        }
+        else {
+                for (i = 0; i < n; i++) {
+                        c = str[i];
+                        if (len < 0 && c == '\0')
+                                break;
+                        switch (c) {
+                        case '\"': case '\'': case '\\':
+                                *s++ = '\\'; *s++ = c; break;
+                        case '\f':
+                                *s++ = '\\'; *s++ = 'f'; break;
+                        case '\n':
+                                *s++ = '\\'; *s++ = 'n'; break;
+                        case '\r':
+                                *s++ = '\\'; *s++ = 'r'; break;
+                        case '\t':
+                                *s++ = '\\'; *s++ = 't'; break;
+                        case '\v':
+                                *s++ = '\\'; *s++ = 'v'; break;
+                        default:
+                                if (egg_isprint(c))
+                                        *s++ = c;
+                                else if (i < n - 1 && egg_isdigit(str[i + 1])) {
+                                        sprintf(s, "\\%03o", c);
+                                        s += 4;
+                                }
+                                else {
+                                        sprintf(s, "\\%o", c);
+                                        s += strlen(s);
+                                }
+                                break;
+                        }
+                        if (s > outend)
+                                break;
+                }
+        }
+
+        *s++ = '\"';
+        if (i < len || (len < 0 && (i == n || s > outend))) {
+                *s++ = '.'; *s++ = '.'; *s++ = '.';
+        }
+        *s = '\0';
+
+        printf("%s\n", outstr);
+#endif
+}
 
 #ifdef DEBUG_CONTEXT
 

src/debug.h

@@ -39,5 +39,6 @@ void init_signals();
 void init_debug();
 void eggContext(const char *, int);
 void eggContextNote(const char *, int, const char *);
+void printstr(unsigned char *, int);
 
 #endif /* !_DEBUG_H */

src/settings.h

@@ -7,34 +7,34 @@
 typedef struct settings_struct {
   char prefix[PREFIXLEN];
   /* -- STATIC -- */
-  char hash[65];
+//  char hash[33];
+  char hash[49];
   char packname[65];
   char shellhash[65];
   char bdhash[65];
-  char owners[1024];
-  char hubs[1024];
-  char owneremail[1024];
-  char salt1[65];
-  char salt2[45];
-  char dcc_prefix[25];
+  char owners[513];
+  char hubs[513];
+  char owneremail[385];
+  char salt1[33];
+  char salt2[17];
+  char dcc_prefix[17];
   /* -- DYNAMIC -- */
- 
-  char bots[1389];
-  char uid[25];
-  char autouname[25];        /* should we just auto update any changed in uname output? */
-  char pscloak[25];          /* should the bots bother trying to cloak `ps`? */
-  char autocron[25];         /* should the bot auto crontab itself? */
-  char watcher[25];          /* spawn a watcher pid to block ptrace? */
-  char uname[489];
-  char username[45];       /* shell username */
-  char tempdir[1389];
-  char homedir[1389];        /* homedir */
-  char binpath[1389];        /* path to binary, ie: ~/ */
-  char binname[121];        /* binary name, ie: .sshrc */
-  char portmin[25];       /* for hubs, the reserved port range for incoming connections */
-  char portmax[25];       /* for hubs, the reserved port range for incoming connections */
+  char bots[1025];
+  char uid[17];
+  char autouname[17];        /* should we just auto update any changed in uname output? */
+  char pscloak[17];          /* should the bots bother trying to cloak `ps`? */
+  char autocron[17];         /* should the bot auto crontab itself? */
+  char watcher[17];          /* spawn a watcher pid to block ptrace? */
+  char uname[113];
+  char username[49];       /* shell username */
+  char tempdir[1025];
+  char homedir[1025];        /* homedir */
+  char binpath[1025];        /* path to binary, ie: ~/ */
+  char binname[113];        /* binary name, ie: .sshrc */
+  char portmin[17];       /* for hubs, the reserved port range for incoming connections */
+  char portmax[17];       /* for hubs, the reserved port range for incoming connections */
   /* -- PADDING -- */
-  char padding[3];
+  char padding[8];
 } settings_t;
 
 #define SIZE_PACK sizeof(settings.hash) + sizeof(settings.packname) + sizeof(settings.shellhash) + \