← Back to branch summary

~ubuntu-branches/ubuntu/vivid/sflphone/vivid

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.1.0/third_party/srtp/crypto/test/auth_driver.c

  • Committer: Package Import Robot
  • Author(s): Jonathan Riddell
  • Date: 2015-01-07 14:51:16 UTC
  • mfrom: (4.3.5 sid)
  • Revision ID: package-import@ubuntu.com-20150107145116-yxnafinf4lrdvrmx
Tags: 1.4.1-0.1ubuntu1
* Merge with Debian, remaining changes:
 - Drop soprano, nepomuk build-dep
* Drop ubuntu patches, now upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.1.0/third_party/srtp/crypto/test/auth_driver.c
1
 
/*
2
 
 * auth_driver.c
3
 
 *
4
 
 * a driver for auth functions
5
 
 *
6
 
 * David A. McGrew
7
 
 * Cisco Systems, Inc.
8
 
 */
9
 
 
10
 
/*
11
 
 *      
12
 
 * Copyright (c) 2001-2006, Cisco Systems, Inc.
13
 
 * All rights reserved.
14
 
 * 
15
 
 * Redistribution and use in source and binary forms, with or without
16
 
 * modification, are permitted provided that the following conditions
17
 
 * are met:
18
 
 * 
19
 
 *   Redistributions of source code must retain the above copyright
20
 
 *   notice, this list of conditions and the following disclaimer.
21
 
 * 
22
 
 *   Redistributions in binary form must reproduce the above
23
 
 *   copyright notice, this list of conditions and the following
24
 
 *   disclaimer in the documentation and/or other materials provided
25
 
 *   with the distribution.
26
 
 * 
27
 
 *   Neither the name of the Cisco Systems, Inc. nor the names of its
28
 
 *   contributors may be used to endorse or promote products derived
29
 
 *   from this software without specific prior written permission.
30
 
 * 
31
 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32
 
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33
 
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
34
 
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
35
 
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
36
 
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
37
 
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
38
 
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
39
 
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
40
 
 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
41
 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
42
 
 * OF THE POSSIBILITY OF SUCH DAMAGE.
43
 
 *
44
 
 */
45
 
 
46
 
 
47
 
#include <stdio.h>    /* for printf() */
48
 
#include <stdlib.h>   /* for xalloc() */
49
 
#include <unistd.h>   /* for getopt() */
50
 
 
51
 
#include "auth.h"
52
 
#include "null_auth.h"
53
 
 
54
 
#define PRINT_DEBUG_DATA 0
55
 
 
56
 
extern auth_type_t tmmhv2;
57
 
 
58
 
const uint16_t msg0[9] = {
59
 
  0x6015, 0xf141, 0x5ba1, 0x29a0, 0xf604, 0xd1c, 0x2d9, 0xaa8a, 0x7931
60
 
};
61
 
 
62
 
/* key1 is for TAG_WORDS = 2 */
63
 
 
64
 
const uint16_t key1[47] = {
65
 
  0xe627, 0x6a01, 0x5ea7, 0xf27a, 0xc536, 0x2192, 0x11be, 0xea35,
66
 
  0xdb9d, 0x63d6, 0xfa8a, 0xfc45, 0xe08b, 0xd216, 0xced2, 0x7853,
67
 
  0x1a82, 0x22f5, 0x90fb, 0x1c29, 0x708e, 0xd06f, 0x82c3, 0xbee6,
68
 
  0x4f21, 0x6f33, 0x65c0, 0xd211, 0xc25e, 0x9138, 0x4fa3, 0x7c1f,
69
 
  0x61ac, 0x3489, 0x2976, 0x8c19, 0x8252, 0xddbf, 0xcad3, 0xc28f,
70
 
  0x68d6, 0x58dd, 0x504f, 0x2bbf, 0x0278, 0x70b7, 0xcfca
71
 
};
72
 
 
73
 
double
74
 
auth_bits_per_second(auth_t *h, int msg_len);
75
 
 
76
 
 
77
 
void
78
 
usage(char *prog_name) {
79
 
  printf("usage: %s [ -t | -v ]\n", prog_name);
80
 
  exit(255);
81
 
}
82
 
 
83
 
#define MAX_MSG_LEN 2048
84
 
 
85
 
int
86
 
