Chinaunix首页 | 论坛 | 博客
  • 博客访问: 326148
  • 博文数量: 90
  • 博客积分: 0
  • 博客等级: 民兵
  • 技术积分: 113
  • 用 户 组: 普通用户
  • 注册时间: 2016-01-27 19:56
文章分类

全部博文(90)

文章存档

2017年(12)

2016年(78)

分类: C/C++

2016-03-22 13:40:20

最近做一个关于网页认证的测试程序,要用到sha-256算法,因为本人比较懒,在国内论坛着了半天没有发现可以直接拿来用的。最后在github上下载了一个,直接能用,共享给大家参考:
sha256.h

点击(此处)折叠或打开

  1. /*
  2. * SHA-256 implementation.
  3. *
  4. * Copyright (c) 2010 Ilya O. Levin, http://www.literatecode.com
  5. *
  6. * Permission to use, copy, modify, and distribute this software for any
  7. * purpose with or without fee is hereby granted, provided that the above
  8. * copyright notice and this permission notice appear in all copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11. * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12. * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13. * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14. * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15. * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #ifdef _MSC_VER
  19. #ifndef uint8_t
  20. typedef unsigned __int8 uint8_t;
  21. #endif
  22. #ifndef uint32_t
  23. typedef unsigned __int32 uint32_t;
  24. #endif
  25. #ifndef uint64_t
  26. typedef __int64 int64_t;
  27. typedef unsigned __int64 uint64_t;
  28. #endif
  29. #else
  30. #include <stdint.h>
  31. #endif

  32. #ifdef __cplusplus
  33. extern "C"
  34. {
  35. #endif

  36.    typedef struct {
  37.        uint32_t buf[16];
  38.        uint32_t hash[8];
  39.        uint32_t len[2];
  40.    } sha256_context;

  41.    void sha256_init(sha256_context *);
  42.    void sha256_hash(sha256_context *, uint8_t * /* data */, uint32_t /* len */);
  43.    void sha256_done(sha256_context *, uint8_t * /* hash */);

  44. #ifdef __cplusplus
  45. }
  46. #endif
sha256.c

