← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/third_party/srtp/crypto/hash/sha1.c

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/third_party/srtp/crypto/hash/sha1.c
1
 
/*
2
 
 * sha1.c
3
 
 *
4
 
 * an implementation of the Secure Hash Algorithm v.1 (SHA-1),
5
 
 * specified in FIPS 180-1
6
 
 *
7
 
 * David A. McGrew
8
 
 * Cisco Systems, Inc.
9
 
 */
10
 
 
11
 
/*
12
 
 *
13
 
 * Copyright (c) 2001-2006, Cisco Systems, Inc.
14
 
 * All rights reserved.
15
 
 *
16
 
 * Redistribution and use in source and binary forms, with or without
17
 
 * modification, are permitted provided that the following conditions
18
 
 * are met:
19
 
 *
20
 
 *   Redistributions of source code must retain the above copyright
21
 
 *   notice, this list of conditions and the following disclaimer.
22
 
 *
23
 
 *   Redistributions in binary form must reproduce the above
24
 
 *   copyright notice, this list of conditions and the following
25
 
 *   disclaimer in the documentation and/or other materials provided
26
 
 *   with the distribution.
27
 
 *
28
 
 *   Neither the name of the Cisco Systems, Inc. nor the names of its
29
 
 *   contributors may be used to endorse or promote products derived
30
 
 *   from this software without specific prior written permission.
31
 
 *
32
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
33
 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
34
 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
35
 
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
36
 
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
37
 
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
38
 
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
39
 
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41
 
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
42
 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
43
 
 * OF THE POSSIBILITY OF SUCH DAMAGE.
44
 
 *
45
 
 */
46
 
 
47
 
 
48
 
#include "sha1.h"
49
 
 
50
 
debug_module_t mod_sha1 = {
51
 
  0,                 /* debugging is off by default */
52
 
  "sha-1"            /* printable module name       */
53
 
};
54
 
 
55
 
/* SN == Rotate left N bits */
56
 
#define S1(X)  ((X << 1)  | (X >> 31))
57
 
#define S5(X)  ((X << 5)  | (X >> 27))
58
 
#define S30(X) ((X << 30) | (X >> 2))
59
 
 
60
 
#define f0(B,C,D) ((B & C) | (~B & D))
61
 
#define f1(B,C,D) (B ^ C ^ D)
62
 
#define f2(B,C,D) ((B & C) | (B & D) | (C & D))
63
 
#define f3(B,C,D) (B ^ C ^ D)
64
 
 
65
 
/*
66
 
 * nota bene: the variable K0 appears in the curses library, so we
67
 
 * give longer names to these variables to avoid spurious warnings
68
 
 * on systems that uses curses
69
 
 */
70
 
 
71
 
uint32_t SHA_K0 = 0x5A827999;   /* Kt for 0  <= t <= 19 */
72
 
uint32_t SHA_K1 = 0x6ED9EBA1;   /* Kt for 20 <= t <= 39 */
73
 
uint32_t SHA_K2 = 0x8F1BBCDC;   /* Kt for 40 <= t <= 59 */
74
 
uint32_t SHA_K3 = 0xCA62C1D6;   /* Kt for 60 <= t <= 79 */
75
 
 
76
 
void
77
 
sha1(const uint8_t *msg,  int octets_in_msg, uint32_t hash_value[5]) {
78
 
  sha1_ctx_t ctx;
79
 
 
80
 
  sha1_init(&ctx);
81
 
  sha1_update(&ctx, msg, octets_in_msg);
82
 
  sha1_final(&ctx, hash_value);
83
 
 
84
 
}
85
 
 
86
 
/*
87
 
 *  sha1_core(M, H) computes the core compression function, where M is
88
 
 *  the next part of the message (in network byte order) and H is the
89
 
 *  intermediate state { H0, H1, ...} (in host byte order)
90
 
 *
91
 
 *  this function does not do any of the padding required in the
92
 
 *  complete SHA1 function
93
 
 *
94
 
 *  this function is used in the SEAL 3.0 key setup routines
95
 
 *  (crypto/cipher/seal.c)
96
 
 */
97
 
 
98
 
void
99
 
