Botan  1.11.15
src/lib/hash/sha2_32/sha2_32.cpp
Go to the documentation of this file.
00001 /*
00002 * SHA-{224,256}
00003 * (C) 1999-2010 Jack Lloyd
00004 *     2007 FlexSecure GmbH
00005 *
00006 * Botan is released under the Simplified BSD License (see license.txt)
00007 */
00008 
00009 #include <botan/internal/hash_utils.h>
00010 #include <botan/sha2_32.h>
00011 
00012 namespace Botan {
00013 
00014 BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_224, "SHA-224");
00015 BOTAN_REGISTER_HASH_NAMED_NOARGS(SHA_256, "SHA-256");
00016 
00017 namespace {
00018 
00019 namespace SHA2_32 {
00020 
00021 /*
00022 * SHA-256 Rho Function
00023 */
00024 inline u32bit rho(u32bit X, u32bit rot1, u32bit rot2, u32bit rot3)
00025    {
00026    return (rotate_right(X, rot1) ^ rotate_right(X, rot2) ^
00027            rotate_right(X, rot3));
00028    }
00029 
00030 /*
00031 * SHA-256 Sigma Function
00032 */
00033 inline u32bit sigma(u32bit X, u32bit rot1, u32bit rot2, u32bit shift)
00034    {
00035    return (rotate_right(X, rot1) ^ rotate_right(X, rot2) ^ (X >> shift));
00036    }
00037 
00038 /*
00039 * SHA-256 F1 Function
00040 *
00041 * Use a macro as many compilers won't inline a function this big,
00042 * even though it is much faster if inlined.
00043 */
00044 #define SHA2_32_F(A, B, C, D, E, F, G, H, M1, M2, M3, M4, magic)   \
00045    do {                                                            \
00046       H += magic + rho(E, 6, 11, 25) + ((E & F) ^ (~E & G)) + M1;  \
00047       D += H;                                                      \
00048       H += rho(A, 2, 13, 22) + ((A & B) | ((A | B) & C));          \
00049       M1 += sigma(M2, 17, 19, 10) + M3 + sigma(M4, 7, 18, 3);      \
00050    } while(0);
00051 
00052 /*
00053 * SHA-224 / SHA-256 compression function
00054 */
00055 void compress(secure_vector<u32bit>& digest,
00056               const byte input[], size_t blocks)
00057    {
00058    u32bit A = digest[0], B = digest[1], C = digest[2],
00059           D = digest[3], E = digest[4], F = digest[5],
00060           G = digest[6], H = digest[7];
00061 
00062    for(size_t i = 0; i != blocks; ++i)
00063       {
00064       u32bit W00 = load_be<u32bit>(input,  0);
00065       u32bit W01 = load_be<u32bit>(input,  1);
00066       u32bit W02 = load_be<u32bit>(input,  2);
00067       u32bit W03 = load_be<u32bit>(input,  3);
00068       u32bit W04 = load_be<u32bit>(input,  4);
00069       u32bit W05 = load_be<u32bit>(input,  5);
00070       u32bit W06 = load_be<u32bit>(input,  6);
00071       u32bit W07 = load_be<u32bit>(input,  7);
00072       u32bit W08 = load_be<u32bit>(input,  8);
00073       u32bit W09 = load_be<u32bit>(input,  9);
00074       u32bit W10 = load_be<u32bit>(input, 10);
00075       u32bit W11 = load_be<u32bit>(input, 11);
00076       u32bit W12 = load_be<u32bit>(input, 12);
00077       u32bit W13 = load_be<u32bit>(input, 13);
00078       u32bit W14 = load_be<u32bit>(input, 14);
00079       u32bit W15 = load_be<u32bit>(input, 15);
00080 
00081       SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x428A2F98);
00082       SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x71374491);
00083       SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0xB5C0FBCF);
00084       SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0xE9B5DBA5);
00085       SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x3956C25B);
00086       SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x59F111F1);
00087       SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x923F82A4);
00088       SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0xAB1C5ED5);
00089       SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xD807AA98);
00090       SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x12835B01);
00091       SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x243185BE);
00092       SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x550C7DC3);
00093       SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x72BE5D74);
00094       SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0x80DEB1FE);
00095       SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x9BDC06A7);
00096       SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC19BF174);
00097       SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0xE49B69C1);
00098       SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0xEFBE4786);
00099       SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x0FC19DC6);
00100       SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x240CA1CC);
00101       SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x2DE92C6F);
00102       SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4A7484AA);
00103       SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5CB0A9DC);
00104       SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x76F988DA);
00105       SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x983E5152);
00106       SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA831C66D);
00107       SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xB00327C8);
00108       SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xBF597FC7);
00109       SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xC6E00BF3);
00110       SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD5A79147);
00111       SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0x06CA6351);
00112       SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x14292967);
00113       SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x27B70A85);
00114       SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x2E1B2138);
00115       SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x4D2C6DFC);
00116       SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x53380D13);
00117       SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x650A7354);
00118       SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x766A0ABB);
00119       SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x81C2C92E);
00120       SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x92722C85);
00121       SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0xA2BFE8A1);
00122       SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0xA81A664B);
00123       SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0xC24B8B70);
00124       SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0xC76C51A3);
00125       SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0xD192E819);
00126       SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xD6990624);
00127       SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xF40E3585);
00128       SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0x106AA070);
00129       SHA2_32_F(A, B, C, D, E, F, G, H, W00, W14, W09, W01, 0x19A4C116);
00130       SHA2_32_F(H, A, B, C, D, E, F, G, W01, W15, W10, W02, 0x1E376C08);
00131       SHA2_32_F(G, H, A, B, C, D, E, F, W02, W00, W11, W03, 0x2748774C);
00132       SHA2_32_F(F, G, H, A, B, C, D, E, W03, W01, W12, W04, 0x34B0BCB5);
00133       SHA2_32_F(E, F, G, H, A, B, C, D, W04, W02, W13, W05, 0x391C0CB3);
00134       SHA2_32_F(D, E, F, G, H, A, B, C, W05, W03, W14, W06, 0x4ED8AA4A);
00135       SHA2_32_F(C, D, E, F, G, H, A, B, W06, W04, W15, W07, 0x5B9CCA4F);
00136       SHA2_32_F(B, C, D, E, F, G, H, A, W07, W05, W00, W08, 0x682E6FF3);
00137       SHA2_32_F(A, B, C, D, E, F, G, H, W08, W06, W01, W09, 0x748F82EE);
00138       SHA2_32_F(H, A, B, C, D, E, F, G, W09, W07, W02, W10, 0x78A5636F);
00139       SHA2_32_F(G, H, A, B, C, D, E, F, W10, W08, W03, W11, 0x84C87814);
00140       SHA2_32_F(F, G, H, A, B, C, D, E, W11, W09, W04, W12, 0x8CC70208);
00141       SHA2_32_F(E, F, G, H, A, B, C, D, W12, W10, W05, W13, 0x90BEFFFA);
00142       SHA2_32_F(D, E, F, G, H, A, B, C, W13, W11, W06, W14, 0xA4506CEB);
00143       SHA2_32_F(C, D, E, F, G, H, A, B, W14, W12, W07, W15, 0xBEF9A3F7);
00144       SHA2_32_F(B, C, D, E, F, G, H, A, W15, W13, W08, W00, 0xC67178F2);
00145 
00146       A = (digest[0] += A);
00147       B = (digest[1] += B);
00148       C = (digest[2] += C);
00149       D = (digest[3] += D);
00150       E = (digest[4] += E);
00151       F = (digest[5] += F);
00152       G = (digest[6] += G);
00153       H = (digest[7] += H);
00154 
00155       input += 64;
00156       }
00157    }
00158 
00159 }
00160 
00161 }
00162 
00163 /*
00164 * SHA-224 compression function
00165 */
00166 void SHA_224::compress_n(const byte input[], size_t blocks)
00167    {
00168    SHA2_32::compress(digest, input, blocks);
00169    }
00170 
00171 /*
00172 * Copy out the digest
00173 */
00174 void SHA_224::copy_out(byte output[])
00175    {
00176    copy_out_vec_be(output, output_length(), digest);
00177    }
00178 
00179 /*
00180 * Clear memory of sensitive data
00181 */
00182 void SHA_224::clear()
00183    {
00184    MDx_HashFunction::clear();
00185    digest[0] = 0xC1059ED8;
00186    digest[1] = 0x367CD507;
00187    digest[2] = 0x3070DD17;
00188    digest[3] = 0xF70E5939;
00189    digest[4] = 0xFFC00B31;
00190    digest[5] = 0x68581511;
00191    digest[6] = 0x64F98FA7;
00192    digest[7] = 0xBEFA4FA4;
00193    }
00194 
00195 /*
00196 * SHA-256 compression function
00197 */
00198 void SHA_256::compress_n(const byte input[], size_t blocks)
00199    {
00200    SHA2_32::compress(digest, input, blocks);
00201    }
00202 
00203 /*
00204 * Copy out the digest
00205 */
00206 void SHA_256::copy_out(byte output[])
00207    {
00208    copy_out_vec_be(output, output_length(), digest);
00209    }
00210 
00211 /*
00212 * Clear memory of sensitive data
00213 */
00214 void SHA_256::clear()
00215    {
00216    MDx_HashFunction::clear();
00217    digest[0] = 0x6A09E667;
00218    digest[1] = 0xBB67AE85;
00219    digest[2] = 0x3C6EF372;
00220    digest[3] = 0xA54FF53A;
00221    digest[4] = 0x510E527F;
00222    digest[5] = 0x9B05688C;
00223    digest[6] = 0x1F83D9AB;
00224    digest[7] = 0x5BE0CD19;
00225    }
00226 
00227 }