File: sha.h

package info (click to toggle)
ykclient 2.15-2
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 1,768 kB
  • sloc: sh: 11,547; ansic: 3,702; makefile: 102
file content (270 lines) | stat: -rw-r--r-- 8,880 bytes parent folder | download | duplicates (3)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
/**************************** sha.h ****************************/
/******************* See RFC 4634 for details ******************/
#ifndef _SHA_H_
#define _SHA_H_

/*
 *  Description:
 *      This file implements the Secure Hash Signature Standard
 *      algorithms as defined in the National Institute of Standards
 *      and Technology Federal Information Processing Standards
 *      Publication (FIPS PUB) 180-1 published on April 17, 1995, 180-2
 *      published on August 1, 2002, and the FIPS PUB 180-2 Change
 *      Notice published on February 28, 2004.
 *
 *      A combined document showing all algorithms is available at
 *              http://csrc.nist.gov/publications/fips/
 *              fips180-2/fips180-2withchangenotice.pdf
 *
 *      The five hashes are defined in these sizes:
 *              SHA-1           20 byte / 160 bit
 *              SHA-224         28 byte / 224 bit
 *              SHA-256         32 byte / 256 bit
 *              SHA-384         48 byte / 384 bit
 *              SHA-512         64 byte / 512 bit
 */

#include <stdint.h>
/*
 * If you do not have the ISO standard stdint.h header file, then you
 * must typedef the following:
 *    name              meaning
 *  uint64_t         unsigned 64 bit integer
 *  uint32_t         unsigned 32 bit integer
 *  uint8_t          unsigned 8 bit integer (i.e., unsigned char)
 *  int_least16_t    integer of >= 16 bits
 *
 */

#ifndef _SHA_enum_
#define _SHA_enum_
/*
 *  All SHA functions return one of these values.
 */
enum
{
  shaSuccess = 0,
  shaNull,			/* Null pointer parameter */
  shaInputTooLong,		/* input data too long */
  shaStateError,		/* called Input after FinalBits or Result */
  shaBadParam			/* passed a bad parameter */
};
#endif /* _SHA_enum_ */

/*
 *  These constants hold size information for each of the SHA
 *  hashing operations
 */
enum
{
  SHA1_Message_Block_Size = 64, SHA224_Message_Block_Size = 64,
  SHA256_Message_Block_Size = 64, SHA384_Message_Block_Size = 128,
  SHA512_Message_Block_Size = 128,
  USHA_Max_Message_Block_Size = SHA512_Message_Block_Size,

  SHA1HashSize = 20, SHA224HashSize = 28, SHA256HashSize = 32,
  SHA384HashSize = 48, SHA512HashSize = 64,
  USHAMaxHashSize = SHA512HashSize,

  SHA1HashSizeBits = 160, SHA224HashSizeBits = 224,
  SHA256HashSizeBits = 256, SHA384HashSizeBits = 384,
  SHA512HashSizeBits = 512, USHAMaxHashSizeBits = SHA512HashSizeBits
};

/*
 *  These constants are used in the USHA (unified sha) functions.
 */
typedef enum SHAversion
{
  SHA1, SHA224, SHA256, SHA384, SHA512
} SHAversion;

/*
 *  This structure will hold context information for the SHA-1
 *  hashing operation.
 */
typedef struct SHA1Context
{
  uint32_t Intermediate_Hash[SHA1HashSize / 4];	/* Message Digest */

  uint32_t Length_Low;		/* Message length in bits */
  uint32_t Length_High;		/* Message length in bits */

  int_least16_t Message_Block_Index;	/* Message_Block array index */
  /* 512-bit message blocks */
  uint8_t Message_Block[SHA1_Message_Block_Size];

  int Computed;			/* Is the digest computed? */
  int Corrupted;		/* Is the digest corrupted? */
} SHA1Context;

/*
 *  This structure will hold context information for the SHA-256
 *  hashing operation.
 */
typedef struct SHA256Context
{
  uint32_t Intermediate_Hash[SHA256HashSize / 4];	/* Message Digest */

  uint32_t Length_Low;		/* Message length in bits */
  uint32_t Length_High;		/* Message length in bits */

  int_least16_t Message_Block_Index;	/* Message_Block array index */
  /* 512-bit message blocks */
  uint8_t Message_Block[SHA256_Message_Block_Size];

  int Computed;			/* Is the digest computed? */
  int Corrupted;		/* Is the digest corrupted? */
} SHA256Context;

/*
 *  This structure will hold context information for the SHA-512
 *  hashing operation.
 */
typedef struct SHA512Context
{
#ifdef USE_32BIT_ONLY
  uint32_t Intermediate_Hash[SHA512HashSize / 4];	/* Message Digest  */
  uint32_t Length[4];		/* Message length in bits */
#else				/* !USE_32BIT_ONLY */
  uint64_t Intermediate_Hash[SHA512HashSize / 8];	/* Message Digest */
  uint64_t Length_Low, Length_High;	/* Message length in bits */
#endif				/* USE_32BIT_ONLY */
  int_least16_t Message_Block_Index;	/* Message_Block array index */
  /* 1024-bit message blocks */
  uint8_t Message_Block[SHA512_Message_Block_Size];

  int Computed;			/* Is the digest computed? */
  int Corrupted;		/* Is the digest corrupted? */
} SHA512Context;