点击(此处)折叠或打开

  1. /*
  2. * SHA-256 implementation.
  3. *
  4. * Copyright (c) 2010 Ilya O. Levin, http://www.literatecode.com
  5. *
  6. * Permission to use, copy, modify, and distribute this software for any
  7. * purpose with or without fee is hereby granted, provided that the above
  8. * copyright notice and this permission notice appear in all copies.
  9. *
  10. * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  11. * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  12. * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  13. * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  14. * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  15. * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  16. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  17. */
  18. #define SWAP_BYTES
  19. // #define USE_STD_MEMCPY
  20. #define SELF_TEST

  21. #ifdef USE_STD_MEMCPY
  22. #include <string.h>
  23. #endif
  24. #include "sha256.h"

  25. #ifdef __cplusplus
  26. extern "C" {
  27. #endif

  28. #define RL(x,n) (((x) << n) | ((x) >> (32 - n)))
  29. #define RR(x,n) (((x) >> n) | ((x) << (32 - n)))

  30. #define S0(x) (RR((x), 2) ^ RR((x),13) ^ RR((x),22))
  31. #define S1(x) (RR((x), 6) ^ RR((x),11) ^ RR((x),25))
  32. #define G0(x) (RR((x), 7) ^ RR((x),18) ^ ((x) >> 3))
  33. #define G1(x) (RR((x),17) ^ RR((x),19) ^ ((x) >> 10))

  34. #ifdef SWAP_BYTES
  35. #define BSWP(x,y) _bswapw((uint32_t *)(x), (uint32_t)(y))
  36. #else
  37. #define BSWP(p,n)
  38. #endif
  39. #ifdef USE_STD_MEMCPY
  40. #define MEMCP(x,y,z) memcpy((x),(y),(z))
  41. #else
  42. #define MEMCP(x,y,z) _memcp((x),(y),(z))
  43. #endif

  44. #ifndef __cdecl
  45. #define __cdecl
  46. #endif

  47. static const uint32_t K[64] = {
  48.      0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
  49.      0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
  50.      0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
  51.      0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
  52.      0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
  53.      0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
  54.      0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
  55.      0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
  56.      0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
  57.      0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
  58.      0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
  59.      0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
  60.      0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
  61.      0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
  62.      0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
  63.      0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
  64. };

  65. /* -------------------------------------------------------------------------- */
  66. static void _bswapw(uint32_t *p, uint32_t i)
  67. {
  68.     while (i--) p[i] = (RR(p[i],24) & 0x00ff00ff) | (RR(p[i],8) & 0xff00ff00);

  69. } /* _bswapw */

  70. /* -------------------------------------------------------------------------- */
  71. #ifndef USE_STD_MEMCPY
  72. void * __cdecl _memcp (void *d, const void *s, uint32_t sz)
  73. {
  74.     void *rv = d;

  75.     while (sz--) *(char *)d = *(char *)s, d = (char *)d + 1, s = (char *)s + 1;

  76.     return(rv);
  77. } /* _memcp */
  78. #endif

  79. /* -------------------------------------------------------------------------- */
  80. static void _rtrf(uint32_t *b, uint32_t *p, uint32_t i, uint32_t j)
  81. {
  82.     #define B(x, y) b[(x-y) & 7]
  83.     #define P(x, y) p[(x+y) & 15]

  84.     B(7,i) += (j ? (p[i & 15] += G1(P(i,14)) + P(i,9) + G0(P(i,1))) : p[i & 15])
  85.               + K[i+j] + S1(B(4,i))
  86.               + (B(6,i) ^ (B(4,i) & (B(5,i) ^ B(6,i))));
  87.     B(3,i) += B(7,i);
  88.     B(7,i) += S0(B(0,i)) + ( (B(0,i) & B(1,i)) | (B(2,i) & (B(0,i) ^ B(1,i))) );

  89.     #undef P
  90.     #undef B
  91. } /* _rtrf */

  92. /* -------------------------------------------------------------------------- */
  93. static void _hash(sha256_context *ctx)
  94. {
  95.     uint32_t b[8], *p, j;

  96.     b[0] = ctx->hash[0]; b[1] = ctx->hash[1]; b[2] = ctx->hash[2];
  97.     b[3] = ctx->hash[3]; b[4] = ctx->hash[4]; b[5] = ctx->hash[5];
  98.     b[6] = ctx->hash[6]; b[7] = ctx->hash[7];

  99.     for (p = ctx->buf, j = 0; j < 64; j += 16)
  100.         _rtrf(b, p, 0, j), _rtrf(b, p, 1, j), _rtrf(b, p, 2, j),
  101.         _rtrf(b, p, 3, j), _rtrf(b, p, 4, j), _rtrf(b, p, 5, j),
  102.         _rtrf(b, p, 6, j), _rtrf(b, p, 7, j), _rtrf(b, p, 8, j),
  103.         _rtrf(b, p, 9, j), _rtrf(b, p, 10, j), _rtrf(b, p, 11, j),
  104.         _rtrf(b, p, 12, j), _rtrf(b, p, 13, j), _rtrf(b, p, 14, j),
  105.         _rtrf(b, p, 15, j);

  106.     ctx->hash[0] += b[0]; ctx->hash[1] += b[1]; ctx->hash[2] += b[2];
  107.     ctx->hash[3] += b[3]; ctx->hash[4] += b[4]; ctx->hash[5] += b[5];
  108.     ctx->hash[6] += b[6]; ctx->hash[7] += b[7];

  109. } /* _hash */

  110. /* -------------------------------------------------------------------------- */
  111. void sha256_init(sha256_context ctx[1])
  112. {
  113.     ctx->len[0] = ctx->len[1] = 0;
  114.     ctx->hash[0] = 0x6a09e667; ctx->hash[1] = 0xbb67ae85;
  115.     ctx->hash[2] = 0x3c6ef372; ctx->hash[3] = 0xa54ff53a;
  116.     ctx->hash[4] = 0x510e527f; ctx->hash[5] = 0x9b05688c;
  117.     ctx->hash[6] = 0x1f83d9ab; ctx->hash[7] = 0x5be0cd19;

  118. } /* sha256_init */

  119. /* -------------------------------------------------------------------------- */
  120. void sha256_hash(sha256_context *ctx, uint8_t *dat, uint32_t sz)
  121. {
  122.     register uint32_t i = ctx->len[0] & 63, l, j;

  123.     if ((ctx->len[0] += sz) < sz) ++(ctx->len[1]);

  124.     for (j = 0, l = 64-i; sz >= l; j += l, sz -= l, l = 64, i = 0)
  125.     {
  126.         MEMCP(&ctx->buf[i], &dat[j], l);
  127.         BSWP(ctx->buf, 16 );
  128.         _hash(ctx);
  129.     }
  130.     MEMCP(&ctx->buf[i], &dat[j], sz);

  131. } /* _hash */

  132. /* -------------------------------------------------------------------------- */
  133. void sha256_done(sha256_context *ctx, uint8_t *buf)
  134. {
  135.     uint32_t i = (uint32_t)(ctx->len[0] & 63), j = ((~i) & 3) << 3;

  136.     BSWP(ctx->buf, (i + 3) >> 2);

  137.     ctx->buf[i >> 2] &= 0xffffff80 << j; /* add padding */
  138.     ctx->buf[i >> 2] |= 0x00000080 << j;

  139.     if (i < 56) i = (i >> 2) + 1;
  140.        else ctx->buf[15] ^= (i < 60) ? ctx->buf[15] : 0, _hash(ctx), i = 0;

  141.     while (i < 14) ctx->buf[i++] = 0;

  142.     ctx->buf[14] = (ctx->len[1] << 3)|(ctx->len[0] >> 29); /* add length */
  143.     ctx->buf[15] = ctx->len[0] << 3;

  144.     _hash(ctx);

  145.     for (i = 0; i < 32; i++)
  146.        ctx->buf[i % 16] = 0, /* may remove this line in case of a DIY cleanup */
  147.        buf[i] = (uint8_t)(ctx->hash[i >> 2] >> ((~i & 3) << 3));

  148. } /* sha256_done */


  149. #ifdef SELF_TEST
  150. #pragma warning (push, 0)
  151. #include <stdio.h>
  152. #include <stdlib.h>
  153. #include <string.h>
  154. #pragma warning(pop)

  155. char *buf[] = {
  156.     "",
  157.     "e3b0c442 98fc1c14 9afbf4c8 996fb924 27ae41e4 649b934c a495991b 7852b855",

  158.     "abc",
  159.     "ba7816bf 8f01cfea 414140de 5dae2223 b00361a3 96177a9c b410ff61 f20015ad",

  160.     "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
  161.     "248d6a61 d20638b8 e5c02693 0c3e6039 a33ce459 64ff2167 f6ecedd4 19db06c1",

  162.     "The quick brown fox jumps over the lazy dog",
  163.     "d7a8fbb3 07d78094 69ca9abc b0082e4f 8d5651e4 6d3cdb76 2d02d0bf 37c9e592",

  164.     "The quick brown fox jumps over the lazy cog", /* avalanche effect test */
  165.     "e4c4d8f3 bf76b692 de791a17 3e053211 50f7a345 b46484fe 427f6acc 7ecc81be",

  166.     "bhn5bjmoniertqea40wro2upyflkydsibsk8ylkmgbvwi420t44cq034eou1szc1k0mk46oeb7ktzmlxqkbte2sy",
  167.     "9085df2f 02e0cc45 5928d0f5 1b27b4bf 1d9cd260 a66ed1fd a11b0a3f f5756d99"
  168. };

  169. int main(int argc, char *argv[])
  170. {
  171.     sha256_context ctx;
  172.     uint8_t hv[32];
  173.     uint32_t i, j;

  174.     for (j = 0; j < (sizeof(buf)/sizeof(buf[0])); j += 2)
  175.     {
  176.         sha256_init(&ctx);
  177.         sha256_hash(&ctx, (uint8_t *)buf[j], (uint32_t)strlen(buf[j]));
  178.         sha256_done(&ctx, hv);
  179.         printf("input = %s\ndigest: %s\nresult: ", buf[j], buf[j+1]);
  180.         for (i = 0; i < 32; i++) printf("%02x%s", hv[i], ((i%4)==3)?" ":"");
  181.         printf("\n\n");
  182.     }

  183.     for (j = 1; j < (uint32_t)argc; j++)
  184.     {
  185.         printf("argv[%d]: %s\nresult: ", (int)j, argv[j]);
  186.         sha256_init(&ctx);
  187.         sha256_hash(&ctx, (uint8_t *)argv[j], (uint32_t)strlen(argv[j]));
  188.         sha256_done(&ctx, hv);
  189.         for (i = 0; i < 32; i++) printf("%02x%s", hv[i], ((i%4)==3)?" ":"");
  190.         printf("\n\n");
  191.     }

  192.     return 0;
  193. } /* main */
  194. #endif

  195. #ifdef __cplusplus
  196. }
  197. #endif
    经测试完全可以直接编译运行。

阅读(1932) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~