"{ Encoding: utf8 }"

"

 COPYRIGHT (c) 1999-2013 by eXept Software AG

	      All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:libbasic' }"

"{ NameSpace: Smalltalk }"

HashStream subclass:#SHA1Stream

	instanceVariableNames:'hashContext'

	classVariableNames:'HashSize ContextSize'

	poolDictionaries:''

	category:'System-Crypt-Hashing'

!

!SHA1Stream primitiveDefinitions!

%{

#if defined(__LSBFIRST) || defined(__LSBFIRST__)

# ifndef LITTLE_ENDIAN

#  define LITTLE_ENDIAN /* This should be #define'd if true. */

# endif

#endif

#define SHA1HANDSOFF /* Copies data before messing with it. */

#ifndef _STDIO_H_INCLUDED_

# include <stdio.h>

# define _STDIO_H_INCLUDED_

#endif

#ifndef _STRING_H_INCLUDED_

# include <string.h>

# define _STRING_H_INCLUDED_

#endif

typedef struct {

    unsigned int32 state[5];

    unsigned int32 count[2];

    unsigned char buffer[64];

} SHA1_CTX;

#if (defined(__GNUC__) || defined(__CLANG__))

# define STATIC_INLINE static inline

#else

# define STATIC_INLINE static

#endif

#if (defined(__GNUC__) || defined(__CLANG__))

# if (defined(__SSE4_1__) && defined(__SHA__))

#  if __SSE4_1__ && __SHA__

// # define __SSE4_1__ 1

// # define __SHA__    1

#   include <immintrin.h>

 static void SHA1Transform(unsigned int32 state[5], unsigned char buffer[64]);

 // static void __attribute__ ((__target__ ("sha,sse4.1"))) SHA1Transform_x86(unsigned int32 state[5], unsigned char buffer[64]);

 static void SHA1Transform_x86(unsigned int32 state[5], unsigned char buffer[64]);

#   define USE_SHA_INTRINSICS

#  endif

# endif

#endif

#ifndef USE_SHA_INTRINSICS

# define SHA1Transform SHA1Transform_generic

#endif

#if USE_ANSI_C

 static void SHA1Transform_generic(unsigned int32 state[5], unsigned char buffer[64]);

 STATIC_INLINE void SHA1Init(SHA1_CTX* context);

 void SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len);

 void SHA1Final(unsigned char digest[20], SHA1_CTX* context);

#else /* general: compiles everywhere */

# define SHA1Init   __SHA1Init

# define SHA1Update __SHA1Update

# define SHA1Final  __SHA2Final

STATIC_INLINE void SHA1Init();

 void SHA1Update();

 void SHA1Final();

#endif /* USE_ANSI_C */

%}

! !

!SHA1Stream primitiveFunctions!

%{

/*

 * SHA-1 in C

 * By Steve Reid <steve@edmweb.com>

 * 100% Public Domain

 */

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

/* blk0() and blk() perform the initial expand. */

/* I got the idea of expanding during the round function from SSLeay */

// 876543210 -> rol,24 -> 108765432 -> & -> 10xx65xx

// 876543210 -> rol,8  -> 654321087 -> & -> xx43xx87

// oring: 10436587

#ifdef LITTLE_ENDIAN

// cg: does not make any difference (actually, slightly slower, as it seems)...

# if 0 && (defined(__i386__) || defined(__x86__) || defined(__x86_64__)) && (defined(__GNUC__) || defined(__CLANG__))

   static inline u_int32_t __bswap(u_int32_t v) {

	register u_int32_t l = v;

	__asm__ __volatile__("bswap %0" : "=r" (l) : "0" (l));

	return l;

   }

#  define blk0(i) \

    (block->l[i] = __bswap(block->l[i]))

# else

#  define blk0(i) \

    (block->l[i] = (rol(block->l[i],24)&0xFF00FF00) \

		  |(rol(block->l[i],8)&0x00FF00FF))

# endif

#else

# define blk0(i) block->l[i]

#endif

#define blk(i) (block->l[i&15] = \

    rol(block->l[(i+13)&15] \

	^ block->l[(i+8)&15] \

	^ block->l[(i+2)&15] \

	^ block->l[i&15],1))

/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */

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

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

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

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

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

/*

 * Hash a single 512-bit block. This is the core of the algorithm.

 */

static void

#if USE_ANSI_C

SHA1Transform_generic (unsigned int32 state[5], unsigned char buffer[64])

#else

SHA1Transform_generic (state, buffer)

    unsigned int32 state[5];

    unsigned char buffer[64];

#endif

{

    unsigned int32 a, b, c, d, e;

    typedef union {

	unsigned char c[64];

	unsigned int32 /* long */ l[16];

    } CHAR64LONG16;

    CHAR64LONG16* block;

#ifdef SHA1HANDSOFF

    static unsigned char workspace[64];

    block = (CHAR64LONG16*)workspace;

    memcpy(block, buffer, 64);

#else

    block = (CHAR64LONG16*)buffer;

#endif

    /* Copy context->state[] to working vars */

    a = state[0];

    b = state[1];

    c = state[2];

    d = state[3];

    e = 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 vars back into context.state[] */

    state[0] += a;

    state[1] += b;

    state[2] += c;

    state[3] += d;

    state[4] += e;

    /* Wipe variables */

    a = b = c = d = e = 0;

}

