blob: 94d72733c47833f56bf8534cc0bc115649c7e14b [file] [log] [blame]
Paul Bakker579923c2011-03-26 13:39:34 +00001#include <polarssl/config.h>
2
Paul Bakkerb3dcbc12011-03-13 16:57:25 +00003#ifdef _MSC_VER
4#include <basetsd.h>
5typedef UINT32 uint32_t;
6#else
7#include <inttypes.h>
8#endif
9
10/*
11 * 32-bit integer manipulation macros (big endian)
12 */
13#ifndef GET_ULONG_BE
14#define GET_ULONG_BE(n,b,i) \
15{ \
16 (n) = ( (unsigned long) (b)[(i) ] << 24 ) \
17 | ( (unsigned long) (b)[(i) + 1] << 16 ) \
18 | ( (unsigned long) (b)[(i) + 2] << 8 ) \
19 | ( (unsigned long) (b)[(i) + 3] ); \
20}
21#endif
22
23#ifndef PUT_ULONG_BE
24#define PUT_ULONG_BE(n,b,i) \
25{ \
26 (b)[(i) ] = (unsigned char) ( (n) >> 24 ); \
27 (b)[(i) + 1] = (unsigned char) ( (n) >> 16 ); \
28 (b)[(i) + 2] = (unsigned char) ( (n) >> 8 ); \
29 (b)[(i) + 3] = (unsigned char) ( (n) ); \
30}
31#endif
32
Paul Bakker367dae42009-06-28 21:50:27 +000033int unhexify(unsigned char *obuf, const char *ibuf)
34{
35 unsigned char c, c2;
36 int len = strlen(ibuf) / 2;
37 assert(!(strlen(ibuf) %1)); // must be even number of bytes
38
39 while (*ibuf != 0)
40 {
41 c = *ibuf++;
42 if( c >= '0' && c <= '9' )
43 c -= '0';
44 else if( c >= 'a' && c <= 'f' )
45 c -= 'a' - 10;
46 else if( c >= 'A' && c <= 'F' )
47 c -= 'A' - 10;
48 else
49 assert( 0 );
50
51 c2 = *ibuf++;
52 if( c2 >= '0' && c2 <= '9' )
53 c2 -= '0';
54 else if( c2 >= 'a' && c2 <= 'f' )
55 c2 -= 'a' - 10;
56 else if( c2 >= 'A' && c2 <= 'F' )
57 c2 -= 'A' - 10;
58 else
59 assert( 0 );
60
61 *obuf++ = ( c << 4 ) | c2;
62 }
63
64 return len;
65}
66
67void hexify(unsigned char *obuf, const unsigned char *ibuf, int len)
68{
69 unsigned char l, h;
70
71 while (len != 0)
72 {
73 h = (*ibuf) / 16;
74 l = (*ibuf) % 16;
75
76 if( h < 10 )
77 *obuf++ = '0' + h;
78 else
79 *obuf++ = 'a' + h - 10;
80
81 if( l < 10 )
82 *obuf++ = '0' + l;
83 else
84 *obuf++ = 'a' + l - 10;
85
86 ++ibuf;
87 len--;
88 }
89}
Paul Bakker9dcc3222011-03-08 14:16:06 +000090
91/**
92 * This function just returns data from rand().
Paul Bakker997bbd12011-03-13 15:45:42 +000093 * Although predictable and often similar on multiple
94 * runs, this does not result in identical random on
95 * each run. So do not use this if the results of a
96 * test depend on the random data that is generated.
Paul Bakker9dcc3222011-03-08 14:16:06 +000097 *
98 * rng_state shall be NULL.
99 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000100static int rnd_std_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000101{
Paul Bakkera3d195c2011-11-27 21:07:34 +0000102 size_t i;
103
Paul Bakker9dcc3222011-03-08 14:16:06 +0000104 if( rng_state != NULL )
105 rng_state = NULL;
106
Paul Bakkera3d195c2011-11-27 21:07:34 +0000107 for( i = 0; i < len; ++i )
108 output[i] = rand();
109
110 return( 0 );
Paul Bakker9dcc3222011-03-08 14:16:06 +0000111}
112
113/**
114 * This function only returns zeros
115 *
116 * rng_state shall be NULL.
117 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000118static int rnd_zero_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000119{
120 if( rng_state != NULL )
121 rng_state = NULL;
122
Paul Bakkera3d195c2011-11-27 21:07:34 +0000123 memset( output, 0, len );
124
Paul Bakker9dcc3222011-03-08 14:16:06 +0000125 return( 0 );
126}
127
128typedef struct
129{
130 unsigned char *buf;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000131 size_t length;
Paul Bakker997bbd12011-03-13 15:45:42 +0000132} rnd_buf_info;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000133
134/**
135 * This function returns random based on a buffer it receives.
136 *
Paul Bakker997bbd12011-03-13 15:45:42 +0000137 * rng_state shall be a pointer to a rnd_buf_info structure.
138 *
139 * The number of bytes released from the buffer on each call to
140 * the random function is specified by per_call. (Can be between
141 * 1 and 4)
Paul Bakker9dcc3222011-03-08 14:16:06 +0000142 *
143 * After the buffer is empty it will return rand();
144 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000145static int rnd_buffer_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000146{
Paul Bakker997bbd12011-03-13 15:45:42 +0000147 rnd_buf_info *info = (rnd_buf_info *) rng_state;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000148 size_t use_len;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000149
150 if( rng_state == NULL )
Paul Bakkera3d195c2011-11-27 21:07:34 +0000151 return( rnd_std_rand( NULL, output, len ) );
Paul Bakker9dcc3222011-03-08 14:16:06 +0000152
Paul Bakkera3d195c2011-11-27 21:07:34 +0000153 use_len = len;
154 if( len > info->length )
155 use_len = info->length;
Paul Bakker997bbd12011-03-13 15:45:42 +0000156
Paul Bakkera3d195c2011-11-27 21:07:34 +0000157 if( use_len )
Paul Bakker9dcc3222011-03-08 14:16:06 +0000158 {
Paul Bakkera3d195c2011-11-27 21:07:34 +0000159 memcpy( output, info->buf, use_len );
160 info->buf += use_len;
161 info->length -= use_len;
Paul Bakker9dcc3222011-03-08 14:16:06 +0000162 }
163
Paul Bakkera3d195c2011-11-27 21:07:34 +0000164 if( len - use_len > 0 )
165 return( rnd_std_rand( NULL, output + use_len, len - use_len ) );
166
167 return( 0 );
Paul Bakker9dcc3222011-03-08 14:16:06 +0000168}
Paul Bakker997bbd12011-03-13 15:45:42 +0000169
170/**
171 * Info structure for the pseudo random function
172 *
173 * Key should be set at the start to a test-unique value.
Paul Bakkerb3dcbc12011-03-13 16:57:25 +0000174 * Do not forget endianness!
Paul Bakker997bbd12011-03-13 15:45:42 +0000175 * State( v0, v1 ) should be set to zero.
176 */
177typedef struct
178{
Paul Bakkerb3dcbc12011-03-13 16:57:25 +0000179 uint32_t key[16];
Paul Bakker997bbd12011-03-13 15:45:42 +0000180 uint32_t v0, v1;
181} rnd_pseudo_info;
182
183/**
184 * This function returns random based on a pseudo random function.
185 * This means the results should be identical on all systems.
186 * Pseudo random is based on the XTEA encryption algorithm to
187 * generate pseudorandom.
188 *
189 * rng_state shall be a pointer to a rnd_pseudo_info structure.
190 */
Paul Bakkera3d195c2011-11-27 21:07:34 +0000191static int rnd_pseudo_rand( void *rng_state, unsigned char *output, size_t len )
Paul Bakker997bbd12011-03-13 15:45:42 +0000192{
193 rnd_pseudo_info *info = (rnd_pseudo_info *) rng_state;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000194 uint32_t i, *k, sum, delta=0x9E3779B9;
Paul Bakker997bbd12011-03-13 15:45:42 +0000195
196 if( rng_state == NULL )
Paul Bakkera3d195c2011-11-27 21:07:34 +0000197 return( rnd_std_rand( NULL, output, len ) );
Paul Bakker997bbd12011-03-13 15:45:42 +0000198
Paul Bakkerb3dcbc12011-03-13 16:57:25 +0000199 k = info->key;
Paul Bakkera3d195c2011-11-27 21:07:34 +0000200
201 while( len > 0 )
Paul Bakker997bbd12011-03-13 15:45:42 +0000202 {
Paul Bakkera3d195c2011-11-27 21:07:34 +0000203 size_t use_len = len;
204 sum = 0;
205
206 use_len = 1;
207
208 for( i = 0; i < 32; i++ )
209 {
210 info->v0 += (((info->v1 << 4) ^ (info->v1 >> 5)) + info->v1) ^ (sum + k[sum & 3]);
211 sum += delta;
212 info->v1 += (((info->v0 << 4) ^ (info->v0 >> 5)) + info->v0) ^ (sum + k[(sum>>11) & 3]);
213 }
214
215 memcpy( output, &info->v0, use_len );
216 len -= use_len;
Paul Bakker997bbd12011-03-13 15:45:42 +0000217 }
218
Paul Bakkera3d195c2011-11-27 21:07:34 +0000219 return( 0 );
Paul Bakker997bbd12011-03-13 15:45:42 +0000220}