FFmpeg
hash.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2013 Reimar Döffinger <Reimar.Doeffinger@gmx.de>
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 "hash.h"
24 
25 #include "adler32.h"
26 #include "crc.h"
27 #include "md5.h"
28 #include "murmur3.h"
29 #include "ripemd.h"
30 #include "sha.h"
31 #include "sha512.h"
32 
33 #include "avstring.h"
34 #include "base64.h"
35 #include "error.h"
36 #include "intreadwrite.h"
37 #include "mem.h"
38 
39 enum hashtype {
40  MD5,
41  MURMUR3,
42  RIPEMD128,
43  RIPEMD160,
44  RIPEMD256,
45  RIPEMD320,
46  SHA160,
47  SHA224,
48  SHA256,
49  SHA512_224,
50  SHA512_256,
51  SHA384,
52  SHA512,
53  CRC32,
54  ADLER32,
55  NUM_HASHES
56 };
57 
58 typedef struct AVHashContext {
59  void *ctx;
60  enum hashtype type;
61  const AVCRC *crctab;
62  uint32_t crc;
63 } AVHashContext;
64 
65 static const struct {
66  const char *name;
67  int size;
68 } hashdesc[] = {
69  [MD5] = {"MD5", 16},
70  [MURMUR3] = {"murmur3", 16},
71  [RIPEMD128] = {"RIPEMD128", 16},
72  [RIPEMD160] = {"RIPEMD160", 20},
73  [RIPEMD256] = {"RIPEMD256", 32},
74  [RIPEMD320] = {"RIPEMD320", 40},
75  [SHA160] = {"SHA160", 20},
76  [SHA224] = {"SHA224", 28},
77  [SHA256] = {"SHA256", 32},
78  [SHA512_224] = {"SHA512/224", 28},
79  [SHA512_256] = {"SHA512/256", 32},
80  [SHA384] = {"SHA384", 48},
81  [SHA512] = {"SHA512", 64},
82  [CRC32] = {"CRC32", 4},
83  [ADLER32] = {"adler32", 4},
84 };
85 
86 const char *av_hash_names(int i)
87 {
88  if (i < 0 || i >= NUM_HASHES) return NULL;
89  return hashdesc[i].name;
90 }
91 
92 const char *av_hash_get_name(const AVHashContext *ctx)
93 {
94  return hashdesc[ctx->type].name;
95 }
96 
97 int av_hash_get_size(const AVHashContext *ctx)
98 {
99  return hashdesc[ctx->type].size;
100 }
101 
102 int av_hash_alloc(AVHashContext **ctx, const char *name)
103 {
104  AVHashContext *res;
105  int i;
106  *ctx = NULL;
107  for (i = 0; i < NUM_HASHES; i++)
108  if (av_strcasecmp(name, hashdesc[i].name) == 0)
109  break;
110  if (i >= NUM_HASHES) return AVERROR(EINVAL);
111  res = av_mallocz(sizeof(*res));
112  if (!res) return AVERROR(ENOMEM);
113  res->type = i;
114  switch (i) {
115  case MD5: res->ctx = av_md5_alloc(); break;
116  case MURMUR3: res->ctx = av_murmur3_alloc(); break;
117  case RIPEMD128:
118  case RIPEMD160:
119  case RIPEMD256:
120  case RIPEMD320: res->ctx = av_ripemd_alloc(); break;
121  case SHA160:
122  case SHA224:
123  case SHA256: res->ctx = av_sha_alloc(); break;
124  case SHA512_224:
125  case SHA512_256:
126  case SHA384:
127  case SHA512: res->ctx = av_sha512_alloc(); break;
128  case CRC32: res->crctab = av_crc_get_table(AV_CRC_32_IEEE_LE); break;
129  case ADLER32: break;
130  }
131  if (i != ADLER32 && i != CRC32 && !res->ctx) {
132  av_free(res);
133  return AVERROR(ENOMEM);
134  }
135  *ctx = res;
136  return 0;
137 }
138 
139 void av_hash_init(AVHashContext *ctx)
140 {
141  switch (ctx->type) {
142  case MD5: av_md5_init(ctx->ctx); break;
143  case MURMUR3: av_murmur3_init(ctx->ctx); break;
144  case RIPEMD128: av_ripemd_init(ctx->ctx, 128); break;
145  case RIPEMD160: av_ripemd_init(ctx->ctx, 160); break;
146  case RIPEMD256: av_ripemd_init(ctx->ctx, 256); break;
147  case RIPEMD320: av_ripemd_init(ctx->ctx, 320); break;
148  case SHA160: av_sha_init(ctx->ctx, 160); break;
149  case SHA224: av_sha_init(ctx->ctx, 224); break;
150  case SHA256: av_sha_init(ctx->ctx, 256); break;
151  case SHA512_224: av_sha512_init(ctx->ctx, 224); break;
152  case SHA512_256: av_sha512_init(ctx->ctx, 256); break;
153  case SHA384: av_sha512_init(ctx->ctx, 384); break;
154  case SHA512: av_sha512_init(ctx->ctx, 512); break;
155  case CRC32: ctx->crc = UINT32_MAX; break;
156  case ADLER32: ctx->crc = 1; break;
157  }
158 }
159 
160 #if FF_API_CRYPTO_SIZE_T
161 void av_hash_update(AVHashContext *ctx, const uint8_t *src, int len)
162 #else
163 void av_hash_update(AVHashContext *ctx, const uint8_t *src, size_t len)
164 #endif
165 {
166  switch (ctx->type) {
167  case MD5: av_md5_update(ctx->ctx, src, len); break;
168  case MURMUR3: av_murmur3_update(ctx->ctx, src, len); break;
169  case RIPEMD128:
170  case RIPEMD160:
171  case RIPEMD256:
172  case RIPEMD320: av_ripemd_update(ctx->ctx, src, len); break;
173  case SHA160:
174  case SHA224:
175  case SHA256: av_sha_update(ctx->ctx, src, len); break;
176  case SHA512_224:
177  case SHA512_256:
178  case SHA384:
179  case SHA512: av_sha512_update(ctx->ctx, src, len); break;
180  case CRC32: ctx->crc = av_crc(ctx->crctab, ctx->crc, src, len); break;
181  case ADLER32: ctx->crc = av_adler32_update(ctx->crc, src, len); break;
182  }
183 }
184 
185 void av_hash_final(AVHashContext *ctx, uint8_t *dst)
186 {
187  switch (ctx->type) {
188  case MD5: av_md5_final(ctx->ctx, dst); break;
189  case MURMUR3: av_murmur3_final(ctx->ctx, dst); break;
190  case RIPEMD128:
191  case RIPEMD160:
192  case RIPEMD256:
193  case RIPEMD320: av_ripemd_final(ctx->ctx, dst); break;
194  case SHA160:
195  case SHA224:
196  case SHA256: av_sha_final(ctx->ctx, dst); break;
197  case SHA512_224:
198  case SHA512_256:
199  case SHA384:
200  case SHA512: av_sha512_final(ctx->ctx, dst); break;
201  case CRC32: AV_WB32(dst, ctx->crc ^ UINT32_MAX); break;
202  case ADLER32: AV_WB32(dst, ctx->crc); break;
203  }
204 }
205 
206 void av_hash_final_bin(struct AVHashContext *ctx, uint8_t *dst, int size)
207 {
208  uint8_t buf[AV_HASH_MAX_SIZE];
209  unsigned rsize = av_hash_get_size(ctx);
210 
211  av_hash_final(ctx, buf);
212  memcpy(dst, buf, FFMIN(size, rsize));
213  if (size > rsize)
214  memset(dst + rsize, 0, size - rsize);
215 }
216 
217 void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size)
218 {
219  uint8_t buf[AV_HASH_MAX_SIZE];
220  unsigned rsize = av_hash_get_size(ctx), i;
221 
222  av_hash_final(ctx, buf);
223  for (i = 0; i < FFMIN(rsize, size / 2); i++)
224  snprintf(dst + i * 2, size - i * 2, "%02x", buf[i]);
225 }
226 
227 void av_hash_final_b64(struct AVHashContext *ctx, uint8_t *dst, int size)
228 {
229  uint8_t buf[AV_HASH_MAX_SIZE], b64[AV_BASE64_SIZE(AV_HASH_MAX_SIZE)];
230  unsigned rsize = av_hash_get_size(ctx), osize;
231 
232  av_hash_final(ctx, buf);
233  av_base64_encode(b64, sizeof(b64), buf, rsize);
234  osize = AV_BASE64_SIZE(rsize);
235  memcpy(dst, b64, FFMIN(osize, size));
236  if (size < osize)
237  dst[size - 1] = 0;
238 }
239 
240 void av_hash_freep(AVHashContext **ctx)
241 {
242  if (*ctx)
243  av_freep(&(*ctx)->ctx);
244  av_freep(ctx);
245 }
SHA384
@ SHA384
Definition: hash.c:51
SHA224
@ SHA224
Definition: hash.c:47
AVHashContext::crc
uint32_t crc
Definition: hash.c:62
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
av_ripemd_alloc
struct AVRIPEMD * av_ripemd_alloc(void)
Allocate an AVRIPEMD context.
Definition: ripemd.c:44
AV_HASH_MAX_SIZE
#define AV_HASH_MAX_SIZE
Maximum value that av_hash_get_size() will currently return.
Definition: hash.h:158
AVCRC
uint32_t AVCRC
Definition: crc.h:47
SHA512_256
@ SHA512_256
Definition: hash.c:50
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
MURMUR3
@ MURMUR3
Definition: hash.c:41
AVHashContext::ctx
void * ctx
Definition: hash.c:59
av_sha_init
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Definition: sha.c:273
MD5
@ MD5
Definition: hash.c:40
av_sha512_alloc
struct AVSHA512 * av_sha512_alloc(void)
Allocate an AVSHA512 context.
Definition: sha512.c:43
av_hash_final_b64
void av_hash_final_b64(struct AVHashContext *ctx, uint8_t *dst, int size)
Finalize a hash context and store the Base64 representation of the actual hash value as a string.
Definition: hash.c:227
av_ripemd_update
void av_ripemd_update(AVRIPEMD *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: ripemd.c:515
sha512.h
size
int size
Definition: hash.c:67
hashdesc
static const struct @296 hashdesc[]
AVHashContext::type
enum hashtype type
Definition: hash.c:60
crc.h
SHA512_224
@ SHA512_224
Definition: hash.c:49
RIPEMD256
@ RIPEMD256
Definition: hash.c:44
av_hash_get_name
const char * av_hash_get_name(const AVHashContext *ctx)
Definition: hash.c:92
av_adler32_update
unsigned long av_adler32_update(unsigned long adler, const uint8_t *buf, unsigned int len)
Calculate the Adler32 checksum of a buffer.
Definition: adler32.c:45
av_hash_final_bin
void av_hash_final_bin(struct AVHashContext *ctx, uint8_t *dst, int size)
Finalize a hash context and store the actual hash value in a buffer.
Definition: hash.c:206
intreadwrite.h
ripemd.h
SHA160
@ SHA160
Definition: hash.c:46
av_hash_alloc
int av_hash_alloc(AVHashContext **ctx, const char *name)
Allocate a hash context for the algorithm specified by name.
Definition: hash.c:102
hashtype
hashtype
Definition: hash.c:39
ctx
AVFormatContext * ctx
Definition: movenc.c:48
av_murmur3_alloc
AVMurMur3 * av_murmur3_alloc(void)
Allocate an AVMurMur3 hash context.
Definition: murmur3.c:34
av_sha_final
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:345
RIPEMD160
@ RIPEMD160
Definition: hash.c:43
CRC32
@ CRC32
Definition: hash.c:53
av_murmur3_update
void av_murmur3_update(AVMurMur3 *c, const uint8_t *src, int len)
Update hash context with new data.
Definition: murmur3.c:95
NULL
#define NULL
Definition: coverity.c:32
av_hash_names
const char * av_hash_names(int i)
Get the names of available hash algorithms.
Definition: hash.c:86
sha.h
av_hash_init
void av_hash_init(AVHashContext *ctx)
Initialize or reset a hash context.
Definition: hash.c:139
src
#define src
Definition: vp8dsp.c:255
adler32.h
av_murmur3_final
void av_murmur3_final(AVMurMur3 *c, uint8_t dst[16])
Finish hashing and output digest value.
Definition: murmur3.c:147
av_ripemd_init
av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
Initialize RIPEMD hashing.
Definition: ripemd.c:464
base64.h
av_sha_update
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:315
SHA256
@ SHA256
Definition: hash.c:48
av_hash_freep
void av_hash_freep(AVHashContext **ctx)
Free hash context and set hash context pointer to NULL.
Definition: hash.c:240
error.h
AV_WB32
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
av_ripemd_final
void av_ripemd_final(AVRIPEMD *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: ripemd.c:545
av_hash_final
void av_hash_final(AVHashContext *ctx, uint8_t *dst)
Finalize a hash context and compute the actual hash value.
Definition: hash.c:185
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
av_crc_get_table
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
AVHashContext
Definition: hash.c:58
SHA512
@ SHA512
Definition: hash.c:52
AVHashContext::crctab
const AVCRC * crctab
Definition: hash.c:61
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_BASE64_SIZE
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
i
int i
Definition: input.c:407
av_sha512_update
void av_sha512_update(AVSHA512 *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha512.c:243
av_sha512_init
av_cold int av_sha512_init(AVSHA512 *ctx, int bits)
Initialize SHA-2 512 hashing.
Definition: sha512.c:191
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
name
const char * name
Definition: hash.c:66
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
av_md5_update
void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
Update hash value.
Definition: md5.c:154
RIPEMD128
@ RIPEMD128
Definition: hash.c:42
hash.h
av_crc
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
Definition: crc.c:392
av_md5_alloc
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:48
av_hash_get_size
int av_hash_get_size(const AVHashContext *ctx)
Definition: hash.c:97
av_base64_encode
char * av_base64_encode(char *out, int out_size, const uint8_t *in, int in_size)
Encode data to base64 and null-terminate.
Definition: base64.c:143
ADLER32
@ ADLER32
Definition: hash.c:54
av_hash_update
void av_hash_update(AVHashContext *ctx, const uint8_t *src, int len)
Update a hash context with additional data.
Definition: hash.c:161
AV_CRC_32_IEEE_LE
@ AV_CRC_32_IEEE_LE
Definition: crc.h:54
av_murmur3_init
void av_murmur3_init(AVMurMur3 *c)
Initialize or reinitialize an AVMurMur3 hash context.
Definition: murmur3.c:45
mem.h
av_hash_final_hex
void av_hash_final_hex(struct AVHashContext *ctx, uint8_t *dst, int size)
Finalize a hash context and store the hexadecimal representation of the actual hash value as a string...
Definition: hash.c:217
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
RIPEMD320
@ RIPEMD320
Definition: hash.c:45
avstring.h
murmur3.h
snprintf
#define snprintf
Definition: snprintf.h:34
NUM_HASHES
@ NUM_HASHES
Definition: hash.c:55
Generated on Wed Aug 24 2022 21:34:49 for FFmpeg by   doxygen 1.8.17