2017年中国优秀政务平台推荐及综合影响力评估结果通报

  
      Line
      Branch
      Exec
      Source
    
      /*
    
       * Copyright (C) 2012 Martin Storsjo
    
       *
    
       * This file is part of FFmpeg.
    
       *
    
       * FFmpeg is free software; you can redistribute it and/or
    
       * modify it under the terms of the GNU Lesser General Public
    
       * License as published by the Free Software Foundation; either
    
       * version 2.1 of the License, or (at your option) any later version.
    
       *
    
       * FFmpeg is distributed in the hope that it will be useful,
    
       * but WITHOUT ANY WARRANTY; without even the implied warranty of
    
       * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    
       * Lesser General Public License for more details.
    
       *
    
       * You should have received a copy of the GNU Lesser General Public
    
       * License along with FFmpeg; if not, write to the Free Software
    
       * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
    
       */
    
      #include <stddef.h>
    
      #include <stdint.h>
    
      #include <string.h>
    
      #include "attributes.h"
    
      #include "error.h"
    
      #include "hmac.h"
    
      #include "md5.h"
    
      #include "sha.h"
    
      #include "sha512.h"
    
      #include "mem.h"
    
      #define MAX_HASHLEN 64
    
      #define MAX_BLOCKLEN 128
    
      typedef void (*hmac_final)(void *ctx, uint8_t *dst);
    
      typedef void (*hmac_update)(void *ctx, const uint8_t *src, size_t len);
    
      typedef void (*hmac_init)(void *ctx);
    
      struct AVHMAC {
    
          void *hash;
    
          int blocklen, hashlen;
    
          hmac_final  final;
    
          hmac_update update;
    
          hmac_init   init;
    
          uint8_t key[MAX_BLOCKLEN];
    
          int keylen;
    
      };
    
      #define DEFINE_ALGO_BITS_INIT(prefix, bits)        \
    
      static av_cold void prefix##bits##_init(void *ctx) \
    
      {                                                  \
    
          av_##prefix##_init(ctx, bits);                 \
    
      }
    
      #define DEFINE_ALGO_INIT(prefix)             \
    
      static av_cold void prefix##_init(void *ctx) \
    
      {                                            \
    
          av_##prefix##_init(ctx);                 \
    
      }
    
      #define DEFINE_ALGO(prefix)                                            \
    
      static void prefix##_update(void *ctx, const uint8_t *src, size_t len) \
    
      {                                                                      \
    
          av_##prefix##_update(ctx, src, len);                               \
    
      }                                                                      \
    
      static void prefix##_final(void *ctx, uint8_t *dst)                    \
    
      {                                                                      \
    
          av_##prefix##_final(ctx, dst);                                     \
    
      }
    
      12
      DEFINE_ALGO_INIT(md5)
    
      48
      DEFINE_ALGO_BITS_INIT(sha, 160)
    
      12
      DEFINE_ALGO_BITS_INIT(sha, 224)
    
      12
      DEFINE_ALGO_BITS_INIT(sha, 256)
    
      12
      DEFINE_ALGO_BITS_INIT(sha512, 384)
    
      12
      DEFINE_ALGO_BITS_INIT(sha512, 512)
    
      68
      DEFINE_ALGO(md5)
    
      438
      DEFINE_ALGO(sha)
    
      136
      DEFINE_ALGO(sha512)
    
      21
      AVHMAC *av_hmac_alloc(enum AVHMACType type)
    
      {
    
      21
          AVHMAC *c = av_mallocz(sizeof(*c));
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.

      21
          if (!c)
    
      ✗
              return NULL;
    
        6/7✓ Branch 0 taken 1 times.
✓ Branch 1 taken 16 times.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 1 times.
✓ Branch 4 taken 1 times.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.

      21
          switch (type) {
    
      1
          case AV_HMAC_MD5:
    
      1
              c->blocklen = 64;
    
      1
              c->hashlen  = 16;
    
      1
              c->init     = md5_init;
    
      1
              c->update   = md5_update;
    
      1
              c->final    = md5_final;
    
      1
              c->hash     = av_md5_alloc();
    
      1
              break;
    
      16
          case AV_HMAC_SHA1:
    
      16
              c->blocklen = 64;
    
      16
              c->hashlen  = 20;
    
      16
              c->init     = sha160_init;
    
      16
              c->update   = sha_update;
    
      16
              c->final    = sha_final;
    
      16
              c->hash     = av_sha_alloc();
    
      16
              break;
    
      1
          case AV_HMAC_SHA224:
    
      1
              c->blocklen = 64;
    
      1
              c->hashlen  = 28;
    
      1
              c->init     = sha224_init;
    
      1
              c->update   = sha_update;
    
      1
              c->final    = sha_final;
    
      1
              c->hash     = av_sha_alloc();
    
      1
              break;
    
      1
          case AV_HMAC_SHA256:
    
      1
              c->blocklen = 64;
    
      1
              c->hashlen  = 32;
    
      1
              c->init     = sha256_init;
    
      1
              c->update   = sha_update;
    
      1
              c->final    = sha_final;
    
      1
              c->hash     = av_sha_alloc();
    
      1
              break;
    
      1
          case AV_HMAC_SHA384:
    
      1
              c->blocklen = 128;
    
      1
              c->hashlen  = 48;
    
      1
              c->init     = sha512384_init;
    
      1
              c->update   = sha512_update;
    
      1
              c->final    = sha512_final;
    
      1
              c->hash     = av_sha512_alloc();
    
      1
              break;
    
      1
          case AV_HMAC_SHA512:
    
      1
              c->blocklen = 128;
    
      1
              c->hashlen  = 64;
    
      1
              c->init     = sha512512_init;
    
      1
              c->update   = sha512_update;
    
      1
              c->final    = sha512_final;
    
      1
              c->hash     = av_sha512_alloc();
    
      1
              break;
    
      ✗
          default:
    
      ✗
              av_free(c);
    
      ✗
              return NULL;
    
          }
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.

      21
          if (!c->hash) {
    
      ✗
              av_free(c);
    
      ✗
              return NULL;
    
          }
    
      21
          return c;
    
      }
    
      21
      void av_hmac_free(AVHMAC *c)
    
      {
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.

      21
          if (!c)
    
      ✗
              return;
    
      21
          av_freep(&c->hash);
    
      21
          av_free(c);
    
      }
    
      48
      void av_hmac_init(AVHMAC *c, const uint8_t *key, unsigned int keylen)
    
      {
    
          int i;
    
          uint8_t block[MAX_BLOCKLEN];
    
        2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 36 times.

      48
          if (keylen > c->blocklen) {
    
      12
              c->init(c->hash);
    
      12
              c->update(c->hash, key, keylen);
    
      12
              c->final(c->hash, c->key);
    
      12
              c->keylen = c->hashlen;
    
          } else {
    
      36
              memcpy(c->key, key, keylen);
    
      36
              c->keylen = keylen;
    
          }
    
      48
          c->init(c->hash);
    
        2/2✓ Branch 0 taken 1032 times.
✓ Branch 1 taken 48 times.

      1080
          for (i = 0; i < c->keylen; i++)
    
      1032
              block[i] = c->key[i] ^ 0x36;
    
        2/2✓ Branch 0 taken 2680 times.
✓ Branch 1 taken 48 times.

      2728
          for (i = c->keylen; i < c->blocklen; i++)
    
      2680
              block[i] = 0x36;
    
      48
          c->update(c->hash, block, c->blocklen);
    
      48
      }
    
      57
      void av_hmac_update(AVHMAC *c, const uint8_t *data, unsigned int len)
    
      {
    
      57
          c->update(c->hash, data, len);
    
      57
      }
    
      48
      int av_hmac_final(AVHMAC *c, uint8_t *out, unsigned int outlen)
    
      {
    
          uint8_t block[MAX_BLOCKLEN];
    
          int i;
    
        1/2✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.

      48
          if (outlen < c->hashlen)
    
      ✗
              return AVERROR(EINVAL);
    
      48
          c->final(c->hash, out);
    
      48
          c->init(c->hash);
    
        2/2✓ Branch 0 taken 1032 times.
✓ Branch 1 taken 48 times.

      1080
          for (i = 0; i < c->keylen; i++)
    
      1032
              block[i] = c->key[i] ^ 0x5C;
    
        2/2✓ Branch 0 taken 2680 times.
✓ Branch 1 taken 48 times.

      2728
          for (i = c->keylen; i < c->blocklen; i++)
    
      2680
              block[i] = 0x5C;
    
      48
          c->update(c->hash, block, c->blocklen);
    
      48
          c->update(c->hash, out, c->hashlen);
    
      48
          c->final(c->hash, out);
    
      48
          return c->hashlen;
    
      }
    
      30
      int av_hmac_calc(AVHMAC *c, const uint8_t *data, unsigned int len,
    
                       const uint8_t *key, unsigned int keylen,
    
                       uint8_t *out, unsigned int outlen)
    
      {
    
      30
          av_hmac_init(c, key, keylen);
    
      30
          av_hmac_update(c, data, len);
    
      30
          return av_hmac_final(c, out, outlen);
    
      }

