OpenCores
URL https://opencores.org/ocsvn/apbtoaes128/apbtoaes128/trunk

Subversion Repositories apbtoaes128

[/] [apbtoaes128/] [trunk/] [pli/] [aes_monitor.h] - Blame information for rev 16

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 4 redbear 
//////////////////////////////////////////////////////////////////
2 
////
3 
////
4 
////    AES CORE BLOCK
5 
////
6 
////
7 
////
8 
//// This file is part of the APB to AES128 project
9 
////
10 
//// http://www.opencores.org/cores/apbtoaes128/
11 
////
12 
////
13 
////
14 
//// Description
15 
////
16 
//// Implementation of APB IP core according to
17 
////
18 
//// aes128_spec IP core specification document.
19 
////
20 
////
21 
////
22 
//// To Do: Things are right here but always all block can suffer changes
23 
////
24 
////
25 
////
26 
////
27 
////
28 
//// Author(s): - Felipe Fernandes Da Costa, fefe2560@gmail.com
29 
////
30 
/////////////////////////////////////////////////////////////////
31 
////
32 
////
33 
//// Copyright (C) 2009 Authors and OPENCORES.ORG
34 
////
35 
////
36 
////
37 
//// This source file may be used and distributed without
38 
////
39 
//// restriction provided that this copyright statement is not
40 
////
41 
//// removed from the file and that any derivative work contains
42 
//// the original copyright notice and the associated disclaimer.
43 
////
44 
////
45 
//// This source file is free software; you can redistribute it
46 
////
47 
//// and/or modify it under the terms of the GNU Lesser General
48 
////
49 
//// Public License as published by the Free Software Foundation;
50 
//// either version 2.1 of the License, or (at your option) any
51 
////
52 
//// later version.
53 
////
54 
////
55 
////
56 
//// This source is distributed in the hope that it will be
57 
////
58 
//// useful, but WITHOUT ANY WARRANTY; without even the implied
59 
////
60 
//// warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
61 
////
62 
//// PURPOSE. See the GNU Lesser General Public License for more
63 
//// details.
64 
////
65 
////
66 
////
67 
//// You should have received a copy of the GNU Lesser General
68 
////
69 
//// Public License along with this source; if not, download it
70 
////
71 
//// from http://www.opencores.org/lgpl.shtml
72 
////
73 
////
74 
///////////////////////////////////////////////////////////////////
75 
static int mon_calltf(char*user_data)
76 
{
77 
 
78 
        vpiHandle PRESETn = vpi_handle_by_name("AES_GLADIC_tb.PRESETn", NULL);
79 
        vpiHandle PWDATA = vpi_handle_by_name("AES_GLADIC_tb.PWDATA", NULL);
80 
        vpiHandle PENABLE = vpi_handle_by_name("AES_GLADIC_tb.PENABLE", NULL);
81 9 redbear 
        vpiHandle PSEL = vpi_handle_by_name("AES_GLADIC_tb.PSEL", NULL);
82 4 redbear 
        vpiHandle PWRITE = vpi_handle_by_name("AES_GLADIC_tb.PWRITE", NULL);
83 
        vpiHandle PADDR = vpi_handle_by_name("AES_GLADIC_tb.PADDR", NULL);
84 
        vpiHandle PRDATA = vpi_handle_by_name("AES_GLADIC_tb.PRDATA", NULL);
85 
        vpiHandle PREADY = vpi_handle_by_name("AES_GLADIC_tb.PREADY", NULL);
86 
        vpiHandle PSLVERR = vpi_handle_by_name("AES_GLADIC_tb.PSLVERR", NULL);
87 
        vpiHandle int_ccf = vpi_handle_by_name("AES_GLADIC_tb.int_ccf", NULL);
88 
        vpiHandle int_err = vpi_handle_by_name("AES_GLADIC_tb.int_err", NULL);
89 
        vpiHandle dma_req_wr = vpi_handle_by_name("AES_GLADIC_tb.dma_req_wr", NULL);
90 
        vpiHandle dma_req_rd = vpi_handle_by_name("AES_GLADIC_tb.dma_req_rd", NULL);
91 
 
92 9 redbear 
        std::random_device rd;
93 
        std::uniform_int_distribution<long int> data_in(0,4294967295);
94 
 
95 
 
96 
 
97 
        v_monitor.format=vpiIntVal;
98 
        v_monitor_catch.format=vpiIntVal;
99 
 
100 
 
101 
        vpi_get_value(PRESETn, &v_monitor);
102 
 
103 
        t_monitor.type = vpiScaledRealTime;
104 
        t_monitor.real = 10;
105 
 
106 
        if(v_monitor.value.integer == 1)
107 4 redbear 
        {
108 9 redbear 
                vpi_get_value(PENABLE, &v_monitor);
109 4 redbear 
 
110 9 redbear 
                if(v_monitor.value.integer == 1)
111 
                {
112 4 redbear 
 
113 9 redbear 
                                vpi_get_value(PWRITE, &v_monitor);
114 
 
115 
 
116 
                                if(v_monitor.value.integer == 1)
117 
                                {
118 
                                        vpi_get_value(PADDR, &v_monitor);
119 
 
120 
 
121 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR3)
122 
                                        {
123 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
124 
                                                //printf("%X\n",v_monitor_catch.value.integer);
125 
                                                A=v_monitor_catch.value.integer;
126 
 
127 
                                                INPUT_KEYR[0]=A>>24;
128 
                                                INPUT_KEYR[1]=A>>16;
129 
                                                INPUT_KEYR[2]=A>>8;
130 
                                                INPUT_KEYR[3]=A;
131 
                                        }
132 
 
133 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR2)
134 
                                        {
135 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
136 
                                                //printf("%X\n",v_monitor_catch.value.integer);
137 
                                                B=v_monitor_catch.value.integer;
138 
 
139 
                                                INPUT_KEYR[4]=B>>24;
140 
                                                INPUT_KEYR[5]=B>>16;
141 
                                                INPUT_KEYR[6]=B>>8;
142 
                                                INPUT_KEYR[7]=B;
143 
                                        }
144 
 
145 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR1)
146 
                                        {
147 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
148 
                                                //printf("%X\n",v_monitor_catch.value.integer);
149 
                                                C=v_monitor_catch.value.integer;
150 
 
151 
                                                INPUT_KEYR[8]=C>>24;
152 
                                                INPUT_KEYR[9]=C>>16;
153 
                                                INPUT_KEYR[10]=C>>8;
154 
                                                INPUT_KEYR[11]=C;
155 
                                        }
156 
 
157 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR0)
158 
                                        {
159 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
160 
                                                //printf("%X\n",v_monitor_catch.value.integer);
161 
                                                D=v_monitor_catch.value.integer;
162 
 
163 
                                                INPUT_KEYR[12]=D>>24;
164 
                                                INPUT_KEYR[13]=D>>16;
165 
                                                INPUT_KEYR[14]=D>>8;
166 
                                                INPUT_KEYR[15]=D;
167 
 
168 
                                                //printf("%x%x%x%x\n",INPUT_KEYR[0],INPUT_KEYR[1],INPUT_KEYR[2],INPUT_KEYR[3]);
169 
 
170 
                                                //printf("%x%x%x%x\n",KEYR[0],KEYR[1],KEYR[2],KEYR[3]);
171 
                                        }
172 
 
173 
 
174 
                                        if(v_monitor.value.integer == ADDR_AES_IVR3)
175 
                                        {
176 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
177 
                                                //printf("%X\n",v_monitor_catch.value.integer);
178 
                                                E=v_monitor_catch.value.integer;
179 
 
180 
                                                INPUT_IVR[0]=E>>24;
181 
                                                INPUT_IVR[1]=E>>16;
182 
                                                INPUT_IVR[2]=E>>8;
183 
                                                INPUT_IVR[3]=E;
184 
                                        }
185 
 
186 
                                        if(v_monitor.value.integer == ADDR_AES_IVR2)
187 
                                        {
188 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
189 
                                                //printf("%X\n",v_monitor_catch.value.integer);
190 
                                                F=v_monitor_catch.value.integer;
191 
 
192 
                                                INPUT_IVR[4]=F>>24;
193 
                                                INPUT_IVR[5]=F>>16;
194 
                                                INPUT_IVR[6]=F>>8;
195 
                                                INPUT_IVR[7]=F;
196 
                                        }
197 
 
198 
                                        if(v_monitor.value.integer == ADDR_AES_IVR1)
199 
                                        {
200 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
201 
                                                //printf("%X\n",v_monitor_catch.value.integer);
202 
                                                G=v_monitor_catch.value.integer;
203 
 
204 
                                                INPUT_IVR[8]=G>>24;
205 
                                                INPUT_IVR[9]=G>>16;
206 
                                                INPUT_IVR[10]=G>>8;
207 
                                                INPUT_IVR[11]=G;
208 
                                        }
209 
 
210 
                                        if(v_monitor.value.integer == ADDR_AES_IVR0)
211 
                                        {
212 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
213 
                                                //printf("%X\n",v_monitor_catch.value.integer);
214 
                                                H=v_monitor_catch.value.integer;
215 
 
216 
                                                INPUT_IVR[12]=H>>24;
217 
                                                INPUT_IVR[13]=H>>16;
218 
                                                INPUT_IVR[14]=H>>8;
219 
                                                INPUT_IVR[15]=H;
220 
 
221 
                                        }
222 
 
223 
                                        if(v_monitor.value.integer == ADDR_AES_CR)
224 
                                        {
225 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
226 
                                                //printf("%X\n",v_monitor_catch.value.integer);
227 
                                                I=v_monitor_catch.value.integer;
228 
                                        }
229 
 
230 
                                        if(v_monitor.value.integer == ADDR_AES_DINR)
231 
                                        {
232 
                                                vpi_get_value(PWDATA, &v_monitor_catch);
233 
                                                //printf("%X\n",v_monitor_catch.value.integer);
234 
 
235 
                                                if(counter_monitor == 0)
236 
                                                {
237 
 
238 
                                                        J=v_monitor_catch.value.integer;
239 
                                                        INPUT_TEXT[0]=J>>24;
240 
                                                        INPUT_TEXT[1]=J>>16;
241 
                                                        INPUT_TEXT[2]=J>>8;
242 
                                                        INPUT_TEXT[3]=J;
243 
 
244 
                                                        counter_monitor++;
245 
 
246 
 
247 
                                                }else if(counter_monitor == 1)
248 
                                                {
249 
 
250 
                                                        L=v_monitor_catch.value.integer;
251 
                                                        INPUT_TEXT[4]=L>>24;
252 
                                                        INPUT_TEXT[5]=L>>16;
253 
                                                        INPUT_TEXT[6]=L>>8;
254 
                                                        INPUT_TEXT[7]=L;
255 
 
256 
                                                        counter_monitor++;
257 
 
258 
 
259 
                                                }else if(counter_monitor == 2)
260 
                                                {
261 
 
262 
                                                        M=v_monitor_catch.value.integer;
263 
                                                        INPUT_TEXT[8]=M>>24;
264 
                                                        INPUT_TEXT[9]=M>>16;
265 
                                                        INPUT_TEXT[10]=M>>8;
266 
                                                        INPUT_TEXT[11]=M;
267 
 
268 
                                                        counter_monitor++;
269 
 
270 
 
271 
                                                }else if(counter_monitor == 3)
272 
                                                {
273 
 
274 
                                                        N=v_monitor_catch.value.integer;
275 
                                                        INPUT_TEXT[12]=N>>24;
276 
                                                        INPUT_TEXT[13]=N>>16;
277 
                                                        INPUT_TEXT[14]=N>>8;
278 
                                                        INPUT_TEXT[15]=N;
279 
 
280 
                                                        counter_monitor=0;
281 
                                                }
282 
 
283 
 
284 
 
285 
                                        }
286 
 
287 
                                }else if(v_monitor.value.integer == 0){
288 
 
289 
                                        vpi_get_value(PADDR, &v_monitor);
290 
 
291 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR3)
292 
                                        {
293 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
294 
                                                //printf("%X\n",v_monitor_catch.value.integer);
295 
                                                A=v_monitor_catch.value.integer;
296 
 
297 
                                                OUTPUT_KEYR[0]=A>>24;
298 
                                                OUTPUT_KEYR[1]=A>>16;
299 
                                                OUTPUT_KEYR[2]=A>>8;
300 
                                                OUTPUT_KEYR[3]=A;
301 
 
302 
                                                counter_monitor++;
303 
 
304 
                                                //printf("%x%x%x%x\n",KEYR[0],KEYR[1],KEYR[2],KEYR[3]);
305 
                                        }
306 
 
307 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR2)
308 
                                        {
309 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
310 
                                                //printf("%X\n",v_monitor_catch.value.integer);
311 
                                                B=v_monitor_catch.value.integer;
312 
 
313 
                                                OUTPUT_KEYR[4]=B>>24;
314 
                                                OUTPUT_KEYR[5]=B>>16;
315 
                                                OUTPUT_KEYR[6]=B>>8;
316 
                                                OUTPUT_KEYR[7]=B;
317 
 
318 
                                                counter_monitor++;
319 
 
320 
                                        }
321 
 
322 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR1)
323 
                                        {
324 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
325 
                                                //printf("%X\n",v_monitor_catch.value.integer);
326 
                                                C=v_monitor_catch.value.integer;
327 
 
328 
                                                OUTPUT_KEYR[8]=C>>24;
329 
                                                OUTPUT_KEYR[9]=C>>16;
330 
                                                OUTPUT_KEYR[10]=C>>8;
331 
                                                OUTPUT_KEYR[11]=C;
332 
 
333 
                                                counter_monitor++;
334 
 
335 
 
336 
                                        }
337 
 
338 
                                        if(v_monitor.value.integer == ADDR_AES_KEYR0)
339 
                                        {
340 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
341 
                                                //printf("%X\n",v_monitor_catch.value.integer);
342 
                                                D=v_monitor_catch.value.integer;
343 
 
344 
                                                OUTPUT_KEYR[12]=D>>24;
345 
                                                OUTPUT_KEYR[13]=D>>16;
346 
                                                OUTPUT_KEYR[14]=D>>8;
347 
                                                OUTPUT_KEYR[15]=D;
348 
 
349 
                                                counter_monitor++;
350 
 
351 
                                                        //printf("%x%x%x%x\n",KEYR[0],KEYR[1],KEYR[2],KEYR[3]);
352 
                                        }
353 
 
354 
                                        if(v_monitor.value.integer == ADDR_AES_IVR3)
355 
                                        {
356 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
357 
                                                //printf("%X\n",v_monitor_catch.value.integer);
358 
                                                E=v_monitor_catch.value.integer;
359 
 
360 
                                                OUTPUT_IVR[0]=E>>24;
361 
                                                OUTPUT_IVR[1]=E>>16;
362 
                                                OUTPUT_IVR[2]=E>>8;
363 
                                                OUTPUT_IVR[3]=E;
364 
 
365 
                                                counter_monitor++;
366 
 
367 
                                        }
368 
 
369 
                                        if(v_monitor.value.integer == ADDR_AES_IVR2)
