dnrops
/
radare2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add rahash2 -E to encrypt instead of hash

This commit is contained in:
pancake 2016-03-07 03:24:52 +01:00
parent 00ac90f71b
commit 3f5aa46bd5
5 changed files with 69 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
binr/rahash2/rahash2.c
View File

@ -7,6 +7,7 @@
#include <r_hash.h>
#include <r_util.h>
#include <r_print.h>
#include <r_crypto.h>
#include "../blob/version.c"
static ut64 from = 0LL;
@ -230,7 +231,7 @@ static int do_hash(const char *file, const char *algo, RIO *io, int bsize, int r
}
static int do_help(int line) {
printf ("Usage: rahash2 [-rBhLkv] [-b S] [-a A] [-c H] [-s S] [-f O] [-t O] [file] ...\n");
printf ("Usage: rahash2 [-rBhLkv] [-b S] [-a A] [-c H] [-E A] [-s S] [-f O] [-t O] [file] ...\n");
if (line) return 0;
printf (
" -a algo comma separated list of algorithms (default is 'sha256')\n"
@ -238,10 +239,11 @@ static int do_help(int line) {
" -B show per-block hash\n"
" -c hash compare with this hash\n"
" -e swap endian (use little endian)\n"
" -E algo encrypt (rc4 for now). Use -S to set key\n"
" -d / -D encode/decode base64 string (-s) or file to stdout\n"
" -f from start hashing at given address\n"
" -i num repeat hash N iterations\n"
" -S seed use given seed (hexa or s:string) use ^ to prefix\n"
" -S seed use given seed (hexa or s:string) use ^ to prefix (key for -E)\n"
" -k show hash using the openssh's randomkey algorithm\n"
" -q run in quiet mode (only show results)\n"
" -L list all available algorithms (see -a)\n"
@ -281,6 +283,7 @@ int main(int argc, char **argv) {
int i, ret, c, rad = 0, bsize = 0, numblocks = 0, ule = 0, b64mode = 0;
const char *algo = "sha256"; /* default hashing algorithm */
const char *seed = NULL;
const char *encrypt = NULL;
char *hashstr = NULL;
const char *compareStr = NULL;
ut8 *compareBin = NULL;
@ -290,7 +293,7 @@ int main(int argc, char **argv) {
RHash *ctx;
RIO *io;
while ((c = getopt (argc, argv, "jdDrvea:i:S:s:x:b:nBhf:t:kLqc:")) != -1) {
while ((c = getopt (argc, argv, "jdDrveE:a:i:S:s:x:b:nBhf:t:kLqc:")) != -1) {
switch (c) {
case 'q': quiet = 1; break;
case 'i':
@ -305,6 +308,7 @@ int main(int argc, char **argv) {
case 'n': numblocks = 1; break;
case 'd': b64mode = 1; break;
case 'D': b64mode = 2; break;
case 'E': encrypt = optarg; break;
case 'L': algolist (); return 0;
case 'e': ule = 1; break;
case 'r': rad = 1; break;
@ -410,6 +414,53 @@ int main(int argc, char **argv) {
hashstr_len = to - from;
hashstr[hashstr_len] = '\0';
hashstr_len = r_str_unescape (hashstr);
if (encrypt) {
int seedlen = seed? strlen (seed): 0;
if (seedlen > 0) {
RCrypto *cry = r_crypto_new ();
if (r_crypto_use (cry, encrypt)) {
ut8 *binseed = malloc (seedlen + 1);
if (binseed) {
int len = r_hex_str2bin (seed, binseed);
if (len <1) {
len = seedlen;
strcpy ((char *)binseed, seed);
} else {
seedlen = len;
}
if (r_crypto_set_key (cry, binseed, seedlen, 0, 0)) {
if (hashstr) {
const char *buf = hashstr;
int buflen = hashstr_len;
r_crypto_update (cry, (const ut8*)buf, buflen);
r_crypto_final (cry, NULL, 0);
int result_size = 0;
ut8 *result = r_crypto_get_output (cry, &result_size);
if (result) {
write (1, result, result_size);
free (result);
}
}
} else {
eprintf ("Invalid key\n");
}
free (binseed);
return 0;
} else {
eprintf ("Cannot allocate %d bytes\n", seedlen);
}
} else {
eprintf ("Unknown encryption algorithm '%s'\n", encrypt);
}
r_crypto_free (cry);
} else {
eprintf ("Encryption key not defined. Use -S [key]\n");
}
return 1;
} else
switch (b64mode) {
case 1: // encode
{

8
libr/crypto/crypto.c
View File

@ -49,7 +49,7 @@ R_API struct r_crypto_t *r_crypto_new() {
R_API struct r_crypto_t *r_crypto_as_new(struct r_crypto_t *cry) {
RCrypto *c = R_NEW0 (RCrypto);
if (c != NULL) {
if (c) {
r_crypto_init (c, false); // soft init
memcpy (&c->plugins, &cry->plugins, sizeof (cry->plugins));
}
@ -70,7 +70,7 @@ R_API bool r_crypto_use(RCrypto *cry, const char *algo) {
RListIter *iter;
RCryptoPlugin *h;
r_list_foreach (cry->plugins, iter, h) {
if (h->use (algo)) {
if (h && h->use && h->use (algo)) {
cry->h = h;
cry->key_len = h->get_key_size (cry);
cry->key = calloc (1, cry->key_len);
@ -98,12 +98,12 @@ R_API int r_crypto_set_iv(RCrypto *cry, const ut8 *iv) {
}
// return the number of bytes written in the output buffer
R_API int r_crypto_update(RCrypto *cry, ut8 *buf, int len) {
R_API int r_crypto_update(RCrypto *cry, const ut8 *buf, int len) {
return (cry && cry->h && cry->h->update)?
cry->h->update (cry, buf, len): 0;
}
R_API int r_crypto_final(RCrypto *cry, ut8 *buf, int len) {
R_API int r_crypto_final(RCrypto *cry, const ut8 *buf, int len) {
return (cry && cry->h && cry->h->final)?
cry->h->final (cry, buf, len): 0;
}

9
libr/crypto/p/crypto_rc4.c
View File

@ -24,10 +24,13 @@ static __inline void swap_bytes(ut8 *a, ut8 *b) {
* which can have arbitrary length.
*/
static void rc4_init(struct rc4_state *const state, const ut8 *key, int keylen) {
static bool rc4_init(struct rc4_state *const state, const ut8 *key, int keylen) {
ut8 j;
int i;
if (!state || !key || keylen < 1) {
return false;
}
state->key_size = keylen;
/* Initialize state with identity permutation */
for (i = 0; i < 256; i++)
@ -40,6 +43,7 @@ static void rc4_init(struct rc4_state *const state, const ut8 *key, int keylen)
j += state->perm[i] + key[i % keylen];
swap_bytes (&state->perm[i], &state->perm[j]);
}
return true;
}
/*
@ -70,8 +74,7 @@ static void rc4_crypt(struct rc4_state *const state, const ut8 *inbuf, ut8 *outb
static struct rc4_state st;
static int rc4_set_key(RCrypto *cry, const ut8 *key, int keylen, int mode, int direction) {
rc4_init (&st, key, keylen);
return true;
return rc4_init (&st, key, keylen);
}
static int rc4_get_key_size(RCrypto *cry) {

4
libr/include/r_crypto.h
View File

@ -54,8 +54,8 @@ R_API RCrypto *r_crypto_free(RCrypto *cry);
R_API bool r_crypto_use(RCrypto *cry, const char *algo);
R_API int r_crypto_set_key(RCrypto *cry, const ut8* key, int keylen, int mode, int direction);
R_API int r_crypto_set_iv(RCrypto *cry, const ut8 *iv);
R_API int r_crypto_update(RCrypto *cry, ut8 *buf, int len);
R_API int r_crypto_final(RCrypto *cry, ut8 *buf, int len);
R_API int r_crypto_update(RCrypto *cry, const ut8 *buf, int len);
R_API int r_crypto_final(RCrypto *cry, const ut8 *buf, int len);
R_API int r_crypto_append(RCrypto *cry, const ut8 *buf, int len);
R_API ut8 *r_crypto_get_output(RCrypto *cry, int *size);
#endif

3
man/rahash2.1
View File

@ -8,6 +8,7 @@
.Op Fl BdDehjrkv
.Op Fl a Ar algorithm
.Op Fl b Ar size
.Op Fl E Ar algo
.Op Fl s Ar string
.Op Fl i Ar iterations
.Op Fl S Ar seed
@ -39,6 +40,8 @@ encoDe base64 string or file
Decode base64 string or file
.It Fl e
Use little endian to display checksums
.It Fl E Ar algo
Encrypt instead of hash using the given algorithm (rc4, aes)
.It Fl i Ar iters
Apply the hash Iters times to itself+seed
.It Fl j