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