iPXE
cipher_test.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or any later version.
8  *
9  * This program is distributed in the hope that it will be useful, but
10  * WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
17  * 02110-1301, USA.
18  *
19  * You can also choose to distribute this program under the terms of
20  * the Unmodified Binary Distribution Licence (as given in the file
21  * COPYING.UBDL), provided that you have satisfied its requirements.
22  */
23 
24 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
25 
26 /** @file
27  *
28  * Cipher self-tests
29  *
30  */
31 
32 /* Forcibly enable assertions */
33 #undef NDEBUG
34 
35 #include <stdint.h>
36 #include <stdlib.h>
37 #include <string.h>
38 #include <assert.h>
39 #include <ipxe/crypto.h>
40 #include <ipxe/profile.h>
41 #include <ipxe/test.h>
42 #include "cipher_test.h"
43 
44 /** Number of sample iterations for profiling */
45 #define PROFILE_COUNT 16
46 
47 /**
48  * Report a cipher encryption test result
49  *
50  * @v test Cipher test
51  * @v file Test code file
52  * @v line Test code line
53  */
54 void cipher_encrypt_okx ( struct cipher_test *test, const char *file,
55  unsigned int line ) {
56  struct cipher_algorithm *cipher = test->cipher;
57  size_t len = test->len;
58  uint8_t ctx[cipher->ctxsize];
59  uint8_t ciphertext[len];
60  uint8_t auth[cipher->authsize];
61 
62  /* Initialise cipher */
63  okx ( cipher_setkey ( cipher, ctx, test->key, test->key_len ) == 0,
64  file, line );
65  cipher_setiv ( cipher, ctx, test->iv, test->iv_len );
66 
67  /* Process additional data, if applicable */
68  if ( test->additional_len ) {
69  okx ( is_auth_cipher ( cipher ), file, line );
70  cipher_encrypt ( cipher, ctx, test->additional, NULL,
71  test->additional_len );
72  }
73 
74  /* Perform encryption */
75  cipher_encrypt ( cipher, ctx, test->plaintext, ciphertext, len );
76 
77  /* Compare against expected ciphertext */
78  okx ( memcmp ( ciphertext, test->ciphertext, len ) == 0, file, line );
79 
80  /* Check authentication tag */
81  okx ( cipher->authsize == test->auth_len, file, line );
82  cipher_auth ( cipher, ctx, auth );
83  okx ( memcmp ( auth, test->auth, test->auth_len ) == 0, file, line );
84 
85  /* Reset initialisation vector */
86  cipher_setiv ( cipher, ctx, test->iv, test->iv_len );
87 
88  /* Process additional data, if applicable */
89  if ( test->additional_len ) {
90  cipher_encrypt ( cipher, ctx, test->additional, NULL,
91  test->additional_len );
92  }
93 
94  /* Perform in-place encryption */
95  memcpy ( ciphertext, test->plaintext, len );
96  cipher_encrypt ( cipher, ctx, ciphertext, ciphertext, len );
97 
98  /* Compare against expected ciphertext */
99  okx ( memcmp ( ciphertext, test->ciphertext, len ) == 0, file, line );
100 
101  /* Check authentication tag */
102  cipher_auth ( cipher, ctx, auth );
103  okx ( memcmp ( auth, test->auth, test->auth_len ) == 0, file, line );
104 }
105 
106 /**
107  * Report a cipher decryption test result
108  *
109  * @v test Cipher test
110  * @v file Test code file
111  * @v line Test code line
112  */
113 void cipher_decrypt_okx ( struct cipher_test *test, const char *file,
114  unsigned int line ) {
115  struct cipher_algorithm *cipher = test->cipher;
116  size_t len = test->len;
117  uint8_t ctx[cipher->ctxsize];
118  uint8_t plaintext[len];
119  uint8_t auth[cipher->authsize];
120 
121  /* Initialise cipher */
122  okx ( cipher_setkey ( cipher, ctx, test->key, test->key_len ) == 0,
123  file, line );
124  cipher_setiv ( cipher, ctx, test->iv, test->iv_len );
125 
126  /* Process additional data, if applicable */
127  if ( test->additional_len ) {
128  okx ( is_auth_cipher ( cipher ), file, line );
129  cipher_decrypt ( cipher, ctx, test->additional, NULL,
130  test->additional_len );
131  }
132 
133  /* Perform decryption */
134  cipher_decrypt ( cipher, ctx, test->ciphertext, plaintext, len );
135 
136  /* Compare against expected plaintext */
137  okx ( memcmp ( plaintext, test->plaintext, len ) == 0, file, line );
138 
139  /* Check authentication tag */
140  okx ( cipher->authsize == test->auth_len, file, line );
141  cipher_auth ( cipher, ctx, auth );
142  okx ( memcmp ( auth, test->auth, test->auth_len ) == 0, file, line );
143 
144  /* Reset initialisation vector */
145  cipher_setiv ( cipher, ctx, test->iv, test->iv_len );
146 
147  /* Process additional data, if applicable */
148  if ( test->additional_len ) {
149  cipher_decrypt ( cipher, ctx, test->additional, NULL,
150  test->additional_len );
151  }
152 
153  /* Perform in-place decryption */
154  memcpy ( plaintext, test->ciphertext, len );
155  cipher_decrypt ( cipher, ctx, plaintext, plaintext, len );
156 
157  /* Compare against expected plaintext */
158  okx ( memcmp ( plaintext, test->plaintext, len ) == 0, file, line );
159 
160  /* Check authentication tag */
161  cipher_auth ( cipher, ctx, auth );
162  okx ( memcmp ( auth, test->auth, test->auth_len ) == 0, file, line );
163 }
164 
165 /**
166  * Report a cipher encryption and decryption test result
167  *
168  * @v test Cipher test
169  * @v file Test code file
170  * @v line Test code line
171  */
172 void cipher_okx ( struct cipher_test *test, const char *file,
173  unsigned int line ) {
174  struct cipher_algorithm *cipher = test->cipher;
175  size_t len = test->len;
176 
177  /* Sanity checks */
178  okx ( cipher->blocksize != 0, file, line );
179  okx ( ( len % cipher->blocksize ) == 0, file, line );
180  okx ( ( cipher->alignsize % cipher->blocksize ) == 0, file, line );
181 
182  /* Report encryption test result */
183  cipher_encrypt_okx ( test, file, line );
184 
185  /* Report decryption test result */
186  cipher_decrypt_okx ( test, file, line );
187 }
188 
189 /**
190  * Calculate cipher encryption or decryption cost
191  *
192  * @v cipher Cipher algorithm
193  * @v key_len Length of key
194  * @v op Encryption or decryption operation
195  * @ret cost Cost (in cycles per byte)
196  */
197 static unsigned long
198 cipher_cost ( struct cipher_algorithm *cipher, size_t key_len,
199  void ( * op ) ( struct cipher_algorithm *cipher, void *ctx,
200  const void *src, void *dst, size_t len ) ) {
201  static uint8_t random[8192]; /* Too large for stack */
202  uint8_t key[key_len];
203  uint8_t iv[cipher->blocksize];
204  uint8_t ctx[cipher->ctxsize];
205  struct profiler profiler;
206  unsigned long cost;
207  unsigned int i;
208  int rc;
209 
210  /* Fill buffer with pseudo-random data */
211  srand ( 0x1234568 );
212  for ( i = 0 ; i < sizeof ( random ) ; i++ )
213  random[i] = rand();
214  for ( i = 0 ; i < sizeof ( key ) ; i++ )
215  key[i] = rand();
216  for ( i = 0 ; i < sizeof ( iv ) ; i++ )
217  iv[i] = rand();
218 
219  /* Initialise cipher */
220  rc = cipher_setkey ( cipher, ctx, key, key_len );
221  assert ( rc == 0 );
222  cipher_setiv ( cipher, ctx, iv, sizeof ( iv ) );
223 
224  /* Profile cipher operation */
225  memset ( &profiler, 0, sizeof ( profiler ) );
226  for ( i = 0 ; i < PROFILE_COUNT ; i++ ) {
227  profile_start ( &profiler );
228  op ( cipher, ctx, random, random, sizeof ( random ) );
229  profile_stop ( &profiler );
230  }
231 
232  /* Round to nearest whole number of cycles per byte */
233  cost = ( ( profile_mean ( &profiler ) + ( sizeof ( random ) / 2 ) ) /
234  sizeof ( random ) );
235 
236  return cost;
237 }
238 
239 /**
240  * Calculate cipher encryption cost
241  *
242  * @v cipher Cipher algorithm
243  * @v key_len Length of key
244  * @ret cost Cost (in cycles per byte)
245  */
246 unsigned long cipher_cost_encrypt ( struct cipher_algorithm *cipher,
247  size_t key_len ) {
248  return cipher_cost ( cipher, key_len, cipher_encrypt );
249 }
250 
251 /**
252  * Calculate cipher decryption cost
253  *
254  * @v cipher Cipher algorithm
255  * @v key_len Length of key
256  * @ret cost Cost (in cycles per byte)
257  */
258 unsigned long cipher_cost_decrypt ( struct cipher_algorithm *cipher,
259  size_t key_len ) {
260  return cipher_cost ( cipher, key_len, cipher_decrypt );
261 }
unsigned long profile_mean(struct profiler *profiler)
Get mean sample value.
Definition: profile.c:241
size_t blocksize
Block size.
Definition: crypto.h:59
static int is_auth_cipher(struct cipher_algorithm *cipher)
Definition: crypto.h:256
struct arbelprm_rc_send_wqe rc
Definition: arbel.h:14
size_t alignsize
Alignment size.
Definition: crypto.h:71
static unsigned long cipher_cost(struct cipher_algorithm *cipher, size_t key_len, void(*op)(struct cipher_algorithm *cipher, void *ctx, const void *src, void *dst, size_t len))
Calculate cipher encryption or decryption cost.
Definition: cipher_test.c:198
Self-test infrastructure.
Cryptographic API.
struct golan_eq_context ctx
Definition: CIB_PRM.h:28
A data structure for storing profiling information.
Definition: profile.h:26
static void profile_stop(struct profiler *profiler)
Stop profiling.
Definition: profile.h:171
unsigned long cipher_cost_decrypt(struct cipher_algorithm *cipher, size_t key_len)
Calculate cipher decryption cost.
Definition: cipher_test.c:258
#define cipher_encrypt(cipher, ctx, src, dst, len)
Definition: crypto.h:228
size_t authsize
Authentication tag size.
Definition: crypto.h:73
void cipher_decrypt_okx(struct cipher_test *test, const char *file, unsigned int line)
Report a cipher decryption test result.
Definition: cipher_test.c:113
void * memcpy(void *dest, const void *src, size_t len) __nonnull
A cipher test.
Definition: cipher_test.h:17
void cipher_okx(struct cipher_test *test, const char *file, unsigned int line)
Report a cipher encryption and decryption test result.
Definition: cipher_test.c:172
#define okx(success, file, line)
Report test result.
Definition: test.h:44
Assertions.
assert((readw(&hdr->flags) &(GTF_reading|GTF_writing))==0)
static int rand(void)
Definition: stdlib.h:59
static void srand(unsigned int seed)
Definition: stdlib.h:63
static void profile_start(struct profiler *profiler)
Start profiling.
Definition: profile.h:158
Profiling.
static __always_inline void off_t userptr_t src
Definition: efi_uaccess.h:66
static void cipher_setiv(struct cipher_algorithm *cipher, void *ctx, const void *iv, size_t ivlen)
Definition: crypto.h:218
long int random(void)
Generate a pseudo-random number between 0 and 2147483647L or 2147483562?
Definition: random.c:30
void(* auth)(void *ctx, void *auth)
Generate authentication tag.
Definition: crypto.h:116
unsigned char uint8_t
Definition: stdint.h:10
size_t ctxsize
Context size.
Definition: crypto.h:53
uint32_t cost
Root path cost.
Definition: stp.h:28
#define cipher_decrypt(cipher, ctx, src, dst, len)
Definition: crypto.h:238
Cipher self-tests.
#define PROFILE_COUNT
Number of sample iterations for profiling.
Definition: cipher_test.c:45
static uint16_t struct vmbus_xfer_pages_operations * op
Definition: netvsc.h:327
uint32_t len
Length.
Definition: ena.h:14
uint8_t iv[12]
Initialisation vector.
Definition: gcm.h:12
A cipher algorithm.
Definition: crypto.h:49
static void cipher_auth(struct cipher_algorithm *cipher, void *ctx, void *auth)
Definition: crypto.h:243
void cipher_encrypt_okx(struct cipher_test *test, const char *file, unsigned int line)
Report a cipher encryption test result.
Definition: cipher_test.c:54
int memcmp(const void *first, const void *second, size_t len)
Compare memory regions.
Definition: string.c:114
FILE_LICENCE(GPL2_OR_LATER_OR_UBDL)
unsigned long cipher_cost_encrypt(struct cipher_algorithm *cipher, size_t key_len)
Calculate cipher encryption cost.
Definition: cipher_test.c:246
#define NULL
NULL pointer (VOID *)
Definition: Base.h:362
String functions.
union @382 key
Sense key.
Definition: scsi.h:18
static int test
Definition: epic100.c:73
static int cipher_setkey(struct cipher_algorithm *cipher, void *ctx, const void *key, size_t keylen)
Definition: crypto.h:213
void * memset(void *dest, int character, size_t len) __nonnull