肿物是什么意思	海明威为什么自杀	榴莲不可以和什么食物一起吃	可乐加味精女人喝了什么效果	紫癜是什么意思
至加秦是什么字	雨水是什么意思	大便潜血弱阳性是什么原因	平板支撑是什么	越来越什么
输血四项检查是什么	气管炎吃什么食物好	耿耿于怀是什么意思	梦见黄鼠狼是什么意思	拔完火罐要注意什么
右边腰疼是什么原因	变蛋吃多了有什么好处和坏处	辅食是什么意思	血性是什么意思	长期手淫会有什么危害

心血管科是看什么病hcv9jop1ns5r.cn	门诊号是什么意思hcv8jop9ns8r.cn	爷爷和孙子是什么关系hcv8jop1ns5r.cn	婴儿呛奶是什么原因引起的xjhesheng.com	皮疹和湿疹有什么区别hcv8jop1ns0r.cn
包皮炎吃什么消炎药hcv7jop6ns8r.cn	胃病吃什么水果好aiwuzhiyu.com	什么首阔步hcv9jop8ns0r.cn	足银999是什么意思hcv7jop5ns6r.cn	水煮鱼一般用什么鱼hcv8jop3ns4r.cn
青梅是什么水果hcv9jop2ns5r.cn	什么鱼不属于发物hcv9jop0ns8r.cn	蚂蚁怕什么helloaicloud.com	老巫婆是什么意思hcv8jop4ns9r.cn	罗贯中和施耐庵是什么关系hcv8jop8ns5r.cn
小便发黄是什么原因引起的hcv8jop5ns1r.cn	女生的隐私部位长什么样cl108k.com	吃饭吧唧嘴有什么说法jiuxinfghf.com	什么情况下需要做造影hcv8jop1ns2r.cn	吴亦凡什么学历hcv8jop7ns4r.cn

Line	Branch	Exec	Source
1			/*
2			* Copyright (C) 2012 Martin Storsjo
3			*
4			* This file is part of FFmpeg.
5			*
6			* FFmpeg is free software; you can redistribute it and/or
7			* modify it under the terms of the GNU Lesser General Public
8			* License as published by the Free Software Foundation; either
9			* version 2.1 of the License, or (at your option) any later version.
10			*
11			* FFmpeg is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14			* Lesser General Public License for more details.
15			*
16			* You should have received a copy of the GNU Lesser General Public
17			* License along with FFmpeg; if not, write to the Free Software
18			* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19			*/
20
21			#include <stddef.h>
22			#include <stdint.h>
23			#include <string.h>
24
25			#include "attributes.h"
26			#include "error.h"
27			#include "hmac.h"
28			#include "md5.h"
29			#include "sha.h"
30			#include "sha512.h"
31			#include "mem.h"
32
33			#define MAX_HASHLEN 64
34			#define MAX_BLOCKLEN 128
35
36			typedef void (hmac_final)(void ctx, uint8_t *dst);
37			typedef void (hmac_update)(void ctx, const uint8_t *src, size_t len);
38			typedef void (hmac_init)(void ctx);
39
40			struct AVHMAC {
41			void *hash;
42			int blocklen, hashlen;
43			hmac_final final;
44			hmac_update update;
45			hmac_init init;
46			uint8_t key[MAX_BLOCKLEN];
47			int keylen;
48			};
49
50			#define DEFINE_ALGO_BITS_INIT(prefix, bits) \
51			static av_cold void prefix##bits##_init(void *ctx) \
52			{ \
53			av_##prefix##_init(ctx, bits); \
54			}
55
56			#define DEFINE_ALGO_INIT(prefix) \
57			static av_cold void prefix##_init(void *ctx) \
58			{ \
59			av_##prefix##_init(ctx); \
60			}
61
62			#define DEFINE_ALGO(prefix) \
63			static void prefix##_update(void ctx, const uint8_t src, size_t len) \
64			{ \
65			av_##prefix##_update(ctx, src, len); \
66			} \
67			static void prefix##_final(void ctx, uint8_t dst) \
68			{ \
69			av_##prefix##_final(ctx, dst); \
70			}
71
72		12	DEFINE_ALGO_INIT(md5)
73		48	DEFINE_ALGO_BITS_INIT(sha, 160)
74		12	DEFINE_ALGO_BITS_INIT(sha, 224)
75		12	DEFINE_ALGO_BITS_INIT(sha, 256)
76		12	DEFINE_ALGO_BITS_INIT(sha512, 384)
77		12	DEFINE_ALGO_BITS_INIT(sha512, 512)
78		68	DEFINE_ALGO(md5)
79		438	DEFINE_ALGO(sha)
80		136	DEFINE_ALGO(sha512)
81
82		21	AVHMAC *av_hmac_alloc(enum AVHMACType type)
83			{
84		21	AVHMAC c = av_mallocz(sizeof(c));
85	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 21 times.	21	if (!c)
86		✗	return NULL;
87	6/7 ✓ Branch 0 taken 1 times. ✓ Branch 1 taken 16 times. ✓ Branch 2 taken 1 times. ✓ Branch 3 taken 1 times. ✓ Branch 4 taken 1 times. ✓ Branch 5 taken 1 times. ✗ Branch 6 not taken.	21	switch (type) {
88		1	case AV_HMAC_MD5:
89		1	c->blocklen = 64;
90		1	c->hashlen = 16;
91		1	c->init = md5_init;
92		1	c->update = md5_update;
93		1	c->final = md5_final;
94		1	c->hash = av_md5_alloc();
95		1	break;
96		16	case AV_HMAC_SHA1:
97		16	c->blocklen = 64;
98		16	c->hashlen = 20;
99		16	c->init = sha160_init;
100		16	c->update = sha_update;
101		16	c->final = sha_final;
102		16	c->hash = av_sha_alloc();
103		16	break;
104		1	case AV_HMAC_SHA224:
105		1	c->blocklen = 64;
106		1	c->hashlen = 28;
107		1	c->init = sha224_init;
108		1	c->update = sha_update;
109		1	c->final = sha_final;
110		1	c->hash = av_sha_alloc();
111		1	break;
112		1	case AV_HMAC_SHA256:
113		1	c->blocklen = 64;
114		1	c->hashlen = 32;
115		1	c->init = sha256_init;
116		1	c->update = sha_update;
117		1	c->final = sha_final;
118		1	c->hash = av_sha_alloc();
119		1	break;
120		1	case AV_HMAC_SHA384:
121		1	c->blocklen = 128;
122		1	c->hashlen = 48;
123		1	c->init = sha512384_init;
124		1	c->update = sha512_update;
125		1	c->final = sha512_final;
126		1	c->hash = av_sha512_alloc();
127		1	break;
128		1	case AV_HMAC_SHA512:
129		1	c->blocklen = 128;
130		1	c->hashlen = 64;
131		1	c->init = sha512512_init;
132		1	c->update = sha512_update;
133		1	c->final = sha512_final;
134		1	c->hash = av_sha512_alloc();
135		1	break;
136		✗	default:
137		✗	av_free(c);
138		✗	return NULL;
139			}
140	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 21 times.	21	if (!c->hash) {
141		✗	av_free(c);
142		✗	return NULL;
143			}
144		21	return c;
145			}
146
147		21	void av_hmac_free(AVHMAC *c)
148			{
149	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 21 times.	21	if (!c)
150		✗	return;
151		21	av_freep(&c->hash);
152		21	av_free(c);
153			}
154
155		48	void av_hmac_init(AVHMAC c, const uint8_t key, unsigned int keylen)
156			{
157			int i;
158			uint8_t block[MAX_BLOCKLEN];
159	2/2 ✓ Branch 0 taken 12 times. ✓ Branch 1 taken 36 times.	48	if (keylen > c->blocklen) {
160		12	c->init(c->hash);
161		12	c->update(c->hash, key, keylen);
162		12	c->final(c->hash, c->key);
163		12	c->keylen = c->hashlen;
164			} else {
165		36	memcpy(c->key, key, keylen);
166		36	c->keylen = keylen;
167			}
168		48	c->init(c->hash);
169	2/2 ✓ Branch 0 taken 1032 times. ✓ Branch 1 taken 48 times.	1080	for (i = 0; i < c->keylen; i++)
170		1032	block[i] = c->key[i] ^ 0x36;
171	2/2 ✓ Branch 0 taken 2680 times. ✓ Branch 1 taken 48 times.	2728	for (i = c->keylen; i < c->blocklen; i++)
172		2680	block[i] = 0x36;
173		48	c->update(c->hash, block, c->blocklen);
174		48	}
175
176		57	void av_hmac_update(AVHMAC c, const uint8_t data, unsigned int len)
177			{
178		57	c->update(c->hash, data, len);
179		57	}
180
181		48	int av_hmac_final(AVHMAC c, uint8_t out, unsigned int outlen)
182			{
183			uint8_t block[MAX_BLOCKLEN];
184			int i;
185	1/2 ✗ Branch 0 not taken. ✓ Branch 1 taken 48 times.	48	if (outlen < c->hashlen)
186		✗	return AVERROR(EINVAL);
187		48	c->final(c->hash, out);
188		48	c->init(c->hash);
189	2/2 ✓ Branch 0 taken 1032 times. ✓ Branch 1 taken 48 times.	1080	for (i = 0; i < c->keylen; i++)
190		1032	block[i] = c->key[i] ^ 0x5C;
191	2/2 ✓ Branch 0 taken 2680 times. ✓ Branch 1 taken 48 times.	2728	for (i = c->keylen; i < c->blocklen; i++)
192		2680	block[i] = 0x5C;
193		48	c->update(c->hash, block, c->blocklen);
194		48	c->update(c->hash, out, c->hashlen);
195		48	c->final(c->hash, out);
196		48	return c->hashlen;
197			}
198
199		30	int av_hmac_calc(AVHMAC c, const uint8_t data, unsigned int len,
200			const uint8_t *key, unsigned int keylen,
201			uint8_t *out, unsigned int outlen)
202			{
203		30	av_hmac_init(c, key, keylen);
204		30	av_hmac_update(c, data, len);
205		30	return av_hmac_final(c, out, outlen);
206			}
207