ReactOS 0.4.15-dev-7924-g5949c20
Classes | Macros | Typedefs | Functions
sha2.h File Reference
#include <basetsd.h>
Include dependency graph for sha2.h:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _SHA256_CTX
 
struct  _SHA512_CTX
 

Macros

#define SHA256_BLOCK_LENGTH   64
 
#define SHA256_DIGEST_LENGTH   32
 
#define SHA256_DIGEST_STRING_LENGTH   (SHA256_DIGEST_LENGTH * 2 + 1)
 
#define SHA384_BLOCK_LENGTH   128
 
#define SHA384_DIGEST_LENGTH   48
 
#define SHA384_DIGEST_STRING_LENGTH   (SHA384_DIGEST_LENGTH * 2 + 1)
 
#define SHA512_BLOCK_LENGTH   128
 
#define SHA512_DIGEST_LENGTH   64
 
#define SHA512_DIGEST_STRING_LENGTH   (SHA512_DIGEST_LENGTH * 2 + 1)
 

Typedefs

typedef UINT8 sha2_byte
 
typedef UINT32 sha2_word32
 
typedef UINT64 sha2_word64
 
typedef struct _SHA256_CTX SHA256_CTX
 
typedef struct _SHA512_CTX SHA512_CTX
 
typedef SHA512_CTX SHA384_CTX
 

Functions

void SHA256_Init (SHA256_CTX *)
 
void SHA256_Update (SHA256_CTX *, const sha2_byte *, size_t)
 
void SHA256_Final (sha2_byte[SHA256_DIGEST_LENGTH], SHA256_CTX *)
 
char * SHA256_End (SHA256_CTX *, char[SHA256_DIGEST_STRING_LENGTH])
 
char * SHA256_Data (const sha2_byte *, size_t, char[SHA256_DIGEST_STRING_LENGTH])
 
void SHA384_Init (SHA384_CTX *)
 
void SHA384_Update (SHA384_CTX *, const sha2_byte *, size_t)
 
void SHA384_Final (sha2_byte[SHA384_DIGEST_LENGTH], SHA384_CTX *)
 
char * SHA384_End (SHA384_CTX *, char[SHA384_DIGEST_STRING_LENGTH])
 
char * SHA384_Data (const sha2_byte *, size_t, char[SHA384_DIGEST_STRING_LENGTH])
 
void SHA512_Init (SHA512_CTX *)
 
void SHA512_Update (SHA512_CTX *, const sha2_byte *, size_t)
 
void SHA512_Final (sha2_byte[SHA512_DIGEST_LENGTH], SHA512_CTX *)
 
char * SHA512_End (SHA512_CTX *, char[SHA512_DIGEST_STRING_LENGTH])
 
char * SHA512_Data (const sha2_byte *, size_t, char[SHA512_DIGEST_STRING_LENGTH])
 

Macro Definition Documentation

◆ SHA256_BLOCK_LENGTH

#define SHA256_BLOCK_LENGTH   64

Definition at line 39 of file sha2.h.

◆ SHA256_DIGEST_LENGTH

#define SHA256_DIGEST_LENGTH   32

Definition at line 40 of file sha2.h.

◆ SHA256_DIGEST_STRING_LENGTH

#define SHA256_DIGEST_STRING_LENGTH   (SHA256_DIGEST_LENGTH * 2 + 1)

Definition at line 41 of file sha2.h.

◆ SHA384_BLOCK_LENGTH

#define SHA384_BLOCK_LENGTH   128

Definition at line 42 of file sha2.h.

◆ SHA384_DIGEST_LENGTH

#define SHA384_DIGEST_LENGTH   48

Definition at line 43 of file sha2.h.

◆ SHA384_DIGEST_STRING_LENGTH

#define SHA384_DIGEST_STRING_LENGTH   (SHA384_DIGEST_LENGTH * 2 + 1)

Definition at line 44 of file sha2.h.

◆ SHA512_BLOCK_LENGTH

#define SHA512_BLOCK_LENGTH   128

Definition at line 45 of file sha2.h.

