monotone

monotone Mtn Source Tree

Root/botan/sha160.cpp

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

Archive Download this file

Branches

Tags

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