hash.c File Reference

#include <stdio.h>
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "widltypes.h"
#include "hash.h"

Include dependency graph for hash.c:

Go to the source code of this file.

Macros
#define	DWORD2BE(x)   ((((x) >> 24) & 0xff) | (((x) >> 8) & 0xff00) | (((x) << 8) & 0xff0000) | (((x) << 24) & 0xff000000))
#define	rol(value, bits)   (((value) << (bits)) | ((value) >> (32 - (bits))))
#define	blk0(i)   (block[i] = DWORD2BE(block[i]))
#define	blk1(i)   (block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15]^block[(i+2)&15]^block[i&15],1))
#define	f1(x, y, z)   (z^(x&(y^z)))
#define	f2(x, y, z)   (x^y^z)
#define	f3(x, y, z)   ((x&y)|(z&(x|y)))
#define	f4(x, y, z)   (x^y^z)
#define	R0(v, w, x, y, z, i)   z+=f1(w,x,y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define	R1(v, w, x, y, z, i)   z+=f1(w,x,y)+blk1(i)+0x5A827999+rol(v,5);w=rol(w,30);
#define	R2(v, w, x, y, z, i)   z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
#define	R3(v, w, x, y, z, i)   z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
#define	R4(v, w, x, y, z, i)   z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);

Functions
unsigned int	lhash_val_of_name_sys (syskind_t skind, int lcid, const char *lpStr)
static void	sha1_transform (struct sha1_context *ctx)
void	sha1_init (struct sha1_context *ctx)
void	sha1_update (struct sha1_context *ctx, const char *data, size_t data_size)
void	sha1_finalize (struct sha1_context *ctx, unsigned int result[5])

Variables
static const unsigned char	Lookup_16 [128 *3]
static const unsigned char	Lookup_32 [128 *3]
static const unsigned char	Lookup_48 [128 *3]
static const unsigned char	Lookup_64 [128 *3]
static const unsigned char	Lookup_80 [128 *3]
static const unsigned char	Lookup_112 [128 *3]
static const unsigned char	Lookup_128 [128 *3]
static const unsigned char	Lookup_144 [128 *3]
static const unsigned char	Lookup_160 [128 *3]
static const unsigned char	Lookup_176 [128 *3]
static const unsigned char	Lookup_208 [128 *3]
static const unsigned char	Lookup_224 [128 *3]

Macro Definition Documentation

blk0

#define blk0

(

i

)

(block[i] = DWORD2BE(block[i]))

Definition at line 608 of file hash.c.

blk1

#define blk1

(

i

)

(block[i&15] = rol(block[(i+13)&15]^block[(i+8)&15]^block[(i+2)&15]^block[i&15],1))

Definition at line 609 of file hash.c.

DWORD2BE

#define DWORD2BE

(

x

)

((((x) >> 24) & 0xff) | (((x) >> 8) & 0xff00) | (((x) << 8) & 0xff0000) | (((x) << 24) & 0xff000000))

Definition at line 604 of file hash.c.

f1

#define f1	(		x,
			y,
			z
	)		(z^(x&(y^z)))

Definition at line 610 of file hash.c.

f2

#define f2	(		x,
			y,
			z
	)		(x^y^z)

Definition at line 611 of file hash.c.

f3

#define f3	(		x,
			y,
			z
	)		((x&y)|(z&(x|y)))

Definition at line 612 of file hash.c.

f4

#define f4	(		x,
			y,
			z
	)		(x^y^z)

Definition at line 613 of file hash.c.

R0

#define R0	(		v,
			w,
			x,
			y,
			z,
			i
	)		z+=f1(w,x,y)+blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);

Definition at line 615 of file hash.c.

R1

#define R1	(		v,
			w,
			x,
			y,
			z,
			i
	)		z+=f1(w,x,y)+blk1(i)+0x5A827999+rol(v,5);w=rol(w,30);

Definition at line 616 of file hash.c.

R2

#define R2	(		v,
			w,
			x,
			y,
			z,
			i
	)		z+=f2(w,x,y)+blk1(i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);

Definition at line 617 of file hash.c.

R3

#define R3	(		v,
			w,
			x,
			y,
			z,
			i
	)		z+=f3(w,x,y)+blk1(i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);

Definition at line 618 of file hash.c.

R4

#define R4	(		v,
			w,
			x,
			y,
			z,
			i
	)		z+=f4(w,x,y)+blk1(i)+0xCA62C1D6+rol(v,5);w=rol(w,30);

Definition at line 619 of file hash.c.

rol

#define rol	(		value,
			bits
	)		(((value) << (bits)) | ((value) >> (32 - (bits))))

Definition at line 607 of file hash.c.

Function Documentation

lhash_val_of_name_sys()

unsigned int lhash_val_of_name_sys	(	syskind_t	skind,
		int	lcid,
		const char *	lpStr
	)

Definition at line 511 of file hash.c.