◆ SHA512_DIGEST_LENGTH

#define SHA512_DIGEST_LENGTH   64

Definition at line 46 of file sha2.h.

◆ SHA512_DIGEST_STRING_LENGTH

#define SHA512_DIGEST_STRING_LENGTH   (SHA512_DIGEST_LENGTH * 2 + 1)

Definition at line 47 of file sha2.h.

Typedef Documentation

◆ SHA256_CTX

typedef struct _SHA256_CTX SHA256_CTX

◆ sha2_byte

typedef UINT8 sha2_byte

Definition at line 51 of file sha2.h.

◆ sha2_word32

typedef UINT32 sha2_word32

Definition at line 52 of file sha2.h.

◆ sha2_word64

typedef UINT64 sha2_word64

Definition at line 53 of file sha2.h.

◆ SHA384_CTX

typedef SHA512_CTX SHA384_CTX

Definition at line 66 of file sha2.h.

◆ SHA512_CTX

typedef struct _SHA512_CTX SHA512_CTX

Function Documentation

◆ SHA256_Data()

char * SHA256_Data ( const sha2_byte *  data,
size_t  len,
char  digest[SHA256_DIGEST_STRING_LENGTH] 
)

Definition at line 593 of file sha2.c.

593 {
594 SHA256_CTX context;
595
596 SHA256_Init(&context);
597 SHA256_Update(&context, data, len);
598 return SHA256_End(&context, digest);
599}
data
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
len
GLenum GLsizei len
Definition: glext.h:6722
SHA256_Init
void SHA256_Init(SHA256_CTX *context)
Definition: sha2.c:275
SHA256_Update
void SHA256_Update(SHA256_CTX *context, const sha2_byte *data, size_t len)
Definition: sha2.c:459
SHA256_End
char * SHA256_End(SHA256_CTX *context, char buffer[])
Definition: sha2.c:570
_SHA256_CTX
Definition: sha2.h:55
context
Definition: http.c:7252

◆ SHA256_End()

char * SHA256_End ( SHA256_CTX *  ,
char  [SHA256_DIGEST_STRING_LENGTH] 
)

◆ SHA256_Final()

void SHA256_Final ( sha2_byte  [SHA256_DIGEST_LENGTH],
SHA256_CTX *   
)

◆ SHA256_Init()

void SHA256_Init ( SHA256_CTX *  context)

Definition at line 275 of file sha2.c.

275 {
276 if (context == NULL) {
277 return;
278 }
279 MEMCPY_BCOPY(context->state, sha256_initial_hash_value, SHA256_DIGEST_LENGTH);
280 MEMSET_BZERO(context->buffer, SHA256_BLOCK_LENGTH);
281 context->bitcount = 0;
282}
NULL
#define NULL
Definition: types.h:112
sha256_initial_hash_value
static const sha2_word32 sha256_initial_hash_value[8]
Definition: sha2.c:188
MEMSET_BZERO
#define MEMSET_BZERO(p, l)
Definition: sha2.c:115
MEMCPY_BCOPY
#define MEMCPY_BCOPY(d, s, l)
Definition: sha2.c:116
SHA256_DIGEST_LENGTH
#define SHA256_DIGEST_LENGTH
Definition: sha2.h:40
SHA256_BLOCK_LENGTH
#define SHA256_BLOCK_LENGTH
Definition: sha2.h:39

Referenced by init_hash_impl(), and SHA256_Data().

◆ SHA256_Update()

void SHA256_Update ( SHA256_CTX *  context,
const sha2_byte *  data,
size_t  len 
)

Definition at line 459 of file sha2.c.