/*
 *  This structure will hold context information for the SHA-224
 *  hashing operation. It uses the SHA-256 structure for computation.
 */
typedef struct SHA256Context SHA224Context;

/*
 *  This structure will hold context information for the SHA-384
 *  hashing operation. It uses the SHA-512 structure for computation.
 */
typedef struct SHA512Context SHA384Context;

/*
 *  This structure holds context information for all SHA
 *  hashing operations.
 */
typedef struct USHAContext
{
  int whichSha;			/* which SHA is being used */
  union
  {
    SHA1Context sha1Context;
    SHA224Context sha224Context;
    SHA256Context sha256Context;
    SHA384Context sha384Context;
    SHA512Context sha512Context;
  } ctx;
} USHAContext;

/*
 *  This structure will hold context information for the HMAC
 *  keyed hashing operation.
 */
typedef struct HMACContext
{
  int whichSha;			/* which SHA is being used */
  int hashSize;			/* hash size of SHA being used */
  int blockSize;		/* block size of SHA being used */
  USHAContext shaContext;	/* SHA context */
  unsigned char k_opad[USHA_Max_Message_Block_Size];
  /* outer padding - key XORd with opad */
} HMACContext;

/*
 *  Function Prototypes
 */

/* SHA-1 */
extern int SHA1Reset (SHA1Context *);
extern int SHA1Input (SHA1Context *, const uint8_t * bytes,
		      unsigned int bytecount);
extern int SHA1FinalBits (SHA1Context *, const uint8_t bits,
			  unsigned int bitcount);
extern int SHA1Result (SHA1Context *, uint8_t Message_Digest[SHA1HashSize]);

/* SHA-224 */
extern int SHA224Reset (SHA224Context *);
extern int SHA224Input (SHA224Context *, const uint8_t * bytes,
			unsigned int bytecount);
extern int SHA224FinalBits (SHA224Context *, const uint8_t bits,
			    unsigned int bitcount);
extern int SHA224Result (SHA224Context *,
			 uint8_t Message_Digest[SHA224HashSize]);

/* SHA-256 */
extern int SHA256Reset (SHA256Context *);
extern int SHA256Input (SHA256Context *, const uint8_t * bytes,
			unsigned int bytecount);
extern int SHA256FinalBits (SHA256Context *, const uint8_t bits,
			    unsigned int bitcount);
extern int SHA256Result (SHA256Context *,
			 uint8_t Message_Digest[SHA256HashSize]);

/* SHA-384 */
extern int SHA384Reset (SHA384Context *);
extern int SHA384Input (SHA384Context *, const uint8_t * bytes,
			unsigned int bytecount);
extern int SHA384FinalBits (SHA384Context *, const uint8_t bits,
			    unsigned int bitcount);
extern int SHA384Result (SHA384Context *,
			 uint8_t Message_Digest[SHA384HashSize]);

/* SHA-512 */
extern int SHA512Reset (SHA512Context *);
extern int SHA512Input (SHA512Context *, const uint8_t * bytes,
			unsigned int bytecount);
extern int SHA512FinalBits (SHA512Context *, const uint8_t bits,
			    unsigned int bitcount);
extern int SHA512Result (SHA512Context *,
			 uint8_t Message_Digest[SHA512HashSize]);

/* Unified SHA functions, chosen by whichSha */
extern int USHAReset (USHAContext *, SHAversion whichSha);
extern int USHAInput (USHAContext *,
		      const uint8_t * bytes, unsigned int bytecount);
extern int USHAFinalBits (USHAContext *,
			  const uint8_t bits, unsigned int bitcount);
extern int USHAResult (USHAContext *,
		       uint8_t Message_Digest[USHAMaxHashSize]);
extern int USHABlockSize (enum SHAversion whichSha);
extern int USHAHashSize (enum SHAversion whichSha);
extern int USHAHashSizeBits (enum SHAversion whichSha);

/*
 * HMAC Keyed-Hashing for Message Authentication, RFC2104,
 * for all SHAs.
 * This interface allows a fixed-length text input to be used.
 */
extern int hmac (SHAversion whichSha,	/* which SHA algorithm to use */
		 const unsigned char *text,	/* pointer to data stream */
		 int text_len,	/* length of data stream */
		 const unsigned char *key,	/* pointer to authentication key */
		 int key_len,	/* length of authentication key */
		 uint8_t digest[USHAMaxHashSize]);	/* caller digest to fill in */

/*
 * HMAC Keyed-Hashing for Message Authentication, RFC2104,
 * for all SHAs.
 * This interface allows any length of text input to be used.
 */
extern int hmacReset (HMACContext * ctx, enum SHAversion whichSha,
		      const unsigned char *key, int key_len);
extern int hmacInput (HMACContext * ctx, const unsigned char *text,
		      int text_len);

extern int hmacFinalBits (HMACContext * ctx, const uint8_t bits,
			  unsigned int bitcount);
extern int hmacResult (HMACContext * ctx, uint8_t digest[USHAMaxHashSize]);

#endif /* _SHA_H_ */