370 
                                        {
371 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
372 
                                                //printf("%X\n",v_monitor_catch.value.integer);
373 
                                                F=v_monitor_catch.value.integer;
374 
 
375 
                                                OUTPUT_IVR[4]=F>>24;
376 
                                                OUTPUT_IVR[5]=F>>16;
377 
                                                OUTPUT_IVR[6]=F>>8;
378 
                                                OUTPUT_IVR[7]=F;
379 
 
380 
                                                counter_monitor++;
381 
 
382 
 
383 
                                        }
384 
 
385 
                                        if(v_monitor.value.integer == ADDR_AES_IVR1)
386 
                                        {
387 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
388 
                                                //printf("%X\n",v_monitor_catch.value.integer);
389 
                                                G=v_monitor_catch.value.integer;
390 
 
391 
                                                OUTPUT_IVR[8]=G>>24;
392 
                                                OUTPUT_IVR[9]=G>>16;
393 
                                                OUTPUT_IVR[10]=G>>8;
394 
                                                OUTPUT_IVR[11]=G;
395 
 
396 
                                                counter_monitor++;
397 
 
398 
                                        }
399 
 
400 
                                        if(v_monitor.value.integer == ADDR_AES_IVR0)
401 
                                        {
402 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
403 
                                                //printf("%X\n",v_monitor_catch.value.integer);
404 
                                                H=v_monitor_catch.value.integer;
405 
 
406 
                                                OUTPUT_IVR[12]=H>>24;
407 
                                                OUTPUT_IVR[13]=H>>16;
408 
                                                OUTPUT_IVR[14]=H>>8;
409 
                                                OUTPUT_IVR[15]=H;
410 
 
411 
                                                counter_monitor++;
412 
                                        }
413 
 
414 
 
415 12 redbear 
                                        if(v_monitor.value.integer == ADDR_AES_SR)
416 
                                        {
417 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
418 
                                                //printf("%X\n",v_monitor_catch.value.integer);
419 
                                                O =v_monitor_catch.value.integer;
420 
 
421 
                                                if(type_bfm == AES_WR_ERROR_DOUTR_ONLY || type_bfm == AES_WR_ERROR_DINR_ONLY)
422 
                                                {
423 
                                                        counter_monitor++;
424 
                                                }
425 
                                        }
426 
 
427 9 redbear 
                                        if(v_monitor.value.integer == ADDR_AES_DOUTR)
428 
                                        {
429 
 
430 
                                                vpi_get_value(PRDATA, &v_monitor_catch);
431 
                                                //vpi_put_value(PRDATA, &v_monitor_catch, &t_monitor, vpiTransportDelay);
432 
                                                //printf("%X\n",v_monitor_catch.value.integer);
433 
 
434 
                                                if(counter_monitor == 0)
435 
                                                {
436 
 
437 
                                                        J=v_monitor_catch.value.integer;
438 
                                                        OUTPUT_TEXT[0]=J>>24;
439 
                                                        OUTPUT_TEXT[1]=J>>16;
440 
                                                        OUTPUT_TEXT[2]=J>>8;
441 
                                                        OUTPUT_TEXT[3]=J;
442 
 
443 
                                                        counter_monitor++;
444 
 
445 
 
446 
                                                }else if(counter_monitor == 1)
447 
                                                {
448 
                                                        L=v_monitor_catch.value.integer;
449 
                                                        OUTPUT_TEXT[4]=L>>24;
450 
                                                        OUTPUT_TEXT[5]=L>>16;
451 
                                                        OUTPUT_TEXT[6]=L>>8;
452 
                                                        OUTPUT_TEXT[7]=L;
453 
 
454 
                                                        counter_monitor++;
455 
 
456 
 
457 
 
458 
                                                }else if(counter_monitor == 2)
459 
                                                {
460 
 
461 
                                                        M=v_monitor_catch.value.integer;
462 
                                                        OUTPUT_TEXT[8]=M>>24;
463 
                                                        OUTPUT_TEXT[9]=M>>16;
464 
                                                        OUTPUT_TEXT[10]=M>>8;
465 
                                                        OUTPUT_TEXT[11]=M;
466 
 
467 
                                                        counter_monitor++;
468 
 
469 
 
470 
                                                }else if(counter_monitor == 3)
471 
                                                {
472 
 
473 
                                                        N=v_monitor_catch.value.integer;
474 
                                                        OUTPUT_TEXT[12]=N>>24;
475 
                                                        OUTPUT_TEXT[13]=N>>16;
476 
                                                        OUTPUT_TEXT[14]=N>>8;
477 
                                                        OUTPUT_TEXT[15]=N;
478 
 
479 
                                                        counter_monitor++;
480 
                                                }
481 
 
482 
 
483 
                                        }
484 
 
485 
                                        // vpi_mcd_printf(1,"%d\n",counter_monitor);
486 
 
487 
 
488 12 redbear 
                                        if(counter_monitor == 12  && FIPS_ENABLE == FIPS)