sha1_core(const uint32_t M[16], uint32_t hash_value[5]) {
100
 
  uint32_t H0;
101
 
  uint32_t H1;
102
 
  uint32_t H2;
103
 
  uint32_t H3;
104
 
  uint32_t H4;
105
 
  uint32_t W[80];
106
 
  uint32_t A, B, C, D, E, TEMP;
107
 
  int t;
108
 
 
109
 
  /* copy hash_value into H0, H1, H2, H3, H4 */
110
 
  H0 = hash_value[0];
111
 
  H1 = hash_value[1];
112
 
  H2 = hash_value[2];
113
 
  H3 = hash_value[3];
114
 
  H4 = hash_value[4];
115
 
 
116
 
  /* copy/xor message into array */
117
 
 
118
 
  W[0]  = be32_to_cpu(M[0]);
119
 
  W[1]  = be32_to_cpu(M[1]);
120
 
  W[2]  = be32_to_cpu(M[2]);
121
 
  W[3]  = be32_to_cpu(M[3]);
122
 
  W[4]  = be32_to_cpu(M[4]);
123
 
  W[5]  = be32_to_cpu(M[5]);
124
 
  W[6]  = be32_to_cpu(M[6]);
125
 
  W[7]  = be32_to_cpu(M[7]);
126
 
  W[8]  = be32_to_cpu(M[8]);
127
 
  W[9]  = be32_to_cpu(M[9]);
128
 
  W[10] = be32_to_cpu(M[10]);
129
 
  W[11] = be32_to_cpu(M[11]);
130
 
  W[12] = be32_to_cpu(M[12]);
131
 
  W[13] = be32_to_cpu(M[13]);
132
 
  W[14] = be32_to_cpu(M[14]);
133
 
  W[15] = be32_to_cpu(M[15]);
134
 
  TEMP = W[13] ^ W[8]  ^ W[2]  ^ W[0];  W[16] = S1(TEMP);
135
 
  TEMP = W[14] ^ W[9]  ^ W[3]  ^ W[1];  W[17] = S1(TEMP);
136
 
  TEMP = W[15] ^ W[10] ^ W[4]  ^ W[2];  W[18] = S1(TEMP);
137
 
  TEMP = W[16] ^ W[11] ^ W[5]  ^ W[3];  W[19] = S1(TEMP);
138
 
  TEMP = W[17] ^ W[12] ^ W[6]  ^ W[4];  W[20] = S1(TEMP);
139
 
  TEMP = W[18] ^ W[13] ^ W[7]  ^ W[5];  W[21] = S1(TEMP);
140
 
  TEMP = W[19] ^ W[14] ^ W[8]  ^ W[6];  W[22] = S1(TEMP);
141
 
  TEMP = W[20] ^ W[15] ^ W[9]  ^ W[7];  W[23] = S1(TEMP);
142
 
  TEMP = W[21] ^ W[16] ^ W[10] ^ W[8];  W[24] = S1(TEMP);
143
 
  TEMP = W[22] ^ W[17] ^ W[11] ^ W[9];  W[25] = S1(TEMP);
144
 
  TEMP = W[23] ^ W[18] ^ W[12] ^ W[10]; W[26] = S1(TEMP);
145
 
  TEMP = W[24] ^ W[19] ^ W[13] ^ W[11]; W[27] = S1(TEMP);
146
 
  TEMP = W[25] ^ W[20] ^ W[14] ^ W[12]; W[28] = S1(TEMP);
147
 
  TEMP = W[26] ^ W[21] ^ W[15] ^ W[13]; W[29] = S1(TEMP);
148
 
  TEMP = W[27] ^ W[22] ^ W[16] ^ W[14]; W[30] = S1(TEMP);
149
 
  TEMP = W[28] ^ W[23] ^ W[17] ^ W[15]; W[31] = S1(TEMP);
150
 
 
151
 
  /* process the remainder of the array */
152
 
  for (t=32; t < 80; t++) {
153
 
    TEMP = W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16];
154
 
    W[t] = S1(TEMP);
155
 
  }
156
 
 
157
 
  A = H0; B = H1; C = H2; D = H3; E = H4;
158
 
 
159
 
  for (t=0; t < 20; t++) {
160
 
    TEMP = S5(A) + f0(B,C,D) + E + W[t] + SHA_K0;
161
 
    E = D; D = C; C = S30(B); B = A; A = TEMP;
162
 
  }
163
 
  for (   ; t < 40; t++) {
164
 
    TEMP = S5(A) + f1(B,C,D) + E + W[t] + SHA_K1;
165
 
    E = D; D = C; C = S30(B); B = A; A = TEMP;
166
 
  }
167
 
  for (   ; t < 60; t++) {
168
 
    TEMP = S5(A) + f2(B,C,D) + E + W[t] + SHA_K2;
169
 
    E = D; D = C; C = S30(B); B = A; A = TEMP;
170
 
  }
171
 
  for (   ; t < 80; t++) {
172
 
    TEMP = S5(A) + f3(B,C,D) + E + W[t] + SHA_K3;
173
 
    E = D; D = C; C = S30(B); B = A; A = TEMP;
174
 
  }
175
 
 
176
 
  hash_value[0] = H0 + A;