#if defined(USE_SHA_INTRINSICS)

//

// a specially tuned version

//

static void

SHA1Transform_x86 (unsigned int32 state[5], unsigned char buffer[64])

{

    unsigned int32 a, b, c, d, e;

    typedef union {

	unsigned char c[64];

	unsigned int32 /* long */ l[16];

    } CHAR64LONG16;

    CHAR64LONG16* block;

#ifdef SHA1HANDSOFF

    static unsigned char workspace[64];

    block = (CHAR64LONG16*)workspace;

    memcpy(block, buffer, 64);

#else

    block = (CHAR64LONG16*)buffer;

#endif

    __m128i ABCD, ABCD_SAVE, E0, E0_SAVE, E1;

    __m128i MSG0, MSG1, MSG2, MSG3;

    const __m128i MASK = _mm_set_epi64x(0x0001020304050607ULL, 0x08090a0b0c0d0e0fULL);

    /* Load initial values */

    ABCD = _mm_loadu_si128((const __m128i*) state);

    E0 = _mm_set_epi32(state[4], 0, 0, 0);

    ABCD = _mm_shuffle_epi32(ABCD, 0x1B);

	/* Save current state  */

	ABCD_SAVE = ABCD;

	E0_SAVE = E0;

	/* Rounds 0-3 */

	MSG0 = _mm_loadu_si128((const __m128i*)(block + 0));

	MSG0 = _mm_shuffle_epi8(MSG0, MASK);

	E0 = _mm_add_epi32(E0, MSG0);

	E1 = ABCD;

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0);

	/* Rounds 4-7 */

	MSG1 = _mm_loadu_si128((const __m128i*)(block + 16));

	MSG1 = _mm_shuffle_epi8(MSG1, MASK);

	E1 = _mm_sha1nexte_epu32(E1, MSG1);

	E0 = ABCD;

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 0);

	MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);

	/* Rounds 8-11 */

	MSG2 = _mm_loadu_si128((const __m128i*)(block + 32));

	MSG2 = _mm_shuffle_epi8(MSG2, MASK);

	E0 = _mm_sha1nexte_epu32(E0, MSG2);

	E1 = ABCD;

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0);

	MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);

	MSG0 = _mm_xor_si128(MSG0, MSG2);

	/* Rounds 12-15 */

	MSG3 = _mm_loadu_si128((const __m128i*)(block + 48));

	MSG3 = _mm_shuffle_epi8(MSG3, MASK);

	E1 = _mm_sha1nexte_epu32(E1, MSG3);

	E0 = ABCD;

	MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 0);

	MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);

	MSG1 = _mm_xor_si128(MSG1, MSG3);

	/* Rounds 16-19 */

	E0 = _mm_sha1nexte_epu32(E0, MSG0);

	E1 = ABCD;

	MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 0);

	MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);

	MSG2 = _mm_xor_si128(MSG2, MSG0);

	/* Rounds 20-23 */

	E1 = _mm_sha1nexte_epu32(E1, MSG1);

	E0 = ABCD;

	MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1);

	MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);

	MSG3 = _mm_xor_si128(MSG3, MSG1);

	/* Rounds 24-27 */

	E0 = _mm_sha1nexte_epu32(E0, MSG2);

	E1 = ABCD;

	MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 1);

	MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);

	MSG0 = _mm_xor_si128(MSG0, MSG2);

	/* Rounds 28-31 */

	E1 = _mm_sha1nexte_epu32(E1, MSG3);

	E0 = ABCD;

	MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1);

	MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);

	MSG1 = _mm_xor_si128(MSG1, MSG3);

	/* Rounds 32-35 */

	E0 = _mm_sha1nexte_epu32(E0, MSG0);

	E1 = ABCD;

	MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 1);

	MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);

	MSG2 = _mm_xor_si128(MSG2, MSG0);

	/* Rounds 36-39 */

	E1 = _mm_sha1nexte_epu32(E1, MSG1);

	E0 = ABCD;

	MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 1);

	MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);

	MSG3 = _mm_xor_si128(MSG3, MSG1);

	/* Rounds 40-43 */

	E0 = _mm_sha1nexte_epu32(E0, MSG2);

	E1 = ABCD;

	MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2);

	MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);

	MSG0 = _mm_xor_si128(MSG0, MSG2);

	/* Rounds 44-47 */

	E1 = _mm_sha1nexte_epu32(E1, MSG3);

	E0 = ABCD;

	MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 2);

	MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);

	MSG1 = _mm_xor_si128(MSG1, MSG3);

	/* Rounds 48-51 */

	E0 = _mm_sha1nexte_epu32(E0, MSG0);

	E1 = ABCD;

	MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2);

	MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);

	MSG2 = _mm_xor_si128(MSG2, MSG0);

	/* Rounds 52-55 */

	E1 = _mm_sha1nexte_epu32(E1, MSG1);

	E0 = ABCD;

	MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 2);

	MSG0 = _mm_sha1msg1_epu32(MSG0, MSG1);

	MSG3 = _mm_xor_si128(MSG3, MSG1);

	/* Rounds 56-59 */

	E0 = _mm_sha1nexte_epu32(E0, MSG2);

	E1 = ABCD;

	MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 2);

	MSG1 = _mm_sha1msg1_epu32(MSG1, MSG2);

	MSG0 = _mm_xor_si128(MSG0, MSG2);

	/* Rounds 60-63 */

	E1 = _mm_sha1nexte_epu32(E1, MSG3);

	E0 = ABCD;

	MSG0 = _mm_sha1msg2_epu32(MSG0, MSG3);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3);

	MSG2 = _mm_sha1msg1_epu32(MSG2, MSG3);

	MSG1 = _mm_xor_si128(MSG1, MSG3);

	/* Rounds 64-67 */

	E0 = _mm_sha1nexte_epu32(E0, MSG0);

	E1 = ABCD;

	MSG1 = _mm_sha1msg2_epu32(MSG1, MSG0);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 3);

	MSG3 = _mm_sha1msg1_epu32(MSG3, MSG0);

	MSG2 = _mm_xor_si128(MSG2, MSG0);

	/* Rounds 68-71 */

	E1 = _mm_sha1nexte_epu32(E1, MSG1);

	E0 = ABCD;

	MSG2 = _mm_sha1msg2_epu32(MSG2, MSG1);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3);

	MSG3 = _mm_xor_si128(MSG3, MSG1);

	/* Rounds 72-75 */

	E0 = _mm_sha1nexte_epu32(E0, MSG2);

	E1 = ABCD;

	MSG3 = _mm_sha1msg2_epu32(MSG3, MSG2);

	ABCD = _mm_sha1rnds4_epu32(ABCD, E0, 3);

	/* Rounds 76-79 */

	E1 = _mm_sha1nexte_epu32(E1, MSG3);

	E0 = ABCD;

	ABCD = _mm_sha1rnds4_epu32(ABCD, E1, 3);

	/* Combine state */

	E0 = _mm_sha1nexte_epu32(E0, E0_SAVE);

	ABCD = _mm_add_epi32(ABCD, ABCD_SAVE);

    /* Save state */

    ABCD = _mm_shuffle_epi32(ABCD, 0x1B);

    _mm_storeu_si128((__m128i*) state, ABCD);

    state[4] = _mm_extract_epi32(E0, 3);

}

