1 /* $OpenBSD: sha.h,v 1.21 2015/09/13 21:09:56 doug Exp $ */ 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 core.stdc.config.c_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 module libressl_d.openssl.sha; 59 60 61 private static import core.stdc.config; 62 public import core.stdc.stddef; 63 public import libressl_d.openssl.opensslconf; 64 65 //#if !defined(HAVE_ATTRIBUTE__BOUNDED__) && !defined(__OpenBSD__) 66 //#define __bounded__(x, y, z) 67 //#endif 68 69 extern (C): 70 nothrow @nogc: 71 72 version (OPENSSL_NO_SHA) { 73 static assert(false, "SHA is disabled."); 74 } else version (OPENSSL_NO_SHA1) { 75 static assert(false, "SHA is disabled."); 76 } 77 78 /* 79 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 80 * ! SHA_LONG has to be at least 32 bits wide. ! 81 * !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 82 */ 83 84 alias SHA_LONG = uint; 85 86 enum SHA_LBLOCK = 16; 87 88 /** 89 * SHA treats input data as a 90 * contiguous array of 32 bit 91 * wide big-endian values. 92 */ 93 enum SHA_CBLOCK = .SHA_LBLOCK * 4; 94 95 enum SHA_LAST_BLOCK = .SHA_CBLOCK - 8; 96 enum SHA_DIGEST_LENGTH = 20; 97 98 struct SHAstate_st 99 { 100 .SHA_LONG h0; 101 .SHA_LONG h1; 102 .SHA_LONG h2; 103 .SHA_LONG h3; 104 .SHA_LONG h4; 105 .SHA_LONG Nl; 106 .SHA_LONG Nh; 107 .SHA_LONG[.SHA_LBLOCK] data; 108 uint num; 109 } 110 111 alias SHA_CTX = SHAstate_st; 112 113 version (OPENSSL_NO_SHA1) { 114 } else { 115 int SHA1_Init(.SHA_CTX* c); 116 117 //__attribute__((__bounded__(__buffer__, 2, 3))); 118 int SHA1_Update(.SHA_CTX* c, const (void)* data, size_t len); 119 120 int SHA1_Final(ubyte* md, .SHA_CTX* c); 121 122 //__attribute__((__bounded__(__buffer__, 1, 2))); 123 ubyte* SHA1(const (ubyte)* d, size_t n, ubyte* md); 124 125 void SHA1_Transform(.SHA_CTX* c, const (ubyte)* data); 126 } 127 128 /** 129 * SHA-256 treats input data as a 130 * contiguous array of 32 bit 131 * wide big-endian values. 132 */ 133 enum SHA256_CBLOCK = .SHA_LBLOCK * 4; 134 135 enum SHA224_DIGEST_LENGTH = 28; 136 enum SHA256_DIGEST_LENGTH = 32; 137 138 struct SHA256state_st 139 { 140 .SHA_LONG[8] h; 141 .SHA_LONG Nl; 142 .SHA_LONG Nh; 143 .SHA_LONG[.SHA_LBLOCK] data; 144 uint num; 145 uint md_len; 146 } 147 148 alias SHA256_CTX = .SHA256state_st; 149 150 version (OPENSSL_NO_SHA256) { 151 } else { 152 int SHA224_Init(.SHA256_CTX* c); 153 154 //__attribute__((__bounded__(__buffer__, 2, 3))); 155 int SHA224_Update(.SHA256_CTX* c, const (void)* data, size_t len); 156 157 int SHA224_Final(ubyte* md, .SHA256_CTX* c); 158 159 //__attribute__((__bounded__(__buffer__, 1, 2))); 160 ubyte* SHA224(const (ubyte)* d, size_t n, ubyte* md); 161 162 int SHA256_Init(.SHA256_CTX* c); 163 164 //__attribute__((__bounded__(__buffer__, 2, 3))); 165 int SHA256_Update(.SHA256_CTX* c, const (void)* data, size_t len); 166 167 int SHA256_Final(ubyte* md, .SHA256_CTX* c); 168 169 //__attribute__((__bounded__(__buffer__, 1, 2))); 170 ubyte* SHA256(const (ubyte)* d, size_t n, ubyte* md); 171 172 void SHA256_Transform(.SHA256_CTX* c, const (ubyte)* data); 173 } 174 175 enum SHA384_DIGEST_LENGTH = 48; 176 enum SHA512_DIGEST_LENGTH = 64; 177 178 version (OPENSSL_NO_SHA512) { 179 } else { 180 /* 181 * Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64 182 * being exactly 64-bit wide. See Implementation Notes in sha512.c 183 * for further details. 184 */ 185 186 /** 187 * SHA-512 treats input data as a 188 * contiguous array of 64 bit 189 * wide big-endian values. 190 */ 191 enum SHA512_CBLOCK = .SHA_LBLOCK * 8; 192 193 alias SHA_LONG64 = ulong; 194 195 struct SHA512state_st 196 { 197 .SHA_LONG64[8] h; 198 .SHA_LONG64 Nl; 199 .SHA_LONG64 Nh; 200 201 union u_ 202 { 203 .SHA_LONG64[.SHA_LBLOCK] d; 204 ubyte[.SHA512_CBLOCK] p; 205 } 206 207 u_ u; 208 uint num; 209 uint md_len; 210 } 211 212 alias SHA512_CTX = .SHA512state_st; 213 } 214 215 version (OPENSSL_NO_SHA512) { 216 } else { 217 int SHA384_Init(.SHA512_CTX* c); 218 219 //__attribute__((__bounded__(__buffer__, 2, 3))); 220 int SHA384_Update(.SHA512_CTX* c, const (void)* data, size_t len); 221 222 int SHA384_Final(ubyte* md, .SHA512_CTX* c); 223 224 //__attribute__((__bounded__(__buffer__, 1, 2))); 225 ubyte* SHA384(const (ubyte)* d, size_t n, ubyte* md); 226 227 int SHA512_Init(.SHA512_CTX* c); 228 229 //__attribute__((__bounded__(__buffer__, 2, 3))); 230 int SHA512_Update(.SHA512_CTX* c, const (void)* data, size_t len); 231 232 int SHA512_Final(ubyte* md, .SHA512_CTX* c); 233 234 //__attribute__((__bounded__(__buffer__, 1, 2))); 235 ubyte* SHA512(const (ubyte)* d, size_t n, ubyte* md); 236 237 void SHA512_Transform(.SHA512_CTX* c, const (ubyte)* data); 238 }