177
 
  hash_value[1] = H1 + B;
178
 
  hash_value[2] = H2 + C;
179
 
  hash_value[3] = H3 + D;
180
 
  hash_value[4] = H4 + E;
181
 
 
182
 
  return;
183
 
}
184
 
 
185
 
void
186
 
sha1_init(sha1_ctx_t *ctx) {
187
 
 
188
 
  /* initialize state vector */
189
 
  ctx->H[0] = 0x67452301;
190
 
  ctx->H[1] = 0xefcdab89;
191
 
  ctx->H[2] = 0x98badcfe;
192
 
  ctx->H[3] = 0x10325476;
193
 
  ctx->H[4] = 0xc3d2e1f0;
194
 
 
195
 
  /* indicate that message buffer is empty */
196
 
  ctx->octets_in_buffer = 0;
197
 
 
198
 
  /* reset message bit-count to zero */
199
 
  ctx->num_bits_in_msg = 0;
200
 
 
201
 
}
202
 
 
203
 
void
204
 
sha1_update(sha1_ctx_t *ctx, const uint8_t *msg, int octets_in_msg) {
205
 
  int i;
206
 
  uint8_t *buf = (uint8_t *)ctx->M;
207
 
 
208
 
  /* update message bit-count */
209
 
  ctx->num_bits_in_msg += octets_in_msg * 8;
210
 
 
211
 
  /* loop over 16-word blocks of M */
212
 
  while (octets_in_msg > 0) {
213
 
 
214
 
    if (octets_in_msg + ctx->octets_in_buffer >= 64) {
215
 
 
216
 
      /*
217
 
       * copy words of M into msg buffer until that buffer is full,
218
 
       * converting them into host byte order as needed
219
 
       */
220
 
      octets_in_msg -= (64 - ctx->octets_in_buffer);
221
 
      for (i=ctx->octets_in_buffer; i < 64; i++)
222
 
        buf[i] = *msg++;
223
 
      ctx->octets_in_buffer = 0;
224
 
 
225
 
      /* process a whole block */
226
 
 
227
 
      debug_print(mod_sha1, "(update) running sha1_core()", NULL);
228
 
 
229
 
      sha1_core(ctx->M, ctx->H);
230
 
 
231
 
    } else {
232
 
 
233
 
      debug_print(mod_sha1, "(update) not running sha1_core()", NULL);
234
 
 
235
 
      for (i=ctx->octets_in_buffer;
236
 
           i < (ctx->octets_in_buffer + octets_in_msg); i++)
237
 
        buf[i] = *msg++;
238
 
      ctx->octets_in_buffer += octets_in_msg;
239
 
      octets_in_msg = 0;
240
 
    }
241
 
 
242
 
  }
243
 
 
244
 
}
245
 
 
246
 
/*
247
 
 * sha1_final(ctx, output) computes the result for ctx and copies it
248
 
 * into the twenty octets located at *output
249
 
 */
250
 
 
251
 
void
252
 
