53 {
54 reset();
55 }
56
57 void SHA1::update(const std::string& s) {
58 std::istringstream is(s);
59 update(is);
60 }
61
62 void SHA1::update(std::istream& is) {
63 std::string rest_of_buffer;
64 read(is, rest_of_buffer,
static_cast<std::size_t
>(
static_cast<int>(BLOCK_BYTES) -
static_cast<int>(buffer.size())));
65 buffer += rest_of_buffer;
66
67 while (is) {
68 uint32_t block[BLOCK_INTS];
69 buffer_to_block(buffer, block);
70 transform(block);
71 read(is, buffer, BLOCK_BYTES);
72 }
73 }
74
75
76
77
78
79 std::string SHA1::final() {
80
81 const uint64_t total_bits = (transforms * BLOCK_BYTES + buffer.size()) * 8;
82
83
84 buffer += static_cast<std::string::value_type>(0x80);
85 const std::size_t orig_size = buffer.size();
86 while (buffer.size() < BLOCK_BYTES) {
87 buffer += static_cast<char>(0x00);
88 }
89
90 uint32_t block[BLOCK_INTS];
91 buffer_to_block(buffer, block);
92
93 if (orig_size > BLOCK_BYTES - 8) {
94 transform(block);
95 for (unsigned int i = 0; i < BLOCK_INTS - 2; i++) {
96 block[i] = 0;
97 }
98 }
99
100
101 block[BLOCK_INTS - 1] = static_cast<uint32_t>(total_bits & 0x00000000FFFFFFFF);
102 block[BLOCK_INTS - 2] = static_cast<uint32_t>((total_bits >> 32) & 0x00000000FFFFFFFF);
103 transform(block);
104
105
106 std::ostringstream result;
107 for (unsigned int i = 0; i < DIGEST_INTS; i++) {
108 result << std::hex << std::setfill('0') << std::setw(8);
109 result << (digest[i] & 0xffffffff);
110 }
111
112
113 reset();
114
115 return result.str();
116 }
117
118 void SHA1::reset() {
119
120 digest[0] = 0x67452301;
121 digest[1] = 0xefcdab89;
122 digest[2] = 0x98badcfe;
123 digest[3] = 0x10325476;
124 digest[4] = 0xc3d2e1f0;
125
126
127 transforms = 0;
128 buffer = "";
129 }
130
131
132
133
134
135 void SHA1::transform(uint32_t block[BLOCK_BYTES]) {
136
137 uint32_t a = digest[0];
138 uint32_t b = digest[1];
139 uint32_t c = digest[2];
140 uint32_t d = digest[3];
141 uint32_t e = digest[4];
142
143
224
225
226 digest[0] += a;
227 digest[1] += b;
228 digest[2] += c;
229 digest[3] += d;
230 digest[4] += e;
231
232
233 transforms++;
234 }
235
236 void SHA1::buffer_to_block(const std::string& buffer, uint32_t block[BLOCK_BYTES]) {
237
238 for (unsigned int i = 0; i < BLOCK_INTS; i++) {
239 block[i] = static_cast<uint32_t>((buffer[4 * i + 3] & 0xff) | (buffer[4 * i + 2] & 0xff) << 8 |
240 (buffer[4 * i + 1] & 0xff) << 16 | (buffer[4 * i + 0] & 0xff) << 24);
241 }
242 }
243
244 void SHA1::read(std::istream& is, std::string& s, std::size_t max) {
245 char* sbuf = new char[max];
246 is.read(sbuf, static_cast<std::streamsize>(max));
247 s.assign(sbuf, static_cast<unsigned long>(is.gcount()));
248 delete[] sbuf;
249 }
250
252 std::vector<unsigned char> buf;
253
254 char hex_byte[3];
255 hex_byte[2] = 0;
256
257 for (std::size_t i = 0, j = 0; i < string.size(); i += 2, j += 1) {
258 hex_byte[0] = string.at(i);
259 hex_byte[1] = string.at(i + 1);
260 char* end_ptr = nullptr;
261 buf.push_back(static_cast<unsigned char>(strtoul(hex_byte, &end_ptr, 16)));
262 }
263
264 return buf;
265 }
266
267 std::vector<unsigned char>
sha1(
const std::string&
string) {
268 SHA1 checksum;
269 checksum.update(string);
271 }
272
273}
ssize_t read(int fd, void *buf, std::size_t count)
std::vector< unsigned char > sha1(const std::string &string)
static std::vector< unsigned char > transform_to_binary(const std::string &string)
#define SHA1_R2(v, w, x, y, z, i)
#define SHA1_R3(v, w, x, y, z, i)
#define SHA1_R4(v, w, x, y, z, i)
#define SHA1_R1(v, w, x, y, z, i)
#define SHA1_R0(v, w, x, y, z, i)
1.9.8