{
  unsigned int nOffset, nMask = skind == SYS_MAC ? 1 : 0;
  unsigned int nHiWord, nLoWord = 0x0deadbee;
  const unsigned char *str = (const unsigned char *)lpStr, *pnLookup = NULL;
 
  if (!str)
    return 0;
 
  switch (PRIMARYLANGID(LANGIDFROMLCID(lcid)))
  {
  default:
    nOffset = 16;
    pnLookup = Lookup_16;
    break;
  case LANG_CZECH:  case LANG_HUNGARIAN:  case LANG_POLISH:
  case LANG_SLOVAK: case LANG_SPANISH:
    nOffset = 32;
    pnLookup = Lookup_32;
    break;
  case LANG_HEBREW:
    nOffset = 48;
    pnLookup = Lookup_48;
    break;
  case LANG_JAPANESE:
    nOffset = 64;
    pnLookup = Lookup_64;
    break;
  case LANG_KOREAN:
    nOffset = 80;
    pnLookup = Lookup_80;
    break;
  case LANG_CHINESE:
    nOffset = 112;
    pnLookup = Lookup_112;
    break;
  case LANG_GREEK:
    nOffset = 128;
    pnLookup = Lookup_128;
    break;
  case LANG_ICELANDIC:
    nOffset = 144;
    pnLookup = Lookup_144;
    break;
  case LANG_TURKISH:
    nOffset = 160;
    pnLookup = Lookup_160;
    break;
  case LANG_NORWEGIAN:
    if (SUBLANGID(LANGIDFROMLCID(lcid)) == SUBLANG_NORWEGIAN_NYNORSK)
    {
      nOffset = 176;
      pnLookup = Lookup_176;
    }
    else
    {
      nOffset = 16;
      pnLookup = Lookup_16;
    }
    break;
  case LANG_ARABIC:
  case LANG_FARSI:
    nOffset = 208;
    pnLookup = Lookup_208;
    break;
  case LANG_RUSSIAN:
    nOffset = 224;
    pnLookup = Lookup_224;
    break;
  }
 
  nHiWord = (nOffset | nMask) << 16;
 
  while (*str)
  {
    nLoWord = 37 * nLoWord + pnLookup[*str > 0x7f && nMask ? *str + 0x80 : *str];
    str++;
  }
  /* Constrain to a prime modulo and sizeof(WORD) */
  nLoWord = (nLoWord % 65599) & 0xffff;
 
  return nHiWord | nLoWord;
}

Referenced by ctl2_encode_name().

sha1_finalize()

void sha1_finalize	(	struct sha1_context *	ctx,
		unsigned int	result[5]
	)

Definition at line 703 of file hash.c.

{
   unsigned int *count, length_hi, length_lo, i;
   size_t pad_size, buffer_size;
   char pad[72];
 
   buffer_size = ctx->count[1] & 63;
   if (buffer_size >= 56) pad_size = 56 + 64 - buffer_size;
   else pad_size = 56 - buffer_size;
 
   length_hi = (ctx->count[0] << 3) | (ctx->count[1] >> (32 - 3));
   length_lo = (ctx->count[1] << 3);
 
   memset(pad + 1, 0, pad_size - 1);
   pad[0] = 0x80;
   count = (unsigned int*)(pad + pad_size);
   count[0] = DWORD2BE(length_hi);
   count[1] = DWORD2BE(length_lo);
   sha1_update(ctx, pad, pad_size + 8);
 
   for (i = 0; i < 5; i++) result[i] = DWORD2BE(ctx->state[i]);
 
   sha1_init(ctx);
}

Referenced by compute_interface_signature_uuid().

sha1_init()

void sha1_init

(

struct sha1_context *

ctx

)

Definition at line 666 of file hash.c.

{
   /* SHA1 initialization constants */
   ctx->state[0] = 0x67452301;
   ctx->state[1] = 0xEFCDAB89;
   ctx->state[2] = 0x98BADCFE;
   ctx->state[3] = 0x10325476;
   ctx->state[4] = 0xC3D2E1F0;
   ctx->count[0] = 0;
   ctx->count[1] = 0;
}

sha1_transform()

static void sha1_transform ( struct sha1_context *  ctx )

static

Definition at line 622 of file hash.c.