sha1_final(sha1_ctx_t *ctx, uint32_t *output) {
253
 
  uint32_t A, B, C, D, E, TEMP;
254
 
  uint32_t W[80];
255
 
  int i, t;
256
 
 
257
 
  /*
258
 
   * process the remaining octets_in_buffer, padding and terminating as
259
 
   * necessary
260
 
   */
261
 
  {
262
 
    int tail = ctx->octets_in_buffer % 4;
263
 
 
264
 
    /* copy/xor message into array */
265
 
    for (i=0; i < (ctx->octets_in_buffer+3)/4; i++)
266
 
      W[i]  = be32_to_cpu(ctx->M[i]);
267
 
 
268
 
    /* set the high bit of the octet immediately following the message */
269
 
    switch (tail) {
270
 
    case (3):
271
 
      W[i-1] = (be32_to_cpu(ctx->M[i-1]) & 0xffffff00) | 0x80;
272
 
      W[i] = 0x0;
273
 
      break;
274
 
    case (2):
275
 
      W[i-1] = (be32_to_cpu(ctx->M[i-1]) & 0xffff0000) | 0x8000;
276
 
      W[i] = 0x0;
277
 
      break;
278
 
    case (1):
279
 
      W[i-1] = (be32_to_cpu(ctx->M[i-1]) & 0xff000000) | 0x800000;
280
 
      W[i] = 0x0;
281
 
      break;
282
 
    case (0):
283
 
      W[i] = 0x80000000;
284
 
      break;
285
 
    }
286
 
 
287
 
    /* zeroize remaining words */
288
 
    for (i++   ; i < 15; i++)
289
 
      W[i] = 0x0;
290
 
 
291
 
    /*
292
 
     * if there is room at the end of the word array, then set the
293
 
     * last word to the bit-length of the message; otherwise, set that
294
 
     * word to zero and then we need to do one more run of the
295
 
     * compression algo.
296
 
     */
297
 
    if (ctx->octets_in_buffer < 56)
298
 
      W[15] = ctx->num_bits_in_msg;
299
 
    else if (ctx->octets_in_buffer < 60)
300
 
      W[15] = 0x0;
301
 
 
302
 
    /* process the word array */    for (t=16; t < 80; t++) {
303
 
      TEMP = W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16];
304
 
      W[t] = S1(TEMP);
305
 
    }
306
 
 
307
 
    A = ctx->H[0];
308
 
    B = ctx->H[1];
309
 
    C = ctx->H[2];
310
 
    D = ctx->H[3];
311
 
    E = ctx->H[4];
312
 
 
313
 
    for (t=0; t < 20; t++) {
314
 
      TEMP = S5(A) + f0(B,C,D) + E + W[t] + SHA_K0;
315
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
316
 
    }
317
 
    for (   ; t < 40; t++) {
318
 
      TEMP = S5(A) + f1(B,C,D) + E + W[t] + SHA_K1;
319
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
320
 
    }
321
 
    for (   ; t < 60; t++) {
322
 
      TEMP = S5(A) + f2(B,C,D) + E + W[t] + SHA_K2;
323
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
324
 
    }
325
 
    for (   ; t < 80; t++) {
326
 
      TEMP = S5(A) + f3(B,C,D) + E + W[t] + SHA_K3;
327
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
328
 
    }
329
 
 
330
 
    ctx->H[0] += A;
331
 
    ctx->H[1] += B;
332
 
    ctx->H[2] += C;
333
 
    ctx->H[3] += D;
334
 
    ctx->H[4] += E;
335
 
 
336
 
  }
337
 
 
338
 
  debug_print(mod_sha1, "(final) running sha1_core()", NULL);
339
 
 
340
 
  if (ctx->octets_in_buffer >= 56) {
341
 
 
342
 
    debug_print(mod_sha1, "(final) running sha1_core() again", NULL);
343
 
 
344
 
    /* we need to do one final run of the compression algo */
345
 
 
346
 
    /*
347
 
     * set initial part of word array to zeros, and set the
348
 
     * final part to the number of bits in the message
349
 
     */
350
 
    for (i=0; i < 15; i++)
351
 
      W[i] = 0x0;
352
 
    W[15] = ctx->num_bits_in_msg;
353
 
 
354
 
    /* process the word array */
355
 
    for (t=16; t < 80; t++) {
356
 
      TEMP = W[t-3] ^ W[t-8] ^ W[t-14] ^ W[t-16];
357
 
      W[t] = S1(TEMP);
358
 
    }
359
 
 
360
 
    A = ctx->H[0];
361
 
    B = ctx->H[1];
362
 
    C = ctx->H[2];
363
 
    D = ctx->H[3];
364
 
    E = ctx->H[4];
365
 
 
366
 
    for (t=0; t < 20; t++) {
367
 
      TEMP = S5(A) + f0(B,C,D) + E + W[t] + SHA_K0;
368
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
369
 
    }
370
 
    for (   ; t < 40; t++) {
371
 
      TEMP = S5(A) + f1(B,C,D) + E + W[t] + SHA_K1;
372
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
373
 
    }
374
 
    for (   ; t < 60; t++) {
375
 
      TEMP = S5(A) + f2(B,C,D) + E + W[t] + SHA_K2;
376
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
377
 
    }
378
 
    for (   ; t < 80; t++) {
379
 
      TEMP = S5(A) + f3(B,C,D) + E + W[t] + SHA_K3;
380
 
      E = D; D = C; C = S30(B); B = A; A = TEMP;
381
 
    }
382
 
 
383
 
    ctx->H[0] += A;
384
 
    ctx->H[1] += B;
385
 
    ctx->H[2] += C;
386
 
    ctx->H[3] += D;
387
 
    ctx->H[4] += E;
388
 
  }
389
 
 
390
 
  /* copy result into output buffer */
391
 
  output[0] = be32_to_cpu(ctx->H[0]);
392
 
  output[1] = be32_to_cpu(ctx->H[1]);
393
 
  output[2] = be32_to_cpu(ctx->H[2]);
394
 
  output[3] = be32_to_cpu(ctx->H[3]);
395
 
  output[4] = be32_to_cpu(ctx->H[4]);
396
 
 
397
 
  /* indicate that message buffer in context is empty */
398
 
  ctx->octets_in_buffer = 0;
399
 
 
400
 
  return;
401
 
}