155714Skris/* crypto/bf/bftest.c */ 255714Skris/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) 355714Skris * All rights reserved. 455714Skris * 555714Skris * This package is an SSL implementation written 655714Skris * by Eric Young (eay@cryptsoft.com). 755714Skris * The implementation was written so as to conform with Netscapes SSL. 8296341Sdelphij * 955714Skris * This library is free for commercial and non-commercial use as long as 1055714Skris * the following conditions are aheared to. The following conditions 1155714Skris * apply to all code found in this distribution, be it the RC4, RSA, 1255714Skris * lhash, DES, etc., code; not just the SSL code. The SSL documentation 1355714Skris * included with this distribution is covered by the same copyright terms 1455714Skris * except that the holder is Tim Hudson (tjh@cryptsoft.com). 15296341Sdelphij * 1655714Skris * Copyright remains Eric Young's, and as such any Copyright notices in 1755714Skris * the code are not to be removed. 1855714Skris * If this package is used in a product, Eric Young should be given attribution 1955714Skris * as the author of the parts of the library used. 2055714Skris * This can be in the form of a textual message at program startup or 2155714Skris * in documentation (online or textual) provided with the package. 22296341Sdelphij * 2355714Skris * Redistribution and use in source and binary forms, with or without 2455714Skris * modification, are permitted provided that the following conditions 2555714Skris * are met: 2655714Skris * 1. Redistributions of source code must retain the copyright 2755714Skris * notice, this list of conditions and the following disclaimer. 2855714Skris * 2. Redistributions in binary form must reproduce the above copyright 2955714Skris * notice, this list of conditions and the following disclaimer in the 3055714Skris * documentation and/or other materials provided with the distribution. 3155714Skris * 3. All advertising materials mentioning features or use of this software 3255714Skris * must display the following acknowledgement: 3355714Skris * "This product includes cryptographic software written by 3455714Skris * Eric Young (eay@cryptsoft.com)" 3555714Skris * The word 'cryptographic' can be left out if the rouines from the library 3655714Skris * being used are not cryptographic related :-). 37296341Sdelphij * 4. If you include any Windows specific code (or a derivative thereof) from 3855714Skris * the apps directory (application code) you must include an acknowledgement: 3955714Skris * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" 40296341Sdelphij * 4155714Skris * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND 4255714Skris * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 4355714Skris * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 4455714Skris * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 4555714Skris * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 4655714Skris * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 4755714Skris * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 4855714Skris * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 4955714Skris * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 5055714Skris * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 5155714Skris * SUCH DAMAGE. 52296341Sdelphij * 5355714Skris * The licence and distribution terms for any publically available version or 5455714Skris * derivative of this code cannot be changed. i.e. this code cannot simply be 5555714Skris * copied and put under another distribution licence 5655714Skris * [including the GNU Public Licence.] 5755714Skris */ 5855714Skris 59296341Sdelphij/* 60296341Sdelphij * This has been a quickly hacked 'ideatest.c'. When I add tests for other 61296341Sdelphij * RC2 modes, more of the code will be uncommented. 62296341Sdelphij */ 6355714Skris 6455714Skris#include <stdio.h> 6555714Skris#include <string.h> 6655714Skris#include <stdlib.h> 67160814Ssimon#include <openssl/opensslconf.h> /* To see if OPENSSL_NO_BF is defined */ 6855714Skris 69109998Smarkm#include "../e_os.h" 70109998Smarkm 71109998Smarkm#ifdef OPENSSL_NO_BF 7255714Skrisint main(int argc, char *argv[]) 7355714Skris{ 7455714Skris printf("No BF support\n"); 75296341Sdelphij return (0); 7655714Skris} 7755714Skris#else 78296341Sdelphij# include <openssl/blowfish.h> 7955714Skris 80296341Sdelphij# ifdef CHARSET_EBCDIC 81296341Sdelphij# include <openssl/ebcdic.h> 82296341Sdelphij# endif 8355714Skris 84296341Sdelphijstatic char *bf_key[2] = { 85296341Sdelphij "abcdefghijklmnopqrstuvwxyz", 86296341Sdelphij "Who is John Galt?" 87296341Sdelphij}; 8855714Skris 8955714Skris/* big endian */ 90296341Sdelphijstatic BF_LONG bf_plain[2][2] = { 91296341Sdelphij {0x424c4f57L, 0x46495348L}, 92296341Sdelphij {0xfedcba98L, 0x76543210L} 93296341Sdelphij}; 9455714Skris 95296341Sdelphijstatic BF_LONG bf_cipher[2][2] = { 96296341Sdelphij {0x324ed0feL, 0xf413a203L}, 97296341Sdelphij {0xcc91732bL, 0x8022f684L} 98296341Sdelphij}; 99296341Sdelphij 10055714Skris/************/ 10155714Skris 10255714Skris/* Lets use the DES test vectors :-) */ 103296341Sdelphij# define NUM_TESTS 34 104296341Sdelphijstatic unsigned char ecb_data[NUM_TESTS][8] = { 105296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 106296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 107296341Sdelphij {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 108296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 109296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 110296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 111296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 112296341Sdelphij {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}, 113296341Sdelphij {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57}, 114296341Sdelphij {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E}, 115296341Sdelphij {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86}, 116296341Sdelphij {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E}, 117296341Sdelphij {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6}, 118296341Sdelphij {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE}, 119296341Sdelphij {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6}, 120296341Sdelphij {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE}, 121296341Sdelphij {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16}, 122296341Sdelphij {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F}, 123296341Sdelphij {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46}, 124296341Sdelphij {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E}, 125296341Sdelphij {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76}, 126296341Sdelphij {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07}, 127296341Sdelphij {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F}, 128296341Sdelphij {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7}, 129296341Sdelphij {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF}, 130296341Sdelphij {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6}, 131296341Sdelphij {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF}, 132296341Sdelphij {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}, 133296341Sdelphij {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E}, 134296341Sdelphij {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE}, 135296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 136296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 137296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 138296341Sdelphij {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10} 139296341Sdelphij}; 14055714Skris 141296341Sdelphijstatic unsigned char plain_data[NUM_TESTS][8] = { 142296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 143296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 144296341Sdelphij {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 145296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 146296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 147296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 148296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 149296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 150296341Sdelphij {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42}, 151296341Sdelphij {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA}, 152296341Sdelphij {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72}, 153296341Sdelphij {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A}, 154296341Sdelphij {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2}, 155296341Sdelphij {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A}, 156296341Sdelphij {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2}, 157296341Sdelphij {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A}, 158296341Sdelphij {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02}, 159296341Sdelphij {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A}, 160296341Sdelphij {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32}, 161296341Sdelphij {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA}, 162296341Sdelphij {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62}, 163296341Sdelphij {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2}, 164296341Sdelphij {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA}, 165296341Sdelphij {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92}, 166296341Sdelphij {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A}, 167296341Sdelphij {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2}, 168296341Sdelphij {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A}, 169296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 170296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 171296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 172296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 173296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 174296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 175296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} 176296341Sdelphij}; 17755714Skris 178296341Sdelphijstatic unsigned char cipher_data[NUM_TESTS][8] = { 179296341Sdelphij {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78}, 180296341Sdelphij {0x51, 0x86, 0x6F, 0xD5, 0xB8, 0x5E, 0xCB, 0x8A}, 181296341Sdelphij {0x7D, 0x85, 0x6F, 0x9A, 0x61, 0x30, 0x63, 0xF2}, 182296341Sdelphij {0x24, 0x66, 0xDD, 0x87, 0x8B, 0x96, 0x3C, 0x9D}, 183296341Sdelphij {0x61, 0xF9, 0xC3, 0x80, 0x22, 0x81, 0xB0, 0x96}, 184296341Sdelphij {0x7D, 0x0C, 0xC6, 0x30, 0xAF, 0xDA, 0x1E, 0xC7}, 185296341Sdelphij {0x4E, 0xF9, 0x97, 0x45, 0x61, 0x98, 0xDD, 0x78}, 186296341Sdelphij {0x0A, 0xCE, 0xAB, 0x0F, 0xC6, 0xA0, 0xA2, 0x8D}, 187296341Sdelphij {0x59, 0xC6, 0x82, 0x45, 0xEB, 0x05, 0x28, 0x2B}, 188296341Sdelphij {0xB1, 0xB8, 0xCC, 0x0B, 0x25, 0x0F, 0x09, 0xA0}, 189296341Sdelphij {0x17, 0x30, 0xE5, 0x77, 0x8B, 0xEA, 0x1D, 0xA4}, 190296341Sdelphij {0xA2, 0x5E, 0x78, 0x56, 0xCF, 0x26, 0x51, 0xEB}, 191296341Sdelphij {0x35, 0x38, 0x82, 0xB1, 0x09, 0xCE, 0x8F, 0x1A}, 192296341Sdelphij {0x48, 0xF4, 0xD0, 0x88, 0x4C, 0x37, 0x99, 0x18}, 193296341Sdelphij {0x43, 0x21, 0x93, 0xB7, 0x89, 0x51, 0xFC, 0x98}, 194296341Sdelphij {0x13, 0xF0, 0x41, 0x54, 0xD6, 0x9D, 0x1A, 0xE5}, 195296341Sdelphij {0x2E, 0xED, 0xDA, 0x93, 0xFF, 0xD3, 0x9C, 0x79}, 196296341Sdelphij {0xD8, 0x87, 0xE0, 0x39, 0x3C, 0x2D, 0xA6, 0xE3}, 197296341Sdelphij {0x5F, 0x99, 0xD0, 0x4F, 0x5B, 0x16, 0x39, 0x69}, 198296341Sdelphij {0x4A, 0x05, 0x7A, 0x3B, 0x24, 0xD3, 0x97, 0x7B}, 199296341Sdelphij {0x45, 0x20, 0x31, 0xC1, 0xE4, 0xFA, 0xDA, 0x8E}, 200296341Sdelphij {0x75, 0x55, 0xAE, 0x39, 0xF5, 0x9B, 0x87, 0xBD}, 201296341Sdelphij {0x53, 0xC5, 0x5F, 0x9C, 0xB4, 0x9F, 0xC0, 0x19}, 202296341Sdelphij {0x7A, 0x8E, 0x7B, 0xFA, 0x93, 0x7E, 0x89, 0xA3}, 203296341Sdelphij {0xCF, 0x9C, 0x5D, 0x7A, 0x49, 0x86, 0xAD, 0xB5}, 204296341Sdelphij {0xD1, 0xAB, 0xB2, 0x90, 0x65, 0x8B, 0xC7, 0x78}, 205296341Sdelphij {0x55, 0xCB, 0x37, 0x74, 0xD1, 0x3E, 0xF2, 0x01}, 206296341Sdelphij {0xFA, 0x34, 0xEC, 0x48, 0x47, 0xB2, 0x68, 0xB2}, 207296341Sdelphij {0xA7, 0x90, 0x79, 0x51, 0x08, 0xEA, 0x3C, 0xAE}, 208296341Sdelphij {0xC3, 0x9E, 0x07, 0x2D, 0x9F, 0xAC, 0x63, 0x1D}, 209296341Sdelphij {0x01, 0x49, 0x33, 0xE0, 0xCD, 0xAF, 0xF6, 0xE4}, 210296341Sdelphij {0xF2, 0x1E, 0x9A, 0x77, 0xB7, 0x1C, 0x49, 0xBC}, 211296341Sdelphij {0x24, 0x59, 0x46, 0x88, 0x57, 0x54, 0x36, 0x9A}, 212296341Sdelphij {0x6B, 0x5C, 0x5A, 0x9C, 0x5D, 0x9E, 0x0A, 0x5A}, 213296341Sdelphij}; 21455714Skris 215296341Sdelphijstatic unsigned char cbc_key[16] = { 216296341Sdelphij 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 217296341Sdelphij 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 218296341Sdelphij}; 219296341Sdelphijstatic unsigned char cbc_iv[8] = 220296341Sdelphij { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }; 221296341Sdelphijstatic char cbc_data[40] = "7654321 Now is the time for "; 222296341Sdelphijstatic unsigned char cbc_ok[32] = { 223296341Sdelphij 0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6, 224296341Sdelphij 0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93, 225296341Sdelphij 0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9, 226296341Sdelphij 0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC 227296341Sdelphij}; 22855714Skris 229296341Sdelphijstatic unsigned char cfb64_ok[] = { 230296341Sdelphij 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA, 231296341Sdelphij 0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E, 232296341Sdelphij 0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00, 233296341Sdelphij 0x51, 0x9D, 0x57, 0xA6, 0xC3 234296341Sdelphij}; 23555714Skris 236296341Sdelphijstatic unsigned char ofb64_ok[] = { 237296341Sdelphij 0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA, 238296341Sdelphij 0x62, 0xB3, 0x43, 0xCC, 0x5B, 0x65, 0x58, 0x73, 239296341Sdelphij 0x10, 0xDD, 0x90, 0x8D, 0x0C, 0x24, 0x1B, 0x22, 240296341Sdelphij 0x63, 0xC2, 0xCF, 0x80, 0xDA 241296341Sdelphij}; 24255714Skris 243296341Sdelphij# define KEY_TEST_NUM 25 244296341Sdelphijstatic unsigned char key_test[KEY_TEST_NUM] = { 245296341Sdelphij 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 246296341Sdelphij 0x78, 0x69, 0x5a, 0x4b, 0x3c, 0x2d, 0x1e, 0x0f, 247296341Sdelphij 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 248296341Sdelphij 0x88 249296341Sdelphij}; 25055714Skris 251296341Sdelphijstatic unsigned char key_data[8] = 252296341Sdelphij { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }; 25355714Skris 254296341Sdelphijstatic unsigned char key_out[KEY_TEST_NUM][8] = { 255296341Sdelphij {0xF9, 0xAD, 0x59, 0x7C, 0x49, 0xDB, 0x00, 0x5E}, 256296341Sdelphij {0xE9, 0x1D, 0x21, 0xC1, 0xD9, 0x61, 0xA6, 0xD6}, 257296341Sdelphij {0xE9, 0xC2, 0xB7, 0x0A, 0x1B, 0xC6, 0x5C, 0xF3}, 258296341Sdelphij {0xBE, 0x1E, 0x63, 0x94, 0x08, 0x64, 0x0F, 0x05}, 259296341Sdelphij {0xB3, 0x9E, 0x44, 0x48, 0x1B, 0xDB, 0x1E, 0x6E}, 260296341Sdelphij {0x94, 0x57, 0xAA, 0x83, 0xB1, 0x92, 0x8C, 0x0D}, 261296341Sdelphij {0x8B, 0xB7, 0x70, 0x32, 0xF9, 0x60, 0x62, 0x9D}, 262296341Sdelphij {0xE8, 0x7A, 0x24, 0x4E, 0x2C, 0xC8, 0x5E, 0x82}, 263296341Sdelphij {0x15, 0x75, 0x0E, 0x7A, 0x4F, 0x4E, 0xC5, 0x77}, 264296341Sdelphij {0x12, 0x2B, 0xA7, 0x0B, 0x3A, 0xB6, 0x4A, 0xE0}, 265296341Sdelphij {0x3A, 0x83, 0x3C, 0x9A, 0xFF, 0xC5, 0x37, 0xF6}, 266296341Sdelphij {0x94, 0x09, 0xDA, 0x87, 0xA9, 0x0F, 0x6B, 0xF2}, 267296341Sdelphij {0x88, 0x4F, 0x80, 0x62, 0x50, 0x60, 0xB8, 0xB4}, 268296341Sdelphij {0x1F, 0x85, 0x03, 0x1C, 0x19, 0xE1, 0x19, 0x68}, 269296341Sdelphij {0x79, 0xD9, 0x37, 0x3A, 0x71, 0x4C, 0xA3, 0x4F}, 270296341Sdelphij {0x93, 0x14, 0x28, 0x87, 0xEE, 0x3B, 0xE1, 0x5C}, 271296341Sdelphij {0x03, 0x42, 0x9E, 0x83, 0x8C, 0xE2, 0xD1, 0x4B}, 272296341Sdelphij {0xA4, 0x29, 0x9E, 0x27, 0x46, 0x9F, 0xF6, 0x7B}, 273296341Sdelphij {0xAF, 0xD5, 0xAE, 0xD1, 0xC1, 0xBC, 0x96, 0xA8}, 274296341Sdelphij {0x10, 0x85, 0x1C, 0x0E, 0x38, 0x58, 0xDA, 0x9F}, 275296341Sdelphij {0xE6, 0xF5, 0x1E, 0xD7, 0x9B, 0x9D, 0xB2, 0x1F}, 276296341Sdelphij {0x64, 0xA6, 0xE1, 0x4A, 0xFD, 0x36, 0xB4, 0x6F}, 277296341Sdelphij {0x80, 0xC7, 0xD7, 0xD4, 0x5A, 0x54, 0x79, 0xAD}, 278296341Sdelphij {0x05, 0x04, 0x4B, 0x62, 0xFA, 0x52, 0xD0, 0x80}, 279296341Sdelphij}; 28055714Skris 281296341Sdelphijstatic int test(void); 282296341Sdelphijstatic int print_test_data(void); 28355714Skrisint main(int argc, char *argv[]) 284296341Sdelphij{ 285296341Sdelphij int ret; 28655714Skris 287296341Sdelphij if (argc > 1) 288296341Sdelphij ret = print_test_data(); 289296341Sdelphij else 290296341Sdelphij ret = test(); 29155714Skris 292296341Sdelphij# ifdef OPENSSL_SYS_NETWARE 293296341Sdelphij if (ret) 294296341Sdelphij printf("ERROR: %d\n", ret); 295296341Sdelphij# endif 296296341Sdelphij EXIT(ret); 297296341Sdelphij return (0); 298296341Sdelphij} 29955714Skris 30055714Skrisstatic int print_test_data(void) 301296341Sdelphij{ 302296341Sdelphij unsigned int i, j; 30355714Skris 304296341Sdelphij printf("ecb test data\n"); 305296341Sdelphij printf("key bytes\t\tclear bytes\t\tcipher bytes\n"); 306296341Sdelphij for (i = 0; i < NUM_TESTS; i++) { 307296341Sdelphij for (j = 0; j < 8; j++) 308296341Sdelphij printf("%02X", ecb_data[i][j]); 309296341Sdelphij printf("\t"); 310296341Sdelphij for (j = 0; j < 8; j++) 311296341Sdelphij printf("%02X", plain_data[i][j]); 312296341Sdelphij printf("\t"); 313296341Sdelphij for (j = 0; j < 8; j++) 314296341Sdelphij printf("%02X", cipher_data[i][j]); 315296341Sdelphij printf("\n"); 316296341Sdelphij } 31755714Skris 318296341Sdelphij printf("set_key test data\n"); 319296341Sdelphij printf("data[8]= "); 320296341Sdelphij for (j = 0; j < 8; j++) 321296341Sdelphij printf("%02X", key_data[j]); 322296341Sdelphij printf("\n"); 323296341Sdelphij for (i = 0; i < KEY_TEST_NUM - 1; i++) { 324296341Sdelphij printf("c="); 325296341Sdelphij for (j = 0; j < 8; j++) 326296341Sdelphij printf("%02X", key_out[i][j]); 327296341Sdelphij printf(" k[%2u]=", i + 1); 328296341Sdelphij for (j = 0; j < i + 1; j++) 329296341Sdelphij printf("%02X", key_test[j]); 330296341Sdelphij printf("\n"); 331296341Sdelphij } 33255714Skris 333296341Sdelphij printf("\nchaining mode test data\n"); 334296341Sdelphij printf("key[16] = "); 335296341Sdelphij for (j = 0; j < 16; j++) 336296341Sdelphij printf("%02X", cbc_key[j]); 337296341Sdelphij printf("\niv[8] = "); 338296341Sdelphij for (j = 0; j < 8; j++) 339296341Sdelphij printf("%02X", cbc_iv[j]); 340296341Sdelphij printf("\ndata[%d] = '%s'", (int)strlen(cbc_data) + 1, cbc_data); 341296341Sdelphij printf("\ndata[%d] = ", (int)strlen(cbc_data) + 1); 342296341Sdelphij for (j = 0; j < strlen(cbc_data) + 1; j++) 343296341Sdelphij printf("%02X", cbc_data[j]); 344296341Sdelphij printf("\n"); 345296341Sdelphij printf("cbc cipher text\n"); 346296341Sdelphij printf("cipher[%d]= ", 32); 347296341Sdelphij for (j = 0; j < 32; j++) 348296341Sdelphij printf("%02X", cbc_ok[j]); 349296341Sdelphij printf("\n"); 35055714Skris 351296341Sdelphij printf("cfb64 cipher text\n"); 352296341Sdelphij printf("cipher[%d]= ", (int)strlen(cbc_data) + 1); 353296341Sdelphij for (j = 0; j < strlen(cbc_data) + 1; j++) 354296341Sdelphij printf("%02X", cfb64_ok[j]); 355296341Sdelphij printf("\n"); 35655714Skris 357296341Sdelphij printf("ofb64 cipher text\n"); 358296341Sdelphij printf("cipher[%d]= ", (int)strlen(cbc_data) + 1); 359296341Sdelphij for (j = 0; j < strlen(cbc_data) + 1; j++) 360296341Sdelphij printf("%02X", ofb64_ok[j]); 361296341Sdelphij printf("\n"); 362296341Sdelphij return (0); 363296341Sdelphij} 36455714Skris 36555714Skrisstatic int test(void) 366296341Sdelphij{ 367296341Sdelphij unsigned char cbc_in[40], cbc_out[40], iv[8]; 368296341Sdelphij int i, n, err = 0; 369296341Sdelphij BF_KEY key; 370296341Sdelphij BF_LONG data[2]; 371296341Sdelphij unsigned char out[8]; 372296341Sdelphij BF_LONG len; 37355714Skris 374296341Sdelphij# ifdef CHARSET_EBCDIC 375296341Sdelphij ebcdic2ascii(cbc_data, cbc_data, strlen(cbc_data)); 376296341Sdelphij# endif 37755714Skris 378296341Sdelphij printf("testing blowfish in raw ecb mode\n"); 379296341Sdelphij for (n = 0; n < 2; n++) { 380296341Sdelphij# ifdef CHARSET_EBCDIC 381296341Sdelphij ebcdic2ascii(bf_key[n], bf_key[n], strlen(bf_key[n])); 382296341Sdelphij# endif 383296341Sdelphij BF_set_key(&key, strlen(bf_key[n]), (unsigned char *)bf_key[n]); 38455714Skris 385296341Sdelphij data[0] = bf_plain[n][0]; 386296341Sdelphij data[1] = bf_plain[n][1]; 387296341Sdelphij BF_encrypt(data, &key); 388296341Sdelphij if (memcmp(&(bf_cipher[n][0]), &(data[0]), 8) != 0) { 389296341Sdelphij printf("BF_encrypt error encrypting\n"); 390296341Sdelphij printf("got :"); 391296341Sdelphij for (i = 0; i < 2; i++) 392296341Sdelphij printf("%08lX ", (unsigned long)data[i]); 393296341Sdelphij printf("\n"); 394296341Sdelphij printf("expected:"); 395296341Sdelphij for (i = 0; i < 2; i++) 396296341Sdelphij printf("%08lX ", (unsigned long)bf_cipher[n][i]); 397296341Sdelphij err = 1; 398296341Sdelphij printf("\n"); 399296341Sdelphij } 40055714Skris 401296341Sdelphij BF_decrypt(&(data[0]), &key); 402296341Sdelphij if (memcmp(&(bf_plain[n][0]), &(data[0]), 8) != 0) { 403296341Sdelphij printf("BF_encrypt error decrypting\n"); 404296341Sdelphij printf("got :"); 405296341Sdelphij for (i = 0; i < 2; i++) 406296341Sdelphij printf("%08lX ", (unsigned long)data[i]); 407296341Sdelphij printf("\n"); 408296341Sdelphij printf("expected:"); 409296341Sdelphij for (i = 0; i < 2; i++) 410296341Sdelphij printf("%08lX ", (unsigned long)bf_plain[n][i]); 411296341Sdelphij printf("\n"); 412296341Sdelphij err = 1; 413296341Sdelphij } 414296341Sdelphij } 41555714Skris 416296341Sdelphij printf("testing blowfish in ecb mode\n"); 41755714Skris 418296341Sdelphij for (n = 0; n < NUM_TESTS; n++) { 419296341Sdelphij BF_set_key(&key, 8, ecb_data[n]); 42055714Skris 421296341Sdelphij BF_ecb_encrypt(&(plain_data[n][0]), out, &key, BF_ENCRYPT); 422296341Sdelphij if (memcmp(&(cipher_data[n][0]), out, 8) != 0) { 423296341Sdelphij printf("BF_ecb_encrypt blowfish error encrypting\n"); 424296341Sdelphij printf("got :"); 425296341Sdelphij for (i = 0; i < 8; i++) 426296341Sdelphij printf("%02X ", out[i]); 427296341Sdelphij printf("\n"); 428296341Sdelphij printf("expected:"); 429296341Sdelphij for (i = 0; i < 8; i++) 430296341Sdelphij printf("%02X ", cipher_data[n][i]); 431296341Sdelphij err = 1; 432296341Sdelphij printf("\n"); 433296341Sdelphij } 43455714Skris 435296341Sdelphij BF_ecb_encrypt(out, out, &key, BF_DECRYPT); 436296341Sdelphij if (memcmp(&(plain_data[n][0]), out, 8) != 0) { 437296341Sdelphij printf("BF_ecb_encrypt error decrypting\n"); 438296341Sdelphij printf("got :"); 439296341Sdelphij for (i = 0; i < 8; i++) 440296341Sdelphij printf("%02X ", out[i]); 441296341Sdelphij printf("\n"); 442296341Sdelphij printf("expected:"); 443296341Sdelphij for (i = 0; i < 8; i++) 444296341Sdelphij printf("%02X ", plain_data[n][i]); 445296341Sdelphij printf("\n"); 446296341Sdelphij err = 1; 447296341Sdelphij } 448296341Sdelphij } 44955714Skris 450296341Sdelphij printf("testing blowfish set_key\n"); 451296341Sdelphij for (n = 1; n < KEY_TEST_NUM; n++) { 452296341Sdelphij BF_set_key(&key, n, key_test); 453296341Sdelphij BF_ecb_encrypt(key_data, out, &key, BF_ENCRYPT); 454296341Sdelphij /* mips-sgi-irix6.5-gcc vv -mabi=64 bug workaround */ 455296341Sdelphij if (memcmp(out, &(key_out[i = n - 1][0]), 8) != 0) { 456296341Sdelphij printf("blowfish setkey error\n"); 457296341Sdelphij err = 1; 458296341Sdelphij } 459296341Sdelphij } 46055714Skris 461296341Sdelphij printf("testing blowfish in cbc mode\n"); 462296341Sdelphij len = strlen(cbc_data) + 1; 46355714Skris 464296341Sdelphij BF_set_key(&key, 16, cbc_key); 465296341Sdelphij memset(cbc_in, 0, sizeof cbc_in); 466296341Sdelphij memset(cbc_out, 0, sizeof cbc_out); 467296341Sdelphij memcpy(iv, cbc_iv, sizeof iv); 468296341Sdelphij BF_cbc_encrypt((unsigned char *)cbc_data, cbc_out, len, 469296341Sdelphij &key, iv, BF_ENCRYPT); 470296341Sdelphij if (memcmp(cbc_out, cbc_ok, 32) != 0) { 471296341Sdelphij err = 1; 472296341Sdelphij printf("BF_cbc_encrypt encrypt error\n"); 473296341Sdelphij for (i = 0; i < 32; i++) 474296341Sdelphij printf("0x%02X,", cbc_out[i]); 475296341Sdelphij } 476296341Sdelphij memcpy(iv, cbc_iv, 8); 477296341Sdelphij BF_cbc_encrypt(cbc_out, cbc_in, len, &key, iv, BF_DECRYPT); 478296341Sdelphij if (memcmp(cbc_in, cbc_data, strlen(cbc_data) + 1) != 0) { 479296341Sdelphij printf("BF_cbc_encrypt decrypt error\n"); 480296341Sdelphij err = 1; 481296341Sdelphij } 48255714Skris 483296341Sdelphij printf("testing blowfish in cfb64 mode\n"); 48455714Skris 485296341Sdelphij BF_set_key(&key, 16, cbc_key); 486296341Sdelphij memset(cbc_in, 0, 40); 487296341Sdelphij memset(cbc_out, 0, 40); 488296341Sdelphij memcpy(iv, cbc_iv, 8); 489296341Sdelphij n = 0; 490296341Sdelphij BF_cfb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, 491296341Sdelphij &key, iv, &n, BF_ENCRYPT); 492296341Sdelphij BF_cfb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]), 493296341Sdelphij len - 13, &key, iv, &n, BF_ENCRYPT); 494296341Sdelphij if (memcmp(cbc_out, cfb64_ok, (int)len) != 0) { 495296341Sdelphij err = 1; 496296341Sdelphij printf("BF_cfb64_encrypt encrypt error\n"); 497296341Sdelphij for (i = 0; i < (int)len; i++) 498296341Sdelphij printf("0x%02X,", cbc_out[i]); 499296341Sdelphij } 500296341Sdelphij n = 0; 501296341Sdelphij memcpy(iv, cbc_iv, 8); 502296341Sdelphij BF_cfb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n, BF_DECRYPT); 503296341Sdelphij BF_cfb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, 504296341Sdelphij &key, iv, &n, BF_DECRYPT); 505296341Sdelphij if (memcmp(cbc_in, cbc_data, (int)len) != 0) { 506296341Sdelphij printf("BF_cfb64_encrypt decrypt error\n"); 507296341Sdelphij err = 1; 508296341Sdelphij } 50955714Skris 510296341Sdelphij printf("testing blowfish in ofb64\n"); 51155714Skris 512296341Sdelphij BF_set_key(&key, 16, cbc_key); 513296341Sdelphij memset(cbc_in, 0, 40); 514296341Sdelphij memset(cbc_out, 0, 40); 515296341Sdelphij memcpy(iv, cbc_iv, 8); 516296341Sdelphij n = 0; 517296341Sdelphij BF_ofb64_encrypt((unsigned char *)cbc_data, cbc_out, (long)13, &key, iv, 518296341Sdelphij &n); 519296341Sdelphij BF_ofb64_encrypt((unsigned char *)&(cbc_data[13]), &(cbc_out[13]), 520296341Sdelphij len - 13, &key, iv, &n); 521296341Sdelphij if (memcmp(cbc_out, ofb64_ok, (int)len) != 0) { 522296341Sdelphij err = 1; 523296341Sdelphij printf("BF_ofb64_encrypt encrypt error\n"); 524296341Sdelphij for (i = 0; i < (int)len; i++) 525296341Sdelphij printf("0x%02X,", cbc_out[i]); 526296341Sdelphij } 527296341Sdelphij n = 0; 528296341Sdelphij memcpy(iv, cbc_iv, 8); 529296341Sdelphij BF_ofb64_encrypt(cbc_out, cbc_in, 17, &key, iv, &n); 530296341Sdelphij BF_ofb64_encrypt(&(cbc_out[17]), &(cbc_in[17]), len - 17, &key, iv, &n); 531296341Sdelphij if (memcmp(cbc_in, cbc_data, (int)len) != 0) { 532296341Sdelphij printf("BF_ofb64_encrypt decrypt error\n"); 533296341Sdelphij err = 1; 534296341Sdelphij } 53555714Skris 536296341Sdelphij return (err); 537296341Sdelphij} 53855714Skris#endif 539