diff options
Diffstat (limited to 'lib')
| -rw-r--r-- | lib/Makefile | 2 | ||||
| -rw-r--r-- | lib/arc.c (renamed from lib/rc4.c) | 107 | ||||
| -rw-r--r-- | lib/arc.h (renamed from lib/rc4.h) | 16 | ||||
| -rw-r--r-- | lib/base64.c | 4 | ||||
| -rw-r--r-- | lib/base64.h | 2 | ||||
| -rw-r--r-- | lib/misc.c | 48 | ||||
| -rw-r--r-- | lib/misc.h | 2 | ||||
| -rw-r--r-- | lib/ssl_bogus.c | 5 |
8 files changed, 126 insertions, 60 deletions
diff --git a/lib/Makefile b/lib/Makefile index a9038987..bc1966d9 100644 --- a/lib/Makefile +++ b/lib/Makefile @@ -9,7 +9,7 @@ -include ../Makefile.settings # [SH] Program variables -objects = base64.o $(EVENT_HANDLER) http_client.o ini.o md5.o misc.o proxy.o rc4.o sha.o $(SSL_CLIENT) url.o +objects = arc.o base64.o $(EVENT_HANDLER) http_client.o ini.o md5.o misc.o proxy.o sha.o $(SSL_CLIENT) url.o CFLAGS += -Wall LFLAGS += -r @@ -1,7 +1,7 @@ /***************************************************************************\ * * * BitlBee - An IRC to IM gateway * -* Simple (but secure) RC4 implementation for safer password storage. * +* Simple (but secure) ArcFour implementation for safer password storage. * * * * Copyright 2006 Wilmer van der Gaast <wilmer@gaast.net> * * * @@ -22,18 +22,21 @@ \***************************************************************************/ /* - This file implements RC4-encryption, which will mainly be used to save IM - passwords safely in the new XML-format. Possibly other uses will come up - later. It's supposed to be quite reliable (thanks to the use of a 6-byte - IV/seed), certainly compared to the old format. The only realistic way to - crack BitlBee passwords now is to use a sniffer to get your hands on the - user's password. + This file implements ArcFour-encryption, which will mainly be used to + save IM passwords safely in the new XML-format. Possibly other uses will + come up later. It's supposed to be quite reliable (thanks to the use of a + 6-byte IV/seed), certainly compared to the old format. The only realistic + way to crack BitlBee passwords now is to use a sniffer to get your hands + on the user's password. If you see that something's wrong in this implementation (I asked a couple of people to look at it already, but who knows), please tell me. - The reason I chose for RC4 is because it's pretty simple but effective, + The reason I picked ArcFour is because it's pretty simple but effective, so it will work without adding several KBs or an extra library dependency. + + (ArcFour is an RC4-compatible cipher. See for details: + http://www.mozilla.org/projects/security/pki/nss/draft-kaukonen-cipher-arcfour-03.txt) */ @@ -42,55 +45,62 @@ #include <stdlib.h> #include <string.h> #include "misc.h" -#include "rc4.h" +#include "arc.h" /* Add some seed to the password, to make sure we *never* use the same key. This defines how many bytes we use as a seed. */ -#define RC4_IV_LEN 6 +#define ARC_IV_LEN 6 /* To defend against a "Fluhrer, Mantin and Shamir attack", it is recommended to shuffle S[] just a bit more before you start to use it. This defines how many bytes we'll request before we'll really use them for encryption. */ -#define RC4_CYCLES 1024 +#define ARC_CYCLES 1024 -struct rc4_state *rc4_keymaker( unsigned char *key, int kl, int cycles ) +struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles ) { - struct rc4_state *st; + struct arc_state *st; int i, j, tmp; + unsigned char S2[256]; - st = g_malloc( sizeof( struct rc4_state ) ); + st = g_malloc( sizeof( struct arc_state ) ); st->i = st->j = 0; - for( i = 0; i < 256; i ++ ) - st->S[i] = i; - if( kl <= 0 ) kl = strlen( (char*) key ); + for( i = 0; i < 256; i ++ ) + { + st->S[i] = i; + S2[i] = key[i%kl]; + } + for( i = j = 0; i < 256; i ++ ) { - j = ( j + st->S[i] + key[i%kl] ) & 0xff; + j = ( j + st->S[i] + S2[i] ) & 0xff; tmp = st->S[i]; st->S[i] = st->S[j]; st->S[j] = tmp; } + memset( S2, 0, 256 ); + i = j = 0; + for( i = 0; i < cycles; i ++ ) - rc4_getbyte( st ); + arc_getbyte( st ); return st; } /* - For those who don't know, RC4 is basically an algorithm that generates a - stream of bytes after you give it a key. Just get a byte from it and xor - it with your cleartext. To decrypt, just give it the same key again and - start xorring. + For those who don't know, ArcFour is basically an algorithm that generates + a stream of bytes after you give it a key. Just get a byte from it and + xor it with your cleartext. To decrypt, just give it the same key again + and start xorring. - The function above initializes the RC4 byte generator, the next function - can be used to get bytes from the generator (and shuffle things a bit). + The function above initializes the byte generator, the next function can + be used to get bytes from the generator (and shuffle things a bit). */ -unsigned char rc4_getbyte( struct rc4_state *st ) +unsigned char arc_getbyte( struct arc_state *st ) { unsigned char tmp; @@ -100,16 +110,17 @@ unsigned char rc4_getbyte( struct rc4_state *st ) tmp = st->S[st->i]; st->S[st->i] = st->S[st->j]; st->S[st->j] = tmp; + tmp = (st->S[st->i] + st->S[st->j]) & 0xff; - return st->S[(st->S[st->i] + st->S[st->j]) & 0xff]; + return st->S[tmp]; } /* The following two functions can be used for reliable encryption and decryption. Known plaintext attacks are prevented by adding some (6, - by default) random bytes to the password before setting up the RC4 + by default) random bytes to the password before setting up the state structures. These 6 bytes are also saved in the results, because of - course we'll need them in rc4_decode(). + course we'll need them in arc_decode(). Because the length of the resulting string is unknown to the caller, it should pass a char**. Since the encode/decode functions allocate @@ -121,50 +132,50 @@ unsigned char rc4_getbyte( struct rc4_state *st ) Both functions return the number of bytes in the result string. */ -int rc4_encode( unsigned char *clear, int clear_len, unsigned char **crypt, char *password ) +int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password ) { - struct rc4_state *st; + struct arc_state *st; unsigned char *key; int key_len, i; - key_len = strlen( password ) + RC4_IV_LEN; + key_len = strlen( password ) + ARC_IV_LEN; if( clear_len <= 0 ) - clear_len = strlen( (char*) clear ); + clear_len = strlen( clear ); /* Prepare buffers and the key + IV */ - *crypt = g_malloc( clear_len + RC4_IV_LEN ); + *crypt = g_malloc( clear_len + ARC_IV_LEN ); key = g_malloc( key_len ); strcpy( (char*) key, password ); /* Add the salt. Save it for later (when decrypting) and, of course, add it to the encryption key. */ - random_bytes( crypt[0], RC4_IV_LEN ); - memcpy( key + key_len - RC4_IV_LEN, crypt[0], RC4_IV_LEN ); + random_bytes( crypt[0], ARC_IV_LEN ); + memcpy( key + key_len - ARC_IV_LEN, crypt[0], ARC_IV_LEN ); /* Generate the initial S[] from the IVed key. */ - st = rc4_keymaker( key, key_len, RC4_CYCLES ); + st = arc_keymaker( key, key_len, ARC_CYCLES ); g_free( key ); for( i = 0; i < clear_len; i ++ ) - crypt[0][i+RC4_IV_LEN] = clear[i] ^ rc4_getbyte( st ); + crypt[0][i+ARC_IV_LEN] = clear[i] ^ arc_getbyte( st ); g_free( st ); - return clear_len + RC4_IV_LEN; + return clear_len + ARC_IV_LEN; } -int rc4_decode( unsigned char *crypt, int crypt_len, unsigned char **clear, char *password ) +int arc_decode( unsigned char *crypt, int crypt_len, char **clear, char *password ) { - struct rc4_state *st; + struct arc_state *st; unsigned char *key; int key_len, clear_len, i; - key_len = strlen( password ) + RC4_IV_LEN; - clear_len = crypt_len - RC4_IV_LEN; + key_len = strlen( password ) + ARC_IV_LEN; + clear_len = crypt_len - ARC_IV_LEN; if( clear_len < 0 ) { - *clear = (unsigned char*) g_strdup( "" ); + *clear = g_strdup( "" ); return 0; } @@ -172,15 +183,15 @@ int rc4_decode( unsigned char *crypt, int crypt_len, unsigned char **clear, char *clear = g_malloc( clear_len + 1 ); key = g_malloc( key_len ); strcpy( (char*) key, password ); - for( i = 0; i < RC4_IV_LEN; i ++ ) - key[key_len-RC4_IV_LEN+i] = crypt[i]; + for( i = 0; i < ARC_IV_LEN; i ++ ) + key[key_len-ARC_IV_LEN+i] = crypt[i]; /* Generate the initial S[] from the IVed key. */ - st = rc4_keymaker( key, key_len, RC4_CYCLES ); + st = arc_keymaker( key, key_len, ARC_CYCLES ); g_free( key ); for( i = 0; i < clear_len; i ++ ) - clear[0][i] = crypt[i+RC4_IV_LEN] ^ rc4_getbyte( st ); + clear[0][i] = crypt[i+ARC_IV_LEN] ^ arc_getbyte( st ); clear[0][i] = 0; /* Nice to have for plaintexts. */ g_free( st ); @@ -1,9 +1,9 @@ /***************************************************************************\ * * * BitlBee - An IRC to IM gateway * -* Simple (but secure) RC4 implementation for safer password storage. * +* Simple (but secure) ArcFour implementation for safer password storage. * * * -* Copyright 2006 Wilmer van der Gaast <wilmer@gaast.net> * +* Copyright 2007 Wilmer van der Gaast <wilmer@gaast.net> * * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * @@ -22,15 +22,15 @@ \***************************************************************************/ -/* See rc4.c for more information. */ +/* See arc.c for more information. */ -struct rc4_state +struct arc_state { unsigned char S[256]; unsigned char i, j; }; -struct rc4_state *rc4_keymaker( unsigned char *key, int kl, int cycles ); -unsigned char rc4_getbyte( struct rc4_state *st ); -int rc4_encode( unsigned char *clear, int clear_len, unsigned char **crypt, char *password ); -int rc4_decode( unsigned char *crypt, int crypt_len, unsigned char **clear, char *password ); +struct arc_state *arc_keymaker( unsigned char *key, int kl, int cycles ); +unsigned char arc_getbyte( struct arc_state *st ); +int arc_encode( char *clear, int clear_len, unsigned char **crypt, char *password ); +int arc_decode( unsigned char *crypt, int crypt_len, char **clear, char *password ); diff --git a/lib/base64.c b/lib/base64.c index 69069dae..64e9692a 100644 --- a/lib/base64.c +++ b/lib/base64.c @@ -30,10 +30,10 @@ static const char real_b64[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv char *tobase64(const char *text) { - return base64_encode(text, strlen(text)); + return base64_encode((const unsigned char *)text, strlen(text)); } -char *base64_encode(const char *in, int len) +char *base64_encode(const unsigned char *in, int len) { char *out; diff --git a/lib/base64.h b/lib/base64.h index 570f2b14..ebd74bf1 100644 --- a/lib/base64.h +++ b/lib/base64.h @@ -26,7 +26,7 @@ #include <gmodule.h> G_MODULE_EXPORT char *tobase64( const char *text ); -G_MODULE_EXPORT char *base64_encode( const char *in, int len ); +G_MODULE_EXPORT char *base64_encode( const unsigned char *in, int len ); G_MODULE_EXPORT int base64_encode_real( const unsigned char *in, int inlen, unsigned char *out, const char *b64digits ); G_MODULE_EXPORT char *frombase64( const char *in ); G_MODULE_EXPORT int base64_decode( const char *in, unsigned char **out ); @@ -544,3 +544,51 @@ struct ns_srv_reply *srv_lookup( char *service, char *protocol, char *domain ) return reply; } + +/* Word wrapping. Yes, I know this isn't UTF-8 clean. I'm willing to take the risk. */ +char *word_wrap( char *msg, int line_len ) +{ + GString *ret = g_string_sized_new( strlen( msg ) + 16 ); + + while( strlen( msg ) > line_len ) + { + int i; + + /* First try to find out if there's a newline already. Don't + want to add more splits than necessary. */ + for( i = line_len; i > 0 && msg[i] != '\n'; i -- ); + if( msg[i] == '\n' ) + { + g_string_append_len( ret, msg, i + 1 ); + msg += i + 1; + continue; + } + + for( i = line_len; i > 0; i -- ) + { + if( msg[i] == '-' ) + { + g_string_append_len( ret, msg, i + 1 ); + g_string_append_c( ret, '\n' ); + msg += i + 1; + break; + } + else if( msg[i] == ' ' ) + { + g_string_append_len( ret, msg, i ); + g_string_append_c( ret, '\n' ); + msg += i + 1; + break; + } + } + if( i == 0 ) + { + g_string_append_len( ret, msg, line_len ); + g_string_append_c( ret, '\n' ); + msg += line_len; + } + } + g_string_append( ret, msg ); + + return g_string_free( ret, FALSE ); +} @@ -63,4 +63,6 @@ G_MODULE_EXPORT int bool2int( char *value ); G_MODULE_EXPORT struct ns_srv_reply *srv_lookup( char *service, char *protocol, char *domain ); +G_MODULE_EXPORT char *word_wrap( char *msg, int line_len ); + #endif diff --git a/lib/ssl_bogus.c b/lib/ssl_bogus.c index 00aaa7c4..5bae3496 100644 --- a/lib/ssl_bogus.c +++ b/lib/ssl_bogus.c @@ -51,6 +51,11 @@ int ssl_getfd( void *conn ) return( -1 ); } +void *ssl_starttls( int fd, ssl_input_function func, gpointer data ) +{ + return NULL; +} + b_input_condition ssl_getdirection( void *conn ) { return GAIM_INPUT_READ; |