459 {
460 unsigned int freespace, usedspace;
461
462 if (len == 0) {
463 /* Calling with no data is valid - we do nothing */
464 return;
465 }
466
467 /* Sanity check: */
468 assert(context != NULL && data != NULL);
469
470 usedspace = (context->bitcount >> 3) % SHA256_BLOCK_LENGTH;
471 if (usedspace > 0) {
472 /* Calculate how much free space is available in the buffer */
473 freespace = SHA256_BLOCK_LENGTH - usedspace;
474
475 if (len >= freespace) {
476 /* Fill the buffer completely and process it */
477 MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
478 context->bitcount += freespace << 3;
479 len -= freespace;
480 data += freespace;
481 SHA256_Transform(context, (sha2_word32*)context->buffer);
482 } else {
483 /* The buffer is not yet full */
484 MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
485 context->bitcount += len << 3;
486 /* Clean up: */
487 usedspace = freespace = 0;
488 return;
489 }
490 }
491 while (len >= SHA256_BLOCK_LENGTH) {
492 /* Process as many complete blocks as we can */
493 SHA256_Transform(context, (const sha2_word32*)data);
494 context->bitcount += SHA256_BLOCK_LENGTH << 3;
495 len -= SHA256_BLOCK_LENGTH;
496 data += SHA256_BLOCK_LENGTH;
497 }
498 if (len > 0) {
499 /* There's left-overs, so save 'em */
500 MEMCPY_BCOPY(context->buffer, data, len);
501 context->bitcount += len << 3;
502 }
503 /* Clean up: */
504 usedspace = freespace = 0;
505}
assert
#define assert(x)
Definition: debug.h:53
SHA256_Transform
void SHA256_Transform(SHA256_CTX *, const sha2_word32 *)
Definition: sha2.c:379
sha2_word32
UINT32 sha2_word32
Definition: sha2.h:52

Referenced by SHA256_Data(), and update_hash_impl().

◆ SHA384_Data()

char * SHA384_Data ( const sha2_byte *  data,
size_t  len,
char  digest[SHA384_DIGEST_STRING_LENGTH] 
)

Definition at line 997 of file sha2.c.

997 {
998 SHA384_CTX context;
999
1000 SHA384_Init(&context);
1001 SHA384_Update(&context, data, len);
1002 return SHA384_End(&context, digest);
1003}
SHA384_End
char * SHA384_End(SHA384_CTX *context, char buffer[])
Definition: sha2.c:974
SHA384_Init
void SHA384_Init(SHA384_CTX *context)
Definition: sha2.c:932
SHA384_Update
void SHA384_Update(SHA384_CTX *context, const sha2_byte *data, size_t len)
Definition: sha2.c:941
_SHA512_CTX
Definition: sha2.h:60

◆ SHA384_End()

char * SHA384_End ( SHA384_CTX *  ,
char  [SHA384_DIGEST_STRING_LENGTH] 
)

◆ SHA384_Final()

void SHA384_Final ( sha2_byte  [SHA384_DIGEST_LENGTH],
SHA384_CTX *   
)

◆ SHA384_Init()

void SHA384_Init ( SHA384_CTX *  context)

Definition at line 932 of file sha2.c.

932 {
933 if (context == NULL) {
934 return;
935 }
936 MEMCPY_BCOPY(context->state, sha384_initial_hash_value, SHA512_DIGEST_LENGTH);
937 MEMSET_BZERO(context->buffer, SHA384_BLOCK_LENGTH);
938 context->bitcount[0] = context->bitcount[1] = 0;
939}
sha384_initial_hash_value
static const sha2_word64 sha384_initial_hash_value[8]
Definition: sha2.c:244
SHA512_DIGEST_LENGTH
#define SHA512_DIGEST_LENGTH
Definition: sha2.h:46
SHA384_BLOCK_LENGTH
#define SHA384_BLOCK_LENGTH
Definition: sha2.h:42

Referenced by init_hash_impl(), and SHA384_Data().

◆ SHA384_Update()

void SHA384_Update ( SHA384_CTX *  context,
const sha2_byte *  data,
size_t  len 
)

Definition at line 941 of file sha2.c.

941 {
942 SHA512_Update((SHA512_CTX*)context, data, len);
943}
SHA512_Update
void SHA512_Update(SHA512_CTX *context, const sha2_byte *data, size_t len)
Definition: sha2.c:781

Referenced by SHA384_Data(), and update_hash_impl().

◆ SHA512_Data()

