F´ Flight Software - C/C++ Documentation  NASA-v1.5.0
A framework for building embedded system applications to NASA flight quality standards.
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
sha.h
Go to the documentation of this file.
1 /* crypto/sha/sha.h */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  *
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to. The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code. The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  *
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  *
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  * notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  * notice, this list of conditions and the following disclaimer in the
30  * documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  * must display the following acknowledgement:
33  * "This product includes cryptographic software written by
34  * Eric Young (eay@cryptsoft.com)"
35  * The word 'cryptographic' can be left out if the rouines from the library
36  * being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from
38  * the apps directory (application code) you must include an acknowledgement:
39  * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  *
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed. i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58 
59 #ifndef HEADER_SHA_H
60 # define HEADER_SHA_H
61 
62 # include <openssl/e_os2.h>
63 # include <stddef.h>
64 
65 #ifdef __cplusplus
66 extern "C" {
67 #endif
68 
69 # if defined(OPENSSL_NO_SHA) || (defined(OPENSSL_NO_SHA0) && defined(OPENSSL_NO_SHA1))
70 # error SHA is disabled.
71 # endif
72 
73 # if defined(OPENSSL_FIPS)
74 # define FIPS_SHA_SIZE_T size_t
75 # endif
76 
77 /*-
78  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
79  * ! SHA_LONG has to be at least 32 bits wide. If it's wider, then !
80  * ! SHA_LONG_LOG2 has to be defined along. !
81  * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
82  */
83 
84 # if defined(__LP32__)
85 # define SHA_LONG unsigned long
86 # elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__)
87 # define SHA_LONG unsigned long
88 # define SHA_LONG_LOG2 3
89 # else
90 # define SHA_LONG unsigned int
91 # endif
92 
93 # define SHA_LBLOCK 16
94 # define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a
95  * contiguous array of 32 bit wide
96  * big-endian values. */
97 # define SHA_LAST_BLOCK (SHA_CBLOCK-8)
98 # define SHA_DIGEST_LENGTH 20
99 
100 typedef struct SHAstate_st {
101  SHA_LONG h0, h1, h2, h3, h4;
102  SHA_LONG Nl, Nh;
103  SHA_LONG data[SHA_LBLOCK];
104  unsigned int num;
105 } SHA_CTX;
106 
107 # ifndef OPENSSL_NO_SHA0
108 # ifdef OPENSSL_FIPS
109 int private_SHA_Init(SHA_CTX *c);
110 # endif
111 int SHA_Init(SHA_CTX *c);
112 int SHA_Update(SHA_CTX *c, const void *data, size_t len);
113 int SHA_Final(unsigned char *md, SHA_CTX *c);
114 unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md);
115 void SHA_Transform(SHA_CTX *c, const unsigned char *data);
116 # endif
117 # ifndef OPENSSL_NO_SHA1
118 # ifdef OPENSSL_FIPS
119 int private_SHA1_Init(SHA_CTX *c);
120 # endif
121 int SHA1_Init(SHA_CTX *c);
122 int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
123 int SHA1_Final(unsigned char *md, SHA_CTX *c);
124 unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
125 void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
126 # endif
127 
128 # define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a
129  * contiguous array of 32 bit wide
130  * big-endian values. */
131 # define SHA224_DIGEST_LENGTH 28
132 # define SHA256_DIGEST_LENGTH 32
133 
134 typedef struct SHA256state_st {
135  SHA_LONG h[8];
136  SHA_LONG Nl, Nh;
137  SHA_LONG data[SHA_LBLOCK];
138  unsigned int num, md_len;
139 } SHA256_CTX;
140 
141 # ifndef OPENSSL_NO_SHA256
142 # ifdef OPENSSL_FIPS
143 int private_SHA224_Init(SHA256_CTX *c);
144 int private_SHA256_Init(SHA256_CTX *c);
145 # endif
146 int SHA224_Init(SHA256_CTX *c);
147 int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
148 int SHA224_Final(unsigned char *md, SHA256_CTX *c);
149 unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
150 int SHA256_Init(SHA256_CTX *c);
151 int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
152 int SHA256_Final(unsigned char *md, SHA256_CTX *c);
153 unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
154 void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
155 # endif
156 
157 # define SHA384_DIGEST_LENGTH 48
158 # define SHA512_DIGEST_LENGTH 64
159 
160 # ifndef OPENSSL_NO_SHA512
161 /*
162  * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64
163  * being exactly 64-bit wide. See Implementation Notes in sha512.c
164  * for further details.
165  */
166 /*
167  * SHA-512 treats input data as a
168  * contiguous array of 64 bit
169  * wide big-endian values.
170  */
171 # define SHA512_CBLOCK (SHA_LBLOCK*8)
172 # if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
173 # define SHA_LONG64 unsigned __int64
174 # define U64(C) C##UI64
175 # elif defined(__arch64__)
176 # define SHA_LONG64 unsigned long
177 # define U64(C) C##UL
178 # else
179 # define SHA_LONG64 unsigned long long
180 # define U64(C) C##ULL
181 # endif
182 
183 typedef struct SHA512state_st {
184  SHA_LONG64 h[8];
185  SHA_LONG64 Nl, Nh;
186  union {
187  SHA_LONG64 d[SHA_LBLOCK];
188  unsigned char p[SHA512_CBLOCK];
189  } u;
190  unsigned int num, md_len;
191 } SHA512_CTX;
192 # endif
193 
194 # ifndef OPENSSL_NO_SHA512
195 # ifdef OPENSSL_FIPS
196 int private_SHA384_Init(SHA512_CTX *c);
197 int private_SHA512_Init(SHA512_CTX *c);
198 # endif
199 int SHA384_Init(SHA512_CTX *c);
200 int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
201 int SHA384_Final(unsigned char *md, SHA512_CTX *c);
202 unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
203 int SHA512_Init(SHA512_CTX *c);
204 int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
205 int SHA512_Final(unsigned char *md, SHA512_CTX *c);
206 unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
207 void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
208 # endif
209 
210 #ifdef __cplusplus
211 }
212 #endif
213 
214 #endif
SHA512state_st::md_len
unsigned int md_len
Definition: sha.h:186
SHA224_Init
int SHA224_Init(SHA256_CTX *c)
SHA384_Update
int SHA384_Update(SHA512_CTX *c, const void *data, size_t len)
SHA1
unsigned char * SHA1(const unsigned char *d, size_t n, unsigned char *md)
SHA512state_st::Nh
SHA_LONG64 Nh
Definition: sha.h:181
SHA512_Update
int SHA512_Update(SHA512_CTX *c, const void *data, size_t len)
SHA_Final
int SHA_Final(unsigned char *md, SHA_CTX *c)
SHA_LONG
#define SHA_LONG
Definition: sha.h:90
SHA256state_st::md_len
unsigned int md_len
Definition: sha.h:134
SHA384_Final
int SHA384_Final(unsigned char *md, SHA512_CTX *c)
SHA256state_st
Definition: sha.h:130
SHA512state_st
Definition: sha.h:179
SHA512_Transform
void SHA512_Transform(SHA512_CTX *c, const unsigned char *data)
SHA_Update
int SHA_Update(SHA_CTX *c, const void *data, size_t len)
SHA
unsigned char * SHA(const unsigned char *d, size_t n, unsigned char *md)
SHAstate_st::Nl
SHA_LONG Nl
Definition: sha.h:100
SHAstate_st::Nh
SHA_LONG Nh
Definition: sha.h:100
SHA512state_st::d
SHA_LONG64 d[SHA_LBLOCK]
Definition: sha.h:183
SHA512_Final
int SHA512_Final(unsigned char *md, SHA512_CTX *c)
SHAstate_st
Definition: sha.h:98
SHA256
unsigned char * SHA256(const unsigned char *d, size_t n, unsigned char *md)
SHAstate_st::data
SHA_LONG data[SHA_LBLOCK]
Definition: sha.h:101
SHA_CTX
struct SHAstate_st SHA_CTX
SHAstate_st::h3
SHA_LONG h3
Definition: sha.h:99
SHA_LONG64
#define SHA_LONG64
Definition: sha.h:175
SHA1_Update
int SHA1_Update(SHA_CTX *c, const void *data, size_t len)
SHA256state_st::h
SHA_LONG h[8]
Definition: sha.h:131
SHAstate_st::h4
SHA_LONG h4
Definition: sha.h:99
SHA256_Transform
void SHA256_Transform(SHA256_CTX *c, const unsigned char *data)
SHA_Init
int SHA_Init(SHA_CTX *c)
SHA1_Transform
void SHA1_Transform(SHA_CTX *c, const unsigned char *data)
SHA224_Final
int SHA224_Final(unsigned char *md, SHA256_CTX *c)
SHA512state_st::Nl
SHA_LONG64 Nl
Definition: sha.h:181
SHA512
unsigned char * SHA512(const unsigned char *d, size_t n, unsigned char *md)
SHA512state_st::h
SHA_LONG64 h[8]
Definition: sha.h:180
SHA256_Init
int SHA256_Init(SHA256_CTX *c)
SHA_Transform
void SHA_Transform(SHA_CTX *c, const unsigned char *data)
SHA256_Final
int SHA256_Final(unsigned char *md, SHA256_CTX *c)
SHA512state_st::u
union SHA512state_st::@0 u
SHAstate_st::num
unsigned int num
Definition: sha.h:102
SHA_LBLOCK
#define SHA_LBLOCK
Definition: sha.h:93
SHA384
unsigned char * SHA384(const unsigned char *d, size_t n, unsigned char *md)
SHA512_CTX
struct SHA512state_st SHA512_CTX
SHA224_Update
int SHA224_Update(SHA256_CTX *c, const void *data, size_t len)
SHA256state_st::Nl
SHA_LONG Nl
Definition: sha.h:132
SHAstate_st::h0
SHA_LONG h0
Definition: sha.h:99
SHA1_Final
int SHA1_Final(unsigned char *md, SHA_CTX *c)
SHA256_CTX
struct SHA256state_st SHA256_CTX
SHA256state_st::num
unsigned int num
Definition: sha.h:134
SHA256state_st::Nh
SHA_LONG Nh
Definition: sha.h:132
SHA512state_st::num
unsigned int num
Definition: sha.h:186
SHAstate_st::h1
SHA_LONG h1
Definition: sha.h:99
SHA512state_st::p
unsigned char p[SHA512_CBLOCK]
Definition: sha.h:184
SHA224
unsigned char * SHA224(const unsigned char *d, size_t n, unsigned char *md)
SHA256state_st::data
SHA_LONG data[SHA_LBLOCK]
Definition: sha.h:133
SHA1_Init
int SHA1_Init(SHA_CTX *c)
SHA256_Update
int SHA256_Update(SHA256_CTX *c, const void *data, size_t len)
SHA512_CBLOCK
#define SHA512_CBLOCK
Definition: sha.h:167
SHA512_Init
int SHA512_Init(SHA512_CTX *c)
SHA384_Init
int SHA384_Init(SHA512_CTX *c)
SHAstate_st::h2
SHA_LONG h2
Definition: sha.h:99