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,
56 };
57 
58 typedef struct AVHashContext {
59  void *ctx;
60  enum hashtype type;
61  const AVCRC *crctab;
62  uint32_t crc;
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 
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 
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
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 
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 {
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 {
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 {
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 
241 {
242  if (*ctx)
243  av_freep(&(*ctx)->ctx);
244  av_freep(ctx);
245 }
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha.c:345
#define NULL
Definition: coverity.c:32
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
void av_ripemd_update(AVRIPEMD *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: ripemd.c:515
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Definition: sha.c:273
Memory handling functions.
Public header for RIPEMD hash function implementation.
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
Definition: hash.c:51
Definition: hash.c:43
Public header for MurmurHash3 hash function implementation.
void av_md5_update(AVMD5 *ctx, const uint8_t *src, int len)
Update hash value.
Definition: md5.c:154
#define AV_HASH_MAX_SIZE
Maximum value that av_hash_get_size() will currently return.
Definition: hash.h:158
struct AVMD5 * av_md5_alloc(void)
Allocate an AVMD5 context.
Definition: md5.c:48
void av_ripemd_final(AVRIPEMD *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: ripemd.c:545
const char * name
Definition: hash.c:66
uint8_t
Generic hashing API.
Definition: hash.c:47
Definition: hash.c:41
Public header for CRC hash function implementation.
Definition: hash.c:40
uint32_t crc
Definition: hash.c:62
struct AVSHA512 * av_sha512_alloc(void)
Allocate an AVSHA512 context.
Definition: sha512.c:43
void av_murmur3_init(AVMurMur3 *c)
Initialize or reinitialize an AVMurMur3 hash context.
Definition: murmur3.c:45
ptrdiff_t size
Definition: opengl_enc.c:100
#define src
Definition: vp8dsp.c:255
void av_hash_init(AVHashContext *ctx)
Initialize or reset a hash context.
Definition: hash.c:139
error code definitions
Definition: hash.c:44
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
void av_hash_final(AVHashContext *ctx, uint8_t *dst)
Finalize a hash context and compute the actual hash value.
Definition: hash.c:185
int av_hash_alloc(AVHashContext **ctx, const char *name)
Allocate a hash context for the algorithm specified by name.
Definition: hash.c:102
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
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
struct AVRIPEMD * av_ripemd_alloc(void)
Allocate an AVRIPEMD context.
Definition: ripemd.c:44
#define AV_BASE64_SIZE(x)
Calculate the output size needed to base64-encode x bytes to a null-terminated string.
Definition: base64.h:66
#define FFMIN(a, b)
Definition: common.h:105
const char * av_hash_names(int i)
Get the names of available hash algorithms.
Definition: hash.c:86
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:215
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha.c:315
Definition: hash.c:42
static const struct @296 hashdesc[]
const char * av_hash_get_name(const AVHashContext *ctx)
Definition: hash.c:92
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
Definition: hash.c:53
Public header for Adler-32 hash function implementation.
Definition: hash.c:46
int av_hash_get_size(const AVHashContext *ctx)
Definition: hash.c:97
void av_sha512_update(AVSHA512 *ctx, const uint8_t *data, unsigned int len)
Update hash value.
Definition: sha512.c:243
Public header for SHA-1 & SHA-256 hash function implementations.
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
Definition: sha.c:45
void av_hash_update(AVHashContext *ctx, const uint8_t *src, int len)
Update a hash context with additional data.
Definition: hash.c:161
void av_md5_init(AVMD5 *ctx)
Initialize MD5 hashing.
Definition: md5.c:143
av_cold int av_sha512_init(AVSHA512 *ctx, int bits)
Initialize SHA-2 512 hashing.
Definition: sha512.c:191
void av_hash_freep(AVHashContext **ctx)
Free hash context and set hash context pointer to NULL.
Definition: hash.c:240
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
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
#define snprintf
Definition: snprintf.h:34
void av_md5_final(AVMD5 *ctx, uint8_t *dst)
Finish hashing and output digest value.
Definition: md5.c:192
enum hashtype type
Definition: hash.c:60
Definition: hash.c:45
Definition: hash.c:52
Definition: hash.c:48
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
Definition: crc.c:374
av_cold int av_ripemd_init(AVRIPEMD *ctx, int bits)
Initialize RIPEMD hashing.
Definition: ripemd.c:464
Public header for SHA-512 implementation.
void av_murmur3_update(AVMurMur3 *c, const uint8_t *src, int len)
Update hash context with new data.
Definition: murmur3.c:95
const AVCRC * crctab
Definition: hash.c:61
int size
Definition: hash.c:67
void * ctx
Definition: hash.c:59
#define av_free(p)
hashtype
Definition: hash.c:39
int len
void av_sha512_final(AVSHA512 *ctx, uint8_t *digest)
Finish hashing and output digest value.
Definition: sha512.c:273
Public header for MD5 hash function implementation.
#define av_freep(p)
AVMurMur3 * av_murmur3_alloc(void)
Allocate an AVMurMur3 hash context.
Definition: murmur3.c:34
void av_murmur3_final(AVMurMur3 *c, uint8_t dst[16])
Finish hashing and output digest value.
Definition: murmur3.c:147
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
uint32_t AVCRC
Definition: crc.h:47
int i
Definition: input.c:407
Definition: hash.c:54
const char * name
Definition: opengl_enc.c:102