From 8898ad9b25fca6afe2374d293a981db02a83d7e9 Mon Sep 17 00:00:00 2001 From: "FWoltermann@gmail.com" Date: Thu, 31 May 2012 14:46:27 +0000 Subject: Committing the documentation to svn to have it accessible online --- Doc/doxygen/html/_sha1_8cpp_source.html | 706 ++++++++++++++++++++++++++++++++ 1 file changed, 706 insertions(+) create mode 100644 Doc/doxygen/html/_sha1_8cpp_source.html (limited to 'Doc/doxygen/html/_sha1_8cpp_source.html') diff --git a/Doc/doxygen/html/_sha1_8cpp_source.html b/Doc/doxygen/html/_sha1_8cpp_source.html new file mode 100644 index 0000000..0c18d05 --- /dev/null +++ b/Doc/doxygen/html/_sha1_8cpp_source.html @@ -0,0 +1,706 @@ + + + + + +Starshatter_Open: D:/SRC/StarshatterSVN/nGenEx/Sha1.cpp Source File + + + + + + + + + + + + + +
+
+ + + + + + +
+
Starshatter_Open +
+
Open source Starshatter engine
+
+
+ + + + + +
+
+ +
+
+
+ +
+ + + + +
+ +
+ +
+
+
Sha1.cpp
+
+
+Go to the documentation of this file.
1 /*
+
2 * Sha1.cpp
+
3 *
+
4 * Copyright (C) 1998
+
5 * Paul E. Jones <paulej@acm.org>
+
6 * All Rights Reserved.
+
7 *
+
8 *****************************************************************************
+
9 * $Id: sha1.cpp,v 1.6 2001/03/20 06:54:54 paulej Exp $
+
10 *****************************************************************************
+
11 *
+
12 * Description:
+
13 * This class implements the Secure Hashing Standard as defined
+
14 * in FIPS PUB 180-1 published April 17, 1995.
+
15 *
+
16 * The Secure Hashing Standard, which uses the Secure Hashing
+
17 * Algorithm (SHA), produces a 160-bit message digest for a
+
18 * given data stream. In theory, it is highly improbable that
+
19 * two messages will produce the same message digest. Therefore,
+
20 * this algorithm can serve as a means of providing a "fingerprint"
+
21 * for a message.
+
22 *
+
23 * Portability Issues:
+
24 * SHA-1 is defined in terms of 32-bit "words". This code was
+
25 * written with the expectation that the processor has at least
+
26 * a 32-bit machine word size. If the machine word size is larger,
+
27 * the code should still function properly. One caveat to that
+
28 * is that the input functions taking characters and character arrays
+
29 * assume that only 8 bits of information are stored in each character.
+
30 *
+
31 * Caveats:
+
32 * SHA-1 is designed to work with messages less than 2^64 bits long.
+
33 * Although SHA-1 allows a message digest to be generated for
+
34 * messages of any number of bits less than 2^64, this implementation
+
35 * only works with messages with a length that is a multiple of 8
+
36 * bits.
+
37 *
+
38 */
+
39 
+
40 
+
41 #include "Sha1.h"
+
42 
+
43 /*
+
44 * SHA1
+
45 *
+
46 * Description:
+
47 * This is the constructor for the sha1 class.
+
48 *
+
49 * Parameters:
+
50 * None.
+
51 *
+
52 * Returns:
+
53 * Nothing.
+
54 *
+
55 * Comments:
+
56 *
+
57 */
+
58 SHA1::SHA1()
+
59 {
+
60  Reset();
+
61 }
+
62 
+
63 /*
+
64 * ~SHA1
+
65 *
+
66 * Description:
+
67 * This is the destructor for the sha1 class
+
68 *
+
69 * Parameters:
+
70 * None.
+
71 *
+
72 * Returns:
+
73 * Nothing.
+
74 *
+
75 * Comments:
+
76 *
+
77 */
+
78 SHA1::~SHA1()
+
79 {
+
80  // The destructor does nothing
+
81 }
+
82 
+
83 /*
+
84 * Reset
+
85 *
+
86 * Description:
+
87 * This function will initialize the sha1 class member variables
+
88 * in preparation for computing a new message digest.
+
89 *
+
90 * Parameters:
+
91 * None.
+
92 *
+
93 * Returns:
+
94 * Nothing.
+
95 *
+
96 * Comments:
+
97 *
+
98 */
+
99 void SHA1::Reset()
+
100 {
+
101  Length_Low = 0;
+
102  Length_High = 0;
+
103  Message_Block_Index = 0;
+
104 
+
105  H[0] = 0x67452301;
+
106  H[1] = 0xEFCDAB89;
+
107  H[2] = 0x98BADCFE;
+
108  H[3] = 0x10325476;
+
109  H[4] = 0xC3D2E1F0;
+
110 
+
111  Computed = false;
+
112  Corrupted = false;
+
113 }
+
114 
+
115 /*
+
116 * Result
+
117 *
+
118 * Description:
+
119 * This function will return the 160-bit message digest into the
+
120 * array provided.
+
121 *
+
122 * Parameters:
+
123 * message_digest_array: [out]
+
124 * This is an array of five unsigned integers which will be filled
+
125 * with the message digest that has been computed.
+
126 *
+
127 * Returns:
+
128 * True if successful, false if it failed.
+
129 *
+
130 * Comments:
+
131 *
+
132 */
+
133 bool SHA1::Result(unsigned *message_digest_array)
+
134 {
+
135  int i; // Counter
+
136 
+
137  if (Corrupted)
+
138  {
+
139  return false;
+
140  }
+
141 
+
142  if (!Computed)
+
143  {
+
144  PadMessage();
+
145  Computed = true;
+
146  }
+
147 
+
148  for(i = 0; i < 5; i++)
+
149  {
+
150  message_digest_array[i] = H[i];
+
151  }
+
152 
+
153  return true;
+
154 }
+
155 
+
156 /*
+
157 * Input
+
158 *
+
159 * Description:
+
160 * This function accepts an array of octets as the next portion of
+
161 * the message.
+
162 *
+
163 * Parameters:
+
164 * message_array: [in]
+
165 * An array of characters representing the next portion of the
+
166 * message.
+
167 *
+
168 * Returns:
+
169 * Nothing.
+
170 *
+
171 * Comments:
+
172 *
+
173 */
+
174 void SHA1::Input( const unsigned char *message_array,
+
175 unsigned length)
+
176 {
+
177  if (!length)
+
178  {
+
179  return;
+
180  }
+
181 
+
182  if (Computed || Corrupted)
+
183  {
+
184  Corrupted = true;
+
185  return;
+
186  }
+
187 
+
188  while(length-- && !Corrupted)
+
189  {
+
190  Message_Block[Message_Block_Index++] = (*message_array & 0xFF);
+
191 
+
192  Length_Low += 8;
+
193  Length_Low &= 0xFFFFFFFF; // Force it to 32 bits
+
194  if (Length_Low == 0)
+
195  {
+
196  Length_High++;
+
197  Length_High &= 0xFFFFFFFF; // Force it to 32 bits
+
198  if (Length_High == 0)
+
199  {
+
200  Corrupted = true; // Message is too long
+
201  }
+
202  }
+
203 
+
204  if (Message_Block_Index == 64)
+
205  {
+
206  ProcessMessageBlock();
+
207  }
+
208 
+
209  message_array++;
+
210  }
+
211 }
+
212 
+
213 /*
+
214 * Input
+
215 *
+
216 * Description:
+
217 * This function accepts an array of octets as the next portion of
+
218 * the message.
+
219 *
+
220 * Parameters:
+
221 * message_array: [in]
+
222 * An array of characters representing the next portion of the
+
223 * message.
+
224 * length: [in]
+
225 * The length of the message_array
+
226 *
+
227 * Returns:
+
228 * Nothing.
+
229 *
+
230 * Comments:
+
231 *
+
232 */
+
233 void SHA1::Input( const char *message_array,
+
234 unsigned length)
+
235 {
+
236  Input((unsigned char *) message_array, length);
+
237 }
+
238 
+
239 /*
+
240 * Input
+
241 *
+
242 * Description:
+
243 * This function accepts a single octets as the next message element.
+
244 *
+
245 * Parameters:
+
246 * message_element: [in]
+
247 * The next octet in the message.
+
248 *
+
249 * Returns:
+
250 * Nothing.
+
251 *
+
252 * Comments:
+
253 *
+
254 */
+
255 void SHA1::Input(unsigned char message_element)
+
256 {
+
257  Input(&message_element, 1);
+
258 }
+
259 
+
260 /*
+
261 * Input
+
262 *
+
263 * Description:
+
264 * This function accepts a single octet as the next message element.
+
265 *
+
266 * Parameters:
+
267 * message_element: [in]
+
268 * The next octet in the message.
+
269 *
+
270 * Returns:
+
271 * Nothing.
+
272 *
+
273 * Comments:
+
274 *
+
275 */
+
276 void SHA1::Input(char message_element)
+
277 {
+
278  Input((unsigned char *) &message_element, 1);
+
279 }
+
280 
+
281 /*
+
282 * operator<<
+
283 *
+
284 * Description:
+
285 * This operator makes it convenient to provide character strings to
+
286 * the SHA1 object for processing.
+
287 *
+
288 * Parameters:
+
289 * message_array: [in]
+
290 * The character array to take as input.
+
291 *
+
292 * Returns:
+
293 * A reference to the SHA1 object.
+
294 *
+
295 * Comments:
+
296 * Each character is assumed to hold 8 bits of information.
+
297 *
+
298 */
+
299 SHA1& SHA1::operator<<(const char *message_array)
+
300 {
+
301  const char *p = message_array;
+
302 
+
303  while(*p)
+
304  {
+
305  Input(*p);
+
306  p++;
+
307  }
+
308 
+
309  return *this;
+
310 }
+
311 
+
312 /*
+
313 * operator<<
+
314 *
+
315 * Description:
+
316 * This operator makes it convenient to provide character strings to
+
317 * the SHA1 object for processing.
+
318 *
+
319 * Parameters:
+
320 * message_array: [in]
+
321 * The character array to take as input.
+
322 *
+
323 * Returns:
+
324 * A reference to the SHA1 object.
+
325 *
+
326 * Comments:
+
327 * Each character is assumed to hold 8 bits of information.
+
328 *
+
329 */
+
330 SHA1& SHA1::operator<<(const unsigned char *message_array)
+
331 {
+
332  const unsigned char *p = message_array;
+
333 
+
334  while(*p)
+
335  {
+
336  Input(*p);
+
337  p++;
+
338  }
+
339 
+
340  return *this;
+
341 }
+
342 
+
343 /*
+
344 * operator<<
+
345 *
+
346 * Description:
+
347 * This function provides the next octet in the message.
+
348 *
+
349 * Parameters:
+
350 * message_element: [in]
+
351 * The next octet in the message
+
352 *
+
353 * Returns:
+
354 * A reference to the SHA1 object.
+
355 *
+
356 * Comments:
+
357 * The character is assumed to hold 8 bits of information.
+
358 *
+
359 */
+
360 SHA1& SHA1::operator<<(const char message_element)
+
361 {
+
362  Input((unsigned char *) &message_element, 1);
+
363 
+
364  return *this;
+
365 }
+
366 
+
367 /*
+
368 * operator<<
+
369 *
+
370 * Description:
+
371 * This function provides the next octet in the message.
+
372 *
+
373 * Parameters:
+
374 * message_element: [in]
+
375 * The next octet in the message
+
376 *
+
377 * Returns:
+
378 * A reference to the SHA1 object.
+
379 *
+
380 * Comments:
+
381 * The character is assumed to hold 8 bits of information.
+
382 *
+
383 */
+
384 SHA1& SHA1::operator<<(const unsigned char message_element)
+
385 {
+
386  Input(&message_element, 1);
+
387 
+
388  return *this;
+
389 }
+
390 
+
391 /*
+
392 * ProcessMessageBlock
+
393 *
+
394 * Description:
+
395 * This function will process the next 512 bits of the message
+
396 * stored in the Message_Block array.
+
397 *
+
398 * Parameters:
+
399 * None.
+
400 *
+
401 * Returns:
+
402 * Nothing.
+
403 *
+
404 * Comments:
+
405 * Many of the variable names in this function, especially the single
+
406 * character names, were used because those were the names used
+
407 * in the publication.
+
408 *
+
409 */
+
410 void SHA1::ProcessMessageBlock()
+
411 {
+
412  const unsigned K[] = { // Constants defined for SHA-1
+
413  0x5A827999,
+
414  0x6ED9EBA1,
+
415  0x8F1BBCDC,
+
416  0xCA62C1D6
+
417  };
+
418  int t; // Loop counter
+
419  unsigned temp; // Temporary word value
+
420  unsigned W[80]; // Word sequence
+
421  unsigned A, B, C, D, E; // Word buffers
+
422 
+
423  /*
+
424  * Initialize the first 16 words in the array W
+
425  */
+
426  for(t = 0; t < 16; t++)
+
427  {
+
428  W[t] = Message_Block[t * 4] << 24;
+
429  W[t] |= Message_Block[t * 4 + 1] << 16;
+
430  W[t] |= Message_Block[t * 4 + 2] << 8;
+
431  W[t] |= Message_Block[t * 4 + 3];
+
432  }
+
433 
+
434  for(t = 16; t < 80; t++)
+
435  {
+
436  W[t] = CircularShift(1,W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16]);
+
437  }
+
438 
+
439  A = H[0];
+
440  B = H[1];
+
441  C = H[2];
+
442  D = H[3];
+
443  E = H[4];
+
444 
+
445  for(t = 0; t < 20; t++)
+
446  {
+
447  temp = CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
+
448  temp &= 0xFFFFFFFF;
+
449  E = D;
+
450  D = C;
+
451  C = CircularShift(30,B);
+
452  B = A;
+
453  A = temp;
+
454  }
+
455 
+
456  for(t = 20; t < 40; t++)
+
457  {
+
458  temp = CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
+
459  temp &= 0xFFFFFFFF;
+
460  E = D;
+
461  D = C;
+
462  C = CircularShift(30,B);
+
463  B = A;
+
464  A = temp;
+
465  }
+
466 
+
467  for(t = 40; t < 60; t++)
+
468  {
+
469  temp = CircularShift(5,A) +
+
470  ((B & C) | (B & D) | (C & D)) + E + W[t] + K[2];
+
471  temp &= 0xFFFFFFFF;
+
472  E = D;
+
473  D = C;
+
474  C = CircularShift(30,B);
+
475  B = A;
+
476  A = temp;
+
477  }
+
478 
+
479  for(t = 60; t < 80; t++)
+
480  {
+
481  temp = CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[3];
+
482  temp &= 0xFFFFFFFF;
+
483  E = D;
+
484  D = C;
+
485  C = CircularShift(30,B);
+
486  B = A;
+
487  A = temp;
+
488  }
+
489 
+
490  H[0] = (H[0] + A) & 0xFFFFFFFF;
+
491  H[1] = (H[1] + B) & 0xFFFFFFFF;
+
492  H[2] = (H[2] + C) & 0xFFFFFFFF;
+
493  H[3] = (H[3] + D) & 0xFFFFFFFF;
+
494  H[4] = (H[4] + E) & 0xFFFFFFFF;
+
495 
+
496  Message_Block_Index = 0;
+
497 }
+
498 
+
499 /*
+
500 * PadMessage
+
501 *
+
502 * Description:
+
503 * According to the standard, the message must be padded to an even
+
504 * 512 bits. The first padding bit must be a '1'. The last 64 bits
+
505 * represent the length of the original message. All bits in between
+
506 * should be 0. This function will pad the message according to those
+
507 * rules by filling the message_block array accordingly. It will also
+
508 * call ProcessMessageBlock() appropriately. When it returns, it
+
509 * can be assumed that the message digest has been computed.
+
510 *
+
511 * Parameters:
+
512 * None.
+
513 *
+
514 * Returns:
+
515 * Nothing.
+
516 *
+
517 * Comments:
+
518 *
+
519 */
+
520 void SHA1::PadMessage()
+
521 {
+
522  /*
+
523  * Check to see if the current message block is too small to hold
+
524  * the initial padding bits and length. If so, we will pad the
+
525  * block, process it, and then continue padding into a second block.
+
526  */
+
527  if (Message_Block_Index > 55)
+
528  {
+
529  Message_Block[Message_Block_Index++] = 0x80;
+
530  while(Message_Block_Index < 64)
+
531  {
+
532  Message_Block[Message_Block_Index++] = 0;
+
533  }
+
534 
+
535  ProcessMessageBlock();
+
536 
+
537  while(Message_Block_Index < 56)
+
538  {
+
539  Message_Block[Message_Block_Index++] = 0;
+
540  }
+
541  }
+
542  else
+
543  {
+
544  Message_Block[Message_Block_Index++] = 0x80;
+
545  while(Message_Block_Index < 56)
+
546  {
+
547  Message_Block[Message_Block_Index++] = 0;
+
548  }
+
549 
+
550  }
+
551 
+
552  /*
+
553  * Store the message length as the last 8 octets
+
554  */
+
555  Message_Block[56] = (Length_High >> 24) & 0xFF;
+
556  Message_Block[57] = (Length_High >> 16) & 0xFF;
+
557  Message_Block[58] = (Length_High >> 8) & 0xFF;
+
558  Message_Block[59] = (Length_High) & 0xFF;
+
559  Message_Block[60] = (Length_Low >> 24) & 0xFF;
+
560  Message_Block[61] = (Length_Low >> 16) & 0xFF;
+
561  Message_Block[62] = (Length_Low >> 8) & 0xFF;
+
562  Message_Block[63] = (Length_Low) & 0xFF;
+
563 
+
564  ProcessMessageBlock();
+
565 }
+
566 
+
567 
+
568 /*
+
569 * CircularShift
+
570 *
+
571 * Description:
+
572 * This member function will perform a circular shifting operation.
+
573 *
+
574 * Parameters:
+
575 * bits: [in]
+
576 * The number of bits to shift (1-31)
+
577 * word: [in]
+
578 * The value to shift (assumes a 32-bit integer)
+
579 *
+
580 * Returns:
+
581 * The shifted value.
+
582 *
+
583 * Comments:
+
584 *
+
585 */
+
586 unsigned SHA1::CircularShift(int bits, unsigned word)
+
587 {
+
588  return ((word << bits) & 0xFFFFFFFF) | ((word & 0xFFFFFFFF) >> (32-bits));
+
589 }
+
+
+ + + + -- cgit v1.1