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 #include "version.h"
32 
33 #define MAX_HASHLEN 64
34 #define MAX_BLOCKLEN 128
35 
36 typedef void (*hmac_final)(void *ctx, uint8_t *dst);
37 #if FF_API_CRYPTO_SIZE_T
38 typedef void (*hmac_update)(void *ctx, const uint8_t *src, int len);
39 #else
40 typedef void (*hmac_update)(void *ctx, const uint8_t *src, size_t len);
41 #endif
42 typedef void (*hmac_init)(void *ctx);
43 
44 struct AVHMAC {
45  void *hash;
46  int blocklen, hashlen;
47  hmac_final final;
48  hmac_update update;
49  hmac_init init;
50  uint8_t key[MAX_BLOCKLEN];
51  int keylen;
52 };
53 
54 #define DEFINE_SHA(bits) \
55 static av_cold void sha ## bits ##_init(void *ctx) \
56 { \
57  av_sha_init(ctx, bits); \
58 }
59 
60 #define DEFINE_SHA512(bits) \
61 static av_cold void sha ## bits ##_init(void *ctx) \
62 { \
63  av_sha512_init(ctx, bits); \
64 }
65 
66 DEFINE_SHA(160)
67 DEFINE_SHA(224)
68 DEFINE_SHA(256)
69 DEFINE_SHA512(384)
70 DEFINE_SHA512(512)
71 
72 AVHMAC *av_hmac_alloc(enum AVHMACType type)
73 {
74  AVHMAC *c = av_mallocz(sizeof(*c));
75  if (!c)
76  return NULL;
77  switch (type) {
78  case AV_HMAC_MD5:
79  c->blocklen = 64;
80  c->hashlen = 16;
81  c->init = (hmac_init) av_md5_init;
82  c->update = (hmac_update) av_md5_update;
83  c->final = (hmac_final) av_md5_final;
84  c->hash = av_md5_alloc();
85  break;
86  case AV_HMAC_SHA1:
87  c->blocklen = 64;
88  c->hashlen = 20;
89  c->init = sha160_init;
90  c->update = (hmac_update) av_sha_update;
91  c->final = (hmac_final) av_sha_final;
92  c->hash = av_sha_alloc();
93  break;
94  case AV_HMAC_SHA224:
95  c->blocklen = 64;
96  c->hashlen = 28;
97  c->init = sha224_init;
98  c->update = (hmac_update) av_sha_update;
99  c->final = (hmac_final) av_sha_final;
100  c->hash = av_sha_alloc();
101  break;
102  case AV_HMAC_SHA256:
103  c->blocklen = 64;
104  c->hashlen = 32;
105  c->init = sha256_init;
106  c->update = (hmac_update) av_sha_update;
107  c->final = (hmac_final) av_sha_final;
108  c->hash = av_sha_alloc();
109  break;
110  case AV_HMAC_SHA384:
111  c->blocklen = 128;
112  c->hashlen = 48;
113  c->init = sha384_init;
114  c->update = (hmac_update) av_sha512_update;
115  c->final = (hmac_final) av_sha512_final;
116  c->hash = av_sha512_alloc();
117  break;
118  case AV_HMAC_SHA512:
119  c->blocklen = 128;
120  c->hashlen = 64;
121  c->init = sha512_init;
122  c->update = (hmac_update) av_sha512_update;
123  c->final = (hmac_final) av_sha512_final;
124  c->hash = av_sha512_alloc();
125  break;
126  default:
127  av_free(c);
128  return NULL;
129  }
130  if (!c->hash) {
131  av_free(c);
132  return NULL;
133  }
134  return c;
135 }
136 
137 void av_hmac_free(AVHMAC *c)
138 {
139  if (!c)
140  return;
141  av_freep(&c->hash);
142  av_free(c);
143 }
144 
145 void av_hmac_init(AVHMAC *c, const uint8_t *key, unsigned int keylen)
146 {
147  int i;
148  uint8_t block[MAX_BLOCKLEN];
149  if (keylen > c->blocklen) {
150  c->init(c->hash);
151  c->update(c->hash, key, keylen);
152  c->final(c->hash, c->key);
153  c->keylen = c->hashlen;
154  } else {
155  memcpy(c->key, key, keylen);
156  c->keylen = keylen;
157  }
158  c->init(c->hash);
159  for (i = 0; i < c->keylen; i++)
160  block[i] = c->key[i] ^ 0x36;
161  for (i = c->keylen; i < c->blocklen; i++)
162  block[i] = 0x36;
163  c->update(c->hash, block, c->blocklen);
164 }
165 
166 void av_hmac_update(AVHMAC *c, const uint8_t *data, unsigned int len)
167 {
168  c->update(c->hash, data, len);
169 }
170 
171 int av_hmac_final(AVHMAC *c, uint8_t *out, unsigned int outlen)
172 {
173  uint8_t block[MAX_BLOCKLEN];
174  int i;
175  if (outlen < c->hashlen)
176  return AVERROR(EINVAL);
177  c->final(c->hash, out);
178  c->init(c->hash);
179  for (i = 0; i < c->keylen; i++)
180  block[i] = c->key[i] ^ 0x5C;
181  for (i = c->keylen; i < c->blocklen; i++)
182  block[i] = 0x5C;
183  c->update(c->hash, block, c->blocklen);
184  c->update(c->hash, out, c->hashlen);
185  c->final(c->hash, out);
186  return c->hashlen;
187 }
188 
189 int av_hmac_calc(AVHMAC *c, const uint8_t *data, unsigned int len,
190  const uint8_t *key, unsigned int keylen,
191  uint8_t *out, unsigned int outlen)
192 {
193  av_hmac_init(c, key, keylen);
194  av_hmac_update(c, data, len);
195  return av_hmac_final(c, out, outlen);
196 }
AVHMAC
Definition: hmac.c:44
DEFINE_SHA512
#define DEFINE_SHA512(bits)
Definition: hmac.c:60
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:273
out
FILE * out
Definition: movenc.c:54
MAX_BLOCKLEN
#define MAX_BLOCKLEN
Definition: hmac.c:34
AV_HMAC_MD5
@ AV_HMAC_MD5
Definition: hmac.h:34
data
const char data[16]
Definition: mxf.c:91
av_sha512_alloc
struct AVSHA512 * av_sha512_alloc(void)
Allocate an AVSHA512 context.
Definition: sha512.c:43
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:189
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:171
AVHMAC::key
uint8_t key[MAX_BLOCKLEN]
Definition: hmac.c:50
hmac_final
void(* hmac_final)(void *ctx, uint8_t *dst)
Definition: hmac.c:36
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:54
ctx
AVFormatContext * ctx
Definition: movenc.c:48
key
const char * key
Definition: hwcontext_opencl.c:168
AVHMAC::update
hmac_update update
Definition: hmac.c:48
av_sha_final
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:345
AV_HMAC_SHA256
@ AV_HMAC_SHA256
Definition: hmac.h:37
NULL
#define NULL
Definition: coverity.c:32
sha.h
hmac_update
void(* hmac_update)(void *ctx, const uint8_t *src, int len)
Definition: hmac.c:38
src
#define src
Definition: vp8dsp.c:254
av_hmac_update
void av_hmac_update(AVHMAC *c, const uint8_t *data, unsigned int len)
Hash data with the HMAC.
Definition: hmac.c:166
AVHMAC::hash
void * hash
Definition: hmac.c:45
AVHMAC::keylen
int keylen
Definition: hmac.c:51
av_sha_update
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:315
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:35
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
AV_HMAC_SHA384
@ AV_HMAC_SHA384
Definition: hmac.h:38
AV_HMAC_SHA512
@ AV_HMAC_SHA512
Definition: hmac.h:39
attributes.h
av_hmac_alloc
AVHMAC * av_hmac_alloc(enum AVHMACType type)
Allocate an AVHMAC context.
Definition: hmac.c:72
av_hmac_free
void av_hmac_free(AVHMAC *c)
Free an AVHMAC context.
Definition: hmac.c:137
av_sha_alloc
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:45
av_md5_init
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:143
av_sha512_update
void av_sha512_update(AVSHA512 *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha512.c:243
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:145
md5.h
uint8_t
uint8_t
Definition: audio_convert.c:194
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:237
len
int len
Definition: vorbis_enc_data.h:452
av_md5_final
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:192
AVHMAC::blocklen
int blocklen
Definition: hmac.c:46
version.h
av_md5_update
void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
Update hash value.
Definition: md5.c:154
AVHMACType
AVHMACType
Definition: hmac.h:33
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:42
mem.h
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVHMAC::hashlen
int hashlen
Definition: hmac.c:46
AV_HMAC_SHA224
@ AV_HMAC_SHA224
Definition: hmac.h:36
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:49
hmac.h
Generated on Wed Aug 24 2022 21:32:07 for FFmpeg by   doxygen 1.8.17