FFmpeg: libavutil/hmac.c Source File

FFmpeg
hmac.c
Go to the documentation of this file.
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 "hmac.h"
27 #include "md5.h"
28 #include "sha.h"
29 #include "sha512.h"
30 #include "mem.h"
31 
32  #define MAX_HASHLEN 64
33  #define MAX_BLOCKLEN 128
34 
35  typedef void (*hmac_final)(void *ctx, uint8_t *dst);
36  typedef void (*hmac_update)(void *ctx, const uint8_t *src, size_t len);
37  typedef void (*hmac_init)(void *ctx);
38 
39  struct AVHMAC {
40   void *hash;
41   int blocklen, hashlen;
42   hmac_final final;
43   hmac_update update;
44   hmac_init init;
45   uint8_t key[MAX_BLOCKLEN];
46   int keylen;
47 };
48 
49  #define DEFINE_SHA(bits) \
50 static av_cold void sha ## bits ##_init(void *ctx) \
51 { \
52  av_sha_init(ctx, bits); \
53 }
54 
55  #define DEFINE_SHA512(bits) \
56 static av_cold void sha ## bits ##_init(void *ctx) \
57 { \
58  av_sha512_init(ctx, bits); \
59 }
60 
61 DEFINE_SHA(160)
62 DEFINE_SHA(224)
63 DEFINE_SHA(256)
64 DEFINE_SHA512(384)
65 DEFINE_SHA512(512)
66 
67  AVHMAC *av_hmac_alloc(enum AVHMACType type)
68 {
69  AVHMAC *c = av_mallocz(sizeof(*c));
70  if (!c)
71  return NULL;
72  switch (type) {
73  case AV_HMAC_MD5:
74  c->blocklen = 64;
75  c->hashlen = 16;
76  c->init = (hmac_init) av_md5_init;
77  c->update = (hmac_update) av_md5_update;
78  c->final = (hmac_final) av_md5_final;
79  c->hash = av_md5_alloc();
80  break;
81  case AV_HMAC_SHA1:
82  c->blocklen = 64;
83  c->hashlen = 20;
84  c->init = sha160_init;
85  c->update = (hmac_update) av_sha_update;
86  c->final = (hmac_final) av_sha_final;
87  c->hash = av_sha_alloc();
88  break;
89  case AV_HMAC_SHA224:
90  c->blocklen = 64;
91  c->hashlen = 28;
92  c->init = sha224_init;
93  c->update = (hmac_update) av_sha_update;
94  c->final = (hmac_final) av_sha_final;
95  c->hash = av_sha_alloc();
96  break;
97  case AV_HMAC_SHA256:
98  c->blocklen = 64;
99  c->hashlen = 32;
100  c->init = sha256_init;
101  c->update = (hmac_update) av_sha_update;
102  c->final = (hmac_final) av_sha_final;
103  c->hash = av_sha_alloc();
104  break;
105  case AV_HMAC_SHA384:
106  c->blocklen = 128;
107  c->hashlen = 48;
108  c->init = sha384_init;
109  c->update = (hmac_update) av_sha512_update;
110  c->final = (hmac_final) av_sha512_final;
111  c->hash = av_sha512_alloc();
112  break;
113  case AV_HMAC_SHA512:
114  c->blocklen = 128;
115  c->hashlen = 64;
116  c->init = sha512_init;
117  c->update = (hmac_update) av_sha512_update;
118  c->final = (hmac_final) av_sha512_final;
119  c->hash = av_sha512_alloc();
120  break;
121  default:
122  av_free(c);
123  return NULL;
124  }
125  if (!c->hash) {
126  av_free(c);
127  return NULL;
128  }
129  return c;
130 }
131 
132  void av_hmac_free(AVHMAC *c)
133 {
134  if (!c)
135  return;
136  av_freep(&c->hash);
137  av_free(c);
138 }
139 
140  void av_hmac_init(AVHMAC *c, const uint8_t *key, unsigned int keylen)
141 {
142  int i;
143  uint8_t block[MAX_BLOCKLEN];
144  if (keylen > c->blocklen) {
145  c->init(c->hash);
146  c->update(c->hash, key, keylen);
147  c->final(c->hash, c->key);
148  c->keylen = c->hashlen;
149  } else {
150  memcpy(c->key, key, keylen);
151  c->keylen = keylen;
152  }
153  c->init(c->hash);
154  for (i = 0; i < c->keylen; i++)
155  block[i] = c->key[i] ^ 0x36;
156  for (i = c->keylen; i < c->blocklen; i++)
157  block[i] = 0x36;
158  c->update(c->hash, block, c->blocklen);
159 }
160 
161  void av_hmac_update(AVHMAC *c, const uint8_t *data, unsigned int len)
162 {
163  c->update(c->hash, data, len);
164 }
165 
166  int av_hmac_final(AVHMAC *c, uint8_t *out, unsigned int outlen)
167 {
168  uint8_t block[MAX_BLOCKLEN];
169  int i;
170  if (outlen < c->hashlen)
171  return AVERROR(EINVAL);
172  c->final(c->hash, out);
173  c->init(c->hash);
174  for (i = 0; i < c->keylen; i++)
175  block[i] = c->key[i] ^ 0x5C;
176  for (i = c->keylen; i < c->blocklen; i++)
177  block[i] = 0x5C;
178  c->update(c->hash, block, c->blocklen);
179  c->update(c->hash, out, c->hashlen);
180  c->final(c->hash, out);
181  return c->hashlen;
182 }
183 
184  int av_hmac_calc(AVHMAC *c, const uint8_t *data, unsigned int len,
185  const uint8_t *key, unsigned int keylen,
186  uint8_t *out, unsigned int outlen)
187 {
188  av_hmac_init(c, key, keylen);
189  av_hmac_update(c, data, len);
190  return av_hmac_final(c, out, outlen);
191 }
AVHMAC
Definition: hmac.c:39
DEFINE_SHA512
#define DEFINE_SHA512(bits)
Definition: hmac.c:55
AVERROR
Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
av_sha512_final
void av_sha512_final(AVSHA512 *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha512.c:275
out
FILE * out
Definition: movenc.c:54
MAX_BLOCKLEN
#define MAX_BLOCKLEN
Definition: hmac.c:33
AV_HMAC_MD5
@ AV_HMAC_MD5
Definition: hmac.h:33
data
const char data[16]
Definition: mxf.c:143
av_sha512_alloc
struct AVSHA512 * av_sha512_alloc(void)
Allocate an AVSHA512 context.
Definition: sha512.c:44
hmac_update
void(* hmac_update)(void *ctx, const uint8_t *src, size_t len)
Definition: hmac.c:36
sha512.h
av_hmac_calc
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)
Hash an array of data with a key.
Definition: hmac.c:184
av_hmac_final
int av_hmac_final(AVHMAC *c, uint8_t *out, unsigned int outlen)
Finish hashing and output the HMAC digest.
Definition: hmac.c:166
AVHMAC::key
uint8_t key[MAX_BLOCKLEN]
Definition: hmac.c:45
hmac_final
void(* hmac_final)(void *ctx, uint8_t *dst)
Definition: hmac.c:35
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
DEFINE_SHA
#define DEFINE_SHA(bits)
Definition: hmac.c:49
ctx
AVFormatContext * ctx
Definition: movenc.c:48
key
const char * key
Definition: hwcontext_opencl.c:174
AVHMAC::update
hmac_update update
Definition: hmac.c:43
av_sha_final
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:347
AV_HMAC_SHA256
@ AV_HMAC_SHA256
Definition: hmac.h:36
NULL
#define NULL
Definition: coverity.c:32
sha.h
av_hmac_update
void av_hmac_update(AVHMAC *c, const uint8_t *data, unsigned int len)
Hash data with the HMAC.
Definition: hmac.c:161
AVHMAC::hash
void * hash
Definition: hmac.c:40
AVHMAC::keylen
int keylen
Definition: hmac.c:46
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AV_HMAC_SHA1
@ AV_HMAC_SHA1
Definition: hmac.h:34
AV_HMAC_SHA384
@ AV_HMAC_SHA384
Definition: hmac.h:37
AV_HMAC_SHA512
@ AV_HMAC_SHA512
Definition: hmac.h:38
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
av_sha_update
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, size_t len)
Update hash value.
Definition: sha.c:315
attributes.h
av_hmac_alloc
AVHMAC * av_hmac_alloc(enum AVHMACType type)
Allocate an AVHMAC context.
Definition: hmac.c:67
av_hmac_free
void av_hmac_free(AVHMAC *c)
Free an AVHMAC context.
Definition: hmac.c:132
av_sha_alloc
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:46
av_md5_init
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:141
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
av_hmac_init
void av_hmac_init(AVHMAC *c, const uint8_t *key, unsigned int keylen)
Initialize an AVHMAC context with an authentication key.
Definition: hmac.c:140
md5.h
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
len
int len
Definition: vorbis_enc_data.h:426
av_md5_final
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:186
AVHMAC::blocklen
int blocklen
Definition: hmac.c:41
AVHMACType
AVHMACType
Definition: hmac.h:32
av_md5_alloc
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:48
hmac_init
void(* hmac_init)(void *ctx)
Definition: hmac.c:37
av_md5_update
void av_md5_update(AVMD5 *ctx, const uint8_t *src, size_t len)
Update hash value.
Definition: md5.c:151
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVHMAC::hashlen
int hashlen
Definition: hmac.c:41
AV_HMAC_SHA224
@ AV_HMAC_SHA224
Definition: hmac.h:35
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
AVHMAC::init
hmac_init init
Definition: hmac.c:44
av_sha512_update
void av_sha512_update(AVSHA512 *ctx, const uint8_t *data, size_t len)
Update hash value.
Definition: sha512.c:243
hmac.h
Generated on Wed Aug 24 2022 21:42:22 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /