/* $Id: hash.c,v 1.4 2005/05/14 23:20:30 harbourn Exp $
* dcfldd - The Enhanced Forensic DD
* By Nicholas Harbour
*/
/* Copyright (C) 85, 90, 91, 1995-2001, 2005 Free Software Foundation, Inc.
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
the Free Software Foundation; either version 2, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
/* GNU dd originally written by Paul Rubin, David MacKenzie, and Stuart Kemp. */
#include "dcfldd.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include "md5.h"
#include "sha1.h"
#include "sha2.h"
#include "hash.h"
#include "log.h"
hashflag_t hashflags = 0;
/* Md5 global data */
MD5_CTX MD5_total_context;
MD5_CTX MD5_window_context;
MD5_CTX MD5_vtotal_context;
MD5_CTX MD5_vwindow_context;
char MD5_hashstr[MD5_DIGEST_STRING_LENGTH + 1] = {'\0'};
/* SHA1 global data */
SHA1Context SHA1_total_context;
SHA1Context SHA1_window_context;
SHA1Context SHA1_vtotal_context;
SHA1Context SHA1_vwindow_context;
char SHA1_hashstr[SHA1_DIGEST_STRING_LENGTH + 1] = {'\0'};
/* SHA256 global data */
SHA256_CTX SHA256_total_context;
SHA256_CTX SHA256_window_context;
SHA256_CTX SHA256_vtotal_context;
SHA256_CTX SHA256_vwindow_context;
char SHA256_hashstr[SHA256_DIGEST_STRING_LENGTH + 1] = {'\0'};
/* SHA384 global data */
SHA384_CTX SHA384_total_context;
SHA384_CTX SHA384_window_context;
SHA384_CTX SHA384_vtotal_context;
SHA384_CTX SHA384_vwindow_context;
char SHA384_hashstr[SHA384_DIGEST_STRING_LENGTH + 1] = {'\0'};
/* SHA512 global data */
SHA512_CTX SHA512_total_context;
SHA512_CTX SHA512_window_context;
SHA512_CTX SHA512_vtotal_context;
SHA512_CTX SHA512_vwindow_context;
char SHA512_hashstr[SHA512_DIGEST_STRING_LENGTH + 1] = {'\0'};
off_t hash_windowlen = 0;
off_t window_beginning = 0;
off_t bytes_in_window = 0;
off_t bytes_in_total = 0;
void (*hashinit)(void *);
void (*hashupdate)(void *, const void *, size_t);
void (*hashfinal)(void *, void *);
void *hashstr_buf;
size_t hashstr_buf_size;
FILE *hash_log;
/* Hash algorithms */
hashlist_t *ihashlist;
hashtype_t hashops[] =
{
{"md5",
1,
&MD5_window_context,
&MD5_total_context,
&MD5_vwindow_context,
&MD5_vtotal_context,
(void (*)(void *)) MD5Init,
(void (*)(void *, const void *, size_t)) MD5Update,
(void (*)(void *, void *)) MD5Final,
&MD5_hashstr[0],
sizeof (MD5_hashstr),
NULL},
{"sha1",
1<<1,
&SHA1_window_context,
&SHA1_total_context,
&SHA1_vwindow_context,
&SHA1_vtotal_context,
(void (*)(void *)) SHA1Init,
(void (*)(void *, const void *, size_t)) SHA1Update,
(void (*)(void *, void *)) SHA1End,
&SHA1_hashstr[0],
sizeof (SHA1_hashstr),
NULL},
{"sha256",
1<<2,
&SHA256_window_context,
&SHA256_total_context,
&SHA256_vwindow_context,
&SHA256_vtotal_context,
(void (*)(void *)) SHA256_Init,
(void (*)(void *, const void *, size_t)) SHA256_Update,
(void (*)(void *, void *)) SHA256_End,
SHA256_hashstr,
sizeof (SHA256_hashstr),
NULL},
{"sha384",
1<<3,
&SHA384_window_context,
&SHA384_total_context,
&SHA384_vwindow_context,
&SHA384_vtotal_context,
(void (*)(void *)) SHA384_Init,
(void (*)(void *, const void *, size_t)) SHA384_Update,
(void (*)(void *, void *)) SHA384_End,
&SHA384_hashstr[0],
sizeof (SHA384_hashstr),
NULL},
{"sha512",
1<<4,
&SHA512_window_context,
&SHA512_total_context,
&SHA512_vwindow_context,
&SHA512_vtotal_context,
(void (*)(void *)) SHA512_Init,
(void (*)(void *, const void *, size_t)) SHA512_Update,
(void (*)(void *, void *)) SHA512_End,
&SHA512_hashstr[0],
sizeof (SHA512_hashstr),
NULL},
{NULL,
0,
NULL,
NULL,
NULL,
NULL,
(void (*)(void *)) NULL,
(void (*)(void *, const void *, size_t)) NULL,
(void (*)(void *, void *)) NULL,
NULL,
0,
NULL}
};
static void add_hash(hashlist_t **hashlist, int hash)
{
hashlist_t *hlptr = *hashlist;
int i;
if (hlptr == NULL) {
hlptr = malloc(sizeof (hashlist_t));
*hashlist = hlptr;
} else {
for ( ; hlptr->next != NULL; hlptr = hlptr->next)
;
hlptr->next = malloc(sizeof (hashlist_t));
hlptr = hlptr->next;
}
hlptr->next = NULL;
hlptr->hash = &hashops[hash];
}
/* add all the appropriate hashops according to the flags */
void init_hashlist(hashlist_t **hashlist, hashflag_t flags)
{
int i;
for (i = 0; hashops[i].name != NULL; i++)
if (hashops[i].flag & flags)
add_hash(hashlist, i);
}
/* not to be confused with init_hashlist, this function calls
* the hashtype specific init function for each hash type in
* the list */
void hashl_init(hashlist_t *hashlist, int context)
{
hashlist_t *hptr;
for (hptr = hashlist; hptr != NULL; hptr = hptr->next) {
void *ctx;
switch (context) {
case WINDOW_CTX:
ctx = hptr->hash->window_context;
break;
case TOTAL_CTX:
ctx = hptr->hash->total_context;
break;
case VWINDOW_CTX:
ctx = hptr->hash->vwindow_context;
break;
case VTOTAL_CTX:
ctx = hptr->hash->vtotal_context;
break;
default:
internal_error("unreachable branch encountered in hashl_init()");
break;
}
(hptr->hash->init)(ctx);
}
}
void hashl_update(hashlist_t *hashlist, int context, const void *buf, size_t len)
{
hashlist_t *hptr;
for (hptr = hashlist; hptr != NULL; hptr = hptr->next) {
void *ctx;
switch (context) {
case WINDOW_CTX:
ctx = hptr->hash->window_context;
break;
case TOTAL_CTX:
ctx = hptr->hash->total_context;
break;
case VWINDOW_CTX:
ctx = hptr->hash->vwindow_context;
break;
case VTOTAL_CTX:
ctx = hptr->hash->vtotal_context;
break;
default:
internal_error("unreachable branch encountered in hashl_update()");
break;
}
(hptr->hash->update)(ctx, buf, len);
}
}
void hashl_final(hashlist_t *hashlist, int context)
{
hashlist_t *hptr;
for (hptr = hashlist; hptr != NULL; hptr = hptr->next) {
void *ctx;
switch (context) {
case WINDOW_CTX:
ctx = hptr->hash->window_context;
break;
case TOTAL_CTX:
ctx = hptr->hash->total_context;
break;
case VWINDOW_CTX:
ctx = hptr->hash->vwindow_context;
break;
case VTOTAL_CTX:
ctx = hptr->hash->vtotal_context;
break;
default:
internal_error("unreachable branch encountered in hashl_final()");
break;
}
/* note that this writes the hash string to the global buffer
* for the specific hashtype, when calling this multiple times
* (i.e. like in verify) copy that buffer out before finalizing
* another list */
(hptr->hash->final)(ctx, hptr->hash->hashstr_buf);
}
}
void hash_update_buf(hashlist_t *hashlist, int winctx, int ttlctx,
void *buf, size_t len)
{
if (hash_windowlen != 0) {
hashl_update(hashlist, winctx, buf, len);
if (winctx == WINDOW_CTX) /* don't do this for verify or you'll get double */
bytes_in_window += len;
}
hashl_update(hashlist, ttlctx, buf, len);
if(ttlctx == TOTAL_CTX)
bytes_in_total += len;
}
void hash_update(hashlist_t *hashlist, void *buf, size_t len)
{
size_t left_in_window = hash_windowlen - bytes_in_window;
if (bytes_in_total == 0)
hashl_init(hashlist, TOTAL_CTX);
if (hash_windowlen == 0)
hash_update_buf(hashlist, WINDOW_CTX, TOTAL_CTX, buf, len);
else {
if (bytes_in_window == 0)
hashl_init(hashlist, WINDOW_CTX);
if (len >= left_in_window) {
hash_update_buf(hashlist, WINDOW_CTX, TOTAL_CTX, buf, left_in_window);
hashl_final(hashlist, WINDOW_CTX);
display_windowhash(hashlist, hash_windowlen);
window_beginning += hash_windowlen;
bytes_in_window = 0;
hash_update(hashlist, buf + left_in_window, len - left_in_window);
} else
hash_update_buf(hashlist, WINDOW_CTX, TOTAL_CTX, buf, len);
}
}
void display_windowhash(hashlist_t *hashlist, off_t windowlen)
{
hashlist_t *hptr;
for (hptr = hashlist; hptr != NULL; hptr = hptr->next)
log_hashwindow(hptr->hash, window_beginning, (window_beginning + windowlen),
input_blocksize, hptr->hash->hashstr_buf);
}
void display_totalhash(hashlist_t *hashlist, int ttlctx)
{
hashlist_t *hptr;
hashl_final(hashlist, ttlctx);
for (hptr = hashlist; hptr != NULL; hptr = hptr->next)
log_hashtotal(hptr->hash, 0, 0,
input_blocksize, hptr->hash->hashstr_buf);
}
void hash_remainder(hashlist_t *hashlist, int winctx)
{
if (hash_windowlen > 0 && bytes_in_window > 0) {
hashl_final(hashlist, winctx);
display_windowhash(hashlist, bytes_in_window);
}
}
syntax highlighted by Code2HTML, v. 0.9.1