static void

#if USE_ANSI_C

SHA1Transform(unsigned int32 state[5], unsigned char buffer[64])

#else

SHA1Transform(state, buffer)

    unsigned int32 state[5];

    unsigned char buffer[64];

#endif

{

    extern unsigned char __cpu_hasSSE4_1_and_SHA;

    if (__cpu_hasSSE4_1_and_SHA) {

	SHA1Transform_x86(state, buffer);

    } else {

	SHA1Transform_generic(state, buffer);

    }

}

#endif

/*

 * SHA1Init - Initialize new context

 */

STATIC_INLINE void

#if USE_ANSI_C

SHA1Init(SHA1_CTX* context)

#else

SHA1Init(context)

    SHA1_CTX* context;

#endif

{

    /* SHA1 initialization constants */

    context->state[0] = 0x67452301;

    context->state[1] = 0xEFCDAB89;

    context->state[2] = 0x98BADCFE;

    context->state[3] = 0x10325476;

    context->state[4] = 0xC3D2E1F0;

    context->count[0] = context->count[1] = 0;

}

/*

 * Run your data through this.

 */

void

#if USE_ANSI_C

SHA1Update(SHA1_CTX* context, unsigned char* data, unsigned int len)

#else

SHA1Update(context, data, len)

    SHA1_CTX* context;

    unsigned char* data;

    unsigned int len;

#endif

{

    unsigned int i, j;

    j = (context->count[0] >> 3) & 63;

    if ((context->count[0] += len << 3) < (len << 3)) context->count[1]++;

    context->count[1] += (len >> 29);

    if ((j + len) > 63) {

	memcpy(&context->buffer[j], data, (i = 64-j));

	SHA1Transform(context->state, context->buffer);

	for ( ; i + 63 < len; i += 64) {

	    SHA1Transform(context->state, &data[i]);

	}

	j = 0;

    }

    else i = 0;

    memcpy(&context->buffer[j], &data[i], len - i);

}

/*

 * Add padding and return the message digest.

 */

void

#if USE_ANSI_C

SHA1Final(unsigned char digest[20], SHA1_CTX* context)

#else

SHA1Final(digest, context)

    unsigned char digest[20];

    SHA1_CTX* context;

#endif

{

    unsigned int32 i, j;

    unsigned char finalcount[8];