155714Skris/* crypto/des/destest.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 59109998Smarkm#include <stdio.h> 60109998Smarkm#include <stdlib.h> 61109998Smarkm 62109998Smarkm#include <openssl/e_os2.h> 63109998Smarkm#if defined(OPENSSL_SYS_WIN32) || defined(OPENSSL_SYS_WIN16) || defined(OPENSSL_SYS_WINDOWS) 64296341Sdelphij# ifndef OPENSSL_SYS_MSDOS 65296341Sdelphij# define OPENSSL_SYS_MSDOS 66296341Sdelphij# endif 6755714Skris#endif 6855714Skris 69109998Smarkm#ifndef OPENSSL_SYS_MSDOS 70296341Sdelphij# if !defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_VMS_DECC) 71296341Sdelphij# include OPENSSL_UNISTD 72296341Sdelphij# endif 7355714Skris#else 74296341Sdelphij# include <io.h> 7555714Skris#endif 7655714Skris#include <string.h> 7755714Skris 78109998Smarkm#ifdef OPENSSL_NO_DES 7955714Skrisint main(int argc, char *argv[]) 8055714Skris{ 8155714Skris printf("No DES support\n"); 82296341Sdelphij return (0); 8355714Skris} 8455714Skris#else 85296341Sdelphij# include <openssl/des.h> 8655714Skris 87296341Sdelphij# define crypt(c,s) (DES_crypt((c),(s))) 8855714Skris 8955714Skris/* tisk tisk - the test keys don't all have odd parity :-( */ 9055714Skris/* test data */ 91296341Sdelphij# define NUM_TESTS 34 92296341Sdelphijstatic unsigned char key_data[NUM_TESTS][8] = { 93296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 94296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 95296341Sdelphij {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 96296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 97296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 98296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 99296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 100296341Sdelphij {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}, 101296341Sdelphij {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57}, 102296341Sdelphij {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E}, 103296341Sdelphij {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86}, 104296341Sdelphij {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E}, 105296341Sdelphij {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6}, 106296341Sdelphij {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE}, 107296341Sdelphij {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6}, 108296341Sdelphij {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE}, 109296341Sdelphij {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16}, 110296341Sdelphij {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F}, 111296341Sdelphij {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46}, 112296341Sdelphij {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E}, 113296341Sdelphij {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76}, 114296341Sdelphij {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07}, 115296341Sdelphij {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F}, 116296341Sdelphij {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7}, 117296341Sdelphij {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF}, 118296341Sdelphij {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6}, 119296341Sdelphij {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF}, 120296341Sdelphij {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}, 121296341Sdelphij {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E}, 122296341Sdelphij {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE}, 123296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 124296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 125296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 126296341Sdelphij {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10} 127296341Sdelphij}; 12855714Skris 129296341Sdelphijstatic unsigned char plain_data[NUM_TESTS][8] = { 130296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 131296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 132296341Sdelphij {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 133296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 134296341Sdelphij {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 135296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 136296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 137296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 138296341Sdelphij {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42}, 139296341Sdelphij {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA}, 140296341Sdelphij {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72}, 141296341Sdelphij {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A}, 142296341Sdelphij {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2}, 143296341Sdelphij {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A}, 144296341Sdelphij {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2}, 145296341Sdelphij {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A}, 146296341Sdelphij {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02}, 147296341Sdelphij {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A}, 148296341Sdelphij {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32}, 149296341Sdelphij {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA}, 150296341Sdelphij {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62}, 151296341Sdelphij {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2}, 152296341Sdelphij {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA}, 153296341Sdelphij {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92}, 154296341Sdelphij {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A}, 155296341Sdelphij {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2}, 156296341Sdelphij {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A}, 157296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 158296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 159296341Sdelphij {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 160296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 161296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 162296341Sdelphij {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 163296341Sdelphij {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} 164296341Sdelphij}; 16555714Skris 166296341Sdelphijstatic unsigned char cipher_data[NUM_TESTS][8] = { 167296341Sdelphij {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7}, 168296341Sdelphij {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58}, 169296341Sdelphij {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B}, 170296341Sdelphij {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33}, 171296341Sdelphij {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D}, 172296341Sdelphij {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD}, 173296341Sdelphij {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7}, 174296341Sdelphij {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4}, 175296341Sdelphij {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B}, 176296341Sdelphij {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71}, 177296341Sdelphij {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A}, 178296341Sdelphij {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A}, 179296341Sdelphij {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95}, 180296341Sdelphij {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B}, 181296341Sdelphij {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09}, 182296341Sdelphij {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A}, 183296341Sdelphij {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F}, 184296341Sdelphij {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88}, 185296341Sdelphij {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77}, 186296341Sdelphij {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A}, 187296341Sdelphij {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56}, 188296341Sdelphij {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56}, 189296341Sdelphij {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56}, 190296341Sdelphij {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC}, 191296341Sdelphij {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A}, 192296341Sdelphij {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41}, 193296341Sdelphij {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93}, 194296341Sdelphij {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00}, 195296341Sdelphij {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06}, 196296341Sdelphij {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7}, 197296341Sdelphij {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51}, 198296341Sdelphij {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE}, 199296341Sdelphij {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D}, 200296341Sdelphij {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2} 201296341Sdelphij}; 20255714Skris 203296341Sdelphijstatic unsigned char cipher_ecb2[NUM_TESTS - 1][8] = { 204296341Sdelphij {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E}, 205296341Sdelphij {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16}, 206296341Sdelphij {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27}, 207296341Sdelphij {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6}, 208296341Sdelphij {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25}, 209296341Sdelphij {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A}, 210296341Sdelphij {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74}, 211296341Sdelphij {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6}, 212296341Sdelphij {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67}, 213296341Sdelphij {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10}, 214296341Sdelphij {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85}, 215296341Sdelphij {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA}, 216296341Sdelphij {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3}, 217296341Sdelphij {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3}, 218296341Sdelphij {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A}, 219296341Sdelphij {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69}, 220296341Sdelphij {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1}, 221296341Sdelphij {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7}, 222296341Sdelphij {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F}, 223296341Sdelphij {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87}, 224296341Sdelphij {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A}, 225296341Sdelphij {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE}, 226296341Sdelphij {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3}, 227296341Sdelphij {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD}, 228296341Sdelphij {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84}, 229296341Sdelphij {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85}, 230296341Sdelphij {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC}, 231296341Sdelphij {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89}, 232296341Sdelphij {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E}, 233296341Sdelphij {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89}, 234296341Sdelphij {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7}, 235296341Sdelphij {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8}, 236296341Sdelphij {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85} 237296341Sdelphij}; 23855714Skris 239296341Sdelphijstatic unsigned char cbc_key[8] = 240296341Sdelphij { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }; 241296341Sdelphijstatic unsigned char cbc2_key[8] = 242296341Sdelphij { 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86 }; 243296341Sdelphijstatic unsigned char cbc3_key[8] = 244296341Sdelphij { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }; 245296341Sdelphijstatic unsigned char cbc_iv[8] = 246296341Sdelphij { 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10 }; 247296341Sdelphij/* 248296341Sdelphij * Changed the following text constant to binary so it will work on ebcdic 249296341Sdelphij * machines :-) 250296341Sdelphij */ 25155714Skris/* static char cbc_data[40]="7654321 Now is the time for \0001"; */ 252296341Sdelphijstatic unsigned char cbc_data[40] = { 253296341Sdelphij 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 254296341Sdelphij 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 255296341Sdelphij 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 256296341Sdelphij 0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00, 257296341Sdelphij 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 258296341Sdelphij}; 25955714Skris 260296341Sdelphijstatic unsigned char cbc_ok[32] = { 261296341Sdelphij 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 262296341Sdelphij 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 263296341Sdelphij 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68, 264296341Sdelphij 0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 265296341Sdelphij}; 26655714Skris 267296341Sdelphij# ifdef SCREW_THE_PARITY 268296341Sdelphij# error "SCREW_THE_PARITY is not ment to be defined." 269296341Sdelphij# error "Original vectors are preserved for reference only." 270296341Sdelphijstatic unsigned char cbc2_key[8] = 271296341Sdelphij { 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87 }; 272296341Sdelphijstatic unsigned char xcbc_ok[32] = { 273296341Sdelphij 0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48, 274296341Sdelphij 0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD, 275296341Sdelphij 0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76, 276296341Sdelphij 0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2, 277296341Sdelphij}; 278296341Sdelphij# else 279296341Sdelphijstatic unsigned char xcbc_ok[32] = { 280296341Sdelphij 0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29, 281296341Sdelphij 0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1, 282296341Sdelphij 0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53, 283296341Sdelphij 0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4, 284296341Sdelphij}; 285296341Sdelphij# endif 28655714Skris 287296341Sdelphijstatic unsigned char cbc3_ok[32] = { 288296341Sdelphij 0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0, 289296341Sdelphij 0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC, 290296341Sdelphij 0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4, 291296341Sdelphij 0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75 292296341Sdelphij}; 29355714Skris 294296341Sdelphijstatic unsigned char pcbc_ok[32] = { 295296341Sdelphij 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 296296341Sdelphij 0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15, 297296341Sdelphij 0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f, 298296341Sdelphij 0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88 299296341Sdelphij}; 30055714Skris 301296341Sdelphijstatic unsigned char cfb_key[8] = 302296341Sdelphij { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }; 303296341Sdelphijstatic unsigned char cfb_iv[8] = 304296341Sdelphij { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef }; 305296341Sdelphijstatic unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8]; 306296341Sdelphijstatic unsigned char plain[24] = { 307296341Sdelphij 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 308296341Sdelphij 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 309296341Sdelphij 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f, 310296341Sdelphij 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20 311296341Sdelphij}; 31255714Skris 313296341Sdelphijstatic unsigned char cfb_cipher8[24] = { 314296341Sdelphij 0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8, 315296341Sdelphij 0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87 316296341Sdelphij}; 31755714Skris 318296341Sdelphijstatic unsigned char cfb_cipher16[24] = { 319296341Sdelphij 0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70, 320296341Sdelphij 0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B 321296341Sdelphij}; 32255714Skris 323296341Sdelphijstatic unsigned char cfb_cipher32[24] = { 324296341Sdelphij 0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD, 325296341Sdelphij 0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6 326296341Sdelphij}; 327296341Sdelphij 328296341Sdelphijstatic unsigned char cfb_cipher48[24] = { 329296341Sdelphij 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85, 330296341Sdelphij 0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F 331296341Sdelphij}; 332296341Sdelphij 333296341Sdelphijstatic unsigned char cfb_cipher64[24] = { 334296341Sdelphij 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B, 335296341Sdelphij 0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22 336296341Sdelphij}; 337296341Sdelphij 338296341Sdelphijstatic unsigned char ofb_key[8] = 339296341Sdelphij { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef }; 340296341Sdelphijstatic unsigned char ofb_iv[8] = 341296341Sdelphij { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef }; 342296341Sdelphijstatic unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8]; 343296341Sdelphijstatic unsigned char ofb_cipher[24] = { 344296341Sdelphij 0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51, 345296341Sdelphij 0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f, 346296341Sdelphij 0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3 347296341Sdelphij}; 348296341Sdelphij 349296341Sdelphij# if 0 350296341Sdelphijstatic DES_LONG cbc_cksum_ret = 0xB462FEF7L; 351296341Sdelphij# else 352296341Sdelphijstatic DES_LONG cbc_cksum_ret = 0xF7FE62B4L; 353296341Sdelphij# endif 354296341Sdelphijstatic unsigned char cbc_cksum_data[8] = 355296341Sdelphij { 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4 }; 356296341Sdelphij 35755714Skrisstatic char *pt(unsigned char *p); 35855714Skrisstatic int cfb_test(int bits, unsigned char *cfb_cipher); 35955714Skrisstatic int cfb64_test(unsigned char *cfb_cipher); 36055714Skrisstatic int ede_cfb64_test(unsigned char *cfb_cipher); 36155714Skrisint main(int argc, char *argv[]) 362296341Sdelphij{ 363296341Sdelphij int j, err = 0; 364296341Sdelphij unsigned int i; 365296341Sdelphij des_cblock in, out, outin, iv3, iv2; 366296341Sdelphij des_key_schedule ks, ks2, ks3; 367296341Sdelphij unsigned char cbc_in[40]; 368296341Sdelphij unsigned char cbc_out[40]; 369296341Sdelphij DES_LONG cs; 370296341Sdelphij unsigned char cret[8]; 371296341Sdelphij# ifdef _CRAY 372296341Sdelphij struct { 373296341Sdelphij int a:32; 374296341Sdelphij int b:32; 375296341Sdelphij } lqret[2]; 376296341Sdelphij# else 377296341Sdelphij DES_LONG lqret[4]; 378296341Sdelphij# endif 379296341Sdelphij int num; 380296341Sdelphij char *str; 38155714Skris 382296341Sdelphij# ifndef OPENSSL_NO_DESCBCM 383296341Sdelphij printf("Doing cbcm\n"); 384296341Sdelphij if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) { 385296341Sdelphij printf("Key error %d\n", j); 386296341Sdelphij err = 1; 387296341Sdelphij } 388296341Sdelphij if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) { 389296341Sdelphij printf("Key error %d\n", j); 390296341Sdelphij err = 1; 391296341Sdelphij } 392296341Sdelphij if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) { 393296341Sdelphij printf("Key error %d\n", j); 394296341Sdelphij err = 1; 395296341Sdelphij } 396296341Sdelphij memset(cbc_out, 0, 40); 397296341Sdelphij memset(cbc_in, 0, 40); 398296341Sdelphij i = strlen((char *)cbc_data) + 1; 399296341Sdelphij /* i=((i+7)/8)*8; */ 400296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 401296341Sdelphij memset(iv2, '\0', sizeof iv2); 40255714Skris 403296341Sdelphij DES_ede3_cbcm_encrypt(cbc_data, cbc_out, 16L, &ks, &ks2, &ks3, &iv3, &iv2, 404296341Sdelphij DES_ENCRYPT); 405296341Sdelphij DES_ede3_cbcm_encrypt(&cbc_data[16], &cbc_out[16], i - 16, &ks, &ks2, 406296341Sdelphij &ks3, &iv3, &iv2, DES_ENCRYPT); 407296341Sdelphij/*- if (memcmp(cbc_out,cbc3_ok, 408296341Sdelphij (unsigned int)(strlen((char *)cbc_data)+1+7)/8*8) != 0) 409296341Sdelphij { 410296341Sdelphij printf("des_ede3_cbc_encrypt encrypt error\n"); 411296341Sdelphij err=1; 412296341Sdelphij } 413296341Sdelphij*/ 414296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 415296341Sdelphij memset(iv2, '\0', sizeof iv2); 416296341Sdelphij DES_ede3_cbcm_encrypt(cbc_out, cbc_in, i, &ks, &ks2, &ks3, &iv3, &iv2, 417296341Sdelphij DES_DECRYPT); 418296341Sdelphij if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) { 419296341Sdelphij unsigned int n; 42055714Skris 421296341Sdelphij printf("des_ede3_cbcm_encrypt decrypt error\n"); 422296341Sdelphij for (n = 0; n < i; ++n) 423296341Sdelphij printf(" %02x", cbc_data[n]); 424296341Sdelphij printf("\n"); 425296341Sdelphij for (n = 0; n < i; ++n) 426296341Sdelphij printf(" %02x", cbc_in[n]); 427296341Sdelphij printf("\n"); 428296341Sdelphij err = 1; 429296341Sdelphij } 430296341Sdelphij# endif 43155714Skris 432296341Sdelphij printf("Doing ecb\n"); 433296341Sdelphij for (i = 0; i < NUM_TESTS; i++) { 434296341Sdelphij DES_set_key_unchecked(&key_data[i], &ks); 435296341Sdelphij memcpy(in, plain_data[i], 8); 436296341Sdelphij memset(out, 0, 8); 437296341Sdelphij memset(outin, 0, 8); 438296341Sdelphij des_ecb_encrypt(&in, &out, ks, DES_ENCRYPT); 439296341Sdelphij des_ecb_encrypt(&out, &outin, ks, DES_DECRYPT); 44055714Skris 441296341Sdelphij if (memcmp(out, cipher_data[i], 8) != 0) { 442296341Sdelphij printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n", 443296341Sdelphij i + 1, pt(key_data[i]), pt(in), pt(cipher_data[i]), 444296341Sdelphij pt(out)); 445296341Sdelphij err = 1; 446296341Sdelphij } 447296341Sdelphij if (memcmp(in, outin, 8) != 0) { 448296341Sdelphij printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n", 449296341Sdelphij i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin)); 450296341Sdelphij err = 1; 451296341Sdelphij } 452296341Sdelphij } 45355714Skris 454296341Sdelphij# ifndef LIBDES_LIT 455296341Sdelphij printf("Doing ede ecb\n"); 456296341Sdelphij for (i = 0; i < (NUM_TESTS - 2); i++) { 457296341Sdelphij DES_set_key_unchecked(&key_data[i], &ks); 458296341Sdelphij DES_set_key_unchecked(&key_data[i + 1], &ks2); 459296341Sdelphij DES_set_key_unchecked(&key_data[i + 2], &ks3); 460296341Sdelphij memcpy(in, plain_data[i], 8); 461296341Sdelphij memset(out, 0, 8); 462296341Sdelphij memset(outin, 0, 8); 463296341Sdelphij des_ecb2_encrypt(&in, &out, ks, ks2, DES_ENCRYPT); 464296341Sdelphij des_ecb2_encrypt(&out, &outin, ks, ks2, DES_DECRYPT); 46555714Skris 466296341Sdelphij if (memcmp(out, cipher_ecb2[i], 8) != 0) { 467296341Sdelphij printf("Encryption error %2d\nk=%s p=%s o=%s act=%s\n", 468296341Sdelphij i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]), 469296341Sdelphij pt(out)); 470296341Sdelphij err = 1; 471296341Sdelphij } 472296341Sdelphij if (memcmp(in, outin, 8) != 0) { 473296341Sdelphij printf("Decryption error %2d\nk=%s p=%s o=%s act=%s\n", 474296341Sdelphij i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin)); 475296341Sdelphij err = 1; 476296341Sdelphij } 477296341Sdelphij } 478296341Sdelphij# endif 47955714Skris 480296341Sdelphij printf("Doing cbc\n"); 481296341Sdelphij if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) { 482296341Sdelphij printf("Key error %d\n", j); 483296341Sdelphij err = 1; 484296341Sdelphij } 485296341Sdelphij memset(cbc_out, 0, 40); 486296341Sdelphij memset(cbc_in, 0, 40); 487296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 488296341Sdelphij des_ncbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks, 489296341Sdelphij &iv3, DES_ENCRYPT); 490296341Sdelphij if (memcmp(cbc_out, cbc_ok, 32) != 0) { 491296341Sdelphij printf("cbc_encrypt encrypt error\n"); 492296341Sdelphij err = 1; 493296341Sdelphij } 49455714Skris 495296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 496296341Sdelphij des_ncbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks, 497296341Sdelphij &iv3, DES_DECRYPT); 498296341Sdelphij if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data)) != 0) { 499296341Sdelphij printf("cbc_encrypt decrypt error\n"); 500296341Sdelphij err = 1; 501296341Sdelphij } 502296341Sdelphij# ifndef LIBDES_LIT 503296341Sdelphij printf("Doing desx cbc\n"); 504296341Sdelphij if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) { 505296341Sdelphij printf("Key error %d\n", j); 506296341Sdelphij err = 1; 507296341Sdelphij } 508296341Sdelphij memset(cbc_out, 0, 40); 509296341Sdelphij memset(cbc_in, 0, 40); 510296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 511296341Sdelphij des_xcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks, 512296341Sdelphij &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT); 513296341Sdelphij if (memcmp(cbc_out, xcbc_ok, 32) != 0) { 514296341Sdelphij printf("des_xcbc_encrypt encrypt error\n"); 515296341Sdelphij err = 1; 516296341Sdelphij } 517296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 518296341Sdelphij des_xcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks, 519296341Sdelphij &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT); 520296341Sdelphij if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) { 521296341Sdelphij printf("des_xcbc_encrypt decrypt error\n"); 522296341Sdelphij err = 1; 523296341Sdelphij } 524296341Sdelphij# endif 52555714Skris 526296341Sdelphij printf("Doing ede cbc\n"); 527296341Sdelphij if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) { 528296341Sdelphij printf("Key error %d\n", j); 529296341Sdelphij err = 1; 530296341Sdelphij } 531296341Sdelphij if ((j = DES_set_key_checked(&cbc2_key, &ks2)) != 0) { 532296341Sdelphij printf("Key error %d\n", j); 533296341Sdelphij err = 1; 534296341Sdelphij } 535296341Sdelphij if ((j = DES_set_key_checked(&cbc3_key, &ks3)) != 0) { 536296341Sdelphij printf("Key error %d\n", j); 537296341Sdelphij err = 1; 538296341Sdelphij } 539296341Sdelphij memset(cbc_out, 0, 40); 540296341Sdelphij memset(cbc_in, 0, 40); 541296341Sdelphij i = strlen((char *)cbc_data) + 1; 542296341Sdelphij /* i=((i+7)/8)*8; */ 543296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 54455714Skris 545296341Sdelphij des_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3, 546296341Sdelphij DES_ENCRYPT); 547296341Sdelphij des_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, ks, ks2, 548296341Sdelphij ks3, &iv3, DES_ENCRYPT); 549296341Sdelphij if (memcmp 550296341Sdelphij (cbc_out, cbc3_ok, 551296341Sdelphij (unsigned int)(strlen((char *)cbc_data) + 1 + 7) / 8 * 8) != 0) { 552296341Sdelphij unsigned int n; 55355714Skris 554296341Sdelphij printf("des_ede3_cbc_encrypt encrypt error\n"); 555296341Sdelphij for (n = 0; n < i; ++n) 556296341Sdelphij printf(" %02x", cbc_out[n]); 557296341Sdelphij printf("\n"); 558296341Sdelphij for (n = 0; n < i; ++n) 559296341Sdelphij printf(" %02x", cbc3_ok[n]); 560296341Sdelphij printf("\n"); 561296341Sdelphij err = 1; 562296341Sdelphij } 563109998Smarkm 564296341Sdelphij memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 565296341Sdelphij des_ede3_cbc_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, DES_DECRYPT); 566296341Sdelphij if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) { 567296341Sdelphij unsigned int n; 56855714Skris 569296341Sdelphij printf("des_ede3_cbc_encrypt decrypt error\n"); 570296341Sdelphij for (n = 0; n < i; ++n) 571296341Sdelphij printf(" %02x", cbc_data[n]); 572296341Sdelphij printf("\n"); 573296341Sdelphij for (n = 0; n < i; ++n) 574296341Sdelphij printf(" %02x", cbc_in[n]); 575296341Sdelphij printf("\n"); 576296341Sdelphij err = 1; 577296341Sdelphij } 578296341Sdelphij# ifndef LIBDES_LIT 579296341Sdelphij printf("Doing pcbc\n"); 580296341Sdelphij if ((j = DES_set_key_checked(&cbc_key, &ks)) != 0) { 581296341Sdelphij printf("Key error %d\n", j); 582296341Sdelphij err = 1; 583296341Sdelphij } 584296341Sdelphij memset(cbc_out, 0, 40); 585296341Sdelphij memset(cbc_in, 0, 40); 586296341Sdelphij des_pcbc_encrypt(cbc_data, cbc_out, strlen((char *)cbc_data) + 1, ks, 587296341Sdelphij &cbc_iv, DES_ENCRYPT); 588296341Sdelphij if (memcmp(cbc_out, pcbc_ok, 32) != 0) { 589296341Sdelphij printf("pcbc_encrypt encrypt error\n"); 590296341Sdelphij err = 1; 591296341Sdelphij } 592296341Sdelphij des_pcbc_encrypt(cbc_out, cbc_in, strlen((char *)cbc_data) + 1, ks, 593296341Sdelphij &cbc_iv, DES_DECRYPT); 594296341Sdelphij if (memcmp(cbc_in, cbc_data, strlen((char *)cbc_data) + 1) != 0) { 595296341Sdelphij printf("pcbc_encrypt decrypt error\n"); 596296341Sdelphij err = 1; 597296341Sdelphij } 598109998Smarkm 599296341Sdelphij printf("Doing "); 600296341Sdelphij printf("cfb8 "); 601296341Sdelphij err += cfb_test(8, cfb_cipher8); 602296341Sdelphij printf("cfb16 "); 603296341Sdelphij err += cfb_test(16, cfb_cipher16); 604296341Sdelphij printf("cfb32 "); 605296341Sdelphij err += cfb_test(32, cfb_cipher32); 606296341Sdelphij printf("cfb48 "); 607296341Sdelphij err += cfb_test(48, cfb_cipher48); 608296341Sdelphij printf("cfb64 "); 609296341Sdelphij err += cfb_test(64, cfb_cipher64); 61055714Skris 611296341Sdelphij printf("cfb64() "); 612296341Sdelphij err += cfb64_test(cfb_cipher64); 61355714Skris 614296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 615296341Sdelphij for (i = 0; i < sizeof(plain); i++) 616296341Sdelphij des_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]), 617296341Sdelphij 8, 1, ks, &cfb_tmp, DES_ENCRYPT); 618296341Sdelphij if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) { 619296341Sdelphij printf("cfb_encrypt small encrypt error\n"); 620296341Sdelphij err = 1; 621296341Sdelphij } 62255714Skris 623296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 624296341Sdelphij for (i = 0; i < sizeof(plain); i++) 625296341Sdelphij des_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]), 626296341Sdelphij 8, 1, ks, &cfb_tmp, DES_DECRYPT); 627296341Sdelphij if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) { 628296341Sdelphij printf("cfb_encrypt small decrypt error\n"); 629296341Sdelphij err = 1; 630296341Sdelphij } 63155714Skris 632296341Sdelphij printf("ede_cfb64() "); 633296341Sdelphij err += ede_cfb64_test(cfb_cipher64); 63455714Skris 635296341Sdelphij printf("done\n"); 63655714Skris 637296341Sdelphij printf("Doing ofb\n"); 638296341Sdelphij DES_set_key_checked(&ofb_key, &ks); 639296341Sdelphij memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 640296341Sdelphij des_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, ks, &ofb_tmp); 641296341Sdelphij if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) { 642296341Sdelphij printf("ofb_encrypt encrypt error\n"); 643296341Sdelphij printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", 644296341Sdelphij ofb_buf1[8 + 0], ofb_buf1[8 + 1], ofb_buf1[8 + 2], 645296341Sdelphij ofb_buf1[8 + 3], ofb_buf1[8 + 4], ofb_buf1[8 + 5], 646296341Sdelphij ofb_buf1[8 + 6], ofb_buf1[8 + 7]); 647296341Sdelphij printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", ofb_buf1[8 + 0], 648296341Sdelphij ofb_cipher[8 + 1], ofb_cipher[8 + 2], ofb_cipher[8 + 3], 649296341Sdelphij ofb_buf1[8 + 4], ofb_cipher[8 + 5], ofb_cipher[8 + 6], 650296341Sdelphij ofb_cipher[8 + 7]); 651296341Sdelphij err = 1; 652296341Sdelphij } 653296341Sdelphij memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 654296341Sdelphij des_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, ks, 655296341Sdelphij &ofb_tmp); 656296341Sdelphij if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) { 657296341Sdelphij printf("ofb_encrypt decrypt error\n"); 658296341Sdelphij printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", 659296341Sdelphij ofb_buf2[8 + 0], ofb_buf2[8 + 1], ofb_buf2[8 + 2], 660296341Sdelphij ofb_buf2[8 + 3], ofb_buf2[8 + 4], ofb_buf2[8 + 5], 661296341Sdelphij ofb_buf2[8 + 6], ofb_buf2[8 + 7]); 662296341Sdelphij printf("%02X %02X %02X %02X %02X %02X %02X %02X\n", plain[8 + 0], 663296341Sdelphij plain[8 + 1], plain[8 + 2], plain[8 + 3], plain[8 + 4], 664296341Sdelphij plain[8 + 5], plain[8 + 6], plain[8 + 7]); 665296341Sdelphij err = 1; 666296341Sdelphij } 66755714Skris 668296341Sdelphij printf("Doing ofb64\n"); 669296341Sdelphij DES_set_key_checked(&ofb_key, &ks); 670296341Sdelphij memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 671296341Sdelphij memset(ofb_buf1, 0, sizeof(ofb_buf1)); 672296341Sdelphij memset(ofb_buf2, 0, sizeof(ofb_buf1)); 673296341Sdelphij num = 0; 674296341Sdelphij for (i = 0; i < sizeof(plain); i++) { 675296341Sdelphij des_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, &ofb_tmp, &num); 676296341Sdelphij } 677296341Sdelphij if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) { 678296341Sdelphij printf("ofb64_encrypt encrypt error\n"); 679296341Sdelphij err = 1; 680296341Sdelphij } 681296341Sdelphij memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 682296341Sdelphij num = 0; 683296341Sdelphij des_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, &ofb_tmp, 684296341Sdelphij &num); 685296341Sdelphij if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) { 686296341Sdelphij printf("ofb64_encrypt decrypt error\n"); 687296341Sdelphij err = 1; 688296341Sdelphij } 68955714Skris 690296341Sdelphij printf("Doing ede_ofb64\n"); 691296341Sdelphij DES_set_key_checked(&ofb_key, &ks); 692296341Sdelphij memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 693296341Sdelphij memset(ofb_buf1, 0, sizeof(ofb_buf1)); 694296341Sdelphij memset(ofb_buf2, 0, sizeof(ofb_buf1)); 695296341Sdelphij num = 0; 696296341Sdelphij for (i = 0; i < sizeof(plain); i++) { 697296341Sdelphij des_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, ks, 698296341Sdelphij ks, &ofb_tmp, &num); 699296341Sdelphij } 700296341Sdelphij if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) { 701296341Sdelphij printf("ede_ofb64_encrypt encrypt error\n"); 702296341Sdelphij err = 1; 703296341Sdelphij } 704296341Sdelphij memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 705296341Sdelphij num = 0; 706296341Sdelphij des_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, ks, ks, 707296341Sdelphij &ofb_tmp, &num); 708296341Sdelphij if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) { 709296341Sdelphij printf("ede_ofb64_encrypt decrypt error\n"); 710296341Sdelphij err = 1; 711296341Sdelphij } 71255714Skris 713296341Sdelphij printf("Doing cbc_cksum\n"); 714296341Sdelphij DES_set_key_checked(&cbc_key, &ks); 715296341Sdelphij cs = des_cbc_cksum(cbc_data, &cret, strlen((char *)cbc_data), ks, 716296341Sdelphij &cbc_iv); 717296341Sdelphij if (cs != cbc_cksum_ret) { 718296341Sdelphij printf("bad return value (%08lX), should be %08lX\n", 719296341Sdelphij (unsigned long)cs, (unsigned long)cbc_cksum_ret); 720296341Sdelphij err = 1; 721296341Sdelphij } 722296341Sdelphij if (memcmp(cret, cbc_cksum_data, 8) != 0) { 723296341Sdelphij printf("bad cbc_cksum block returned\n"); 724296341Sdelphij err = 1; 725296341Sdelphij } 72655714Skris 727296341Sdelphij printf("Doing quad_cksum\n"); 728296341Sdelphij cs = des_quad_cksum(cbc_data, (des_cblock *)lqret, 729296341Sdelphij (long)strlen((char *)cbc_data), 2, 730296341Sdelphij (des_cblock *)cbc_iv); 731296341Sdelphij if (cs != 0x70d7a63aL) { 732296341Sdelphij printf("quad_cksum error, ret %08lx should be 70d7a63a\n", 733296341Sdelphij (unsigned long)cs); 734296341Sdelphij err = 1; 735296341Sdelphij } 736296341Sdelphij# ifdef _CRAY 737296341Sdelphij if (lqret[0].a != 0x327eba8dL) { 738296341Sdelphij printf("quad_cksum error, out[0] %08lx is not %08lx\n", 739296341Sdelphij (unsigned long)lqret[0].a, 0x327eba8dUL); 740296341Sdelphij err = 1; 741296341Sdelphij } 742296341Sdelphij if (lqret[0].b != 0x201a49ccL) { 743296341Sdelphij printf("quad_cksum error, out[1] %08lx is not %08lx\n", 744296341Sdelphij (unsigned long)lqret[0].b, 0x201a49ccUL); 745296341Sdelphij err = 1; 746296341Sdelphij } 747296341Sdelphij if (lqret[1].a != 0x70d7a63aL) { 748296341Sdelphij printf("quad_cksum error, out[2] %08lx is not %08lx\n", 749296341Sdelphij (unsigned long)lqret[1].a, 0x70d7a63aUL); 750296341Sdelphij err = 1; 751296341Sdelphij } 752296341Sdelphij if (lqret[1].b != 0x501c2c26L) { 753296341Sdelphij printf("quad_cksum error, out[3] %08lx is not %08lx\n", 754296341Sdelphij (unsigned long)lqret[1].b, 0x501c2c26UL); 755296341Sdelphij err = 1; 756296341Sdelphij } 757296341Sdelphij# else 758296341Sdelphij if (lqret[0] != 0x327eba8dL) { 759296341Sdelphij printf("quad_cksum error, out[0] %08lx is not %08lx\n", 760296341Sdelphij (unsigned long)lqret[0], 0x327eba8dUL); 761296341Sdelphij err = 1; 762296341Sdelphij } 763296341Sdelphij if (lqret[1] != 0x201a49ccL) { 764296341Sdelphij printf("quad_cksum error, out[1] %08lx is not %08lx\n", 765296341Sdelphij (unsigned long)lqret[1], 0x201a49ccUL); 766296341Sdelphij err = 1; 767296341Sdelphij } 768296341Sdelphij if (lqret[2] != 0x70d7a63aL) { 769296341Sdelphij printf("quad_cksum error, out[2] %08lx is not %08lx\n", 770296341Sdelphij (unsigned long)lqret[2], 0x70d7a63aUL); 771296341Sdelphij err = 1; 772296341Sdelphij } 773296341Sdelphij if (lqret[3] != 0x501c2c26L) { 774296341Sdelphij printf("quad_cksum error, out[3] %08lx is not %08lx\n", 775296341Sdelphij (unsigned long)lqret[3], 0x501c2c26UL); 776296341Sdelphij err = 1; 777296341Sdelphij } 778296341Sdelphij# endif 779296341Sdelphij# endif 78055714Skris 781296341Sdelphij printf("input word alignment test"); 782296341Sdelphij for (i = 0; i < 4; i++) { 783296341Sdelphij printf(" %d", i); 784296341Sdelphij des_ncbc_encrypt(&(cbc_out[i]), cbc_in, 785296341Sdelphij strlen((char *)cbc_data) + 1, ks, 786296341Sdelphij &cbc_iv, DES_ENCRYPT); 787296341Sdelphij } 788296341Sdelphij printf("\noutput word alignment test"); 789296341Sdelphij for (i = 0; i < 4; i++) { 790296341Sdelphij printf(" %d", i); 791296341Sdelphij des_ncbc_encrypt(cbc_out, &(cbc_in[i]), 792296341Sdelphij strlen((char *)cbc_data) + 1, ks, 793296341Sdelphij &cbc_iv, DES_ENCRYPT); 794296341Sdelphij } 795296341Sdelphij printf("\n"); 796296341Sdelphij printf("fast crypt test "); 797296341Sdelphij str = crypt("testing", "ef"); 798296341Sdelphij if (strcmp("efGnQx2725bI2", str) != 0) { 799296341Sdelphij printf("fast crypt error, %s should be efGnQx2725bI2\n", str); 800296341Sdelphij err = 1; 801296341Sdelphij } 802296341Sdelphij str = crypt("bca76;23", "yA"); 803296341Sdelphij if (strcmp("yA1Rp/1hZXIJk", str) != 0) { 804296341Sdelphij printf("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str); 805296341Sdelphij err = 1; 806296341Sdelphij } 807296341Sdelphij# ifdef OPENSSL_SYS_NETWARE 808296341Sdelphij if (err) 809296341Sdelphij printf("ERROR: %d\n", err); 810296341Sdelphij# endif 811296341Sdelphij printf("\n"); 812296341Sdelphij return (err); 813296341Sdelphij} 81455714Skris 81555714Skrisstatic char *pt(unsigned char *p) 816296341Sdelphij{ 817296341Sdelphij static char bufs[10][20]; 818296341Sdelphij static int bnum = 0; 819296341Sdelphij char *ret; 820296341Sdelphij int i; 821296341Sdelphij static char *f = "0123456789ABCDEF"; 82255714Skris 823296341Sdelphij ret = &(bufs[bnum++][0]); 824296341Sdelphij bnum %= 10; 825296341Sdelphij for (i = 0; i < 8; i++) { 826296341Sdelphij ret[i * 2] = f[(p[i] >> 4) & 0xf]; 827296341Sdelphij ret[i * 2 + 1] = f[p[i] & 0xf]; 828296341Sdelphij } 829296341Sdelphij ret[16] = '\0'; 830296341Sdelphij return (ret); 831296341Sdelphij} 83255714Skris 833296341Sdelphij# ifndef LIBDES_LIT 83455714Skris 83555714Skrisstatic int cfb_test(int bits, unsigned char *cfb_cipher) 836296341Sdelphij{ 837296341Sdelphij des_key_schedule ks; 838296341Sdelphij int i, err = 0; 83955714Skris 840296341Sdelphij DES_set_key_checked(&cfb_key, &ks); 841296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 842296341Sdelphij des_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), ks, &cfb_tmp, 843296341Sdelphij DES_ENCRYPT); 844296341Sdelphij if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) { 845296341Sdelphij err = 1; 846296341Sdelphij printf("cfb_encrypt encrypt error\n"); 847296341Sdelphij for (i = 0; i < 24; i += 8) 848296341Sdelphij printf("%s\n", pt(&(cfb_buf1[i]))); 849296341Sdelphij } 850296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 851296341Sdelphij des_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), ks, &cfb_tmp, 852296341Sdelphij DES_DECRYPT); 853296341Sdelphij if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) { 854296341Sdelphij err = 1; 855296341Sdelphij printf("cfb_encrypt decrypt error\n"); 856296341Sdelphij for (i = 0; i < 24; i += 8) 857296341Sdelphij printf("%s\n", pt(&(cfb_buf1[i]))); 858296341Sdelphij } 859296341Sdelphij return (err); 860296341Sdelphij} 86155714Skris 86255714Skrisstatic int cfb64_test(unsigned char *cfb_cipher) 863296341Sdelphij{ 864296341Sdelphij des_key_schedule ks; 865296341Sdelphij int err = 0, i, n; 86655714Skris 867296341Sdelphij DES_set_key_checked(&cfb_key, &ks); 868296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 869296341Sdelphij n = 0; 870296341Sdelphij des_cfb64_encrypt(plain, cfb_buf1, 12, ks, &cfb_tmp, &n, DES_ENCRYPT); 871296341Sdelphij des_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, ks, 872296341Sdelphij &cfb_tmp, &n, DES_ENCRYPT); 873296341Sdelphij if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) { 874296341Sdelphij err = 1; 875296341Sdelphij printf("cfb_encrypt encrypt error\n"); 876296341Sdelphij for (i = 0; i < 24; i += 8) 877296341Sdelphij printf("%s\n", pt(&(cfb_buf1[i]))); 878296341Sdelphij } 879296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 880296341Sdelphij n = 0; 881296341Sdelphij des_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, ks, &cfb_tmp, &n, DES_DECRYPT); 882296341Sdelphij des_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]), 883296341Sdelphij sizeof(plain) - 17, ks, &cfb_tmp, &n, DES_DECRYPT); 884296341Sdelphij if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) { 885296341Sdelphij err = 1; 886296341Sdelphij printf("cfb_encrypt decrypt error\n"); 887296341Sdelphij for (i = 0; i < 24; i += 8) 888296341Sdelphij printf("%s\n", pt(&(cfb_buf2[i]))); 889296341Sdelphij } 890296341Sdelphij return (err); 891296341Sdelphij} 89255714Skris 89355714Skrisstatic int ede_cfb64_test(unsigned char *cfb_cipher) 894296341Sdelphij{ 895296341Sdelphij des_key_schedule ks; 896296341Sdelphij int err = 0, i, n; 89755714Skris 898296341Sdelphij DES_set_key_checked(&cfb_key, &ks); 899296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 900296341Sdelphij n = 0; 901296341Sdelphij des_ede3_cfb64_encrypt(plain, cfb_buf1, 12, ks, ks, ks, &cfb_tmp, &n, 902296341Sdelphij DES_ENCRYPT); 903296341Sdelphij des_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), 904296341Sdelphij sizeof(plain) - 12, ks, ks, ks, 905296341Sdelphij &cfb_tmp, &n, DES_ENCRYPT); 906296341Sdelphij if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) { 907296341Sdelphij err = 1; 908296341Sdelphij printf("ede_cfb_encrypt encrypt error\n"); 909296341Sdelphij for (i = 0; i < 24; i += 8) 910296341Sdelphij printf("%s\n", pt(&(cfb_buf1[i]))); 911296341Sdelphij } 912296341Sdelphij memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 913296341Sdelphij n = 0; 914296341Sdelphij des_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long)17, ks, ks, ks, 915296341Sdelphij &cfb_tmp, &n, DES_DECRYPT); 916296341Sdelphij des_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]), 917296341Sdelphij sizeof(plain) - 17, ks, ks, ks, 918296341Sdelphij &cfb_tmp, &n, DES_DECRYPT); 919296341Sdelphij if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) { 920296341Sdelphij err = 1; 921296341Sdelphij printf("ede_cfb_encrypt decrypt error\n"); 922296341Sdelphij for (i = 0; i < 24; i += 8) 923296341Sdelphij printf("%s\n", pt(&(cfb_buf2[i]))); 924296341Sdelphij } 925296341Sdelphij return (err); 926296341Sdelphij} 92755714Skris 928296341Sdelphij# endif 92955714Skris#endif 930