Chinaunix首页 | 论坛 | 博客

Somebody has to win,so why n

首页　| 　博文目录　| 　关于我

kangkangrun

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

全部博文（90）

文章存档

2017年（12）

2016年（78）

我的朋友
最近访客
推荐博文
相关博文
sha-256 c代码

分类： 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

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

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

  44.    void sha256_init(sha256_context *);
  45.    void sha256_hash(sha256_context *, uint8_t * /* data */, uint32_t /* len */);
  46.    void sha256_done(sha256_context *, uint8_t * /* hash */);

  48. #ifdef __cplusplus
  49. }
  50. #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

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

  27. #ifdef __cplusplus
  28. extern "C" {
  29. #endif

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

  34. #define S0(x) (RR((x), 2) ^ RR((x),13) ^ RR((x),22))
  35. #define S1(x) (RR((x), 6) ^ RR((x),11) ^ RR((x),25))
  36. #define G0(x) (RR((x), 7) ^ RR((x),18) ^ ((x) >> 3))
  37. #define G1(x) (RR((x),17) ^ RR((x),19) ^ ((x) >> 10))

  39. #ifdef SWAP_BYTES
  40. #define BSWP(x,y) _bswapw((uint32_t *)(x), (uint32_t)(y))
  41. #else
  42. #define BSWP(p,n)
  43. #endif
  44. #ifdef USE_STD_MEMCPY
  45. #define MEMCP(x,y,z) memcpy((x),(y),(z))
  46. #else
  47. #define MEMCP(x,y,z) _memcp((x),(y),(z))
  48. #endif

  50. #ifndef __cdecl
  51. #define __cdecl
  52. #endif

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

  73. /* -------------------------------------------------------------------------- */
  74. static void _bswapw(uint32_t *p, uint32_t i)
  75. {
  76.     while (i--) p[i] = (RR(p[i],24) & 0x00ff00ff) | (RR(p[i],8) & 0xff00ff00);

  78. } /* _bswapw */

  80. /* -------------------------------------------------------------------------- */
  81. #ifndef USE_STD_MEMCPY
  82. void * __cdecl _memcp (void *d, const void *s, uint32_t sz)
  83. {
  84.     void *rv = d;

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

  88.     return(rv);
  89. } /* _memcp */
  90. #endif

  92. /* -------------------------------------------------------------------------- */
  93. static void _rtrf(uint32_t *b, uint32_t *p, uint32_t i, uint32_t j)
  94. {
  95.     #define B(x, y) b[(x-y) & 7]
  96.     #define P(x, y) p[(x+y) & 15]

  98.     B(7,i) += (j ? (p[i & 15] += G1(P(i,14)) + P(i,9) + G0(P(i,1))) : p[i & 15])
  99.               + K[i+j] + S1(B(4,i))
  100.               + (B(6,i) ^ (B(4,i) & (B(5,i) ^ B(6,i))));
  101.     B(3,i) += B(7,i);
  102.     B(7,i) += S0(B(0,i)) + ( (B(0,i) & B(1,i)) | (B(2,i) & (B(0,i) ^ B(1,i))) );

  104.     #undef P
  105.     #undef B
  106. } /* _rtrf */

  108. /* -------------------------------------------------------------------------- */
  109. static void _hash(sha256_context *ctx)
  110. {
  111.     uint32_t b[8], *p, j;

  113.     b[0] = ctx->hash[0]; b[1] = ctx->hash[1]; b[2] = ctx->hash[2];
  114.     b[3] = ctx->hash[3]; b[4] = ctx->hash[4]; b[5] = ctx->hash[5];
  115.     b[6] = ctx->hash[6]; b[7] = ctx->hash[7];

  117.     for (p = ctx->buf, j = 0; j < 64; j += 16)
  118.         _rtrf(b, p, 0, j), _rtrf(b, p, 1, j), _rtrf(b, p, 2, j),
  119.         _rtrf(b, p, 3, j), _rtrf(b, p, 4, j), _rtrf(b, p, 5, j),
  120.         _rtrf(b, p, 6, j), _rtrf(b, p, 7, j), _rtrf(b, p, 8, j),
  121.         _rtrf(b, p, 9, j), _rtrf(b, p, 10, j), _rtrf(b, p, 11, j),
  122.         _rtrf(b, p, 12, j), _rtrf(b, p, 13, j), _rtrf(b, p, 14, j),
  123.         _rtrf(b, p, 15, j);

  125.     ctx->hash[0] += b[0]; ctx->hash[1] += b[1]; ctx->hash[2] += b[2];
  126.     ctx->hash[3] += b[3]; ctx->hash[4] += b[4]; ctx->hash[5] += b[5];
  127.     ctx->hash[6] += b[6]; ctx->hash[7] += b[7];

  129. } /* _hash */

  131. /* -------------------------------------------------------------------------- */
  132. void sha256_init(sha256_context ctx[1])
  133. {
  134.     ctx->len[0] = ctx->len[1] = 0;
  135.     ctx->hash[0] = 0x6a09e667; ctx->hash[1] = 0xbb67ae85;
  136.     ctx->hash[2] = 0x3c6ef372; ctx->hash[3] = 0xa54ff53a;
  137.     ctx->hash[4] = 0x510e527f; ctx->hash[5] = 0x9b05688c;
  138.     ctx->hash[6] = 0x1f83d9ab; ctx->hash[7] = 0x5be0cd19;

  140. } /* sha256_init */

  142. /* -------------------------------------------------------------------------- */
  143. void sha256_hash(sha256_context *ctx, uint8_t *dat, uint32_t sz)
  144. {
  145.     register uint32_t i = ctx->len[0] & 63, l, j;

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

  149.     for (j = 0, l = 64-i; sz >= l; j += l, sz -= l, l = 64, i = 0)
  150.     {
  151.         MEMCP(&ctx->buf[i], &dat[j], l);
  152.         BSWP(ctx->buf, 16 );
  153.         _hash(ctx);
  154.     }
  155.     MEMCP(&ctx->buf[i], &dat[j], sz);

  157. } /* _hash */

  159. /* -------------------------------------------------------------------------- */
  160. void sha256_done(sha256_context *ctx, uint8_t *buf)
  161. {
  162.     uint32_t i = (uint32_t)(ctx->len[0] & 63), j = ((~i) & 3) << 3;

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

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

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

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

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

  177.     _hash(ctx);

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

  183. } /* sha256_done */


  186. #ifdef SELF_TEST
  187. #pragma warning (push, 0)
  188. #include <stdio.h>
  189. #include <stdlib.h>
  190. #include <string.h>
  191. #pragma warning(pop)

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

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

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

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

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

  209.     "bhn5bjmoniertqea40wro2upyflkydsibsk8ylkmgbvwi420t44cq034eou1szc1k0mk46oeb7ktzmlxqkbte2sy",
  210.     "9085df2f 02e0cc45 5928d0f5 1b27b4bf 1d9cd260 a66ed1fd a11b0a3f f5756d99"
  211. };

  213. int main(int argc, char *argv[])
  214. {
  215.     sha256_context ctx;
  216.     uint8_t hv[32];
  217.     uint32_t i, j;

  219.     for (j = 0; j < (sizeof(buf)/sizeof(buf[0])); j += 2)
  220.     {
  221.         sha256_init(&ctx);
  222.         sha256_hash(&ctx, (uint8_t *)buf[j], (uint32_t)strlen(buf[j]));
  223.         sha256_done(&ctx, hv);
  224.         printf("input = %s\ndigest: %s\nresult: ", buf[j], buf[j+1]);
  225.         for (i = 0; i < 32; i++) printf("%02x%s", hv[i], ((i%4)==3)?" ":"");
  226.         printf("\n\n");
  227.     }

  229.     for (j = 1; j < (uint32_t)argc; j++)
  230.     {
  231.         printf("argv[%d]: %s\nresult: ", (int)j, argv[j]);
  232.         sha256_init(&ctx);
  233.         sha256_hash(&ctx, (uint8_t *)argv[j], (uint32_t)strlen(argv[j]));
  234.         sha256_done(&ctx, hv);
  235.         for (i = 0; i < 32; i++) printf("%02x%s", hv[i], ((i%4)==3)?" ":"");
  236.         printf("\n\n");
  237.     }

  239.     return 0;
  240. } /* main */
  241. #endif

  243. #ifdef __cplusplus
  244. }
  245. #endif
    经测试完全可以直接编译运行。

阅读(2422) | 评论(0) | 转发(0) |
1

上一篇：md5加密算法c语言版

下一篇：C语言文件操作之文件打开方式

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6