char * SHA512_Data ( const sha2_byte *  data,
size_t  len,
char  digest[SHA512_DIGEST_STRING_LENGTH] 
)

Definition at line 922 of file sha2.c.

922 {
923 SHA512_CTX context;
924
925 SHA512_Init(&context);
926 SHA512_Update(&context, data, len);
927 return SHA512_End(&context, digest);
928}
SHA512_End
char * SHA512_End(SHA512_CTX *context, char buffer[])
Definition: sha2.c:899
SHA512_Init
void SHA512_Init(SHA512_CTX *context)
Definition: sha2.c:603

◆ SHA512_End()

char * SHA512_End ( SHA512_CTX *  ,
char  [SHA512_DIGEST_STRING_LENGTH] 
)

◆ SHA512_Final()

void SHA512_Final ( sha2_byte  [SHA512_DIGEST_LENGTH],
SHA512_CTX *   
)

◆ SHA512_Init()

void SHA512_Init ( SHA512_CTX *  context)

Definition at line 603 of file sha2.c.

603 {
604 if (context == NULL) {
605 return;
606 }
607 MEMCPY_BCOPY(context->state, sha512_initial_hash_value, SHA512_DIGEST_LENGTH);
608 MEMSET_BZERO(context->buffer, SHA512_BLOCK_LENGTH);
609 context->bitcount[0] = context->bitcount[1] = 0;
610}
sha512_initial_hash_value
static const sha2_word64 sha512_initial_hash_value[8]
Definition: sha2.c:256
SHA512_BLOCK_LENGTH
#define SHA512_BLOCK_LENGTH
Definition: sha2.h:45

Referenced by init_hash_impl(), and SHA512_Data().

◆ SHA512_Update()

void SHA512_Update ( SHA512_CTX *  context,
const sha2_byte *  data,
size_t  len 
)

Definition at line 781 of file sha2.c.

781 {
782 unsigned int freespace, usedspace;
783
784 if (len == 0) {
785 /* Calling with no data is valid - we do nothing */
786 return;
787 }
788
789 /* Sanity check: */
790 assert(context != NULL && data != NULL);
791
792 usedspace = (context->bitcount[0] >> 3) % SHA512_BLOCK_LENGTH;
793 if (usedspace > 0) {
794 /* Calculate how much free space is available in the buffer */
795 freespace = SHA512_BLOCK_LENGTH - usedspace;
796
797 if (len >= freespace) {
798 /* Fill the buffer completely and process it */
799 MEMCPY_BCOPY(&context->buffer[usedspace], data, freespace);
800 ADDINC128(context->bitcount, freespace << 3);
801 len -= freespace;
802 data += freespace;
803 SHA512_Transform(context, (sha2_word64*)context->buffer);
804 } else {
805 /* The buffer is not yet full */
806 MEMCPY_BCOPY(&context->buffer[usedspace], data, len);
807 ADDINC128(context->bitcount, len << 3);
808 /* Clean up: */
809 usedspace = freespace = 0;
810 return;
811 }
812 }
813 while (len >= SHA512_BLOCK_LENGTH) {
814 /* Process as many complete blocks as we can */
815 SHA512_Transform(context, (const sha2_word64*)data);
816 ADDINC128(context->bitcount, SHA512_BLOCK_LENGTH << 3);
817 len -= SHA512_BLOCK_LENGTH;
818 data += SHA512_BLOCK_LENGTH;
819 }
820 if (len > 0) {
821 /* There's left-overs, so save 'em */
822 MEMCPY_BCOPY(context->buffer, data, len);
823 ADDINC128(context->bitcount, len << 3);
824 }
825 /* Clean up: */
826 usedspace = freespace = 0;
827}
ADDINC128
#define ADDINC128(w, n)
Definition: sha2.c:89
SHA512_Transform
void SHA512_Transform(SHA512_CTX *, const sha2_word64 *)
Definition: sha2.c:703
sha2_word64
UINT64 sha2_word64
Definition: sha2.h:53

Referenced by SHA384_Update(), SHA512_Data(), and update_hash_impl().