489 9 redbear 
                                        {
490 
                                                printf("Checking results\n\n");
491 
                                                counter_monitor = 0;
492 
 
493 12 redbear 
                                                if(type_bfm == AES_WR_ERROR_DOUTR_ONLY)
494 9 redbear 
                                                {
495 12 redbear 
                                                        if(O == 2 || O == 6)
496 
                                                        {
497 
                                                                printf("AES_WR_ERROR_DOUTR_ONLY PASS\n");
498 
                                                        }else
499 
                                                        {
500 
                                                                printf("AES_WR_ERROR_DOUTR_ONLY FAILs\n");
501 
                                                                printf("%i\n",O);
502 
                                                        }
503 
 
504 
 
505 
                                                }else if(type_bfm == AES_WR_ERROR_DINR_ONLY)
506 
                                                {
507 
 
508 
                                                        if(O == 4)
509 
                                                        {
510 
                                                                printf("AES_WR_ERROR_DINR_ONLY PASS\n");
511 
                                                        }else
512 
                                                        {
513 
                                                                printf("AES_WR_ERROR_DINR_ONLY FAILs\n");
514 
                                                                printf("%i\n",O);
515 
                                                        }
516 
 
517 
 
518 
                                                }else if(I == 4094)// WR
519 
                                                {
520 9 redbear 
                                                        if(memcmp(TEXT_NULL,OUTPUT_TEXT,16) == 0)
521 
                                                        {
522 
                                                                printf("WRITE READ: TEXT CR DISABLED PASSED.\n");
523 
                                                        }else
524 
                                                        {
525 
                                                                printf("WRITE READ: TEXT CR DISABLED FAIL.\n");
526 
                                                        }
527 
 
528 
                                                        if(memcmp(OUTPUT_KEYR,INPUT_KEYR,16) == 0)
529 
                                                        {
530 
                                                                        printf("WRITE READ: KEYR WHEN CR DISABLED PASSED.\n");
531 
                                                        }else
532 
                                                        {
533 
                                                                printf("WRITE READ: KEYR WHEN CR DISABLED FAIL.\n");
534 
                                                        }
535 
 
536 
                                                        if(memcmp(OUTPUT_IVR,INPUT_IVR,16) == 0)
537 
                                                        {
538 
                                                                printf("WRITE READ: IVR WHEN CR DISABLED PASSED.\n");
539 
                                                        }else
540 
                                                        {
541 
                                                                printf("WRITE READ: IVR WHEN CR DISABLED FAIL.\n");
542 
                                                        }
543 
 
544 12 redbear 
                                                }else if(I == 1)//ECB ENCRYPTION DATATYPE 00
545 9 redbear 
                                                {
546 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DERIVATED,16) == 0)
547 
                                                        {
548 12 redbear 
                                                                printf("ECB ENCRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
549 9 redbear 
                                                        }else
550 
                                                        {
551 12 redbear 
                                                                printf("ECB ENCRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
552 9 redbear 
                                                        }
553 
 
554 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
555 
                                                        {
556 12 redbear 
                                                                printf("ECB ENCRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
557 9 redbear 
                                                        }else
558 
                                                        {
559 12 redbear 
                                                                printf("ECB ENCRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
560 9 redbear 
                                                        }
561 
 
562 
 
563 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
564 
                                                        {
565 12 redbear 
                                                                printf("ECB ENCRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
566 9 redbear 
                                                        }else
567 
                                                        {
568 12 redbear 
                                                                printf("ECB ENCRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
569 9 redbear 
                                                        }
570 
 
571 12 redbear 
                                                }else if(I == 3)//ECB ENCRYPTION DATATYPE 01
572 9 redbear 
                                                {
573 
 
574 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
575 
                                                        {
576 
                                                                printf("ECB ENCRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
577 
                                                        }else
578 
                                                        {
579 
                                                                printf("ECB ENCRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
580 
                                                        }
581 
 
582 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
583 
                                                        {
584 
                                                                printf("ECB ENCRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
585 
                                                        }else
586 
                                                        {
587 
                                                                printf("ECB ENCRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
588 
                                                        }
589 
 
590 
 
591 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
592 
                                                        {
593 
                                                                printf("ECB ENCRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
594 
                                                        }else
595 
                                                        {
596 
                                                                printf("ECB ENCRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
597 
                                                        }
598 
 
599 
 
600 
                                                }else if(I == 5)//ECB ENCRYPTION DATATYPE 02
601 
                                                {
602 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
603 
                                                        {
604 
                                                                printf("ECB ENCRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
605 
                                                        }else
606 
                                                        {
607 
                                                                printf("ECB ENCRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
608 
                                                        }
609 
 
610 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
611 
                                                        {
612 
                                                                printf("ECB ENCRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
613 
                                                        }else
614 
                                                        {
615 
                                                                printf("ECB ENCRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
616 
                                                        }
617 
 
618 
 
619 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
620 
                                                        {
621 
                                                                printf("ECB ENCRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
622 
                                                        }else
623 
                                                        {
624 
                                                                printf("ECB ENCRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
625 
                                                        }
626 
 
627 
                                                }else if(I == 7)//ECB ENCRYPTION DATATYPE 03
628 
                                                {
629 
 
630 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
631 
                                                        {
632 
                                                                printf("ECB ENCRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
633 
                                                        }else
634 
                                                        {
635 
                                                                printf("ECB ENCRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
636 
                                                        }
637 
 
638 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
639 
                                                        {
640 
                                                                printf("ECB ENCRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
641 
                                                        }else
642 
                                                        {
643 
                                                                printf("ECB ENCRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
644 
                                                        }
645 
 
646 
 
647 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
648 
                                                        {
649 
                                                                printf("ECB ENCRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
650 
                                                        }else
651 
                                                        {
652 
                                                                printf("ECB ENCRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
653 
                                                        }
654 
 
655 
 
656 
                                                }else if(I == 6145 ) //ECB ENCRYPTION DMA DATATYPE 00
657 
                                                {
658 
 
659 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DERIVATED,16) == 0)
660 
                                                        {
661 12 redbear 
                                                                printf("ECB ENCRYPTION DMA DATATYPE00 : TEXT CYPHER  WHEN CR ENABLE PASSED.\n");
662 9 redbear 
 
663 
                                                        }else
664 
                                                        {
665 12 redbear 
                                                                printf("ECB ENCRYPTION DMA DATATYPE00 : TEXT CYPHER WHEN CR ENABLE FAIL.\n");
666 9 redbear 
                                                        }
667 
 
668 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
669 
                                                        {
670 12 redbear 
                                                                printf("ECB ENCRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
671 9 redbear 
                                                        }else
672 
                                                        {
673 12 redbear 
                                                                printf("ECB ENCRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
674 9 redbear 
                                                        }
675 
 
676 
 
677 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
678 
                                                        {
679 12 redbear 
                                                                printf("ECB ENCRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
680 9 redbear 
                                                        }else
681 
                                                        {
682 12 redbear 
                                                                printf("ECB ENCRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
683 9 redbear 
                                                        }
684 
 
685 12 redbear 
                                                }else if(I == 6147 ) //ECB ENCRYPTION DMA DATATYPE 01
686 9 redbear 
                                                {
687 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
688 
                                                        {
689 
                                                                printf("ECB ENCRYPTION DMA DATATYPE01 : TEXT CYPHER  WHEN CR ENABLE PASSED.\n");
690 9 redbear 
 
691 12 redbear 
                                                        }else
692 
                                                        {
693 
                                                                printf("ECB ENCRYPTION DMA DATATYPE01 : TEXT CYPHER WHEN CR ENABLE FAIL.\n");
694 
                                                        }
695 
 
696 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
697 
                                                        {
698 
                                                                printf("ECB ENCRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
699 
                                                        }else
700 
                                                        {
701 
                                                                printf("ECB ENCRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
702 
                                                        }
703 
 
704 
 
705 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
706 
                                                        {
707 
                                                                printf("ECB ENCRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
708 
                                                        }else
709 
                                                        {
710 
                                                                printf("ECB ENCRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
711 
                                                        }
712 
 
713 
 
714 
                                                }else if (I == 6149 ) //ECB ENCRYPTION DMA DATATYPE 02
715 
                                                {
716 
 
717 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
718 
                                                        {
719 
                                                                printf("ECB ENCRYPTION DMA DATATYPE02 : TEXT CYPHER  WHEN CR ENABLE PASSED.\n");
720 
 
721 
                                                        }else
722 
                                                        {
723 
                                                                printf("ECB ENCRYPTION DMA DATATYPE02 : TEXT CYPHER WHEN CR ENABLE FAIL.\n");
724 
                                                        }
725 
 
726 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
727 
                                                        {
728 
                                                                printf("ECB ENCRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
729 
                                                        }else
730 
                                                        {
731 
                                                                printf("ECB ENCRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
732 
                                                        }
733 
 
734 
 
735 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
736 
                                                        {
737 
                                                                printf("ECB ENCRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
738 
                                                        }else
739 
                                                        {
740 
                                                                printf("ECB ENCRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
741 
                                                        }
742 
 
743 
 
744 
                                                }else if (I == 6151 ) //ECB ENCRYPTION DMA DATATYPE 03
745 
                                                {
746 
 
747 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
748 
                                                        {
749 
                                                                printf("ECB ENCRYPTION DMA DATATYPE03 : TEXT CYPHER  WHEN CR ENABLE PASSED.\n");
750 
 
751 
                                                        }else
752 
                                                        {
753 
                                                                printf("ECB ENCRYPTION DMA DATATYPE03 : TEXT CYPHER WHEN CR ENABLE FAIL.\n");
754 
                                                        }
755 
 
756 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
757 
                                                        {
758 
                                                                printf("ECB ENCRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
759 
                                                        }else
760 
                                                        {
761 
                                                                printf("ECB ENCRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
762 
                                                        }
763 
 
764 
 
765 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
766 
                                                        {
767 
                                                                printf("ECB ENCRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
768 
                                                        }else
769 
                                                        {
770 
                                                                printf("ECB ENCRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
771 
                                                        }
772 
 
773 
 
774 
                                                }else if (I == 513) //ECB ENCRYPTION CCFIE DATA TYPE00
775 
                                                {
776 
 
777 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DERIVATED,16) == 0)
778 
                                                        {
779 12 redbear 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
780 9 redbear 
 
781 
                                                        }else
782 
                                                        {
783 12 redbear 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
784 9 redbear 
                                                        }
785 
 
786 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
787 
                                                        {
788 12 redbear 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
789 9 redbear 
                                                        }else
790 
                                                        {
791 12 redbear 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
792 9 redbear 
                                                        }
793 
 
794 
 
795 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
796 
                                                        {
797 12 redbear 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
798 9 redbear 
                                                        }else
799 
                                                        {
800 12 redbear 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
801 9 redbear 
                                                        }
802 
 
803 12 redbear 
                                                }else if(I == 515)//ECB ENCRYPTION CCFIE DATA TYPE01
804 9 redbear 
                                                {
805 
 
806 12 redbear 
 
807 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
808 
                                                        {
809 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
810 
 
811 
                                                        }else
812 
                                                        {
813 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
814 
                                                        }
815 
 
816 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
817 
                                                        {
818 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
819 
                                                        }else
820 
                                                        {
821 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
822 
                                                        }
823 
 
824 
 
825 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
826 
                                                        {
827 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
828 
                                                        }else
829 
                                                        {
830 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
831 
                                                        }
832 
 
833 
 
834 
                                                }else if(I == 517)//ECB ENCRYPTION CCFIE DATA TYPE02
835 
                                                {
836 
 
837 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
838 
                                                        {
839 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
840 
 
841 
                                                        }else
842 
                                                        {
843 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
844 
                                                        }
845 
 
846 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
847 
                                                        {
848 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
849 
                                                        }else
850 
                                                        {
851 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
852 
                                                        }
853 
 
854 
 
855 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
856 
                                                        {
857 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
858 
                                                        }else
859 
                                                        {
860 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
861 
                                                        }
862 
 
863 
                                                }else if(I == 519)//ECB ENCRYPTION CCFIE DATA TYPE03
864 
                                                {
865 
 
866 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
867 
                                                        {
868 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
869 
 
870 
                                                        }else
871 
                                                        {
872 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
873 
                                                        }
874 
 
875 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
876 
                                                        {
877 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
878 
                                                        }else
879 
                                                        {
880 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
881 
                                                        }
882 
 
883 
 
884 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
885 
                                                        {
886 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
887 
                                                        }else
888 
                                                        {
889 
                                                                printf("ECB ENCRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
890 
                                                        }
891 
 
892 
 
893 
                                                }else if(I == 25)// ECB DERIVATION DECRYPTION DATA TYPE00
894 
                                                {
895 
 
896 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DERIVATED,16) == 0)
897 
                                                        {
898 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
899 9 redbear 
 
900 
                                                        }else
901 
                                                        {
902 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
903 9 redbear 
                                                        }
904 
 
905 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
906 
                                                        {
907 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
908 9 redbear 
                                                        }else
909 
                                                        {
910 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
911 9 redbear 
                                                        }
912 
 
913 
 
914 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
915 
                                                        {
916 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
917 9 redbear 
                                                        }else
918 
                                                        {
919 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
920 9 redbear 
                                                        }
921 
 
922 12 redbear 
                                                }else if(I == 27)// ECB DERIVATION DECRYPTION DATA TYPE01
923 9 redbear 
                                                {
924 
 
925 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
926 
                                                        {
927 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
928 9 redbear 
 
929 12 redbear 
                                                        }else
930 
                                                        {
931 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
932 
                                                        }
933 
 
934 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
935 
                                                        {
936 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
937 
                                                        }else
938 
                                                        {
939 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
940 
                                                        }
941 
 
942 
 
943 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
944 
                                                        {
945 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
946 
                                                        }else
947 
                                                        {
948 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
949 
                                                        }
950 
 
951 
                                                }else if(I == 29)// ECB DERIVATION DECRYPTION DATA TYPE02
952 
                                                {
953 
 
954 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
955 
                                                        {
956 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
957 
 
958 
                                                        }else
959 
                                                        {
960 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
961 
                                                        }
962 
 
963 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
964 
                                                        {
965 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
966 
                                                        }else
967 
                                                        {
968 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
969 
                                                        }
970 
 
971 
 
972 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
973 
                                                        {
974 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
975 
                                                        }else
976 
                                                        {
977 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
978 
                                                        }
979 
 
980 
                                                }else if(I == 31)// ECB DERIVATION DECRYPTION DATA TYPE03
981 
                                                {
982 
 
983 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
984 
                                                        {
985 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
986 
 
987 
                                                        }else
988 
                                                        {
989 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
990 
                                                        }
991 
 
992 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
993 
                                                        {
994 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
995 
                                                        }else
996 
                                                        {
997 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
998 
                                                        }
999 
 
1000 
 
1001 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1002 
                                                        {
1003 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1004 
                                                        }else
1005 
                                                        {
1006 
                                                                printf("ECB DERIVATION DECRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1007 
                                                        }
1008 
 
1009 
                                                }else if(I == 6169)// ECB DERIVATION DECRYPTION DMA DATA TYPE00
1010 
                                                {
1011 
 
1012 
 
1013 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DERIVATED,16) == 0)
1014 
                                                        {
1015 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
1016 9 redbear 
 
1017 
                                                        }else
1018 
                                                        {
1019 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
1020 9 redbear 
                                                        }
1021 
 
1022 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1023 
                                                        {
1024 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1025 9 redbear 
                                                        }else
1026 
                                                        {
1027 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1028 9 redbear 
                                                        }
1029 
 
1030 
 
1031 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1032 
                                                        {
1033 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1034 9 redbear 
                                                        }else
1035 
                                                        {
1036 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1037 9 redbear 
                                                        }
1038 
 
1039 12 redbear 
                                                }else if(I == 6171)// ECB DERIVATION DECRYPTION DMA DATATYPE01
1040 9 redbear 
                                                {
1041 
 
1042 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1043 
                                                        {
1044 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
1045 
 
1046 
                                                        }else
1047 
                                                        {
1048 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
1049 
                                                        }
1050 
 
1051 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1052 
                                                        {
1053 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1054 
                                                        }else
1055 
                                                        {
1056 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1057 
                                                        }
1058 
 
1059 
 
1060 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1061 
                                                        {
1062 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1063 
                                                        }else
1064 
                                                        {
1065 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1066 
                                                        }
1067 
 
1068 
 
1069 
                                                }else if(I == 6173)// ECB DERIVATION DECRYPTION DMA DATATYPE02
1070 
                                                {
1071 
 
1072 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1073 
                                                        {
1074 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
1075 
 
1076 
                                                        }else
1077 
                                                        {
1078 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
1079 
                                                        }
1080 
 
1081 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1082 
                                                        {
1083 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1084 
                                                        }else
1085 
                                                        {
1086 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1087 
                                                        }
1088 
 
1089 
 
1090 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1091 
                                                        {
1092 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1093 
                                                        }else
1094 
                                                        {
1095 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1096 
                                                        }
1097 
 
1098 
 
1099 
 
1100 
                                                }else if(I == 6175)// ECB DERIVATION DECRYPTION DMA DATATYPE03
1101 
                                                {
1102 
 
1103 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1104 
                                                        {
1105 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
1106 
 
1107 
                                                        }else
1108 
                                                        {
1109 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
1110 
                                                        }
1111 
 
1112 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1113 
                                                        {
1114 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1115 
                                                        }else
1116 
                                                        {
1117 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1118 
                                                        }
1119 
 
1120 
 
1121 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1122 
                                                        {
1123 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1124 
                                                        }else
1125 
                                                        {
1126 
                                                                printf("ECB DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1127 
                                                        }
1128 
 
1129 
 
1130 
 
1131 
                                                }else if(I == 537)// ECB DERIVATION DECRYPTION CCFIE DATA TYPE00
1132 
                                                {
1133 
 
1134 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DERIVATED,16) == 0)
1135 
                                                        {
1136 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
1137 9 redbear 
 
1138 
                                                        }else
1139 
                                                        {
1140 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
1141 9 redbear 
                                                        }
1142 
 
1143 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1144 
                                                        {
1145 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1146 9 redbear 
                                                        }else
1147 
                                                        {
1148 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1149 9 redbear 
                                                        }
1150 
 
1151 
 
1152 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1153 
                                                        {
1154 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1155 9 redbear 
                                                        }else
1156 
                                                        {
1157 12 redbear 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1158 9 redbear 
                                                        }
1159 
 
1160 12 redbear 
                                                }else if(I == 539)// ECB DERIVATION DECRYPTION CCFIE DATA TYPE01
1161 9 redbear 
                                                {
1162 
 
1163 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1164 
                                                        {
1165 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
1166 
 
1167 
                                                        }else
1168 
                                                        {
1169 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
1170 
                                                        }
1171 
 
1172 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1173 
                                                        {
1174 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1175 
                                                        }else
1176 
                                                        {
1177 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1178 
                                                        }
1179 
 
1180 
 
1181 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1182 
                                                        {
1183 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1184 
                                                        }else
1185 
                                                        {
1186 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1187 
                                                        }
1188 
 
1189 
                                                }else if(I == 541)// ECB DERIVATION DECRYPTION CCFIE DATA TYPE02
1190 
                                                {
1191 
 
1192 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1193 
                                                        {
1194 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
1195 
 
1196 
                                                        }else
1197 
                                                        {
1198 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
1199 
                                                        }
1200 
 
1201 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1202 
                                                        {
1203 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1204 
                                                        }else
1205 
                                                        {
1206 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1207 
                                                        }
1208 
 
1209 
 
1210 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1211 
                                                        {
1212 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1213 
                                                        }else
1214 
                                                        {
1215 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1216 
                                                        }
1217 
 
1218 
                                                }else if(I == 543)// ECB DERIVATION DECRYPTION CCFIE DATA TYPE03
1219 
                                                {
1220 
 
1221 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1222 
                                                        {
1223 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
1224 
 
1225 
                                                        }else
1226 
                                                        {
1227 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
1228 
                                                        }
1229 
 
1230 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1231 
                                                        {
1232 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1233 
                                                        }else
1234 
                                                        {
1235 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1236 
                                                        }
1237 
 
1238 
 
1239 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1240 
                                                        {
1241 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1242 
                                                        }else
1243 
                                                        {
1244 
                                                                printf("ECB DERIVATION DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1245 
                                                        }
1246 
 
1247 
 
1248 
 
1249 
                                                }else if(I == 17)//ECB DECRYPTION DATA TYPE00
1250 
                                                {
1251 
 
1252 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DERIVATED,16) == 0)
1253 
                                                        {
1254 12 redbear 
                                                                printf("ECB DECRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
1255 9 redbear 
 
1256 
                                                        }else
1257 
                                                        {
1258 12 redbear 
                                                                printf("ECB DECRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
1259 9 redbear 
                                                        }
1260 
 
1261 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1262 
                                                        {
1263 12 redbear 
                                                                printf("ECB DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1264 9 redbear 
                                                        }else
1265 
                                                        {
1266 12 redbear 
                                                                printf("ECB DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1267 9 redbear 
                                                        }
1268 
 
1269 
 
1270 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1271 
                                                        {
1272 12 redbear 
                                                                printf("ECB DECRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1273 9 redbear 
                                                        }else
1274 
                                                        {
1275 12 redbear 
                                                                printf("ECB DECRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1276 9 redbear 
                                                        }
1277 
 
1278 
 
1279 12 redbear 
                                                }else if(I == 19)//ECB DECRYPTION DATA TYPE01
1280 9 redbear 
                                                {
1281 
 
1282 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1283 
                                                        {
1284 
                                                                printf("ECB DECRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
1285 
 
1286 
                                                        }else
1287 
                                                        {
1288 
                                                                printf("ECB DECRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
1289 
                                                        }
1290 
 
1291 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1292 
                                                        {
1293 
                                                                printf("ECB DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1294 
                                                        }else
1295 
                                                        {
1296 
                                                                printf("ECB DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1297 
                                                        }
1298 
 
1299 
 
1300 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1301 
                                                        {
1302 
                                                                printf("ECB DECRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1303 
                                                        }else
1304 
                                                        {
1305 
                                                                printf("ECB DECRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1306 
                                                        }
1307 
 
1308 
 
1309 
                                                }else if(I == 21)//ECB DECRYPTION DATA TYPE02
1310 
                                                {
1311 
 
1312 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1313 
                                                        {
1314 
                                                                printf("ECB DECRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
1315 
 
1316 
                                                        }else
1317 
                                                        {
1318 
                                                                printf("ECB DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
1319 
                                                        }
1320 
 
1321 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1322 
                                                        {
1323 
                                                                printf("ECB DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1324 
                                                        }else
1325 
                                                        {
1326 
                                                                printf("ECB DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1327 
                                                        }
1328 
 
1329 
 
1330 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1331 
                                                        {
1332 
                                                                printf("ECB DECRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1333 
                                                        }else
1334 
                                                        {
1335 
                                                                printf("ECB DECRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1336 
                                                        }
1337 
 
1338 
 
1339 
                                                }else if(I == 23)//ECB DECRYPTION DATA TYPE03
1340 
                                                {
1341 
 
1342 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1343 
                                                        {
1344 
                                                                printf("ECB DECRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
1345 
 
1346 
                                                        }else
1347 
                                                        {
1348 
                                                                printf("ECB DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
1349 
                                                        }
1350 
 
1351 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1352 
                                                        {
1353 
                                                                printf("ECB DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1354 
                                                        }else
1355 
                                                        {
1356 
                                                                printf("ECB DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1357 
                                                        }
1358 
 
1359 
 
1360 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1361 
                                                        {
1362 
                                                                printf("ECB DECRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1363 
                                                        }else
1364 
                                                        {
1365 
                                                                printf("ECB DECRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1366 
                                                        }
1367 
 
1368 
                                                }else if(I == 6161)//ECB DECRYPTION DMA DATA TYPE00
1369 
                                                {
1370 
 
1371 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DERIVATED,16) == 0)
1372 
                                                        {
1373 12 redbear 
                                                                printf("ECB DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
1374 9 redbear 
 
1375 
                                                        }else
1376 
                                                        {
1377 12 redbear 
                                                                printf("ECB DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
1378 9 redbear 
                                                        }
1379 
 
1380 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1381 
                                                        {
1382 12 redbear 
                                                                printf("ECB DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1383 9 redbear 
                                                        }else
1384 
                                                        {
1385 12 redbear 
                                                                printf("ECB DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1386 9 redbear 
                                                        }
1387 
 
1388 
 
1389 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1390 
                                                        {
1391 12 redbear 
                                                                printf("ECB DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1392 9 redbear 
                                                        }else
1393 
                                                        {
1394 12 redbear 
                                                                printf("ECB DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1395 9 redbear 
                                                        }
1396 12 redbear 
 
1397 
                                                }else if(I == 6163)//ECB DECRYPTION DMA DATA TYPE01
1398 9 redbear 
                                                {
1399 
 
1400 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1401 
                                                        {
1402 
                                                                printf("ECB DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
1403 
 
1404 
                                                        }else
1405 
                                                        {
1406 
                                                                printf("ECB DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
1407 
                                                        }
1408 
 
1409 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1410 
                                                        {
1411 
                                                                printf("ECB DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1412 
                                                        }else
1413 
                                                        {
1414 
                                                                printf("ECB DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1415 
                                                        }
1416 
 
1417 
 
1418 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1419 
                                                        {
1420 
                                                                printf("ECB DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1421 
                                                        }else
1422 
                                                        {
1423 
                                                                printf("ECB DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1424 
                                                        }
1425 
 
1426 
 
1427 
                                                }else if(I == 6165)//ECB DECRYPTION DMA DATA TYPE02
1428 
                                                {
1429 
 
1430 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1431 
                                                        {
1432 
                                                                printf("ECB DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
1433 
 
1434 
                                                        }else
1435 
                                                        {
1436 
                                                                printf("ECB DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
1437 
                                                        }
1438 
 
1439 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1440 
                                                        {
1441 
                                                                printf("ECB DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1442 
                                                        }else
1443 
                                                        {
1444 
                                                                printf("ECB DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1445 
                                                        }
1446 
 
1447 
 
1448 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1449 
                                                        {
1450 
                                                                printf("ECB DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1451 
                                                        }else
1452 
                                                        {
1453 
                                                                printf("ECB DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1454 
                                                        }
1455 
 
1456 
 
1457 
                                                }else if(I == 6167)//ECB DECRYPTION DMA DATA TYPE03
1458 
                                                {
1459 
 
1460 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1461 
                                                        {
1462 
                                                                printf("ECB DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
1463 
 
1464 
                                                        }else
1465 
                                                        {
1466 
                                                                printf("ECB DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
1467 
                                                        }
1468 
 
1469 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1470 
                                                        {
1471 
                                                                printf("ECB DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1472 
                                                        }else
1473 
                                                        {
1474 
                                                                printf("ECB DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1475 
                                                        }
1476 
 
1477 
 
1478 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1479 
                                                        {
1480 
                                                                printf("ECB DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1481 
                                                        }else
1482 
                                                        {
1483 
                                                                printf("ECB DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1484 
                                                        }
1485 
 
1486 
 
1487 
                                                }else if(I == 529)//ECB DECRYPTION CCFIE DATATYPE00
1488 
                                                {
1489 
 
1490 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DERIVATED,16) == 0)
1491 
                                                        {
1492 12 redbear 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
1493 9 redbear 
 
1494 
                                                        }else
1495 
                                                        {
1496 12 redbear 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
1497 9 redbear 
                                                        }
1498 
 
1499 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1500 
                                                        {
1501 12 redbear 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1502 9 redbear 
                                                        }else
1503 
                                                        {
1504 12 redbear 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1505 9 redbear 
                                                        }
1506 
 
1507 
 
1508 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1509 
                                                        {
1510 12 redbear 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1511 9 redbear 
                                                        }else
1512 
                                                        {
1513 12 redbear 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1514 9 redbear 
                                                        }
1515 
 
1516 12 redbear 
                                                }else if(I == 531)//ECB DECRYPTION CCFIE DATATYPE01
1517 
                                                {
1518 
 
1519 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1520 
                                                        {
1521 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
1522 
 
1523 
                                                        }else
1524 
                                                        {
1525 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
1526 
                                                        }
1527 
 
1528 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1529 
                                                        {
1530 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1531 
                                                        }else
1532 
                                                        {
1533 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1534 
                                                        }
1535 
 
1536 
 
1537 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1538 
                                                        {
1539 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1540 
                                                        }else
1541 
                                                        {
1542 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1543 
                                                        }
1544 
 
1545 
 
1546 
                                                }else if(I == 533)//ECB DECRYPTION CCFIE DATATYPE02
1547 
                                                {
1548 
 
1549 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1550 
                                                        {
1551 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
1552 
 
1553 
                                                        }else
1554 
                                                        {
1555 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
1556 
                                                        }
1557 
 
1558 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1559 
                                                        {
1560 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1561 
                                                        }else
1562 
                                                        {
1563 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1564 
                                                        }
1565 
 
1566 
 
1567 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1568 
                                                        {
1569 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1570 
                                                        }else
1571 
                                                        {
1572 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1573 
                                                        }
1574 
 
1575 
                                                }else if(I == 535)//ECB DECRYPTION CCFIE DATATYPE03
1576 
                                                {
1577 
 
1578 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_NOT_DATATYPE_DERIVATED,16) == 0)
1579 
                                                        {
1580 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
1581 
 
1582 
                                                        }else
1583 
                                                        {
1584 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
1585 
                                                        }
1586 
 
1587 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1588 
                                                        {
1589 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1590 
                                                        }else
1591 
                                                        {
1592 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1593 
                                                        }
1594 
 
1595 
 
1596 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1597 
                                                        {
1598 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1599 
                                                        }else
1600 
                                                        {
1601 
                                                                printf("ECB DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1602 
                                                        }
1603 
 
1604 
 
1605 9 redbear 
                                                }else if(I == 9) //ECB KEY GENARATION
1606 
                                                {
1607 
 
1608 
 
1609 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
1610 
                                                        {
1611 
                                                                printf("ECB KEY GEN : TEXT CYPHER PASSED.\n");
1612 
 
1613 
                                                        }else
1614 
                                                        {
1615 
                                                                printf("ECB KEY GEN : TEXT CYPHER FAIL.\n");
1616 
                                                        }
1617 
 
1618 
 
1619 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_DERIVATED,16) == 0)
1620 
                                                        {
1621 
                                                                printf("ECB KEY GEN: KEYR WHEN CR ENABLE PASSED.\n");
1622 
                                                        }else
1623 
                                                        {
1624 
                                                                printf("ECB KEY GEN: KEYR WHEN CR ENABLE FAIL.\n");
1625 
                                                        }
1626 
 
1627 
 
1628 
                                                        if(memcmp(OUTPUT_IVR,KEY_FIPS_NOT_DERIVATED,16) == 0)
1629 
                                                        {
1630 
                                                                printf("ECB KEY GEN: IVR WHEN CR ENABLE PASSED.\n");
1631 
                                                        }else
1632 
                                                        {
1633 
                                                                printf("ECB KEY GEN: IVR WHEN CR ENABLE FAIL.\n");
1634 
                                                        }
1635 
 
1636 
                                                }else if(I == 6153)// ECB KEY GENARATION DMA
1637 
                                                {
1638 
 
1639 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
1640 
                                                        {
1641 
                                                                printf("ECB KEY GEN DMA: TEXT CYPHER PASSED.\n");
1642 
 
1643 
                                                        }else
1644 
                                                        {
1645 
                                                                printf("ECB KEY GEN DMA: TEXT CYPHER FAIL.\n");
1646 
                                                        }
1647 
 
1648 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_DERIVATED,16) == 0)
1649 
                                                        {
1650 
                                                                printf("ECB KEY GEN DMA: KEYR WHEN CR ENABLE PASSED.\n");
1651 
                                                        }else
1652 
                                                        {
1653 
                                                                printf("ECB KEY GEN DMA: KEYR WHEN CR ENABLE FAIL.\n");
1654 
                                                        }
1655 
 
1656 
                                                        if(memcmp(OUTPUT_IVR,KEY_FIPS_NOT_DERIVATED,16) == 0)
1657 
                                                        {
1658 
                                                                printf("ECB KEY GEN DMA: IVR WHEN CR ENABLE PASSED.\n");
1659 
                                                        }else
1660 
                                                        {
1661 
                                                                printf("ECB KEY GEN DMA: IVR WHEN CR ENABLE FAIL.\n");
1662 
                                                        }
1663 
 
1664 
                                                }else if(I == 521)// ECB KEY GENARATION CCFIE
1665 
                                                {
1666 
 
1667 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
1668 
                                                        {
1669 
                                                                printf("ECB KEY GEN CCFIE: TEXT CYPHER PASSED.\n");
1670 
 
1671 
                                                        }else
1672 
                                                        {
1673 
                                                                printf("ECB KEY GEN CCFIE: TEXT CYPHER FAIL.\n");
1674 
                                                        }
1675 
 
1676 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_DERIVATED,16) == 0)
1677 
                                                        {
1678 
                                                                printf("ECB KEY GEN CCFIE: KEYR WHEN CR ENABLE PASSED.\n");
1679 
                                                        }else
1680 
                                                        {
1681 
                                                                printf("ECB KEY GEN CCFIE: KEYR WHEN CR ENABLE FAIL.\n");
1682 
                                                        }
1683 
 
1684 
                                                        if(memcmp(OUTPUT_IVR,KEY_FIPS_NOT_DERIVATED,16) == 0)
1685 
                                                        {
1686 
                                                                printf("ECB KEY GEN CCFIE: IVR WHEN CR ENABLE PASSED.\n");
1687 
                                                        }else
1688 
                                                        {
1689 
                                                                printf("ECB KEY GEN CCFIE: IVR WHEN CR ENABLE FAIL.\n");
1690 
                                                        }
1691 
 
1692 12 redbear 
                                                }else if(I == 33) // ENCRYPTION CBC DATA TYPE00
1693 9 redbear 
                                                {
1694 
 
1695 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DERIVATED,16) == 0)
1696 
                                                        {
1697 12 redbear 
                                                                printf("CBC ENCRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
1698 9 redbear 
 
1699 
                                                        }else
1700 
                                                        {
1701 12 redbear 
                                                                printf("CBC ENCRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
1702 9 redbear 
                                                        }
1703 
 
1704 12 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1705 
                                                        {
1706 
                                                                printf("CBC ENCRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1707 
                                                        }else
1708 
                                                        {
1709 
                                                                printf("CBC ENCRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1710 
                                                        }
1711 9 redbear 
 
1712 
 
1713 12 redbear 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1714 
                                                        {
1715 
                                                                printf("CBC ENCRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1716 
                                                        }else
1717 
                                                        {
1718 
                                                                printf("CBC ENCRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1719 
                                                        }
1720 
 
1721 
                                                }else if(I == 35) // ENCRYPTION CBC DATA TYPE01
1722 
                                                {
1723 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
1724 
                                                        {
1725 
                                                                printf("CBC ENCRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
1726 
 
1727 
                                                        }else
1728 
                                                        {
1729 
                                                                printf("CBC ENCRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
1730 
                                                        }
1731 
 
1732 9 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1733 
                                                        {
1734 12 redbear 
                                                                printf("CBC ENCRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1735 9 redbear 
                                                        }else
1736 
                                                        {
1737 12 redbear 
                                                                printf("CBC ENCRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1738 9 redbear 
                                                        }
1739 
 
1740 
 
1741 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1742 
                                                        {
1743 12 redbear 
                                                                printf("CBC ENCRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1744 9 redbear 
                                                        }else
1745 
                                                        {
1746 12 redbear 
                                                                printf("CBC ENCRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1747 9 redbear 
                                                        }
1748 
 
1749 12 redbear 
 
1750 
                                                }else if(I == 37) // ENCRYPTION CBC DATA TYPE02
1751 9 redbear 
                                                {
1752 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
1753 
                                                        {
1754 
                                                                printf("CBC ENCRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
1755 9 redbear 
 
1756 12 redbear 
                                                        }else
1757 
                                                        {
1758 
                                                                printf("CBC ENCRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
1759 
                                                        }
1760 
 
1761 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1762 
                                                        {
1763 
                                                                printf("CBC ENCRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1764 
                                                        }else
1765 
                                                        {
1766 
                                                                printf("CBC ENCRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1767 
                                                        }
1768 
 
1769 
 
1770 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1771 
                                                        {
1772 
                                                                printf("CBC ENCRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1773 
                                                        }else
1774 
                                                        {
1775 
                                                                printf("CBC ENCRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1776 
                                                        }
1777 
 
1778 
 
1779 
                                                }else if(I == 39) // ENCRYPTION CBC DATA TYPE03
1780 
                                                {
1781 
 
1782 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
1783 
                                                        {
1784 
                                                                printf("CBC ENCRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
1785 
 
1786 
                                                        }else
1787 
                                                        {
1788 
                                                                printf("CBC ENCRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
1789 
                                                        }
1790 
 
1791 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1792 
                                                        {
1793 
                                                                printf("CBC ENCRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1794 
                                                        }else
1795 
                                                        {
1796 
                                                                printf("CBC ENCRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1797 
                                                        }
1798 
 
1799 
 
1800 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1801 
                                                        {
1802 
                                                                printf("CBC ENCRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1803 
                                                        }else
1804 
                                                        {
1805 
                                                                printf("CBC ENCRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1806 
                                                        }
1807 
 
1808 
                                                }else if(I == 6177)//CBC ENCRYPTION DMA DATA TYPE00
1809 
                                                {
1810 
 
1811 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DERIVATED,16) == 0)
1812 
                                                        {
1813 12 redbear 
                                                                printf("CBC ENCRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
1814 9 redbear 
 
1815 
                                                        }else
1816 
                                                        {
1817 12 redbear 
                                                                printf("CBC ENCRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
1818 9 redbear 
                                                        }
1819 
 
1820 12 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1821 
                                                        {
1822 
                                                                printf("CBC ENCRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1823 
                                                        }else
1824 
                                                        {
1825 
                                                                printf("CBC ENCRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1826 
                                                        }
1827 9 redbear 
 
1828 
 
1829 12 redbear 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1830 
                                                        {
1831 
                                                                printf("CBC ENCRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1832 
                                                        }else
1833 
                                                        {
1834 
                                                                printf("CBC ENCRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1835 
                                                        }
1836 
 
1837 
                                                }else if(I == 6179)//CBC ENCRYPTION DMA DATA TYPE01
1838 
                                                {
1839 
 
1840 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
1841 
                                                        {
1842 
                                                                printf("CBC ENCRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
1843 
 
1844 
                                                        }else
1845 
                                                        {
1846 
                                                                printf("CBC ENCRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
1847 
                                                        }
1848 
 
1849 9 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1850 
                                                        {
1851 12 redbear 
                                                                printf("CBC ENCRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1852 9 redbear 
                                                        }else
1853 
                                                        {
1854 12 redbear 
                                                                printf("CBC ENCRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1855 9 redbear 
                                                        }
1856 
 
1857 
 
1858 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1859 
                                                        {
1860 12 redbear 
                                                                printf("CBC ENCRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1861 9 redbear 
                                                        }else
1862 
                                                        {
1863 12 redbear 
                                                                printf("CBC ENCRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1864 9 redbear 
                                                        }
1865 
 
1866 12 redbear 
 
1867 
                                                }else if(I == 6181)//CBC ENCRYPTION DMA DATA TYPE02
1868 9 redbear 
                                                {
1869 
 
1870 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
1871 
                                                        {
1872 
                                                                printf("CBC ENCRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
1873 
 
1874 
                                                        }else
1875 
                                                        {
1876 
                                                                printf("CBC ENCRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
1877 
                                                        }
1878 
 
1879 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1880 
                                                        {
1881 
                                                                printf("CBC ENCRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1882 
                                                        }else
1883 
                                                        {
1884 
                                                                printf("CBC ENCRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
1885 
                                                        }
1886 
 
1887 
 
1888 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1889 
                                                        {
1890 
                                                                printf("CBC ENCRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
1891 
                                                        }else
1892 
                                                        {
1893 
                                                                printf("CBC ENCRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
1894 
                                                        }
1895 
 
1896 
                                                }else if(I == 6183)//CBC ENCRYPTION DMA DATA TYPE03
1897 
                                                {
1898 
 
1899 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
1900 
                                                        {
1901 
                                                                printf("CBC ENCRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
1902 
 
1903 
                                                        }else
1904 
                                                        {
1905 
                                                                printf("CBC ENCRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
1906 
                                                        }
1907 
 
1908 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1909 
                                                        {
1910 
                                                                printf("CBC ENCRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
1911 
                                                        }else
1912 
                                                        {
1913 
                                                                printf("CBC ENCRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
1914 
                                                        }
1915 
 
1916 
 
1917 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1918 
                                                        {
1919 
                                                                printf("CBC ENCRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
1920 
                                                        }else
1921 
                                                        {
1922 
                                                                printf("CBC ENCRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
1923 
                                                        }
1924 
 
1925 
                                                }else if(I == 545)//CBC ENCRYPTION CCFIE DATA TYPE00
1926 
                                                {
1927 
 
1928 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DERIVATED,16) == 0)
1929 
                                                        {
1930 12 redbear 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
1931 9 redbear 
 
1932 
                                                        }else
1933 
                                                        {
1934 12 redbear 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
1935 9 redbear 
                                                        }
1936 
 
1937 12 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1938 
                                                        {
1939 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
1940 
                                                        }else
1941 
                                                        {
1942 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
1943 
                                                        }
1944 9 redbear 
 
1945 
 
1946 12 redbear 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1947 
                                                        {
1948 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
1949 
                                                        }else
1950 
                                                        {
1951 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
1952 
                                                        }
1953 
 
1954 
                                                }else if(I == 547)//CBC ENCRYPTION CCFIE DATA TYPE01
1955 
                                                {
1956 
 
1957 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
1958 
                                                        {
1959 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
1960 
 
1961 
                                                        }else
1962 
                                                        {
1963 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
1964 
                                                        }
1965 
 
1966 9 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1967 
                                                        {
1968 12 redbear 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
1969 9 redbear 
                                                        }else
1970 
                                                        {
1971 12 redbear 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
1972 9 redbear 
                                                        }
1973 
 
1974 
 
1975 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
1976 
                                                        {
1977 12 redbear 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
1978 9 redbear 
                                                        }else
1979 
                                                        {
1980 12 redbear 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
1981 9 redbear 
                                                        }
1982 
 
1983 12 redbear 
                                                }else if(I == 549)//CBC ENCRYPTION CCFIE DATA TYPE02
1984 9 redbear 
                                                {
1985 
 
1986 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
1987 
                                                        {
1988 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
1989 9 redbear 
 
1990 12 redbear 
                                                        }else
1991 
                                                        {
1992 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
1993 
                                                        }
1994 
 
1995 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
1996 
                                                        {
1997 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
1998 
                                                        }else
1999 
                                                        {
2000 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2001 
                                                        }
2002 
 
2003 
 
2004 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2005 
                                                        {
2006 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2007 
                                                        }else
2008 
                                                        {
2009 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2010 
                                                        }
2011 
 
2012 
                                                }else if(I == 551)//CBC ENCRYPTION CCFIE DATA TYPE03
2013 
                                                {
2014 
 
2015 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CBC_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
2016 
                                                        {
2017 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
2018 
 
2019 
                                                        }else
2020 
                                                        {
2021 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
2022 
                                                        }
2023 
 
2024 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2025 
                                                        {
2026 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2027 
                                                        }else
2028 
                                                        {
2029 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2030 
                                                        }
2031 
 
2032 
 
2033 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2034 
                                                        {
2035 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2036 
                                                        }else
2037 
                                                        {
2038 
                                                                printf("CBC ENCRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2039 
                                                        }
2040 
 
2041 
 
2042 
                                                }else if(I == 49)// CBC DECRYPTION DATA TYPE00
2043 
                                                {
2044 
 
2045 
 
2046 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DERIVATED,16) == 0)
2047 
                                                        {
2048 12 redbear 
                                                                printf("CBC DECRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
2049 9 redbear 
 
2050 
                                                        }else
2051 
                                                        {
2052 12 redbear 
                                                                printf("CBC DECRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
2053 9 redbear 
 
2054 
                                                        }
2055 
 
2056 12 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2057 
                                                        {
2058 
                                                                printf("CBC DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2059 
                                                        }else
2060 
                                                        {
2061 
                                                                printf("CBC DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2062 
                                                        }
2063 9 redbear 
 
2064 
 
2065 12 redbear 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2066 
                                                        {
2067 
                                                                printf("CBC DECRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2068 
                                                        }else
2069 
                                                        {
2070 
                                                                printf("CBC DECRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2071 
                                                        }
2072 
 
2073 
 
2074 
 
2075 
                                                }else if(I == 51)// CBC DECRYPTION DATA TYPE01
2076 
                                                {
2077 
 
2078 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2079 
                                                        {
2080 
                                                                printf("CBC DECRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
2081 
 
2082 
                                                        }else
2083 
                                                        {
2084 
                                                                printf("CBC DECRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
2085 
 
2086 
                                                        }
2087 
 
2088 9 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2089 
                                                        {
2090 12 redbear 
                                                                printf("CBC DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
2091 9 redbear 
                                                        }else
2092 
                                                        {
2093 12 redbear 
                                                                printf("CBC DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
2094 9 redbear 
                                                        }
2095 
 
2096 
 
2097 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2098 
                                                        {
2099 12 redbear 
                                                                printf("CBC DECRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
2100 9 redbear 
                                                        }else
2101 
                                                        {
2102 12 redbear 
                                                                printf("CBC DECRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
2103 9 redbear 
                                                        }
2104 
 
2105 
 
2106 12 redbear 
                                                }else if(I == 53)// CBC DECRYPTION DATA TYPE02
2107 
                                                {
2108 9 redbear 
 
2109 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2110 
                                                        {
2111 
                                                                printf("CBC DECRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
2112 
 
2113 
                                                        }else
2114 
                                                        {
2115 
                                                                printf("CBC DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
2116 
 
2117 
                                                        }
2118 
 
2119 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2120 
                                                        {
2121 
                                                                printf("CBC DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
2122 
                                                        }else
2123 
                                                        {
2124 
                                                                printf("CBC DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2125 
                                                        }
2126 
 
2127 
 
2128 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2129 
                                                        {
2130 
                                                                printf("CBC DECRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2131 
                                                        }else
2132 
                                                        {
2133 
                                                                printf("CBC DECRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2134 
                                                        }
2135 
 
2136 
 
2137 
                                                }else if(I == 55)// CBC DECRYPTION DATA TYPE03
2138 9 redbear 
                                                {
2139 
 
2140 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2141 
                                                        {
2142 
                                                                printf("CBC DECRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
2143 
 
2144 
                                                        }else
2145 
                                                        {
2146 
                                                                printf("CBC DECRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
2147 
 
2148 
                                                        }
2149 
 
2150 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2151 
                                                        {
2152 
                                                                printf("CBC DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2153 
                                                        }else
2154 
                                                        {
2155 
                                                                printf("CBC DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2156 
                                                        }
2157 
 
2158 
 
2159 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2160 
                                                        {
2161 
                                                                printf("CBC DECRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2162 
                                                        }else
2163 
                                                        {
2164 
                                                                printf("CBC DECRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2165 
                                                        }
2166 
 
2167 
                                                }else if(I == 6193)//CBC DECRYPTION DMA  DATA TYPE00
2168 
                                                {
2169 
 
2170 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DERIVATED,16) == 0)
2171 
                                                        {
2172 12 redbear 
                                                                printf("CBC DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
2173 9 redbear 
 
2174 
                                                        }else
2175 
                                                        {
2176 12 redbear 
                                                                printf("CBC DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
2177 9 redbear 
 
2178 
                                                        }
2179 
 
2180 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2181 
                                                        {
2182 12 redbear 
                                                                printf("CBC DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2183 9 redbear 
                                                        }else
2184 
                                                        {
2185 12 redbear 
                                                                printf("CBC DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2186 9 redbear 
                                                        }
2187 
 
2188 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2189 
                                                        {
2190 12 redbear 
                                                                printf("CBC DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2191 9 redbear 
                                                        }else
2192 
                                                        {
2193 12 redbear 
                                                                printf("CBC DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2194 9 redbear 
                                                        }
2195 
 
2196 12 redbear 
                                                }else if(I == 6195)//CBC DECRYPTION DMA  DATA TYPE01
2197 9 redbear 
                                                {
2198 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2199 
                                                        {
2200 
                                                                printf("CBC DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
2201 9 redbear 
 
2202 12 redbear 
                                                        }else
2203 
                                                        {
2204 
                                                                printf("CBC DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
2205 
 
2206 
                                                        }
2207 
 
2208 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2209 
                                                        {
2210 
                                                                printf("CBC DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
2211 
                                                        }else
2212 
                                                        {
2213 
                                                                printf("CBC DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
2214 
                                                        }
2215 
 
2216 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2217 
                                                        {
2218 
                                                                printf("CBC DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
2219 
                                                        }else
2220 
                                                        {
2221 
                                                                printf("CBC DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
2222 
                                                        }
2223 
 
2224 
                                                }else if(I == 6197)//CBC DECRYPTION DMA  DATA TYPE02
2225 
                                                {
2226 
 
2227 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2228 
                                                        {
2229 
                                                                printf("CBC DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
2230 
 
2231 
                                                        }else
2232 
                                                        {
2233 
                                                                printf("CBC DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
2234 
 
2235 
                                                        }
2236 
 
2237 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2238 
                                                        {
2239 
                                                                printf("CBC DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
2240 
                                                        }else
2241 
                                                        {
2242 
                                                                printf("CBC DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2243 
                                                        }
2244 
 
2245 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2246 
                                                        {
2247 
                                                                printf("CBC DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2248 
                                                        }else
2249 
                                                        {
2250 
                                                                printf("CBC DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2251 
                                                        }
2252 
 
2253 
 
2254 
                                                }else if(I == 6199)//CBC DECRYPTION DMA  DATA TYPE03
2255 
                                                {
2256 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2257 
                                                        {
2258 
                                                                printf("CBC DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
2259 
 
2260 
                                                        }else
2261 
                                                        {
2262 
                                                                printf("CBC DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
2263 
 
2264 
                                                        }
2265 
 
2266 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2267 
                                                        {
2268 
                                                                printf("CBC DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2269 
                                                        }else
2270 
                                                        {
2271 
                                                                printf("CBC DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2272 
                                                        }
2273 
 
2274 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2275 
                                                        {
2276 
                                                                printf("CBC DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2277 
                                                        }else
2278 
                                                        {
2279 
                                                                printf("CBC DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2280 
                                                        }
2281 
 
2282 
 
2283 
                                                }else if(I == 561)// CBC DECRYPTION CCFIE DATA TYPE00
2284 
                                                {
2285 
 
2286 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DERIVATED,16) == 0)
2287 
                                                        {
2288 12 redbear 
                                                                printf("CBC DECRYPTION CCFIE  DATATYPE00: TEXT CYPHER PASSED.\n");
2289 9 redbear 
 
2290 
                                                        }else
2291 
                                                        {
2292 12 redbear 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
2293 9 redbear 
 
2294 
                                                        }
2295 
 
2296 
 
2297 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2298 
                                                        {
2299 12 redbear 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2300 9 redbear 
                                                        }else
2301 
                                                        {
2302 12 redbear 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2303 9 redbear 
                                                        }
2304 
 
2305 
 
2306 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2307 
                                                        {
2308 12 redbear 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2309 9 redbear 
                                                        }else
2310 
                                                        {
2311 12 redbear 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2312 9 redbear 
                                                        }
2313 
 
2314 12 redbear 
                                                }else if(I == 563)// CBC DECRYPTION CCFIE DATATYPE01
2315 
                                                {
2316 
 
2317 
 
2318 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2319 
                                                        {
2320 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
2321 
 
2322 
                                                        }else
2323 
                                                        {
2324 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
2325 
 
2326 
                                                        }
2327 
 
2328 
 
2329 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2330 
                                                        {
2331 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE01 : KEYR WHEN CR ENABLE PASSED.\n");
2332 
                                                        }else
2333 
                                                        {
2334 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE01 : KEYR WHEN CR ENABLE FAIL.\n");
2335 
                                                        }
2336 
 
2337 
 
2338 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2339 
                                                        {
2340 
                                                                printf("CBC DECRYPTION  CCFIE DATATYPE01 : IVR WHEN CR ENABLE PASSED.\n");
2341 
                                                        }else
2342 
                                                        {
2343 
                                                                printf("CBC DECRYPTION  CCFIE DATATYPE01 : IVR WHEN CR ENABLE FAIL.\n");
2344 
                                                        }
2345 
 
2346 
 
2347 
 
2348 
                                                }else if(I == 565)// CBC DECRYPTION CCFIE DATATYPE02
2349 
                                                {
2350 
 
2351 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2352 
                                                        {
2353 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
2354 
 
2355 
                                                        }else
2356 
                                                        {
2357 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
2358 
 
2359 
                                                        }
2360 
 
2361 
 
2362 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2363 
                                                        {
2364 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE02 : KEYR WHEN CR ENABLE PASSED.\n");
2365 
                                                        }else
2366 
                                                        {
2367 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE02 : KEYR WHEN CR ENABLE FAIL.\n");
2368 
                                                        }
2369 
 
2370 
 
2371 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2372 
                                                        {
2373 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE02 : IVR WHEN CR ENABLE PASSED.\n");
2374 
                                                        }else
2375 
                                                        {
2376 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE02 : IVR WHEN CR ENABLE FAIL.\n");
2377 
                                                        }
2378 
 
2379 
 
2380 
                                                }else if(I == 567)// CBC DECRYPTION CCFIE DATATYPE03
2381 
                                                {
2382 
 
2383 
 
2384 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2385 
                                                        {
2386 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
2387 
 
2388 
                                                        }else
2389 
                                                        {
2390 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
2391 
 
2392 
                                                        }
2393 
 
2394 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2395 
                                                        {
2396 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2397 
                                                        }else
2398 
                                                        {
2399 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2400 
                                                        }
2401 
 
2402 
 
2403 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2404 
                                                        {
2405 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2406 
                                                        }else
2407 
                                                        {
2408 
                                                                printf("CBC DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2409 
                                                        }
2410 
 
2411 
 
2412 9 redbear 
                                                }else if(I == 41) //CBC KEY GENERATION
2413 
                                                {
2414 
 
2415 
 
2416 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
2417 
                                                        {
2418 
                                                                printf("CBC KEY GEN  : TEXT CYPHER PASSED.\n");
2419 
 
2420 
                                                        }else
2421 
                                                        {
2422 
                                                                printf("CBC KEY GEN  : TEXT CYPHER FAIL.\n");
2423 
 
2424 
                                                        }
2425 
 
2426 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_CBC_DERIVATED,16) == 0)
2427 
                                                        {
2428 
                                                                printf("CBC KEY GEN  : KEYR WHEN CR ENABLE PASSED.\n");
2429 
                                                        }else
2430 
                                                        {
2431 
                                                                printf("CBC KEY GEN  : KEYR WHEN CR ENABLE FAIL.\n");
2432 
                                                        }
2433 
 
2434 
                                                        if(memcmp(OUTPUT_IVR,IV_FIPS_CBC_NOT_DERIVATED,16) == 0)
2435 
                                                        {
2436 
                                                                printf("CBC KEY GEN  : IVR WHEN CR ENABLE PASSED.\n");
2437 
                                                        }else
2438 
                                                        {
2439 
                                                                printf("CBC KEY GEN  : IVR WHEN CR ENABLE FAIL.\n");
2440 
                                                        }
2441 
 
2442 
 
2443 
 
2444 
                                                }else if(I == 6185) //CBC KEY GENERATION DMA
2445 
                                                {
2446 
 
2447 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
2448 
                                                        {
2449 
                                                                printf("CBC KEY GEN DMA : TEXT CYPHER PASSED.\n");
2450 
 
2451 
                                                        }else
2452 
                                                        {
2453 
                                                                printf("CBC KEY GEN DMA : TEXT CYPHER FAIL.\n");
2454 
                                                        }
2455 
 
2456 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_CBC_DERIVATED,16) == 0)
2457 
                                                        {
2458 
                                                                printf("CBC KEY GEN DMA : KEYR WHEN CR ENABLE PASSED.\n");
2459 
                                                        }else
2460 
                                                        {
2461 
                                                                printf("CBC KEY GEN DMA : KEYR WHEN CR ENABLE FAIL.\n");
2462 
                                                        }
2463 
 
2464 
                                                        if(memcmp(OUTPUT_IVR,IV_FIPS_CBC_NOT_DERIVATED,16) == 0)
2465 
                                                        {
2466 
                                                                printf("CBC KEY GEN DMA : IVR WHEN CR ENABLE PASSED.\n");
2467 
                                                        }else
2468 
                                                        {
2469 
                                                                printf("CBC KEY GEN DMA : IVR WHEN CR ENABLE FAIL.\n");
2470 
                                                        }
2471 
 
2472 12 redbear 
                                                }else if(I == 553 ) //CBC KEY GENERATION CCFIE
2473 9 redbear 
                                                {
2474 
 
2475 
 
2476 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
2477 
                                                        {
2478 
                                                                printf("CBC KEY GEN CCFIE : TEXT CYPHER PASSED.\n");
2479 
 
2480 
                                                        }else
2481 
                                                        {
2482 
                                                                printf("CBC KEY GEN CCFIE : TEXT CYPHER FAIL.\n");
2483 
                                                        }
2484 
 
2485 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_CBC_DERIVATED,16) == 0)
2486 
                                                        {
2487 
                                                                printf("CBC KEY GEN CCFIE : KEYR WHEN CR ENABLE PASSED.\n");
2488 
                                                        }else
2489 
                                                        {
2490 
                                                                printf("CBC KEY GEN CCFIE : KEYR WHEN CR ENABLE FAIL.\n");
2491 
                                                        }
2492 
 
2493 
                                                        if(memcmp(OUTPUT_IVR,IV_FIPS_CBC_NOT_DERIVATED,16) == 0)
2494 
                                                        {
2495 
                                                                printf("CBC KEY GEN CCFIE : IVR WHEN CR ENABLE PASSED.\n");
2496 
                                                        }else
2497 
                                                        {
2498 
                                                                printf("CBC KEY GEN CCFIE : IVR WHEN CR ENABLE FAIL.\n");
2499 
                                                        }
2500 
 
2501 12 redbear 
                                                }else if(I == 57)// CBC DERIVATION DECRYPTION DATA TYPE00
2502 9 redbear 
                                                {
2503 
 
2504 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DERIVATED,16) == 0)
2505 
                                                        {
2506 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
2507 9 redbear 
 
2508 
                                                        }else
2509 
                                                        {
2510 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
2511 9 redbear 
                                                        }
2512 
 
2513 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2514 
                                                        {
2515 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2516 9 redbear 
                                                        }else
2517 
                                                        {
2518 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2519 9 redbear 
                                                        }
2520 
 
2521 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2522 
                                                        {
2523 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2524 9 redbear 
                                                        }else
2525 
                                                        {
2526 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2527 9 redbear 
                                                        }
2528 
 
2529 12 redbear 
                                                }else if(I == 59)// CBC DERIVATION DECRYPTION DATA TYPE01
2530 9 redbear 
                                                {
2531 
 
2532 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2533 
                                                        {
2534 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
2535 
 
2536 
                                                        }else
2537 
                                                        {
2538 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
2539 
                                                        }
2540 
 
2541 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2542 
                                                        {
2543 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
2544 
                                                        }else
2545 
                                                        {
2546 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
2547 
                                                        }
2548 
 
2549 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2550 
                                                        {
2551 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
2552 
                                                        }else
2553 
                                                        {
2554 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
2555 
                                                        }
2556 
 
2557 
 
2558 
 
2559 
 
2560 
                                                }else if(I == 61)// CBC DERIVATION DECRYPTION DATA TYPE02
2561 
                                                {
2562 
 
2563 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2564 
                                                        {
2565 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
2566 
 
2567 
                                                        }else
2568 
                                                        {
2569 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
2570 
                                                        }
2571 
 
2572 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2573 
                                                        {
2574 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
2575 
                                                        }else
2576 
                                                        {
2577 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2578 
                                                        }
2579 
 
2580 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2581 
                                                        {
2582 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2583 
                                                        }else
2584 
                                                        {
2585 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2586 
                                                        }
2587 
 
2588 
 
2589 
                                                }else if(I == 63)// CBC DERIVATION DECRYPTION DATA TYPE03
2590 
                                                {
2591 
 
2592 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2593 
                                                        {
2594 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
2595 
 
2596 
                                                        }else
2597 
                                                        {
2598 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
2599 
                                                        }
2600 
 
2601 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2602 
                                                        {
2603 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2604 
                                                        }else
2605 
                                                        {
2606 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2607 
                                                        }
2608 
 
2609 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2610 
                                                        {
2611 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2612 
                                                        }else
2613 
                                                        {
2614 
                                                                printf("CBC DERIVATION DECRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2615 
                                                        }
2616 
 
2617 
 
2618 
                                                }else if(I == 6201) // CBC DERIVATION DECRYPTION DMA DATATYPE00
2619 
                                                {
2620 
 
2621 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DERIVATED,16) == 0)
2622 
                                                        {
2623 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
2624 9 redbear 
 
2625 
                                                        }else
2626 
                                                        {
2627 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
2628 9 redbear 
                                                        }
2629 
 
2630 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2631 
                                                        {
2632 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2633 9 redbear 
                                                        }else
2634 
                                                        {
2635 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2636 9 redbear 
                                                        }
2637 
 
2638 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2639 
                                                        {
2640 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2641 9 redbear 
                                                        }else
2642 
                                                        {
2643 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2644 9 redbear 
                                                        }
2645 
 
2646 12 redbear 
                                                }else if(I == 6203) // CBC DERIVATION DECRYPTION DMA DATATYPE01
2647 9 redbear 
                                                {
2648 
 
2649 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2650 
                                                        {
2651 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
2652 
 
2653 
                                                        }else
2654 
                                                        {
2655 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
2656 
                                                        }
2657 
 
2658 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2659 
                                                        {
2660 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
2661 
                                                        }else
2662 
                                                        {
2663 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
2664 
                                                        }
2665 
 
2666 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2667 
                                                        {
2668 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
2669 
                                                        }else
2670 
                                                        {
2671 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
2672 
                                                        }
2673 
 
2674 
 
2675 
 
2676 
                                                }else if(I == 6205) // CBC DERIVATION DECRYPTION DMA DATATYPE02
2677 
                                                {
2678 
 
2679 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2680 
                                                        {
2681 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
2682 
 
2683 
                                                        }else
2684 
                                                        {
2685 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
2686 
                                                        }
2687 
 
2688 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2689 
                                                        {
2690 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
2691 
                                                        }else
2692 
                                                        {
2693 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2694 
                                                        }
2695 
 
2696 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2697 
                                                        {
2698 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2699 
                                                        }else
2700 
                                                        {
2701 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2702 
                                                        }
2703 
 
2704 
 
2705 
                                                }else if(I == 6207) // CBC DERIVATION DECRYPTION DMA DATATYPE03
2706 
                                                {
2707 
 
2708 
 
2709 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2710 
                                                        {
2711 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
2712 
 
2713 
                                                        }else
2714 
                                                        {
2715 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
2716 
                                                        }
2717 
 
2718 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2719 
                                                        {
2720 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2721 
                                                        }else
2722 
                                                        {
2723 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2724 
                                                        }
2725 
 
2726 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2727 
                                                        {
2728 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2729 
                                                        }else
2730 
                                                        {
2731 
                                                                printf("CBC DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2732 
                                                        }
2733 
 
2734 
 
2735 
 
2736 
                                                }else if(I == 569) // CBC DERIVATION DECRYPTION CCFIE DATATYPE00
2737 
                                                {
2738 
 
2739 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DERIVATED,16) == 0)
2740 
                                                        {
2741 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
2742 9 redbear 
 
2743 
                                                        }else
2744 
                                                        {
2745 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
2746 9 redbear 
                                                        }
2747 
 
2748 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2749 
                                                        {
2750 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2751 9 redbear 
                                                        }else
2752 
                                                        {
2753 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2754 9 redbear 
                                                        }
2755 
 
2756 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2757 
                                                        {
2758 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2759 9 redbear 
                                                        }else
2760 
                                                        {
2761 12 redbear 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2762 9 redbear 
                                                        }
2763 
 
2764 
 
2765 12 redbear 
                                                }else if(I == 571) // CBC DERIVATION DECRYPTION CCFIE DATATYPE01
2766 9 redbear 
                                                {
2767 
 
2768 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2769 
                                                        {
2770 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
2771 9 redbear 
 
2772 12 redbear 
                                                        }else
2773 
                                                        {
2774 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
2775 
                                                        }
2776 
 
2777 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2778 
                                                        {
2779 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
2780 
                                                        }else
2781 
                                                        {
2782 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
2783 
                                                        }
2784 
 
2785 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2786 
                                                        {
2787 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
2788 
                                                        }else
2789 
                                                        {
2790 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
2791 
                                                        }
2792 
 
2793 
 
2794 
                                                }else if(I == 573) // CBC DERIVATION DECRYPTION CCFIE DATATYPE02
2795 
                                                {
2796 
 
2797 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2798 
                                                        {
2799 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
2800 
 
2801 
                                                        }else
2802 
                                                        {
2803 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
2804 
                                                        }
2805 
 
2806 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2807 
                                                        {
2808 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
2809 
                                                        }else
2810 
                                                        {
2811 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2812 
                                                        }
2813 
 
2814 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2815 
                                                        {
2816 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2817 
                                                        }else
2818 
                                                        {
2819 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2820 
                                                        }
2821 
 
2822 
                                                }else if(I == 575) // CBC DERIVATION DECRYPTION CCFIE DATATYPE03
2823 
                                                {
2824 
 
2825 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CBC_NOT_DATATYPE_DERIVATED,16) == 0)
2826 
                                                        {
2827 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
2828 
 
2829 
                                                        }else
2830 
                                                        {
2831 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
2832 
                                                        }
2833 
 
2834 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2835 
                                                        {
2836 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2837 
                                                        }else
2838 
                                                        {
2839 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2840 
                                                        }
2841 
 
2842 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2843 
                                                        {
2844 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2845 
                                                        }else
2846 
                                                        {
2847 
                                                                printf("CBC DERIVATION DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2848 
                                                        }
2849 
 
2850 
 
2851 
 
2852 
                                                }else if(I == 65)// CTR ENCFRYPTION DATATYPE00
2853 
                                                {
2854 
 
2855 
 
2856 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DERIVATED,16) == 0)
2857 
                                                        {
2858 12 redbear 
                                                                printf("CTR ENCRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
2859 9 redbear 
 
2860 
                                                        }else
2861 
                                                        {
2862 12 redbear 
                                                                printf("CTR ENCRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
2863 9 redbear 
                                                        }
2864 
 
2865 
 
2866 
 
2867 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2868 
                                                        {
2869 12 redbear 
                                                                printf("CTR ENCRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
2870 9 redbear 
                                                        }else
2871 
                                                        {
2872 12 redbear 
                                                                printf("CTR ENCRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
2873 9 redbear 
                                                        }
2874 
 
2875 
 
2876 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2877 
                                                        {
2878 12 redbear 
                                                                printf("CTR ENCRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
2879 9 redbear 
                                                        }else
2880 
                                                        {
2881 12 redbear 
                                                                printf("CTR ENCRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
2882 9 redbear 
                                                        }
2883 
 
2884 
 
2885 
 
2886 12 redbear 
                                                }else if(I == 67)// CTR ENCFRYPTION DATATYPE01
2887 9 redbear 
                                                {
2888 
 
2889 
 
2890 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
2891 
                                                        {
2892 
                                                                printf("CTR ENCRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
2893 
 
2894 
                                                        }else
2895 
                                                        {
2896 
                                                                printf("CTR ENCRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
2897 
                                                        }
2898 
 
2899 
 
2900 
 
2901 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2902 
                                                        {
2903 
                                                                printf("CTR ENCRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
2904 
                                                        }else
2905 
                                                        {
2906 
                                                                printf("CTR ENCRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
2907 
                                                        }
2908 
 
2909 
 
2910 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2911 
                                                        {
2912 
                                                                printf("CTR ENCRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
2913 
                                                        }else
2914 
                                                        {
2915 
                                                                printf("CTR ENCRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
2916 
                                                        }
2917 
 
2918 
 
2919 
 
2920 
                                                }else if(I == 69)// CTR ENCFRYPTION DATATYPE02
2921 
                                                {
2922 
 
2923 
 
2924 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
2925 
                                                        {
2926 
                                                                printf("CTR ENCRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
2927 
 
2928 
                                                        }else
2929 
                                                        {
2930 
                                                                printf("CTR ENCRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
2931 
                                                        }
2932 
 
2933 
 
2934 
 
2935 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2936 
                                                        {
2937 
                                                                printf("CTR ENCRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
2938 
                                                        }else
2939 
                                                        {
2940 
                                                                printf("CTR ENCRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
2941 
                                                        }
2942 
 
2943 
 
2944 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2945 
                                                        {
2946 
                                                                printf("CTR ENCRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
2947 
                                                        }else
2948 
                                                        {
2949 
                                                                printf("CTR ENCRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
2950 
                                                        }
2951 
 
2952 
 
2953 
 
2954 
                                                }else if(I == 71)// CTR ENCFRYPTION DATATYPE03
2955 
                                                {
2956 
 
2957 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
2958 
                                                        {
2959 
                                                                printf("CTR ENCRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
2960 
 
2961 
                                                        }else
2962 
                                                        {
2963 
                                                                printf("CTR ENCRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
2964 
                                                        }
2965 
 
2966 
 
2967 
 
2968 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
2969 
                                                        {
2970 
                                                                printf("CTR ENCRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
2971 
                                                        }else
2972 
                                                        {
2973 
                                                                printf("CTR ENCRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
2974 
                                                        }
2975 
 
2976 
 
2977 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
2978 
                                                        {
2979 
                                                                printf("CTR ENCRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
2980 
                                                        }else
2981 
                                                        {
2982 
                                                                printf("CTR ENCRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
2983 
                                                        }
2984 
 
2985 
 
2986 
 
2987 
                                                }else if(I == 6209)// CTR ENCRYPTION DMA DATATYPE00
2988 
                                                {
2989 
 
2990 
 
2991 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DERIVATED,16) == 0)
2992 
                                                        {
2993 12 redbear 
                                                                printf("CTR ENCRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
2994 9 redbear 
 
2995 
                                                        }else
2996 
                                                        {
2997 12 redbear 
                                                                printf("CTR ENCRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
2998 9 redbear 
                                                        }
2999 
 
3000 
 
3001 
 
3002 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3003 
                                                        {
3004 12 redbear 
                                                                printf("CTR ENCRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3005 9 redbear 
                                                        }else
3006 
                                                        {
3007 12 redbear 
                                                                printf("CTR ENCRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3008 9 redbear 
                                                        }
3009 
 
3010 
 
3011 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3012 
                                                        {
3013 12 redbear 
                                                                printf("CTR ENCRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3014 9 redbear 
                                                        }else
3015 
                                                        {
3016 12 redbear 
                                                                printf("CTR ENCRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3017 9 redbear 
                                                        }
3018 
 
3019 
 
3020 12 redbear 
                                                }else if(I == 6211)// CTR ENCRYPTION DMA DATATYPE01
3021 9 redbear 
                                                {
3022 
 
3023 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
3024 
                                                        {
3025 
                                                                printf("CTR ENCRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
3026 
 
3027 
                                                        }else
3028 
                                                        {
3029 
                                                                printf("CTR ENCRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
3030 
                                                        }
3031 
 
3032 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3033 
                                                        {
3034 
                                                                printf("CTR ENCRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3035 
                                                        }else
3036 
                                                        {
3037 
                                                                printf("CTR ENCRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3038 
                                                        }
3039 
 
3040 
 
3041 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3042 
                                                        {
3043 
                                                                printf("CTR ENCRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3044 
                                                        }else
3045 
                                                        {
3046 
                                                                printf("CTR ENCRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3047 
                                                        }
3048 
 
3049 
                                                }else if(I == 6213)// CTR ENCRYPTION DMA DATATYPE02
3050 
                                                {
3051 
 
3052 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
3053 
                                                        {
3054 
                                                                printf("CTR ENCRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
3055 
 
3056 
                                                        }else
3057 
                                                        {
3058 
                                                                printf("CTR ENCRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
3059 
                                                        }
3060 
 
3061 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3062 
                                                        {
3063 
                                                                printf("CTR ENCRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3064 
                                                        }else
3065 
                                                        {
3066 
                                                                printf("CTR ENCRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3067 
                                                        }
3068 
 
3069 
 
3070 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3071 
                                                        {
3072 
                                                                printf("CTR ENCRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3073 
                                                        }else
3074 
                                                        {
3075 
                                                                printf("CTR ENCRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3076 
                                                        }
3077 
 
3078 
 
3079 
 
3080 
                                                }else if(I == 6215)// CTR ENCRYPTION DMA DATATYPE03
3081 
                                                {
3082 
 
3083 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
3084 
                                                        {
3085 
                                                                printf("CTR ENCRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
3086 
 
3087 
                                                        }else
3088 
                                                        {
3089 
                                                                printf("CTR ENCRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
3090 
                                                        }
3091 
 
3092 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3093 
                                                        {
3094 
                                                                printf("CTR ENCRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3095 
                                                        }else
3096 
                                                        {
3097 
                                                                printf("CTR ENCRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3098 
                                                        }
3099 
 
3100 
 
3101 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3102 
                                                        {
3103 
                                                                printf("CTR ENCRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3104 
                                                        }else
3105 
                                                        {
3106 
                                                                printf("CTR ENCRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3107 
                                                        }
3108 
 
3109 
 
3110 
 
3111 
                                                }else if(I == 577)// CTR ENCRYPTION CCFIE DATATYPE00
3112 
                                                {
3113 
 
3114 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DERIVATED,16) == 0)
3115 
                                                        {
3116 12 redbear 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
3117 9 redbear 
 
3118 
                                                        }else
3119 
                                                        {
3120 12 redbear 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
3121 9 redbear 
                                                        }
3122 
 
3123 
 
3124 
 
3125 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3126 
                                                        {
3127 12 redbear 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3128 9 redbear 
                                                        }else
3129 
                                                        {
3130 12 redbear 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3131 9 redbear 
                                                        }
3132 
 
3133 
 
3134 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3135 
                                                        {
3136 12 redbear 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3137 9 redbear 
                                                        }else
3138 
                                                        {
3139 12 redbear 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3140 9 redbear 
                                                        }
3141 
 
3142 
 
3143 12 redbear 
                                                }else if(I == 579)// CTR ENCRYPTION CCFIE DATATYPE01
3144 9 redbear 
                                                {
3145 
 
3146 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T01_DERIVATED,16) == 0)
3147 
                                                        {
3148 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
3149 
 
3150 
                                                        }else
3151 
                                                        {
3152 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
3153 
                                                        }
3154 
 
3155 
 
3156 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3157 
                                                        {
3158 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3159 
                                                        }else
3160 
                                                        {
3161 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3162 
                                                        }
3163 
 
3164 
 
3165 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3166 
                                                        {
3167 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3168 
                                                        }else
3169 
                                                        {
3170 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3171 
                                                        }
3172 
 
3173 
                                                }else if(I == 581)// CTR ENCRYPTION CCFIE DATATYPE02
3174 
                                                {
3175 
 
3176 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T02_DERIVATED,16) == 0)
3177 
                                                        {
3178 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
3179 
 
3180 
                                                        }else
3181 
                                                        {
3182 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
3183 
                                                        }
3184 
 
3185 
 
3186 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3187 
                                                        {
3188 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3189 
                                                        }else
3190 
                                                        {
3191 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3192 
                                                        }
3193 
 
3194 
 
3195 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3196 
                                                        {
3197 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3198 
                                                        }else
3199 
                                                        {
3200 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3201 
                                                        }
3202 
 
3203 
                                                }else if(I == 583)// CTR ENCRYPTION CCFIE DATATYPE03
3204 
                                                {
3205 
 
3206 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_CTR_FIPS_DATATYPE_T03_DERIVATED,16) == 0)
3207 
                                                        {
3208 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
3209 
 
3210 
                                                        }else
3211 
                                                        {
3212 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
3213 
                                                        }
3214 
 
3215 
 
3216 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3217 
                                                        {
3218 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3219 
                                                        }else
3220 
                                                        {
3221 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3222 
                                                        }
3223 
 
3224 
 
3225 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3226 
                                                        {
3227 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3228 
                                                        }else
3229 
                                                        {
3230 
                                                                printf("CTR ENCRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3231 
                                                        }
3232 
 
3233 
                                                }else if(I == 81) //CTR DECRYPTION DATATYPE00
3234 
                                                {
3235 
 
3236 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DERIVATED,16) == 0)
3237 
                                                        {
3238 12 redbear 
                                                                printf("CTR DECRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
3239 9 redbear 
 
3240 
                                                        }else
3241 
                                                        {
3242 12 redbear 
                                                                printf("CTR DECRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
3243 9 redbear 
                                                        }
3244 
 
3245 
 
3246 12 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3247 
                                                        {
3248 
                                                                printf("CTR DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3249 
                                                        }else
3250 
                                                        {
3251 
                                                                printf("CTR DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3252 
                                                        }
3253 9 redbear 
 
3254 12 redbear 
 
3255 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3256 
                                                        {
3257 
                                                                printf("CTR DECRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3258 
                                                        }else
3259 
                                                        {
3260 
                                                                printf("CTR DECRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3261 
                                                        }
3262 
 
3263 
                                                }else if(I == 83) //CTR DECRYPTION DATATYPE01
3264 
                                                {
3265 
 
3266 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3267 
                                                        {
3268 
                                                                printf("CTR DECRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
3269 
 
3270 
                                                        }else
3271 
                                                        {
3272 
                                                                printf("CTR DECRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
3273 
                                                        }
3274 
 
3275 
 
3276 9 redbear 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3277 
                                                        {
3278 12 redbear 
                                                                printf("CTR DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3279 9 redbear 
                                                        }else
3280 
                                                        {
3281 12 redbear 
                                                                printf("CTR DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3282 9 redbear 
                                                        }
3283 
 
3284 
 
3285 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3286 
                                                        {
3287 12 redbear 
                                                                printf("CTR DECRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3288 9 redbear 
                                                        }else
3289 
                                                        {
3290 12 redbear 
                                                                printf("CTR DECRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3291 9 redbear 
                                                        }
3292 
 
3293 12 redbear 
                                                }else if(I == 85) //CTR DECRYPTION DATATYPE02
3294 9 redbear 
                                                {
3295 
 
3296 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3297 
                                                        {
3298 
                                                                printf("CTR DECRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
3299 
 
3300 
                                                        }else
3301 
                                                        {
3302 
                                                                printf("CTR DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
3303 
                                                        }
3304 
 
3305 
 
3306 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3307 
                                                        {
3308 
                                                                printf("CTR DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3309 
                                                        }else
3310 
                                                        {
3311 
                                                                printf("CTR DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3312 
                                                        }
3313 
 
3314 
 
3315 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3316 
                                                        {
3317 
                                                                printf("CTR DECRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3318 
                                                        }else
3319 
                                                        {
3320 
                                                                printf("CTR DECRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3321 
                                                        }
3322 
 
3323 
 
3324 
                                                }else if(I == 87) //CTR DECRYPTION DATATYPE03
3325 
                                                {
3326 
 
3327 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3328 
                                                        {
3329 
                                                                printf("CTR DECRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
3330 
 
3331 
                                                        }else
3332 
                                                        {
3333 
                                                                printf("CTR DECRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
3334 
                                                        }
3335 
 
3336 
 
3337 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3338 
                                                        {
3339 
                                                                printf("CTR DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3340 
                                                        }else
3341 
                                                        {
3342 
                                                                printf("CTR DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3343 
                                                        }
3344 
 
3345 
 
3346 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3347 
                                                        {
3348 
                                                                printf("CTR DECRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3349 
                                                        }else
3350 
                                                        {
3351 
                                                                printf("CTR DECRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3352 
                                                        }
3353 
 
3354 
 
3355 
 
3356 
                                                }else if(I == 6225) //CTR DECRYPTION DMA DATATYPE00
3357 
                                                {
3358 
 
3359 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DERIVATED,16) == 0)
3360 
                                                        {
3361 12 redbear 
                                                                printf("CTR DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
3362 9 redbear 
 
3363 
                                                        }else
3364 
                                                        {
3365 12 redbear 
                                                                printf("CTR DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
3366 9 redbear 
                                                        }
3367 
 
3368 
 
3369 
 
3370 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3371 
                                                        {
3372 12 redbear 
                                                                printf("CTR DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3373 9 redbear 
                                                        }else
3374 
                                                        {
3375 12 redbear 
                                                                printf("CTR DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3376 9 redbear 
                                                        }
3377 
 
3378 
 
3379 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3380 
                                                        {
3381 12 redbear 
                                                                printf("CTR DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3382 9 redbear 
                                                        }else
3383 
                                                        {
3384 12 redbear 
                                                                printf("CTR DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3385 9 redbear 
                                                        }
3386 
 
3387 
 
3388 12 redbear 
                                                }else if(I == 6227) //CTR DECRYPTION DMA DATATYPE01
3389 9 redbear 
                                                {
3390 
 
3391 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3392 
                                                        {
3393 
                                                                printf("CTR DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
3394 
 
3395 
                                                        }else
3396 
                                                        {
3397 
                                                                printf("CTR DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
3398 
                                                        }
3399 
 
3400 
 
3401 
 
3402 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3403 
                                                        {
3404 
                                                                printf("CTR DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3405 
                                                        }else
3406 
                                                        {
3407 
                                                                printf("CTR DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3408 
                                                        }
3409 
 
3410 
 
3411 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3412 
                                                        {
3413 
                                                                printf("CTR DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3414 
                                                        }else
3415 
                                                        {
3416 
                                                                printf("CTR DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3417 
                                                        }
3418 
 
3419 
 
3420 
                                                }else if(I == 6229) //CTR DECRYPTION DMA DATATYPE02
3421 
                                                {
3422 
 
3423 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3424 
                                                        {
3425 
                                                                printf("CTR DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
3426 
 
3427 
                                                        }else
3428 
                                                        {
3429 
                                                                printf("CTR DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
3430 
                                                        }
3431 
 
3432 
 
3433 
 
3434 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3435 
                                                        {
3436 
                                                                printf("CTR DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3437 
                                                        }else
3438 
                                                        {
3439 
                                                                printf("CTR DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3440 
                                                        }
3441 
 
3442 
 
3443 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3444 
                                                        {
3445 
                                                                printf("CTR DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3446 
                                                        }else
3447 
                                                        {
3448 
                                                                printf("CTR DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3449 
                                                        }
3450 
 
3451 
 
3452 
                                                }else if(I == 6231) //CTR DECRYPTION DMA DATATYPE03
3453 
                                                {
3454 
 
3455 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3456 
                                                        {
3457 
                                                                printf("CTR DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
3458 
 
3459 
                                                        }else
3460 
                                                        {
3461 
                                                                printf("CTR DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
3462 
                                                        }
3463 
 
3464 
 
3465 
 
3466 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3467 
                                                        {
3468 
                                                                printf("CTR DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3469 
                                                        }else
3470 
                                                        {
3471 
                                                                printf("CTR DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3472 
                                                        }
3473 
 
3474 
 
3475 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3476 
                                                        {
3477 
                                                                printf("CTR DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3478 
                                                        }else
3479 
                                                        {
3480 
                                                                printf("CTR DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3481 
                                                        }
3482 
 
3483 
 
3484 
 
3485 
                                                }else if(I == 593) //CTR DECRYPTION CCFIE DATATYPE00
3486 
                                                {
3487 
 
3488 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DERIVATED,16) == 0)
3489 
                                                        {
3490 12 redbear 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE00: TEXT CYPHER PASSED.\n");
3491 9 redbear 
 
3492 
                                                        }else
3493 
                                                        {
3494 12 redbear 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE00: TEXT CYPHER FAIL.\n");
3495 9 redbear 
                                                        }
3496 
 
3497 
 
3498 
 
3499 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3500 
                                                        {
3501 12 redbear 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3502 9 redbear 
                                                        }else
3503 
                                                        {
3504 12 redbear 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3505 9 redbear 
                                                        }
3506 
 
3507 
 
3508 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3509 
                                                        {
3510 12 redbear 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3511 9 redbear 
                                                        }else
3512 
                                                        {
3513 12 redbear 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3514 9 redbear 
                                                        }
3515 
 
3516 
 
3517 12 redbear 
                                                }else if(I == 595) //CTR DECRYPTION CCFIE DATATYPE01
3518 9 redbear 
                                                {
3519 
 
3520 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3521 
                                                        {
3522 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE01: TEXT CYPHER PASSED.\n");
3523 
 
3524 
                                                        }else
3525 
                                                        {
3526 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE01: TEXT CYPHER FAIL.\n");
3527 
                                                        }
3528 
 
3529 
 
3530 
 
3531 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3532 
                                                        {
3533 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3534 
                                                        }else
3535 
                                                        {
3536 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3537 
                                                        }
3538 
 
3539 
 
3540 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3541 
                                                        {
3542 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3543 
                                                        }else
3544 
                                                        {
3545 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3546 
                                                        }
3547 
 
3548 
 
3549 
                                                }else if(I == 597) //CTR DECRYPTION CCFIE DATATYPE02
3550 
                                                {
3551 
 
3552 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3553 
                                                        {
3554 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE02: TEXT CYPHER PASSED.\n");
3555 
 
3556 
                                                        }else
3557 
                                                        {
3558 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE02: TEXT CYPHER FAIL.\n");
3559 
                                                        }
3560 
 
3561 
 
3562 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3563 
                                                        {
3564 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3565 
                                                        }else
3566 
                                                        {
3567 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3568 
                                                        }
3569 
 
3570 
 
3571 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3572 
                                                        {
3573 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3574 
                                                        }else
3575 
                                                        {
3576 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3577 
                                                        }
3578 
 
3579 
 
3580 
                                                }else if(I == 599) //CTR DECRYPTION CCFIE DATATYPE03
3581 
                                                {
3582 
 
3583 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3584 
                                                        {
3585 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE03: TEXT CYPHER PASSED.\n");
3586 
 
3587 
                                                        }else
3588 
                                                        {
3589 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE03: TEXT CYPHER FAIL.\n");
3590 
                                                        }
3591 
 
3592 
 
3593 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3594 
                                                        {
3595 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3596 
                                                        }else
3597 
                                                        {
3598 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3599 
                                                        }
3600 
 
3601 
 
3602 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3603 
                                                        {
3604 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3605 
                                                        }else
3606 
                                                        {
3607 
                                                                printf("CTR DECRYPTION CCFIE DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3608 
                                                        }
3609 
 
3610 
 
3611 
 
3612 
                                                }else if(I == 89) //CTR DERIVATION DECRYPTION DATATYPE00
3613 
                                                {
3614 
 
3615 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DERIVATED,16) == 0)
3616 
                                                        {
3617 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE00: TEXT CYPHER PASSED.\n");
3618 9 redbear 
 
3619 
                                                        }else
3620 
                                                        {
3621 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE00: TEXT CYPHER FAIL.\n");
3622 9 redbear 
                                                        }
3623 
 
3624 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3625 
                                                        {
3626 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3627 9 redbear 
                                                        }else
3628 
                                                        {
3629 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3630 9 redbear 
                                                        }
3631 
 
3632 
 
3633 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3634 
                                                        {
3635 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3636 9 redbear 
                                                        }else
3637 
                                                        {
3638 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3639 9 redbear 
                                                        }
3640 
 
3641 12 redbear 
                                                }else if(I == 91) //CTR DERIVATION DECRYPTION DATATYPE01
3642 9 redbear 
                                                {
3643 
 
3644 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3645 
                                                        {
3646 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE01: TEXT CYPHER PASSED.\n");
3647 
 
3648 
                                                        }else
3649 
                                                        {
3650 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE01: TEXT CYPHER FAIL.\n");
3651 
                                                        }
3652 
 
3653 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3654 
                                                        {
3655 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3656 
                                                        }else
3657 
                                                        {
3658 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3659 
                                                        }
3660 
 
3661 
 
3662 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3663 
                                                        {
3664 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3665 
                                                        }else
3666 
                                                        {
3667 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3668 
                                                        }
3669 
 
3670 
                                                }else if(I == 93) //CTR DERIVATION DECRYPTION DATATYPE02
3671 
                                                {
3672 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3673 
                                                        {
3674 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE02: TEXT CYPHER PASSED.\n");
3675 
 
3676 
                                                        }else
3677 
                                                        {
3678 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE02: TEXT CYPHER FAIL.\n");
3679 
                                                        }
3680 
 
3681 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3682 
                                                        {
3683 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3684 
                                                        }else
3685 
                                                        {
3686 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3687 
                                                        }
3688 
 
3689 
 
3690 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3691 
                                                        {
3692 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3693 
                                                        }else
3694 
                                                        {
3695 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3696 
                                                        }
3697 
 
3698 
 
3699 
 
3700 
                                                }else if(I == 95) //CTR DERIVATION DECRYPTION DATATYPE03
3701 
                                                {
3702 
 
3703 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3704 
                                                        {
3705 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE03: TEXT CYPHER PASSED.\n");
3706 
 
3707 
                                                        }else
3708 
                                                        {
3709 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE03: TEXT CYPHER FAIL.\n");
3710 
                                                        }
3711 
 
3712 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3713 
                                                        {
3714 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3715 
                                                        }else
3716 
                                                        {
3717 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3718 
                                                        }
3719 
 
3720 
 
3721 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3722 
                                                        {
3723 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3724 
                                                        }else
3725 
                                                        {
3726 
                                                                printf("CTR DERIVATION DECRYPTION DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3727 
                                                        }
3728 
 
3729 
 
3730 
                                                }else if(I == 6233) //CTR DERIVATION DECRYPTION DMA DATATYPE00
3731 
                                                {
3732 
 
3733 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DERIVATED,16) == 0)
3734 
                                                        {
3735 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
3736 9 redbear 
 
3737 
                                                        }else
3738 
                                                        {
3739 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
3740 9 redbear 
                                                        }
3741 
 
3742 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3743 
                                                        {
3744 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3745 9 redbear 
                                                        }else
3746 
                                                        {
3747 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3748 9 redbear 
                                                        }
3749 
 
3750 
 
3751 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3752 
                                                        {
3753 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3754 9 redbear 
                                                        }else
3755 
                                                        {
3756 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3757 9 redbear 
                                                        }
3758 
 
3759 12 redbear 
                                                }else if(I == 6235) //CTR DERIVATION DECRYPTION DMA DATATYPE01
3760 9 redbear 
                                                {
3761 
 
3762 12 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3763 
                                                        {
3764 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
3765 
 
3766 
                                                        }else
3767 
                                                        {
3768 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
3769 
                                                        }
3770 
 
3771 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3772 
                                                        {
3773 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3774 
                                                        }else
3775 
                                                        {
3776 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3777 
                                                        }
3778 
 
3779 
 
3780 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3781 
                                                        {
3782 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3783 
                                                        }else
3784 
                                                        {
3785 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3786 
                                                        }
3787 
 
3788 
 
3789 
                                                }else if(I == 6237) //CTR DERIVATION DECRYPTION DMA DATATYPE02
3790 
                                                {
3791 
 
3792 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3793 
                                                        {
3794 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
3795 
 
3796 
                                                        }else
3797 
                                                        {
3798 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
3799 
                                                        }
3800 
 
3801 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3802 
                                                        {
3803 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3804 
                                                        }else
3805 
                                                        {
3806 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3807 
                                                        }
3808 
 
3809 
 
3810 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3811 
                                                        {
3812 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3813 
                                                        }else
3814 
                                                        {
3815 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3816 
                                                        }
3817 
 
3818 
 
3819 
                                                }else if(I == 6239) //CTR DERIVATION DECRYPTION DMA DATATYPE03
3820 
                                                {
3821 
 
3822 
 
3823 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3824 
                                                        {
3825 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
3826 
 
3827 
                                                        }else
3828 
                                                        {
3829 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
3830 
                                                        }
3831 
 
3832 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3833 
                                                        {
3834 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3835 
                                                        }else
3836 
                                                        {
3837 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3838 
                                                        }
3839 
 
3840 
 
3841 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3842 
                                                        {
3843 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3844 
                                                        }else
3845 
                                                        {
3846 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3847 
                                                        }
3848 
 
3849 
 
3850 
 
3851 
                                                }else if(I == 601) //CTR DERIVATION DECRYPTION CCFIE DATATYPE00
3852 
                                                {
3853 
 
3854 9 redbear 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DERIVATED,16) == 0)
3855 
                                                        {
3856 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER PASSED.\n");
3857 9 redbear 
 
3858 
                                                        }else
3859 
                                                        {
3860 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: TEXT CYPHER FAIL.\n");
3861 9 redbear 
                                                        }
3862 
 
3863 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3864 
                                                        {
3865 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE PASSED.\n");
3866 9 redbear 
                                                        }else
3867 
                                                        {
3868 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: KEYR WHEN CR ENABLE FAIL.\n");
3869 9 redbear 
                                                        }
3870 
 
3871 
 
3872 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3873 
                                                        {
3874 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE PASSED.\n");
3875 9 redbear 
                                                        }else
3876 
                                                        {
3877 12 redbear 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE00: IVR WHEN CR ENABLE FAIL.\n");
3878 9 redbear 
                                                        }
3879 
 
3880 12 redbear 
                                                }else if(I == 603) //CTR DERIVATION DECRYPTION CCFIE DATATYPE01
3881 
                                                {
3882 
 
3883 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3884 
                                                        {
3885 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER PASSED.\n");
3886 
 
3887 
                                                        }else
3888 
                                                        {
3889 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: TEXT CYPHER FAIL.\n");
3890 
                                                        }
3891 
 
3892 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3893 
                                                        {
3894 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE PASSED.\n");
3895 
                                                        }else
3896 
                                                        {
3897 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: KEYR WHEN CR ENABLE FAIL.\n");
3898 
                                                        }
3899 
 
3900 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3901 
                                                        {
3902 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE PASSED.\n");
3903 
                                                        }else
3904 
                                                        {
3905 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE01: IVR WHEN CR ENABLE FAIL.\n");
3906 
                                                        }
3907 
 
3908 
                                                }else if(I == 605) //CTR DERIVATION DECRYPTION CCFIE DATATYPE02
3909 
                                                {
3910 
 
3911 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3912 
                                                        {
3913 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER PASSED.\n");
3914 
 
3915 
                                                        }else
3916 
                                                        {
3917 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: TEXT CYPHER FAIL.\n");
3918 
                                                        }
3919 
 
3920 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3921 
                                                        {
3922 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE PASSED.\n");
3923 
                                                        }else
3924 
                                                        {
3925 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: KEYR WHEN CR ENABLE FAIL.\n");
3926 
                                                        }
3927 
 
3928 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3929 
                                                        {
3930 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE PASSED.\n");
3931 
                                                        }else
3932 
                                                        {
3933 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE02: IVR WHEN CR ENABLE FAIL.\n");
3934 
                                                        }
3935 
 
3936 
                                                }else if(I == 607) //CTR DERIVATION DECRYPTION CCFIE DATATYPE03
3937 
                                                {
3938 
 
3939 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_FIPS_CTR_NOT_DATATYPE_DERIVATED,16) == 0)
3940 
                                                        {
3941 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER PASSED.\n");
3942 
 
3943 
                                                        }else
3944 
                                                        {
3945 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: TEXT CYPHER FAIL.\n");
3946 
                                                        }
3947 
 
3948 
                                                        if(memcmp(OUTPUT_KEYR,TEXT_NULL,16) == 0)
3949 
                                                        {
3950 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE PASSED.\n");
3951 
                                                        }else
3952 
                                                        {
3953 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: KEYR WHEN CR ENABLE FAIL.\n");
3954 
                                                        }
3955 
 
3956 
                                                        if(memcmp(OUTPUT_IVR,TEXT_NULL,16) == 0)
3957 
                                                        {
3958 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE PASSED.\n");
3959 
                                                        }else
3960 
                                                        {
3961 
                                                                printf("CTR DERIVATION DECRYPTION DMA DATATYPE03: IVR WHEN CR ENABLE FAIL.\n");
3962 
                                                        }
3963 
 
3964 9 redbear 
                                                }else if(I == 73)// CTR KEY GENERATION
3965 
                                                {
3966 
 
3967 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
3968 
                                                        {
3969 
                                                                printf("CTR KEY GEN: TEXT CYPHER PASSED.\n");
3970 
 
3971 
                                                        }else
3972 
                                                        {
3973 
                                                                printf("CTR KEY GEN: TEXT CYPHER FAIL.\n");
3974 
                                                        }
3975 
 
3976 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_CTR_DERIVATED,16) == 0)
3977 
                                                        {
3978 
                                                                printf("CTR KEY GEN: KEYR WHEN CR ENABLE PASSED.\n");
3979 
                                                        }else
3980 
                                                        {
3981 
                                                                printf("CTR KEY GEN: KEYR WHEN CR ENABLE FAIL.\n");
3982 
                                                        }
3983 
 
3984 
 
3985 
                                                        if(memcmp(OUTPUT_IVR,IV_FIPS_CTR_NOT_DERIVATED,16) == 0)
3986 
                                                        {
3987 
                                                                printf("CTR KEY GEN: IVR WHEN CR ENABLE PASSED.\n");
3988 
                                                        }else
3989 
                                                        {
3990 
                                                                printf("CTR KEY GEN: IVR WHEN CR ENABLE FAIL.\n");
3991 
                                                        }
3992 
 
3993 
 
3994 
                                                }else if(I == 6217) // CTR KEY GENERATION DMA
3995 
                                                {
3996 
 
3997 
 
3998 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
3999 
                                                        {
4000 
                                                                printf("CTR KEY GEN DMA: TEXT CYPHER PASSED.\n");
4001 
 
4002 
                                                        }else
4003 
                                                        {
4004 
                                                                printf("CTR KEY GEN DMA: TEXT CYPHER FAIL.\n");
4005 
                                                        }
4006 
 
4007 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_CTR_DERIVATED,16) == 0)
4008 
                                                        {
4009 
                                                                printf("CTR KEY GEN DMA: KEYR WHEN CR ENABLE PASSED.\n");
4010 
                                                        }else
4011 
                                                        {
4012 
                                                                printf("CTR KEY GEN DMA: KEYR WHEN CR ENABLE FAIL.\n");
4013 
                                                        }
4014 
 
4015 
 
4016 
                                                        if(memcmp(OUTPUT_IVR,IV_FIPS_CTR_NOT_DERIVATED,16) == 0)
4017 
                                                        {
4018 
                                                                printf("CTR KEY GEN DMA: IVR WHEN CR ENABLE PASSED.\n");
4019 
                                                        }else
4020 
                                                        {
4021 
                                                                printf("CTR KEY GEN DMA: IVR WHEN CR ENABLE FAIL.\n");
4022 
                                                        }
4023 
 
4024 
                                                }else if(I == 585) // CTR KEY GENERATION CCFIE
4025 
                                                {
4026 
 
4027 
                                                        if(memcmp(OUTPUT_TEXT,TEXT_NULL,16) == 0)
4028 
                                                        {
4029 
                                                                printf("CTR KEY GEN CCFIE: TEXT CYPHER PASSED.\n");
4030 
 
4031 
                                                        }else
4032 
                                                        {
4033 
                                                                printf("CTR KEY GEN CCFIE: TEXT CYPHER FAIL.\n");
4034 
                                                        }
4035 
 
4036 
                                                        if(memcmp(OUTPUT_KEYR,KEY_FIPS_CTR_DERIVATED,16) == 0)
4037 
                                                        {
4038 
                                                                printf("CTR KEY GEN CCFIE: KEYR WHEN CR ENABLE PASSED.\n");
4039 
                                                        }else
4040 
                                                        {
4041 
                                                                printf("CTR KEY GEN CCFIE: KEYR WHEN CR ENABLE FAIL.\n");
4042 
                                                        }
4043 
 
4044 
 
4045 
                                                        if(memcmp(OUTPUT_IVR,IV_FIPS_CTR_NOT_DERIVATED,16) == 0)
4046 
                                                        {
4047 
                                                                printf("CTR KEY GEN CCFIE: IVR WHEN CR ENABLE PASSED.\n");
4048 
                                                        }else
4049 
                                                        {
4050 
                                                                printf("CTR KEY GEN CCFIE: IVR WHEN CR ENABLE FAIL.\n");
4051 
                                                        }
4052 
 
4053 
                                                }
4054 
 
4055 
 
4056 
 
4057 
 
4058 
 
4059 
                                        }//counter == 12
4060 12 redbear 
                                        else
4061 
                                        {
4062 9 redbear 
 
4063 12 redbear 
 
4064 
                                        }
4065 
 
4066 9 redbear 
                                }
4067 
 
4068 
 
4069 
 
4070 
 
4071 
                }
4072 
 
4073 
 
4074 
 
4075 
 
4076 
 
4077 4 redbear 
        }
4078 
 
4079 
        return 0;
4080 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.