50 #define rol(value, bits) (((value) << (bits)) | ((value) >> (32 - (bits)))) 53 #define blk0(i) (block[i] = AV_RB32(buffer + 4 * (i))) 54 #define blk(i) (block[i] = rol(block[(i)-3] ^ block[(i)-8] ^ block[(i)-14] ^ block[(i)-16], 1)) 56 #define R0(v,w,x,y,z,i) z += (((w)&((x)^(y)))^(y)) + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); 57 #define R1(v,w,x,y,z,i) z += (((w)&((x)^(y)))^(y)) + blk (i) + 0x5A827999 + rol(v, 5); w = rol(w, 30); 58 #define R2(v,w,x,y,z,i) z += ( (w)^(x) ^(y)) + blk (i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30); 59 #define R3(v,w,x,y,z,i) z += ((((w)|(x))&(y))|((w)&(x))) + blk (i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30); 60 #define R4(v,w,x,y,z,i) z += ( (w)^(x) ^(y)) + blk (i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30); 67 unsigned int i,
a,
b,
c, d, e;
75 for (i = 0; i < 80; i++) {
80 t =
rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1);
85 t += ((b&(c^d))^d) + 0x5A827999;
87 t += ( b^c ^d) + 0x6ED9EBA1;
90 t += (((b|
c)&d)|(b&
c)) + 0x8F1BBCDC;
92 t += ( b^c ^d) + 0xCA62C1D6;
103 R0(a, b, c, d, e, 0 + i); \ 104 R0(e, a, b, c, d, 1 + i); \ 105 R0(d, e, a, b, c, 2 + i); \ 106 R0(c, d, e, a, b, 3 + i); \ 107 R0(b, c, d, e, a, 4 + i); \ 112 R0(a, b, c, d, e, 15);
113 R1(e, a, b, c, d, 16);
114 R1(d, e, a, b, c, 17);
115 R1(c, d, e, a, b, 18);
116 R1(b, c, d, e, a, 19);
119 R2(a, b, c, d, e, 0 + i); \ 120 R2(e, a, b, c, d, 1 + i); \ 121 R2(d, e, a, b, c, 2 + i); \ 122 R2(c, d, e, a, b, 3 + i); \ 123 R2(b, c, d, e, a, 4 + i); \ 130 R3(a, b, c, d, e, 0 + i); \ 131 R3(e, a, b, c, d, 1 + i); \ 132 R3(d, e, a, b, c, 2 + i); \ 133 R3(c, d, e, a, b, 3 + i); \ 134 R3(b, c, d, e, a, 4 + i); \ 140 R4(a, b, c, d, e, 0 + i); \ 141 R4(e, a, b, c, d, 1 + i); \ 142 R4(d, e, a, b, c, 2 + i); \ 143 R4(c, d, e, a, b, 3 + i); \ 144 R4(b, c, d, e, a, 4 + i); \ 156 static const uint32_t
K256[64] = {
157 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
158 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
159 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
160 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
161 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
162 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
163 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
164 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
165 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
166 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
167 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
168 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
169 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
170 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
171 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
172 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
176 #define Ch(x,y,z) (((x) & ((y) ^ (z))) ^ (z)) 177 #define Maj(z,y,x) ((((x) | (y)) & (z)) | ((x) & (y))) 179 #define Sigma0_256(x) (rol((x), 30) ^ rol((x), 19) ^ rol((x), 10)) 180 #define Sigma1_256(x) (rol((x), 26) ^ rol((x), 21) ^ rol((x), 7)) 181 #define sigma0_256(x) (rol((x), 25) ^ rol((x), 14) ^ ((x) >> 3)) 182 #define sigma1_256(x) (rol((x), 15) ^ rol((x), 13) ^ ((x) >> 10)) 185 #define blk(i) (block[i] = block[i - 16] + sigma0_256(block[i - 15]) + \ 186 sigma1_256(block[i - 2]) + block[i - 7]) 188 #define ROUND256(a,b,c,d,e,f,g,h) \ 189 T1 += (h) + Sigma1_256(e) + Ch((e), (f), (g)) + K256[i]; \ 191 (h) = T1 + Sigma0_256(a) + Maj((a), (b), (c)); \ 194 #define ROUND256_0_TO_15(a,b,c,d,e,f,g,h) \ 196 ROUND256(a,b,c,d,e,f,g,h) 198 #define ROUND256_16_TO_63(a,b,c,d,e,f,g,h) \ 200 ROUND256(a,b,c,d,e,f,g,h) 204 unsigned int i,
a,
b,
c, d, e,
f,
g,
h;
217 for (i = 0; i < 64; i++) {
238 ROUND256_0_TO_15(a, b, c, d, e, f, g, h); \ 239 ROUND256_0_TO_15(h, a, b, c, d, e, f, g); \ 240 ROUND256_0_TO_15(g, h, a, b, c, d, e, f); \ 241 ROUND256_0_TO_15(f, g, h, a, b, c, d, e); \ 242 ROUND256_0_TO_15(e, f, g, h, a, b, c, d); \ 243 ROUND256_0_TO_15(d, e, f, g, h, a, b, c); \ 244 ROUND256_0_TO_15(c, d, e, f, g, h, a, b); \ 245 ROUND256_0_TO_15(b, c, d, e, f, g, h, a) 250 ROUND256_16_TO_63(a, b, c, d, e, f, g, h); \ 251 ROUND256_16_TO_63(h, a, b, c, d, e, f, g); \ 252 ROUND256_16_TO_63(g, h, a, b, c, d, e, f); \ 253 ROUND256_16_TO_63(f, g, h, a, b, c, d, e); \ 254 ROUND256_16_TO_63(e, f, g, h, a, b, c, d); \ 255 ROUND256_16_TO_63(d, e, f, g, h, a, b, c); \ 256 ROUND256_16_TO_63(c, d, e, f, g, h, a, b); \ 257 ROUND256_16_TO_63(b, c, d, e, f, g, h, a) 278 ctx->
state[0] = 0x67452301;
279 ctx->
state[1] = 0xEFCDAB89;
280 ctx->
state[2] = 0x98BADCFE;
281 ctx->
state[3] = 0x10325476;
282 ctx->
state[4] = 0xC3D2E1F0;
286 ctx->
state[0] = 0xC1059ED8;
287 ctx->
state[1] = 0x367CD507;
288 ctx->
state[2] = 0x3070DD17;
289 ctx->
state[3] = 0xF70E5939;
290 ctx->
state[4] = 0xFFC00B31;
291 ctx->
state[5] = 0x68581511;
292 ctx->
state[6] = 0x64F98FA7;
293 ctx->
state[7] = 0xBEFA4FA4;
297 ctx->
state[0] = 0x6A09E667;
298 ctx->
state[1] = 0xBB67AE85;
299 ctx->
state[2] = 0x3C6EF372;
300 ctx->
state[3] = 0xA54FF53A;
301 ctx->
state[4] = 0x510E527F;
302 ctx->
state[5] = 0x9B05688C;
303 ctx->
state[6] = 0x1F83D9AB;
304 ctx->
state[7] = 0x5BE0CD19;
314 #if FF_API_CRYPTO_SIZE_T 325 for (i = 0; i <
len; i++) {
333 if ((j + len) > 63) {
334 memcpy(&ctx->
buffer[j], data, (i = 64 - j));
336 for (; i + 63 <
len; i += 64)
341 memcpy(&ctx->
buffer[j], &data[i], len - i);
351 while ((ctx->
count & 63) != 56)
void av_sha_final(AVSHA *ctx, uint8_t *digest)
Finish hashing and output digest value.
ptrdiff_t const GLvoid * data
av_cold int av_sha_init(AVSHA *ctx, int bits)
Initialize SHA-1 or SHA-2 hashing.
Memory handling functions.
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Convenience header that includes libavutil's core.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Macro definitions for various function/variable attributes.
void(* transform)(uint32_t *state, const uint8_t buffer[64])
function used to update hash for 512-bit input block
The exact code depends on how similar the blocks are and how related they are to the block
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
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
uint8_t buffer[64]
512-bit buffer of input values used in hash updating
#define R0(v, w, x, y, z, i)
#define R1(v, w, x, y, z, i)
typedef void(APIENTRY *FF_PFNGLACTIVETEXTUREPROC)(GLenum texture)
void av_sha_update(struct AVSHA *ctx, const uint8_t *data, unsigned int len)
Update hash value.
uint64_t count
number of bytes in buffer
static void sha256_transform(uint32_t *state, const uint8_t buffer[64])
uint32_t state[8]
current hash value
Public header for SHA-1 & SHA-256 hash function implementations.
struct AVSHA * av_sha_alloc(void)
Allocate an AVSHA context.
uint8_t digest_len
digest length in 32-bit words
static const uint32_t K256[64]
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
static void sha1_transform(uint32_t state[5], const uint8_t buffer[64])