module-skipjack/src/cipher_test.c

/*
 *    Copyright (C) 1998,1999,2000 Nikos Mavroyanopoulos
 *
 *    This program is free software; you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation; either version 2 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program; if not, write to the Free Software
 *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <mcrypt.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* Prints plaintext and ciphertext in hex for all the algorithms */

#define ALGORITHMS_DIR "../modules/algorithms/.libs"
#define MODES_DIR "../modules/modes/.libs"
/* #define ALGORITHMS_DIR NULL
 * #define MODES_DIR NULL
 */
#define TEXT "a small text, just to test the implementation"

int main()
{
        MCRYPT td, td2;
        int i, t, imax;
        int j, jmax, ivsize;
        int x = 0, siz;
        char **names;
        char **modes;
        char *text;
        unsigned char *IV;
        unsigned char *key;
        int keysize;
        
        names = mcrypt_list_algorithms (ALGORITHMS_DIR, &jmax);
        modes = mcrypt_list_modes (MODES_DIR, &imax);

        if (names==NULL || modes==NULL) {
                fprintf(stderr, "Error getting algorithms/modes\n");
                exit(1);
        }
        
        for (j=0;j<jmax;j++) {
                printf( "Algorithm: %s... ", names[j]);
                if (mcrypt_module_self_test( names[j], ALGORITHMS_DIR)==0) {
                        printf( "ok\n");
                } else {
                        x=1;
                        printf( "\n");
                }

                printf( "Modes:\n");
                        for (i=0;i<imax;i++) {
                                td = mcrypt_module_open(names[j], ALGORITHMS_DIR, modes[i], MODES_DIR);
                                td2 = mcrypt_module_open(names[j], ALGORITHMS_DIR, modes[i], MODES_DIR);
                                if (td != MCRYPT_FAILED) {
                                        keysize = mcrypt_enc_get_key_size(td);
                                        key = calloc(1, keysize);
                                        for (t=0;t<keysize;t++)
                                                key[t] = (t % 255) + 13;
                                        
                                        ivsize = mcrypt_enc_get_iv_size(td);
                                        if (ivsize>0) {
                                                IV = calloc( 1, ivsize);
                                                for (t=0;t<ivsize;t++)
                                                        IV[t] = (t*2 % 255) + 15;
                                        }
                                        if (mcrypt_generic_init( td, key, keysize, IV) < 0) {
                                                fprintf(stderr, "Failed to Initialize algorithm!\n");
                                                return -1;
                                        }

                                        siz = (strlen(TEXT) / mcrypt_enc_get_block_size(td))*mcrypt_enc_get_block_size(td);
                                        text = calloc( 1, siz);
                                        memmove( text, TEXT, siz);

                                        mcrypt_generic( td, text, siz);

                                        if (mcrypt_generic_init( td2, key, keysize, IV) < 0) {
                                                fprintf(stderr, "Failed to Initialize algorithm!\n");
                                                return -1;
                                        }

                                        mdecrypt_generic( td2, text, siz);
                                        if ( memcmp( text, TEXT, siz) == 0) {
                                                printf( "   %s: ok\n", modes[i]);
                                        } else {
                                                printf( "   %s: failed\n", modes[i]);
                                                x=1;
                                        }
                                        mcrypt_generic_deinit(td);
                                        mcrypt_generic_deinit(td2);
                                        mcrypt_module_close(td);
                                        mcrypt_module_close(td2);                                       free(text);
                                        free(key);
                                        if (ivsize>0) free(IV);
                                }
                        }
                printf("\n");
                
        }       
        mcrypt_free_p(names, jmax);
        mcrypt_free_p(modes, imax);
        

        if (x>0) fprintf(stderr, "\nProbably some of the algorithms listed above failed. "
                                "Try not to use these algorithms, and file a bug report to mcrypt-dev@lists.hellug.gr\n\n");
        return x;
}
1	nmav	1.2	/*
2			* Copyright (C) 1998,1999,2000 Nikos Mavroyanopoulos
3			*
4			* This program is free software; you can redistribute it and/or modify
5			* it under the terms of the GNU General Public License as published by
6			* the Free Software Foundation; either version 2 of the License, or
7			* (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the Free Software
16			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
17			*/
18
19			#include <mcrypt.h>
20	nmav	1.1	#include <stdio.h>
21			#include <stdlib.h>
22	nmav	1.2	#include <string.h>
23	nmav	1.1
24			/* Prints plaintext and ciphertext in hex for all the algorithms */
25
26			#define ALGORITHMS_DIR "../modules/algorithms/.libs"
27	nmav	1.2	#define MODES_DIR "../modules/modes/.libs"
28			/* #define ALGORITHMS_DIR NULL
29			* #define MODES_DIR NULL
30			*/
31			#define TEXT "a small text, just to test the implementation"
32
33	nmav	1.1	int main()
34			{
35	nmav	1.2	MCRYPT td, td2;
36			int i, t, imax;
37			int j, jmax, ivsize;
38			int x = 0, siz;
39	nmav	1.1	char **names;
40			char **modes;
41	nmav	1.2	char *text;
42			unsigned char *IV;
43			unsigned char *key;
44			int keysize;
45
46	nmav	1.1	names = mcrypt_list_algorithms (ALGORITHMS_DIR, &jmax);
47			modes = mcrypt_list_modes (MODES_DIR, &imax);
48
49	nmav	1.2	if (names==NULL \|\| modes==NULL) {
50			fprintf(stderr, "Error getting algorithms/modes\n");
51			exit(1);
52			}
53	nmav	1.1
54			for (j=0;j<jmax;j++) {
55			printf( "Algorithm: %s... ", names[j]);
56			if (mcrypt_module_self_test( names[j], ALGORITHMS_DIR)==0) {
57			printf( "ok\n");
58			} else {
59			x=1;
60			printf( "\n");
61			}
62
63	nmav	1.2	printf( "Modes:\n");
64	nmav	1.1	for (i=0;i<imax;i++) {
65			td = mcrypt_module_open(names[j], ALGORITHMS_DIR, modes[i], MODES_DIR);
66	nmav	1.2	td2 = mcrypt_module_open(names[j], ALGORITHMS_DIR, modes[i], MODES_DIR);
67			if (td != MCRYPT_FAILED) {
68			keysize = mcrypt_enc_get_key_size(td);
69			key = calloc(1, keysize);
70			for (t=0;t<keysize;t++)
71			key[t] = (t % 255) + 13;
72
73			ivsize = mcrypt_enc_get_iv_size(td);
74			if (ivsize>0) {
75			IV = calloc( 1, ivsize);
76			for (t=0;t<ivsize;t++)
77			IV[t] = (t*2 % 255) + 15;
78			}
79			if (mcrypt_generic_init( td, key, keysize, IV) < 0) {
80			fprintf(stderr, "Failed to Initialize algorithm!\n");
81			return -1;
82			}
83
84			siz = (strlen(TEXT) / mcrypt_enc_get_block_size(td))*mcrypt_enc_get_block_size(td);
85			text = calloc( 1, siz);
86			memmove( text, TEXT, siz);
87
88			mcrypt_generic( td, text, siz);
89
90			if (mcrypt_generic_init( td2, key, keysize, IV) < 0) {
91			fprintf(stderr, "Failed to Initialize algorithm!\n");
92			return -1;
93			}
94
95			mdecrypt_generic( td2, text, siz);
96			if ( memcmp( text, TEXT, siz) == 0) {
97			printf( " %s: ok\n", modes[i]);
98			} else {
99			printf( " %s: failed\n", modes[i]);
100			x=1;
101			}
102			mcrypt_generic_deinit(td);
103			mcrypt_generic_deinit(td2);
104	nmav	1.1	mcrypt_module_close(td);
105	nmav	1.2	mcrypt_module_close(td2); free(text);
106			free(key);
107			if (ivsize>0) free(IV);
108	nmav	1.1	}
109			}
110			printf("\n");
111
112			}
113	nmav	1.2	mcrypt_free_p(names, jmax);
114			mcrypt_free_p(modes, imax);
115
116	nmav	1.1
117			if (x>0) fprintf(stderr, "\nProbably some of the algorithms listed above failed. "
118	nmav	1.2	"Try not to use these algorithms, and file a bug report to mcrypt-dev@lists.hellug.gr\n\n");
119	nmav	1.1	return x;
120			}