randomart.c File Reference

#include <rz_hash.h>
#include <rz_util.h>

Go to the source code of this file.

Macros
#define	FLDBASE   8
#define	FLDSIZE_Y   (FLDBASE + 1)
#define	FLDSIZE_X   (FLDBASE * 2 + 1)

Functions
RZ_API RZ_OWN char *	rz_hash_cfg_randomart (RZ_NONNULL const ut8 *buffer, ut32 length, ut64 address)
	Generates a randomart that is meant to be an easily validate buffers. More...

Macro Definition Documentation

FLDBASE

#define FLDBASE   8

Definition at line 43 of file randomart.c.

FLDSIZE_X

#define FLDSIZE_X   (FLDBASE * 2 + 1)

Definition at line 45 of file randomart.c.

FLDSIZE_Y

#define FLDSIZE_Y   (FLDBASE + 1)

Definition at line 44 of file randomart.c.

Function Documentation

rz_hash_cfg_randomart()

RZ_API RZ_OWN char* rz_hash_cfg_randomart	(	RZ_NONNULL const ut8 *	buffer,
		ut32	length,
		ut64	address
	)

Generates a randomart that is meant to be an easily validate buffers.

Parameters

buffer	The buffer to use to generate the
length	The buffer length
addr	The location of the hash (when unknown can be set to 0).

Returns

Definition at line 55 of file randomart.c.

                                                                                                   {
    rz_return_val_if_fail(buffer && length > 0, NULL);
    /*
     * Chars to be used after each other every time the worm
     * intersects with itself.  Matter of taste.
     */
    char *augmentation_string = " .o+=*BOX@%&#/^SE";
    char *retval, *p;
    ut8 field[FLDSIZE_X][FLDSIZE_Y];
    ut32 i, b;
    int x, y;
    size_t len = strlen(augmentation_string) - 1;
 
    // 2*(FLDSIZE_X+3) there are two for loops that iterate over this
    // FLDSIZE_Y * (FLDSIZE_X+3) there is a loop that for each y iterates over the whole FLDSIZE_X
    // The rest is counting the +--[0x%08"PFMT64x"]- and '\0'
    retval = calloc(1, 2 * (FLDSIZE_X + 3) + (FLDSIZE_Y * (FLDSIZE_X + 3)) + 7 + sizeof(PFMT64x));
    if (!retval) {
        return NULL;
    }
 
    /* initialize field */
    memset(field, 0, FLDSIZE_X * FLDSIZE_Y * sizeof(char));
    x = FLDSIZE_X / 2;
    y = FLDSIZE_Y / 2;
 
    /* process raw key */
    for (i = 0; i < length; i++) {
        int input;
        /* each byte conveys four 2-bit move commands */
        input = buffer[i];
        for (b = 0; b < 4; b++) {
            /* evaluate 2 bit, rest is shifted later */
            x += (input & 0x1) ? 1 : -1;
            y += (input & 0x2) ? 1 : -1;
 
            /* assure we are still in bounds */
            x = RZ_MAX(x, 0);
            y = RZ_MAX(y, 0);
            x = RZ_MIN(x, FLDSIZE_X - 1);
            y = RZ_MIN(y, FLDSIZE_Y - 1);
 
            /* augment the field */
            if (field[x][y] < len - 2) {
                field[x][y]++;
            }
            input = input >> 2;
        }
    }
 
    /* mark starting point and end point*/
    field[FLDSIZE_X / 2][FLDSIZE_Y / 2] = len - 1;
    field[x][y] = len;
 
    /* fill in retval */
    sprintf(retval, "+--[0x%08" PFMT64x "]-", address);
    p = strchr(retval, '\0');
 
    /* output upper border */
    for (i = p - retval - 1; i < FLDSIZE_X; i++) {
        *p++ = '-';
    }
    *p++ = '+';
    *p++ = '\n';
 
    /* output content */
    for (y = 0; y < FLDSIZE_Y; y++) {
        *p++ = '|';
        for (x = 0; x < FLDSIZE_X; x++) {
            *p++ = augmentation_string[RZ_MIN(field[x][y], len)];
        }
        *p++ = '|';
        *p++ = '\n';
    }
 
    /* output lower border */
    *p++ = '+';
    for (i = 0; i < FLDSIZE_X; i++) {
        *p++ = '-';
    }
    *p++ = '+';
    *p++ = 0;
 
    return retval;
}

References b, calloc(), FLDSIZE_X, FLDSIZE_Y, i, input(), len, length, memset(), NULL, p, PFMT64x, RZ_MAX, RZ_MIN, rz_return_val_if_fail, sprintf, and x.

Referenced by hash_print_digest(), and rz_cmd_print().