monotone

monotone Mtn Source Tree

Root/botan/sha160.cpp

1/*************************************************
2* SHA-160 Source File *
3* (C) 1999-2006 The Botan Project *
4*************************************************/
5
6#include <botan/sha160.h>
7#include <botan/bit_ops.h>
8
9namespace Botan {
10
11namespace {
12
13/*************************************************
14* SHA-160 F1 Function *
15*************************************************/
16inline void F1(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
17 {
18 E += (D ^ (B & (C ^ D))) + msg + 0x5A827999 + rotate_left(A, 5);
19 B = rotate_left(B, 30);
20 }
21
22/*************************************************
23* SHA-160 F2 Function *
24*************************************************/
25inline void F2(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
26 {
27 E += (B ^ C ^ D) + msg + 0x6ED9EBA1 + rotate_left(A, 5);
28 B = rotate_left(B, 30);
29 }
30
31/*************************************************
32* SHA-160 F3 Function *
33*************************************************/
34inline void F3(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
35 {
36 E += ((B & C) | ((B | C) & D)) + msg + 0x8F1BBCDC + rotate_left(A, 5);
37 B = rotate_left(B, 30);
38 }
39
40/*************************************************
41* SHA-160 F4 Function *
42*************************************************/
43inline void F4(u32bit A, u32bit& B, u32bit C, u32bit D, u32bit& E, u32bit msg)
44 {
45 E += (B ^ C ^ D) + msg + 0xCA62C1D6 + rotate_left(A, 5);
46 B = rotate_left(B, 30);
47 }
48
49}
50
51/*************************************************
52* SHA-160 Compression Function *
53*************************************************/
54void SHA_160::hash(const byte input[])
55 {
56 for(u32bit j = 0; j != 16; ++j)
57 W[j] = make_u32bit(input[4*j], input[4*j+1], input[4*j+2], input[4*j+3]);
58 for(u32bit j = 16; j != 80; ++j)
59 W[j] = rotate_left((W[j-3] ^ W[j-8] ^ W[j-14] ^ W[j-16]), 1);
60
61 u32bit A = digest[0], B = digest[1], C = digest[2],
62 D = digest[3], E = digest[4];
63
64 F1(A,B,C,D,E,W[ 0]); F1(E,A,B,C,D,W[ 1]); F1(D,E,A,B,C,W[ 2]);
65 F1(C,D,E,A,B,W[ 3]); F1(B,C,D,E,A,W[ 4]); F1(A,B,C,D,E,W[ 5]);
66 F1(E,A,B,C,D,W[ 6]); F1(D,E,A,B,C,W[ 7]); F1(C,D,E,A,B,W[ 8]);
67 F1(B,C,D,E,A,W[ 9]); F1(A,B,C,D,E,W[10]); F1(E,A,B,C,D,W[11]);
68 F1(D,E,A,B,C,W[12]); F1(C,D,E,A,B,W[13]); F1(B,C,D,E,A,W[14]);
69 F1(A,B,C,D,E,W[15]); F1(E,A,B,C,D,W[16]); F1(D,E,A,B,C,W[17]);
70 F1(C,D,E,A,B,W[18]); F1(B,C,D,E,A,W[19]);
71
72 F2(A,B,C,D,E,W[20]); F2(E,A,B,C,D,W[21]); F2(D,E,A,B,C,W[22]);
73 F2(C,D,E,A,B,W[23]); F2(B,C,D,E,A,W[24]); F2(A,B,C,D,E,W[25]);
74 F2(E,A,B,C,D,W[26]); F2(D,E,A,B,C,W[27]); F2(C,D,E,A,B,W[28]);
75 F2(B,C,D,E,A,W[29]); F2(A,B,C,D,E,W[30]); F2(E,A,B,C,D,W[31]);
76 F2(D,E,A,B,C,W[32]); F2(C,D,E,A,B,W[33]); F2(B,C,D,E,A,W[34]);
77 F2(A,B,C,D,E,W[35]); F2(E,A,B,C,D,W[36]); F2(D,E,A,B,C,W[37]);
78 F2(C,D,E,A,B,W[38]); F2(B,C,D,E,A,W[39]);
79
80 F3(A,B,C,D,E,W[40]); F3(E,A,B,C,D,W[41]); F3(D,E,A,B,C,W[42]);
81 F3(C,D,E,A,B,W[43]); F3(B,C,D,E,A,W[44]); F3(A,B,C,D,E,W[45]);
82 F3(E,A,B,C,D,W[46]); F3(D,E,A,B,C,W[47]); F3(C,D,E,A,B,W[48]);
83 F3(B,C,D,E,A,W[49]); F3(A,B,C,D,E,W[50]); F3(E,A,B,C,D,W[51]);
84 F3(D,E,A,B,C,W[52]); F3(C,D,E,A,B,W[53]); F3(B,C,D,E,A,W[54]);
85 F3(A,B,C,D,E,W[55]); F3(E,A,B,C,D,W[56]); F3(D,E,A,B,C,W[57]);
86 F3(C,D,E,A,B,W[58]); F3(B,C,D,E,A,W[59]);
87
88 F4(A,B,C,D,E,W[60]); F4(E,A,B,C,D,W[61]); F4(D,E,A,B,C,W[62]);
89 F4(C,D,E,A,B,W[63]); F4(B,C,D,E,A,W[64]); F4(A,B,C,D,E,W[65]);
90 F4(E,A,B,C,D,W[66]); F4(D,E,A,B,C,W[67]); F4(C,D,E,A,B,W[68]);
91 F4(B,C,D,E,A,W[69]); F4(A,B,C,D,E,W[70]); F4(E,A,B,C,D,W[71]);
92 F4(D,E,A,B,C,W[72]); F4(C,D,E,A,B,W[73]); F4(B,C,D,E,A,W[74]);
93 F4(A,B,C,D,E,W[75]); F4(E,A,B,C,D,W[76]); F4(D,E,A,B,C,W[77]);
94 F4(C,D,E,A,B,W[78]); F4(B,C,D,E,A,W[79]);
95
96 digest[0] += A; digest[1] += B; digest[2] += C;
97 digest[3] += D; digest[4] += E;
98 }
99
100/*************************************************
101* Copy out the digest *
102*************************************************/
103void SHA_160::copy_out(byte output[])
104 {
105 for(u32bit j = 0; j != OUTPUT_LENGTH; ++j)
106 output[j] = get_byte(j % 4, digest[j/4]);
107 }
108
109/*************************************************
110* Clear memory of sensitive data *
111*************************************************/
112void SHA_160::clear() throw()
113 {
114 MDx_HashFunction::clear();
115 W.clear();
116 digest[0] = 0x67452301;
117 digest[1] = 0xEFCDAB89;
118 digest[2] = 0x98BADCFE;
119 digest[3] = 0x10325476;
120 digest[4] = 0xC3D2E1F0;
121 }
122
123/*************************************************
124* SHA_160 Constructor *
125*************************************************/
126SHA_160::SHA_160() : MDx_HashFunction(20, 64, true, true), W(80)
127 {
128 clear();
129 }
130
131}

Archive Download this file

Branches

Tags

Quick Links:     www.monotone.ca    -     Downloads    -     Documentation    -     Wiki    -     Code Forge    -     Build Status