← Back to branch summary

~ubuntu-branches/ubuntu/feisty/apache2/feisty

« back to all changes in this revision

Viewing changes to srclib/apr/test/testrand2.c

  • Committer: Bazaar Package Importer
  • Author(s): Andreas Barth
  • Date: 2006-12-09 21:05:45 UTC
  • mfrom: (0.6.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061209210545-h70s0xaqc2v8vqr2
Tags: 2.2.3-3.2
http://bugs.debian.org/396265
* Non-maintainer upload.
* 043_ajp_connection_reuse: Patch from upstream Bugzilla, fixing a critical
  issue with regard to connection reuse in mod_proxy_ajp.
  Closes: #396265

Show diffs side-by-side

added added

removed removed

Lines of Context:
srclib/apr/test/testrand2.c
 
1
/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
 
2
 * applicable.
 
3
 *
 
4
 * Licensed under the Apache License, Version 2.0 (the "License");
 
5
 * you may not use this file except in compliance with the License.
 
6
 * You may obtain a copy of the License at
 
7
 *
 
8
 *     http://www.apache.org/licenses/LICENSE-2.0
 
9
 *
 
10
 * Unless required by applicable law or agreed to in writing, software
 
11
 * distributed under the License is distributed on an "AS IS" BASIS,
 
12
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 
13
 * See the License for the specific language governing permissions and
 
14
 * limitations under the License.
 
15
 */
 
16
 
 
17
#include "apr_general.h"
 
18
#include "apr_random.h"
 
19
#include "apr_thread_proc.h"
 
20
#include <errno.h>
 
21
#include <stdio.h>
 
22
#include <stdlib.h>
 
23
#include "testutil.h"
 
24
 
 
25
static void hexdump(const unsigned char *b,int n)
 
26
    {
 
27
    int i;
 
28
 
 
29
    for(i=0 ; i < n ; ++i)
 
30
        {
 
31
#if 0
 
32
        if((i&0xf) == 0)
 
33
            printf("%04x",i);
 
34
        printf(" %02x",b[i]);
 
35
        if((i&0xf) == 0xf)
 
36
            printf("\n");
 
37
#else
 
38
        printf("0x%02x,",b[i]);
 
39
        if((i&7) == 7)
 
40
            printf("\n");
 
41
#endif
 
42
        }
 
43
    printf("\n");
 
44
    }
 
45
 
 
46
static apr_random_t *r;
 
47
 
 
48
typedef apr_status_t APR_THREAD_FUNC rnd_fn(apr_random_t *r,void *b,apr_size_t n);
 
49
 
 
50
static void rand_run_kat(abts_case *tc,rnd_fn *f,apr_random_t *r,
 
51
                         const unsigned char expected[128])
 
52
    {
 
53
    unsigned char c[128];
 
54
    apr_status_t rv;
 
55
 
 
56
    rv=f(r,c,128);
 
57
    ABTS_INT_EQUAL(tc,0,rv);
 
58
    if(rv)
 
59
        return;
 
60
    if(memcmp(c,expected,128))
 
61
        {
 
62
        hexdump(c,128);
 
63
        hexdump(expected,128);
 
64
        ABTS_FAIL(tc,"Randomness mismatch");
 
65
        }
 
66
    }
 
67
 
 
68
static int rand_check_kat(rnd_fn *f,apr_random_t *r,
 
69
                          const unsigned char expected[128])
 
70
    {
 
71
    unsigned char c[128];
 
72
    apr_status_t rv;
 
73
 
 
74
    rv=f(r,c,128);
 
75
    if(rv)
 
76
        return 2;
 
77
    if(memcmp(c,expected,128))
 
78
        return 1;
 
79
    return 0;
 
80
    }
 
81
 
 
82
static void rand_add_zeroes(apr_random_t *r)
 
83
    {
 
84
    static unsigned char c[2048];
 
85
 
 
86
    apr_random_add_entropy(r,c,sizeof c);
 
87
    }
 
88
 
 
89
static void rand_run_seed_short(abts_case *tc,rnd_fn *f,apr_random_t *r,
 
90
                                int count)
 
91
    {
 
92
    int i;
 
93
    apr_status_t rv;
 
94
    char c[1];
 
95
 
 
96
    for(i=0 ; i < count ; ++i)
 
97
        rand_add_zeroes(r);
 
98
    rv=f(r,c,1);
 
99
    ABTS_INT_EQUAL(tc,1,APR_STATUS_IS_ENOTENOUGHENTROPY(rv));
 
100
    }
 
101
 
 
102
static void rand_seed_short(abts_case *tc, void *data)
 
103
    {
 
104
    r=apr_random_standard_new(p);
 
105
    rand_run_seed_short(tc,apr_random_insecure_bytes,r,32);
 
106
    }
 
107
 
 
108
static void rand_kat(abts_case *tc, void *data)
 
109
    {
 
110
    unsigned char expected[128]=
 
111
        { 0x82,0x04,0xad,0xd2,0x0b,0xd5,0xac,0xda,
 
112
          0x3d,0x85,0x58,0x38,0x54,0x6b,0x69,0x45,
 
113
          0x37,0x4c,0xc7,0xd7,0x87,0xeb,0xbf,0xd9,
 
114
          0xb1,0xb8,0xb8,0x2d,0x9b,0x33,0x6e,0x97,
 
115
          0x04,0x1d,0x4c,0xb0,0xd1,0xdf,0x3d,0xac,
 
116
          0xd2,0xaa,0xfa,0xcd,0x96,0xb7,0xcf,0xb1,
 
117
          0x8e,0x3d,0xb3,0xe5,0x37,0xa9,0x95,0xb4,
 
118
          0xaa,0x3d,0x11,0x1a,0x08,0x20,0x21,0x9f,
 
119
          0xdb,0x08,0x3a,0xb9,0x57,0x9f,0xf2,0x1f,
 
120
          0x27,0xdc,0xb6,0xc0,0x85,0x08,0x05,0xbb,
 
121
          0x13,0xbe,0xb1,0xe9,0x63,0x2a,0xe2,0xa4,
 
122
          0x23,0x15,0x2a,0x10,0xbf,0xdf,0x09,0xb3,
 
123
          0xc7,0xfb,0x2d,0x87,0x48,0x19,0xfb,0xc0,
 
124
          0x15,0x8c,0xcb,0xc6,0xbd,0x89,0x38,0x69,
 
125
          0xa3,0xae,0xa3,0x21,0x58,0x50,0xe7,0xc4,
 
126
          0x87,0xec,0x2e,0xb1,0x2d,0x6a,0xbd,0x46 };
 
127
 
 
128
    rand_add_zeroes(r);
 
129
    rand_run_kat(tc,apr_random_insecure_bytes,r,expected);
 
130
    }    
 
131
 
 
132
static void rand_seed_short2(abts_case *tc, void *data)
 
133
    {
 
134
    rand_run_seed_short(tc,apr_random_secure_bytes,r,320);
 
135
    }
 
136
 
 
137
static void rand_kat2(abts_case *tc, void *data)
 
138
    {
 
139
    unsigned char expected[128]=
 
140
        { 0x38,0x8f,0x01,0x29,0x5a,0x5c,0x1f,0xa8,
 
141
          0x00,0xde,0x16,0x4c,0xe5,0xf7,0x1f,0x58,
 
142
          0xc0,0x67,0xe2,0x98,0x3d,0xde,0x4a,0x75,
 
143
          0x61,0x3f,0x23,0xd8,0x45,0x7a,0x10,0x60,
 
144
          0x59,0x9b,0xd6,0xaf,0xcb,0x0a,0x2e,0x34,
 
145
          0x9c,0x39,0x5b,0xd0,0xbc,0x9a,0xf0,0x7b,
 
146
          0x7f,0x40,0x8b,0x33,0xc0,0x0e,0x2a,0x56,
 
147
          0xfc,0xe5,0xab,0xde,0x7b,0x13,0xf5,0xec,
 
148
          0x15,0x68,0xb8,0x09,0xbc,0x2c,0x15,0xf0,
 
149
          0x7b,0xef,0x2a,0x97,0x19,0xa8,0x69,0x51,
 
150
          0xdf,0xb0,0x5f,0x1a,0x4e,0xdf,0x42,0x02,
 
151
          0x71,0x36,0xa7,0x25,0x64,0x85,0xe2,0x72,
 
152
          0xc7,0x87,0x4d,0x7d,0x15,0xbb,0x15,0xd1,
 
153
          0xb1,0x62,0x0b,0x25,0xd9,0xd3,0xd9,0x5a,
 
154
          0xe3,0x47,0x1e,0xae,0x67,0xb4,0x19,0x9e,
 
155
          0xed,0xd2,0xde,0xce,0x18,0x70,0x57,0x12 };
 
156
 
 
157
    rand_add_zeroes(r);
 
158
    rand_run_kat(tc,apr_random_secure_bytes,r,expected);
 
159
    }    
 
160
 
 
161
static void rand_barrier(abts_case *tc, void *data)
 
162
    {
 
163
    apr_random_barrier(r);
 
164
    rand_run_seed_short(tc,apr_random_secure_bytes,r,320);
 
165
    }
 
166
 
 
167
static void rand_kat3(abts_case *tc, void *data)
 
168
    {
 
169
    unsigned char expected[128]=
 
170
        { 0xe8,0xe7,0xc9,0x45,0xe2,0x2a,0x54,0xb2,
 
171
          0xdd,0xe0,0xf9,0xbc,0x3d,0xf9,0xce,0x3c,
 
172
          0x4c,0xbd,0xc9,0xe2,0x20,0x4a,0x35,0x1c,
 
173
          0x04,0x52,0x7f,0xb8,0x0f,0x60,0x89,0x63,
 
174
          0x8a,0xbe,0x0a,0x44,0xac,0x5d,0xd8,0xeb,
 
175
          0x24,0x7d,0xd1,0xda,0x4d,0x86,0x9b,0x94,
 
176
          0x26,0x56,0x4a,0x5e,0x30,0xea,0xd4,0xa9,
 
177
          0x9a,0xdf,0xdd,0xb6,0xb1,0x15,0xe0,0xfa,
 
178
          0x28,0xa4,0xd6,0x95,0xa4,0xf1,0xd8,0x6e,
 
179
          0xeb,0x8c,0xa4,0xac,0x34,0xfe,0x06,0x92,
 
180
          0xc5,0x09,0x99,0x86,0xdc,0x5a,0x3c,0x92,
 
181
          0xc8,0x3e,0x52,0x00,0x4d,0x01,0x43,0x6f,
 
182
          0x69,0xcf,0xe2,0x60,0x9c,0x23,0xb3,0xa5,
 
183
          0x5f,0x51,0x47,0x8c,0x07,0xde,0x60,0xc6,
 
184
          0x04,0xbf,0x32,0xd6,0xdc,0xb7,0x31,0x01,
 
185
          0x29,0x51,0x51,0xb3,0x19,0x6e,0xe4,0xf8 };
 
186
 
 
187
    rand_run_kat(tc,apr_random_insecure_bytes,r,expected);
 
188
    }    
 
189
 
 
190
static void rand_kat4(abts_case *tc, void *data)
 
191
    {
 
192
    unsigned char expected[128]=
 
193
        { 0x7d,0x0e,0xc4,0x4e,0x3e,0xac,0x86,0x50,
 
194
          0x37,0x95,0x7a,0x98,0x23,0x26,0xa7,0xbf,
 
195
          0x60,0xfb,0xa3,0x70,0x90,0xc3,0x58,0xc6,
 
196
          0xbd,0xd9,0x5e,0xa6,0x77,0x62,0x7a,0x5c,
 
197
          0x96,0x83,0x7f,0x80,0x3d,0xf4,0x9c,0xcc,
 
198
          0x9b,0x0c,0x8c,0xe1,0x72,0xa8,0xfb,0xc9,
 
199
          0xc5,0x43,0x91,0xdc,0x9d,0x92,0xc2,0xce,
 
200
          0x1c,0x5e,0x36,0xc7,0x87,0xb1,0xb4,0xa3,
 
201
          0xc8,0x69,0x76,0xfc,0x35,0x75,0xcb,0x08,
 
202
          0x2f,0xe3,0x98,0x76,0x37,0x80,0x04,0x5c,
 
203
          0xb8,0xb0,0x7f,0xb2,0xda,0xe3,0xa3,0xba,
 
204
          0xed,0xff,0xf5,0x9d,0x3b,0x7b,0xf3,0x32,
 
205
          0x6c,0x50,0xa5,0x3e,0xcc,0xe1,0x84,0x9c,
 
206
          0x17,0x9e,0x80,0x64,0x09,0xbb,0x62,0xf1,
 
207
          0x95,0xf5,0x2c,0xc6,0x9f,0x6a,0xee,0x6d,
 
208
          0x17,0x35,0x5f,0x35,0x8d,0x55,0x0c,0x07 };
 
209
 
 
210
    rand_add_zeroes(r);
 
211
    rand_run_kat(tc,apr_random_secure_bytes,r,expected);
 
212
    }    
 
213
 
 
214
#if APR_HAS_FORK
 
215
static void rand_fork(abts_case *tc, void *data)
 
216
    {
 
217
    apr_proc_t proc;
 
218
    apr_status_t rv;
 
219
    unsigned char expected[128]=
 
220
        {  0xac,0x93,0xd2,0x5c,0xc7,0xf5,0x8d,0xc2,
 
221
           0xd8,0x8d,0xb6,0x7a,0x94,0xe1,0x83,0x4c,
 
222
           0x26,0xe2,0x38,0x6d,0xf5,0xbd,0x9d,0x6e,
 
223
           0x91,0x77,0x3a,0x4b,0x9b,0xef,0x9b,0xa3,
 
224
           0x9f,0xf6,0x6d,0x0c,0xdc,0x4b,0x02,0xe9,
 
225
           0x5d,0x3d,0xfc,0x92,0x6b,0xdf,0xc9,0xef,
 
226
           0xb9,0xa8,0x74,0x09,0xa3,0xff,0x64,0x8d,
 
227
           0x19,0xc1,0x31,0x31,0x17,0xe1,0xb7,0x7a,
 
228
           0xe7,0x55,0x14,0x92,0x05,0xe3,0x1e,0xb8,
 
229
           0x9b,0x1b,0xdc,0xac,0x0e,0x15,0x08,0xa2,
 
230
           0x93,0x13,0xf6,0x04,0xc6,0x9d,0xf8,0x7f,
 
231
           0x26,0x32,0x68,0x43,0x2e,0x5a,0x4f,0x47,
 
232
           0xe8,0xf8,0x59,0xb7,0xfb,0xbe,0x30,0x04,
 
233
           0xb6,0x63,0x6f,0x19,0xf3,0x2c,0xd4,0xeb,
 
234
           0x32,0x8a,0x54,0x01,0xd0,0xaf,0x3f,0x13,
 
235
           0xc1,0x7f,0x10,0x2e,0x08,0x1c,0x28,0x4b, };
 
236
 
 
237
    rv=apr_proc_fork(&proc,p);
 
238
    if(rv == APR_INCHILD)
 
239
        {
 
240
        int n;
 
241
 
 
242
        n=rand_check_kat(apr_random_secure_bytes,r,expected);
 
243
 
 
244
        exit(n);
 
245
        }
 
246
    else if(rv == APR_INPARENT)
 
247
        {
 
248
        int exitcode;
 
249
        apr_exit_why_e why;
 
250
 
 
251
        rand_run_kat(tc,apr_random_secure_bytes,r,expected);
 
252
        apr_proc_wait(&proc,&exitcode,&why,APR_WAIT);
 
253
        if(why != APR_PROC_EXIT)
 
254
            {
 
255
            ABTS_FAIL(tc,"Child terminated abnormally");
 
256
            return;
 
257
            }
 
258
        if(exitcode == 0)
 
259
            {
 
260
            ABTS_FAIL(tc,"Child produced our randomness");
 
261
            return;
 
262
            }
 
263
        else if(exitcode == 2)
 
264
            {
 
265
            ABTS_FAIL(tc,"Child randomness failed");
 
266
            return;
 
267
            }
 
268
        else if(exitcode != 1)
 
269
            {
 
270
            ABTS_FAIL(tc,"Uknown child error");
 
271
            return;
 
272
            }
 
273
        }
 
274
    else
 
275
        {
 
276
        ABTS_FAIL(tc,"Fork failed");
 
277
        return;
 
278
        }
 
279
    }
 
280
#endif    
 
281
        
 
282
abts_suite *testrand2(abts_suite *suite)
 
283
    {
 
284
    suite = ADD_SUITE(suite)
 
285
 
 
286
    abts_run_test(suite, rand_seed_short, NULL);
 
287
    abts_run_test(suite, rand_kat, NULL);
 
288
    abts_run_test(suite, rand_seed_short2, NULL);
 
289
    abts_run_test(suite, rand_kat2, NULL);
 
290
    abts_run_test(suite, rand_barrier, NULL);
 
291
    abts_run_test(suite, rand_kat3, NULL);
 
292
    abts_run_test(suite, rand_kat4, NULL);
 
293
#if APR_HAS_FORK
 
294
    abts_run_test(suite, rand_fork, NULL);
 
295
#endif
 
296
 
 
297
    return suite;
 
298
    }