{
   unsigned int a, b, c, d, e, *block = (unsigned int *)ctx->buffer;
 
   /* Copy ctx->state[] to working variables */
   a = ctx->state[0];
   b = ctx->state[1];
   c = ctx->state[2];
   d = ctx->state[3];
   e = ctx->state[4];
 
   /* 4 rounds of 20 operations each. Loop unrolled. */
   R0(a,b,c,d,e, 0); R0(e,a,b,c,d, 1); R0(d,e,a,b,c, 2); R0(c,d,e,a,b, 3);
   R0(b,c,d,e,a, 4); R0(a,b,c,d,e, 5); R0(e,a,b,c,d, 6); R0(d,e,a,b,c, 7);
   R0(c,d,e,a,b, 8); R0(b,c,d,e,a, 9); R0(a,b,c,d,e,10); R0(e,a,b,c,d,11);
   R0(d,e,a,b,c,12); R0(c,d,e,a,b,13); R0(b,c,d,e,a,14); R0(a,b,c,d,e,15);
   R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
   R2(a,b,c,d,e,20); R2(e,a,b,c,d,21); R2(d,e,a,b,c,22); R2(c,d,e,a,b,23);
   R2(b,c,d,e,a,24); R2(a,b,c,d,e,25); R2(e,a,b,c,d,26); R2(d,e,a,b,c,27);
   R2(c,d,e,a,b,28); R2(b,c,d,e,a,29); R2(a,b,c,d,e,30); R2(e,a,b,c,d,31);
   R2(d,e,a,b,c,32); R2(c,d,e,a,b,33); R2(b,c,d,e,a,34); R2(a,b,c,d,e,35);
   R2(e,a,b,c,d,36); R2(d,e,a,b,c,37); R2(c,d,e,a,b,38); R2(b,c,d,e,a,39);
   R3(a,b,c,d,e,40); R3(e,a,b,c,d,41); R3(d,e,a,b,c,42); R3(c,d,e,a,b,43);
   R3(b,c,d,e,a,44); R3(a,b,c,d,e,45); R3(e,a,b,c,d,46); R3(d,e,a,b,c,47);
   R3(c,d,e,a,b,48); R3(b,c,d,e,a,49); R3(a,b,c,d,e,50); R3(e,a,b,c,d,51);
   R3(d,e,a,b,c,52); R3(c,d,e,a,b,53); R3(b,c,d,e,a,54); R3(a,b,c,d,e,55);
   R3(e,a,b,c,d,56); R3(d,e,a,b,c,57); R3(c,d,e,a,b,58); R3(b,c,d,e,a,59);
   R4(a,b,c,d,e,60); R4(e,a,b,c,d,61); R4(d,e,a,b,c,62); R4(c,d,e,a,b,63);
   R4(b,c,d,e,a,64); R4(a,b,c,d,e,65); R4(e,a,b,c,d,66); R4(d,e,a,b,c,67);
   R4(c,d,e,a,b,68); R4(b,c,d,e,a,69); R4(a,b,c,d,e,70); R4(e,a,b,c,d,71);
   R4(d,e,a,b,c,72); R4(c,d,e,a,b,73); R4(b,c,d,e,a,74); R4(a,b,c,d,e,75);
   R4(e,a,b,c,d,76); R4(d,e,a,b,c,77); R4(c,d,e,a,b,78); R4(b,c,d,e,a,79);
 
   /* Add the working variables back into ctx->state[] */
   ctx->state[0] += a;
   ctx->state[1] += b;
   ctx->state[2] += c;
   ctx->state[3] += d;
   ctx->state[4] += e;
 
   /* Wipe variables */
   a = b = c = d = e = 0;
}

Referenced by sha1_update().

sha1_update()

void sha1_update	(	struct sha1_context *	ctx,
		const char *	data,
		size_t	data_size
	)

Definition at line 678 of file hash.c.

{
   size_t buffer_size;
 
   buffer_size = ctx->count[1] & 63;
   ctx->count[1] += data_size;
   if (ctx->count[1] < data_size) ctx->count[0]++;
   ctx->count[0] += (data_size >> 29);
 
   if (buffer_size + data_size < 64)
      memcpy(&ctx->buffer[buffer_size], data, data_size);
   else
   {
      while (buffer_size + data_size >= 64)
      {
         memcpy(ctx->buffer + buffer_size, data, 64 - buffer_size);
         data += 64 - buffer_size;
         data_size -= 64 - buffer_size;
         sha1_transform(ctx);
         buffer_size = 0;
      }
      memcpy(ctx->buffer + buffer_size, data, data_size);
   }
}

Variable Documentation

Lookup_112

const unsigned char Lookup_112[128 *3]

static

Definition at line 225 of file hash.c.

Lookup_128

const unsigned char Lookup_128[128 *3]

static

Definition at line 263 of file hash.c.

Lookup_144

const unsigned char Lookup_144[128 *3]

static

Definition at line 301 of file hash.c.

Lookup_16

const unsigned char Lookup_16[128 *3]

static

Definition at line 36 of file hash.c.

Lookup_160

const unsigned char Lookup_160[128 *3]

static

Definition at line 339 of file hash.c.

Lookup_176

const unsigned char Lookup_176[128 *3]

static

Definition at line 377 of file hash.c.

Lookup_208

const unsigned char Lookup_208[128 *3]

static

Definition at line 415 of file hash.c.

Lookup_224

const unsigned char Lookup_224[128 *3]

static

Definition at line 453 of file hash.c.

Lookup_32

const unsigned char Lookup_32[128 *3]

static

Definition at line 74 of file hash.c.

Lookup_48

const unsigned char Lookup_48[128 *3]

static

Definition at line 112 of file hash.c.

Lookup_64

const unsigned char Lookup_64[128 *3]

static

Definition at line 150 of file hash.c.

Lookup_80

const unsigned char Lookup_80[128 *3]

static

Definition at line 187 of file hash.c.