main (int argc, char *argv[]) {
87
 
  auth_t *a = NULL;
88
 
  err_status_t status;
89
 
  int i;
90
 
  int c;
91
 
  unsigned do_timing_test = 0;
92
 
  unsigned do_validation = 0;
93
 
 
94
 
  /* process input arguments */
95
 
  while (1) {
96
 
    c = getopt(argc, argv, "tv");
97
 
    if (c == -1) 
98
 
      break;
99
 
    switch (c) {
100
 
    case 't':
101
 
      do_timing_test = 1;
102
 
      break;
103
 
    case 'v':
104
 
      do_validation = 1;
105
 
      break;
106
 
    default:
107
 
      usage(argv[0]);
108
 
    }    
109
 
  }
110
 
  
111
 
  printf("auth driver\nDavid A. McGrew\nCisco Systems, Inc.\n");
112
 
 
113
 
  if (!do_validation && !do_timing_test)
114
 
    usage(argv[0]);
115
 
 
116
 
  if (do_validation) {
117
 
    printf("running self-test for %s...", tmmhv2.description);
118
 
    status = tmmhv2_add_big_test();
119
 
    if (status) {
120
 
      printf("tmmhv2_add_big_test failed with error code %d\n", status);
121
 
      exit(status);
122
 
    }  
123
 
    status = auth_type_self_test(&tmmhv2);
124
 
    if (status) {
125
 
      printf("failed with error code %d\n", status);
126
 
      exit(status);
127
 
    }
128
 
    printf("passed\n");
129
 
  }
130
 
 
131
 
  if (do_timing_test) {
132
 
 
133
 
    /* tmmhv2 timing test */
134
 
    status = auth_type_alloc(&tmmhv2, &a, 94, 4);
135
 
    if (status) {
136
 
      fprintf(stderr, "can't allocate tmmhv2\n");
137
 
      exit(status);
138
 
    }
139
 
    status = auth_init(a, (uint8_t *)key1);
140
 
    if (status) {
141
 
      printf("error initializaing auth function\n");
142
 
      exit(status);
143
 
    }
144
 
    
145
 
    printf("timing %s (tag length %d)\n", 
146
 
           tmmhv2.description, auth_get_tag_length(a));
147
 
    for (i=8; i <= MAX_MSG_LEN; i *= 2)
148
 
      printf("msg len: %d\tgigabits per second: %f\n",
149
 
             i, auth_bits_per_second(a, i) / 1E9);
150
 
 
151
 
    status = auth_dealloc(a);
152
 
    if (status) {
153
 
      printf("error deallocating auth function\n");
154
 
      exit(status);
155
 
    }
156
 
    
157
 
  }
158
 
 
159
 
  return 0;
160
 
}
161
 
 
162
 
#define NUM_TRIALS 100000
163
 
 
164
 
#include <time.h>
165
 
 
166
 
double
167
 
auth_bits_per_second(auth_t *a, int msg_len_octets) {
168
 
  int i;
169
 
  clock_t timer;
170
 
  uint8_t *result;
171
 
  int msg_len = (msg_len_octets + 1)/2;
172
 
  uint16_t *msg_string; 
173
 
 
174
 
  /* create random message */
175
 
  msg_string = (uint16_t *) crypto_alloc(msg_len_octets);
176
 
  if (msg_string == NULL)
177
 
    return 0.0; /* indicate failure */  
178
 
  for (i=0; i < msg_len; i++) 
179
 
    msg_string[i] = (uint16_t) random();
180
 
 
181
 
  /* allocate temporary storage for authentication tag */
182
 
  result = crypto_alloc(auth_get_tag_length(a));
183
 
  if (result == NULL) {
184
 
    free(msg_string);
185
 
    return 0.0; /* indicate failure */  
186
 
  }
187
 
  
188
 
  timer = clock();
189
 
  for (i=0; i < NUM_TRIALS; i++) {
190
 
    auth_compute(a, (uint8_t *)msg_string, msg_len_octets, (uint8_t *)result);
191
 
  }
192
 
  timer = clock() - timer;
193
 
 
194
 
  free(msg_string);
195
 
  free(result);
196
 
  
197
 
  return (double) NUM_TRIALS * 8 * msg_len_octets * CLOCKS_PER_SEC / timer;
198
 
}
199
 
 
200