Revision 0ef37cd5 libavutil/sha1.c

View differences:

libavutil/sha1.c
35 35

  
36 36
/* (R0+R1), R2, R3, R4 are the different operations used in SHA1 */
37 37
#define blk0(i) (block[i] = be2me_32(((const uint32_t*)buffer)[i]))
38
#define blk(i) (block[i] = rol(block[i-3]^block[i-8]^block[i-14]^block[i-16],1))
38
#define blk(i)  (block[i] = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1))
39 39

  
40
#define R0(v,w,x,y,z,i) z+=((w&(x^y))^y)    +blk0(i)+0x5A827999+rol(v,5);w=rol(w,30);
41
#define R1(v,w,x,y,z,i) z+=((w&(x^y))^y)    +blk (i)+0x5A827999+rol(v,5);w=rol(w,30);
42
#define R2(v,w,x,y,z,i) z+=( w^x     ^y)    +blk (i)+0x6ED9EBA1+rol(v,5);w=rol(w,30);
43
#define R3(v,w,x,y,z,i) z+=(((w|x)&y)|(w&x))+blk (i)+0x8F1BBCDC+rol(v,5);w=rol(w,30);
44
#define R4(v,w,x,y,z,i) z+=( w^x     ^y)    +blk (i)+0xCA62C1D6+rol(v,5);w=rol(w,30);
40
#define R0(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk0(i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
41
#define R1(v,w,x,y,z,i) z += ((w&(x^y))^y)     + blk (i) + 0x5A827999 + rol(v, 5); w = rol(w, 30);
42
#define R2(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0x6ED9EBA1 + rol(v, 5); w = rol(w, 30);
43
#define R3(v,w,x,y,z,i) z += (((w|x)&y)|(w&x)) + blk (i) + 0x8F1BBCDC + rol(v, 5); w = rol(w, 30);
44
#define R4(v,w,x,y,z,i) z += ( w^x     ^y)     + blk (i) + 0xCA62C1D6 + rol(v, 5); w = rol(w, 30);
45 45

  
46 46
/* Hash a single 512-bit block. This is the core of the algorithm. */
47 47

  
48
static void transform(uint32_t state[5], const uint8_t buffer[64]){
48
static void transform(uint32_t state[5], const uint8_t buffer[64])
49
{
49 50
    uint32_t block[80];
50 51
    unsigned int i, a, b, c, d, e;
51 52

  
......
55 56
    d = state[3];
56 57
    e = state[4];
57 58
#if CONFIG_SMALL
58
    for(i=0; i<80; i++){
59
    for (i = 0; i < 80; i++) {
59 60
        int t;
60
        if(i<16) t= be2me_32(((uint32_t*)buffer)[i]);
61
        else     t= rol(block[i-3]^block[i-8]^block[i-14]^block[i-16],1);
62
        block[i]= t;
63
        t+= e+rol(a,5);
64
        if(i<40){
65
            if(i<20)    t+= ((b&(c^d))^d)    +0x5A827999;
66
            else        t+= ( b^c     ^d)    +0x6ED9EBA1;
67
        }else{
68
            if(i<60)    t+= (((b|c)&d)|(b&c))+0x8F1BBCDC;
69
            else        t+= ( b^c     ^d)    +0xCA62C1D6;
61
        if (i < 16)
62
            t = be2me_32(((uint32_t*)buffer)[i]);
63
        else
64
            t = rol(block[i-3] ^ block[i-8] ^ block[i-14] ^ block[i-16], 1);
65
        block[i] = t;
66
        t += e + rol(a, 5);
67
        if (i < 40) {
68
            if (i < 20)
69
                t += ((b&(c^d))^d)     + 0x5A827999;
70
            else
71
                t += ( b^c     ^d)     + 0x6ED9EBA1;
72
        } else {
73
            if (i < 60)
74
                t += (((b|c)&d)|(b&c)) + 0x8F1BBCDC;
75
            else
76
                t += ( b^c     ^d)     + 0xCA62C1D6;
70 77
        }
71
        e= d;
72
        d= c;
73
        c= rol(b,30);
74
        b= a;
75
        a= t;
78
        e = d;
79
        d = c;
80
        c = rol(b, 30);
81
        b = a;
82
        a = t;
76 83
    }
77 84
#else
78
    for(i=0; i<15; i+=5){
79
        R0(a,b,c,d,e,0+i); R0(e,a,b,c,d,1+i); R0(d,e,a,b,c,2+i); R0(c,d,e,a,b,3+i); R0(b,c,d,e,a,4+i);
85
    for (i = 0; i < 15; i += 5) {
86
        R0(a, b, c, d, e, 0 + i);
87
        R0(e, a, b, c, d, 1 + i);
88
        R0(d, e, a, b, c, 2 + i);
89
        R0(c, d, e, a, b, 3 + i);
90
        R0(b, c, d, e, a, 4 + i);
80 91
    }
81
    R0(a,b,c,d,e,15); R1(e,a,b,c,d,16); R1(d,e,a,b,c,17); R1(c,d,e,a,b,18); R1(b,c,d,e,a,19);
82
    for(i=20; i<40; i+=5){
83
        R2(a,b,c,d,e,0+i); R2(e,a,b,c,d,1+i); R2(d,e,a,b,c,2+i); R2(c,d,e,a,b,3+i); R2(b,c,d,e,a,4+i);
92
    R0(a, b, c, d, e, 15);
93
    R1(e, a, b, c, d, 16);
94
    R1(d, e, a, b, c, 17);
95
    R1(c, d, e, a, b, 18);
96
    R1(b, c, d, e, a, 19);
97
    for (i = 20; i < 40; i += 5) {
98
        R2(a, b, c, d, e, 0 + i);
99
        R2(e, a, b, c, d, 1 + i);
100
        R2(d, e, a, b, c, 2 + i);
101
        R2(c, d, e, a, b, 3 + i);
102
        R2(b, c, d, e, a, 4 + i);
84 103
    }
85
    for(; i<60; i+=5){
86
        R3(a,b,c,d,e,0+i); R3(e,a,b,c,d,1+i); R3(d,e,a,b,c,2+i); R3(c,d,e,a,b,3+i); R3(b,c,d,e,a,4+i);
104
    for (; i < 60; i += 5) {
105
        R3(a, b, c, d, e, 0 + i);
106
        R3(e, a, b, c, d, 1 + i);
107
        R3(d, e, a, b, c, 2 + i);
108
        R3(c, d, e, a, b, 3 + i);
109
        R3(b, c, d, e, a, 4 + i);
87 110
    }
88
    for(; i<80; i+=5){
89
        R4(a,b,c,d,e,0+i); R4(e,a,b,c,d,1+i); R4(d,e,a,b,c,2+i); R4(c,d,e,a,b,3+i); R4(b,c,d,e,a,4+i);
111
    for (; i < 80; i += 5) {
112
        R4(a, b, c, d, e, 0 + i);
113
        R4(e, a, b, c, d, 1 + i);
114
        R4(d, e, a, b, c, 2 + i);
115
        R4(c, d, e, a, b, 3 + i);
116
        R4(b, c, d, e, a, 4 + i);
90 117
    }
91 118
#endif
92 119
    state[0] += a;
......
96 123
    state[4] += e;
97 124
}
98 125

  
99
void av_sha1_init(AVSHA1* ctx){
126
void av_sha1_init(AVSHA1* ctx)
127
{
100 128
    ctx->state[0] = 0x67452301;
101 129
    ctx->state[1] = 0xEFCDAB89;
102 130
    ctx->state[2] = 0x98BADCFE;
......
105 133
    ctx->count    = 0;
106 134
}
107 135

  
108
void av_sha1_update(AVSHA1* ctx, const uint8_t* data, unsigned int len){
136
void av_sha1_update(AVSHA1* ctx, const uint8_t* data, unsigned int len)
137
{
109 138
    unsigned int i, j;
110 139

  
111 140
    j = ctx->count & 63;
112 141
    ctx->count += len;
113 142
#if CONFIG_SMALL
114
    for( i = 0; i < len; i++ ){
115
        ctx->buffer[ j++ ] = data[i];
116
        if( 64 == j ){
143
    for (i = 0; i < len; i++) {
144
        ctx->buffer[j++] = data[i];
145
        if (64 == j) {
117 146
            transform(ctx->state, ctx->buffer);
118 147
            j = 0;
119 148
        }
120 149
    }
121 150
#else
122 151
    if ((j + len) > 63) {
123
        memcpy(&ctx->buffer[j], data, (i = 64-j));
152
        memcpy(&ctx->buffer[j], data, (i = 64 - j));
124 153
        transform(ctx->state, ctx->buffer);
125
        for ( ; i + 63 < len; i += 64) {
154
        for (; i + 63 < len; i += 64)
126 155
            transform(ctx->state, &data[i]);
127
        }
128
        j=0;
129
    }
130
    else i = 0;
156
        j = 0;
157
    } else
158
        i = 0;
131 159
    memcpy(&ctx->buffer[j], &data[i], len - i);
132 160
#endif
133 161
}
134 162

  
135
void av_sha1_final(AVSHA1* ctx, uint8_t digest[20]){
163
void av_sha1_final(AVSHA1* ctx, uint8_t digest[20])
164
{
136 165
    int i;
137
    uint64_t finalcount= be2me_64(ctx->count<<3);
166
    uint64_t finalcount = be2me_64(ctx->count << 3);
138 167

  
139 168
    av_sha1_update(ctx, "\200", 1);
140
    while ((ctx->count & 63) != 56) {
169
    while ((ctx->count & 63) != 56)
141 170
        av_sha1_update(ctx, "", 1);
142
    }
143 171
    av_sha1_update(ctx, (uint8_t *)&finalcount, 8); /* Should cause a transform() */
144
    for(i=0; i<5; i++)
145
        ((uint32_t*)digest)[i]= be2me_32(ctx->state[i]);
172
    for (i = 0; i < 5; i++)
173
        ((uint32_t*)digest)[i] = be2me_32(ctx->state[i]);
146 174
}
147 175

  
148 176
#ifdef TEST
149 177
#include <stdio.h>
150 178
#undef printf
151 179

  
152
int main(void){
180
int main(void)
181
{
153 182
    int i, k;
154 183
    AVSHA1 ctx;
155 184
    unsigned char digest[20];
156 185

  
157
    for(k=0; k<3; k++){
186
    for (k = 0; k < 3; k++) {
158 187
        av_sha1_init(&ctx);
159
        if(k==0)
188
        if (k == 0)
160 189
            av_sha1_update(&ctx, "abc", 3);
161
        else if(k==1)
190
        else if (k == 1)
162 191
            av_sha1_update(&ctx, "abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq", 56);
163 192
        else
164
            for(i=0; i<1000*1000; i++)
193
            for (i = 0; i < 1000 * 1000; i++)
165 194
                av_sha1_update(&ctx, "a", 1);
166 195
        av_sha1_final(&ctx, digest);
167 196
        for (i = 0; i < 20; i++)

Also available in: Unified diff