1/* $NetBSD: t_des.c,v 1.1 2010/08/25 16:46:36 jmmv Exp $ */ 2 3/* 4 * Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) All rights 5 * reserved. 6 * 7 * This package is an SSL implementation written by Eric Young 8 * (eay@cryptsoft.com). The implementation was written so as to conform with 9 * Netscapes SSL. 10 * 11 * This library is free for commercial and non-commercial use as long as the 12 * following conditions are aheared to. The following conditions apply to 13 * all code found in this distribution, be it the RC4, RSA, lhash, DES, etc., 14 * code; not just the SSL code. The SSL documentation included with this 15 * distribution is covered by the same copyright terms except that the holder 16 * is Tim Hudson (tjh@cryptsoft.com). 17 * 18 * Copyright remains Eric Young's, and as such any Copyright notices in the code 19 * are not to be removed. If this package is used in a product, Eric Young 20 * should be given attribution as the author of the parts of the library 21 * used. This can be in the form of a textual message at program startup or 22 * in documentation (online or textual) provided with the package. 23 * 24 * Redistribution and use in source and binary forms, with or without 25 * modification, are permitted provided that the following conditions are 26 * met: 1. Redistributions of source code must retain the copyright notice, 27 * this list of conditions and the following disclaimer. 2. Redistributions 28 * in binary form must reproduce the above copyright notice, this list of 29 * conditions and the following disclaimer in the documentation and/or other 30 * materials provided with the distribution. 3. All advertising materials 31 * mentioning features or use of this software must display the following 32 * acknowledgement: "This product includes cryptographic software written by 33 * Eric Young (eay@cryptsoft.com)" The word 'cryptographic' can be left out 34 * if the rouines from the library being used are not cryptographic related 35 * :-). 4. If you include any Windows specific code (or a derivative thereof) 36 * from the apps directory (application code) you must include an 37 * acknowledgement: "This product includes software written by Tim Hudson 38 * (tjh@cryptsoft.com)" 39 * 40 * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND ANY EXPRESS OR IMPLIED 41 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 42 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN 43 * NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 44 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 45 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 46 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER 47 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 48 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 49 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 50 * SUCH DAMAGE. 51 * 52 * The licence and distribution terms for any publically available version or 53 * derivative of this code cannot be changed. i.e. this code cannot simply 54 * be copied and put under another distribution licence [including the GNU 55 * Public Licence.] 56 */ 57 58#include <atf-c.h> 59#include <des.h> 60#include <stdio.h> 61#include <stdlib.h> 62#include <string.h> 63#include <unistd.h> 64 65#define crypt(c,s) (des_crypt((c),(s))) 66 67/* tisk tisk - the test keys don't all have odd parity :-( */ 68/* test data */ 69#define NUM_TESTS 34 70static unsigned char key_data[NUM_TESTS][8] = { 71 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 72 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 73 {0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 74 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 75 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 76 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 77 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 78 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10}, 79 {0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57}, 80 {0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E}, 81 {0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86}, 82 {0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E}, 83 {0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6}, 84 {0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE}, 85 {0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6}, 86 {0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE}, 87 {0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16}, 88 {0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F}, 89 {0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46}, 90 {0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E}, 91 {0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76}, 92 {0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07}, 93 {0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F}, 94 {0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7}, 95 {0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF}, 96 {0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6}, 97 {0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF}, 98 {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01}, 99 {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E}, 100 {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE}, 101 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 102 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 103 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 104 {0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10} 105}; 106 107static unsigned char plain_data[NUM_TESTS][8] = { 108 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 109 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 110 {0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}, 111 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 112 {0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11}, 113 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 114 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 115 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 116 {0x01, 0xA1, 0xD6, 0xD0, 0x39, 0x77, 0x67, 0x42}, 117 {0x5C, 0xD5, 0x4C, 0xA8, 0x3D, 0xEF, 0x57, 0xDA}, 118 {0x02, 0x48, 0xD4, 0x38, 0x06, 0xF6, 0x71, 0x72}, 119 {0x51, 0x45, 0x4B, 0x58, 0x2D, 0xDF, 0x44, 0x0A}, 120 {0x42, 0xFD, 0x44, 0x30, 0x59, 0x57, 0x7F, 0xA2}, 121 {0x05, 0x9B, 0x5E, 0x08, 0x51, 0xCF, 0x14, 0x3A}, 122 {0x07, 0x56, 0xD8, 0xE0, 0x77, 0x47, 0x61, 0xD2}, 123 {0x76, 0x25, 0x14, 0xB8, 0x29, 0xBF, 0x48, 0x6A}, 124 {0x3B, 0xDD, 0x11, 0x90, 0x49, 0x37, 0x28, 0x02}, 125 {0x26, 0x95, 0x5F, 0x68, 0x35, 0xAF, 0x60, 0x9A}, 126 {0x16, 0x4D, 0x5E, 0x40, 0x4F, 0x27, 0x52, 0x32}, 127 {0x6B, 0x05, 0x6E, 0x18, 0x75, 0x9F, 0x5C, 0xCA}, 128 {0x00, 0x4B, 0xD6, 0xEF, 0x09, 0x17, 0x60, 0x62}, 129 {0x48, 0x0D, 0x39, 0x00, 0x6E, 0xE7, 0x62, 0xF2}, 130 {0x43, 0x75, 0x40, 0xC8, 0x69, 0x8F, 0x3C, 0xFA}, 131 {0x07, 0x2D, 0x43, 0xA0, 0x77, 0x07, 0x52, 0x92}, 132 {0x02, 0xFE, 0x55, 0x77, 0x81, 0x17, 0xF1, 0x2A}, 133 {0x1D, 0x9D, 0x5C, 0x50, 0x18, 0xF7, 0x28, 0xC2}, 134 {0x30, 0x55, 0x32, 0x28, 0x6D, 0x6F, 0x29, 0x5A}, 135 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 136 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 137 {0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF}, 138 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}, 139 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 140 {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, 141 {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF} 142}; 143 144static unsigned char cipher_data[NUM_TESTS][8] = { 145 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7}, 146 {0x73, 0x59, 0xB2, 0x16, 0x3E, 0x4E, 0xDC, 0x58}, 147 {0x95, 0x8E, 0x6E, 0x62, 0x7A, 0x05, 0x55, 0x7B}, 148 {0xF4, 0x03, 0x79, 0xAB, 0x9E, 0x0E, 0xC5, 0x33}, 149 {0x17, 0x66, 0x8D, 0xFC, 0x72, 0x92, 0x53, 0x2D}, 150 {0x8A, 0x5A, 0xE1, 0xF8, 0x1A, 0xB8, 0xF2, 0xDD}, 151 {0x8C, 0xA6, 0x4D, 0xE9, 0xC1, 0xB1, 0x23, 0xA7}, 152 {0xED, 0x39, 0xD9, 0x50, 0xFA, 0x74, 0xBC, 0xC4}, 153 {0x69, 0x0F, 0x5B, 0x0D, 0x9A, 0x26, 0x93, 0x9B}, 154 {0x7A, 0x38, 0x9D, 0x10, 0x35, 0x4B, 0xD2, 0x71}, 155 {0x86, 0x8E, 0xBB, 0x51, 0xCA, 0xB4, 0x59, 0x9A}, 156 {0x71, 0x78, 0x87, 0x6E, 0x01, 0xF1, 0x9B, 0x2A}, 157 {0xAF, 0x37, 0xFB, 0x42, 0x1F, 0x8C, 0x40, 0x95}, 158 {0x86, 0xA5, 0x60, 0xF1, 0x0E, 0xC6, 0xD8, 0x5B}, 159 {0x0C, 0xD3, 0xDA, 0x02, 0x00, 0x21, 0xDC, 0x09}, 160 {0xEA, 0x67, 0x6B, 0x2C, 0xB7, 0xDB, 0x2B, 0x7A}, 161 {0xDF, 0xD6, 0x4A, 0x81, 0x5C, 0xAF, 0x1A, 0x0F}, 162 {0x5C, 0x51, 0x3C, 0x9C, 0x48, 0x86, 0xC0, 0x88}, 163 {0x0A, 0x2A, 0xEE, 0xAE, 0x3F, 0xF4, 0xAB, 0x77}, 164 {0xEF, 0x1B, 0xF0, 0x3E, 0x5D, 0xFA, 0x57, 0x5A}, 165 {0x88, 0xBF, 0x0D, 0xB6, 0xD7, 0x0D, 0xEE, 0x56}, 166 {0xA1, 0xF9, 0x91, 0x55, 0x41, 0x02, 0x0B, 0x56}, 167 {0x6F, 0xBF, 0x1C, 0xAF, 0xCF, 0xFD, 0x05, 0x56}, 168 {0x2F, 0x22, 0xE4, 0x9B, 0xAB, 0x7C, 0xA1, 0xAC}, 169 {0x5A, 0x6B, 0x61, 0x2C, 0xC2, 0x6C, 0xCE, 0x4A}, 170 {0x5F, 0x4C, 0x03, 0x8E, 0xD1, 0x2B, 0x2E, 0x41}, 171 {0x63, 0xFA, 0xC0, 0xD0, 0x34, 0xD9, 0xF7, 0x93}, 172 {0x61, 0x7B, 0x3A, 0x0C, 0xE8, 0xF0, 0x71, 0x00}, 173 {0xDB, 0x95, 0x86, 0x05, 0xF8, 0xC8, 0xC6, 0x06}, 174 {0xED, 0xBF, 0xD1, 0xC6, 0x6C, 0x29, 0xCC, 0xC7}, 175 {0x35, 0x55, 0x50, 0xB2, 0x15, 0x0E, 0x24, 0x51}, 176 {0xCA, 0xAA, 0xAF, 0x4D, 0xEA, 0xF1, 0xDB, 0xAE}, 177 {0xD5, 0xD4, 0x4F, 0xF7, 0x20, 0x68, 0x3D, 0x0D}, 178 {0x2A, 0x2B, 0xB0, 0x08, 0xDF, 0x97, 0xC2, 0xF2} 179}; 180 181static unsigned char cipher_ecb2[NUM_TESTS - 1][8] = { 182 {0x92, 0x95, 0xB5, 0x9B, 0xB3, 0x84, 0x73, 0x6E}, 183 {0x19, 0x9E, 0x9D, 0x6D, 0xF3, 0x9A, 0xA8, 0x16}, 184 {0x2A, 0x4B, 0x4D, 0x24, 0x52, 0x43, 0x84, 0x27}, 185 {0x35, 0x84, 0x3C, 0x01, 0x9D, 0x18, 0xC5, 0xB6}, 186 {0x4A, 0x5B, 0x2F, 0x42, 0xAA, 0x77, 0x19, 0x25}, 187 {0xA0, 0x6B, 0xA9, 0xB8, 0xCA, 0x5B, 0x17, 0x8A}, 188 {0xAB, 0x9D, 0xB7, 0xFB, 0xED, 0x95, 0xF2, 0x74}, 189 {0x3D, 0x25, 0x6C, 0x23, 0xA7, 0x25, 0x2F, 0xD6}, 190 {0xB7, 0x6F, 0xAB, 0x4F, 0xBD, 0xBD, 0xB7, 0x67}, 191 {0x8F, 0x68, 0x27, 0xD6, 0x9C, 0xF4, 0x1A, 0x10}, 192 {0x82, 0x57, 0xA1, 0xD6, 0x50, 0x5E, 0x81, 0x85}, 193 {0xA2, 0x0F, 0x0A, 0xCD, 0x80, 0x89, 0x7D, 0xFA}, 194 {0xCD, 0x2A, 0x53, 0x3A, 0xDB, 0x0D, 0x7E, 0xF3}, 195 {0xD2, 0xC2, 0xBE, 0x27, 0xE8, 0x1B, 0x68, 0xE3}, 196 {0xE9, 0x24, 0xCF, 0x4F, 0x89, 0x3C, 0x5B, 0x0A}, 197 {0xA7, 0x18, 0xC3, 0x9F, 0xFA, 0x9F, 0xD7, 0x69}, 198 {0x77, 0x2C, 0x79, 0xB1, 0xD2, 0x31, 0x7E, 0xB1}, 199 {0x49, 0xAB, 0x92, 0x7F, 0xD0, 0x22, 0x00, 0xB7}, 200 {0xCE, 0x1C, 0x6C, 0x7D, 0x85, 0xE3, 0x4A, 0x6F}, 201 {0xBE, 0x91, 0xD6, 0xE1, 0x27, 0xB2, 0xE9, 0x87}, 202 {0x70, 0x28, 0xAE, 0x8F, 0xD1, 0xF5, 0x74, 0x1A}, 203 {0xAA, 0x37, 0x80, 0xBB, 0xF3, 0x22, 0x1D, 0xDE}, 204 {0xA6, 0xC4, 0xD2, 0x5E, 0x28, 0x93, 0xAC, 0xB3}, 205 {0x22, 0x07, 0x81, 0x5A, 0xE4, 0xB7, 0x1A, 0xAD}, 206 {0xDC, 0xCE, 0x05, 0xE7, 0x07, 0xBD, 0xF5, 0x84}, 207 {0x26, 0x1D, 0x39, 0x2C, 0xB3, 0xBA, 0xA5, 0x85}, 208 {0xB4, 0xF7, 0x0F, 0x72, 0xFB, 0x04, 0xF0, 0xDC}, 209 {0x95, 0xBA, 0xA9, 0x4E, 0x87, 0x36, 0xF2, 0x89}, 210 {0xD4, 0x07, 0x3A, 0xF1, 0x5A, 0x17, 0x82, 0x0E}, 211 {0xEF, 0x6F, 0xAF, 0xA7, 0x66, 0x1A, 0x7E, 0x89}, 212 {0xC1, 0x97, 0xF5, 0x58, 0x74, 0x8A, 0x20, 0xE7}, 213 {0x43, 0x34, 0xCF, 0xDA, 0x22, 0xC4, 0x86, 0xC8}, 214 {0x08, 0xD7, 0xB4, 0xFB, 0x62, 0x9D, 0x08, 0x85} 215}; 216 217static unsigned char cbc_key[8] = { 218 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 219}; 220static unsigned char cbc2_key[8] = { 221 0xf1, 0xe0, 0xd3, 0xc2, 0xb5, 0xa4, 0x97, 0x86, 222}; 223static unsigned char cbc3_key[8] = { 224 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 225}; 226static unsigned char cbc_iv[8] = { 227 0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10, 228}; 229/* 230 * Changed the following text constant to binary so it will work on ebcdic 231 * machines :-) 232 */ 233/* static char cbc_data[40]="7654321 Now is the time for \0001"; */ 234static unsigned char cbc_data[40] = { 235 0x37, 0x36, 0x35, 0x34, 0x33, 0x32, 0x31, 0x20, 236 0x4E, 0x6F, 0x77, 0x20, 0x69, 0x73, 0x20, 0x74, 237 0x68, 0x65, 0x20, 0x74, 0x69, 0x6D, 0x65, 0x20, 238 0x66, 0x6F, 0x72, 0x20, 0x00, 0x31, 0x00, 0x00, 239 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 240}; 241 242static unsigned char cbc_ok[32] = { 243 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 244 0xac, 0xd8, 0xae, 0xfd, 0xdf, 0xd8, 0xa1, 0xeb, 245 0x46, 0x8e, 0x91, 0x15, 0x78, 0x88, 0xba, 0x68, 246 0x1d, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4, 247}; 248 249#ifdef SCREW_THE_PARITY 250#error "SCREW_THE_PARITY is not ment to be defined." 251#error "Original vectors are preserved for reference only." 252static unsigned char cbc2_key[8] = { 253 0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87, 254}; 255static unsigned char xcbc_ok[32] = { 256 0x86, 0x74, 0x81, 0x0D, 0x61, 0xA4, 0xA5, 0x48, 257 0xB9, 0x93, 0x03, 0xE1, 0xB8, 0xBB, 0xBD, 0xBD, 258 0x64, 0x30, 0x0B, 0xB9, 0x06, 0x65, 0x81, 0x76, 259 0x04, 0x1D, 0x77, 0x62, 0x17, 0xCA, 0x2B, 0xD2, 260}; 261#else 262static unsigned char xcbc_ok[32] = { 263 0x84, 0x6B, 0x29, 0x14, 0x85, 0x1E, 0x9A, 0x29, 264 0x54, 0x73, 0x2F, 0x8A, 0xA0, 0xA6, 0x11, 0xC1, 265 0x15, 0xCD, 0xC2, 0xD7, 0x95, 0x1B, 0x10, 0x53, 266 0xA6, 0x3C, 0x5E, 0x03, 0xB2, 0x1A, 0xA3, 0xC4, 267}; 268#endif 269 270static unsigned char cbc3_ok[32] = { 271 0x3F, 0xE3, 0x01, 0xC9, 0x62, 0xAC, 0x01, 0xD0, 272 0x22, 0x13, 0x76, 0x3C, 0x1C, 0xBD, 0x4C, 0xDC, 273 0x79, 0x96, 0x57, 0xC0, 0x64, 0xEC, 0xF5, 0xD4, 274 0x1C, 0x67, 0x38, 0x12, 0xCF, 0xDE, 0x96, 0x75 275}; 276 277static unsigned char pcbc_ok[32] = { 278 0xcc, 0xd1, 0x73, 0xff, 0xab, 0x20, 0x39, 0xf4, 279 0x6d, 0xec, 0xb4, 0x70, 0xa0, 0xe5, 0x6b, 0x15, 280 0xae, 0xa6, 0xbf, 0x61, 0xed, 0x7d, 0x9c, 0x9f, 281 0xf7, 0x17, 0x46, 0x3b, 0x8a, 0xb3, 0xcc, 0x88 282}; 283 284static unsigned char cfb_key[8] = { 285 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 286}; 287static unsigned char cfb_iv[8] = { 288 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 289}; 290static unsigned char cfb_buf1[40], cfb_buf2[40], cfb_tmp[8]; 291static unsigned char plain[24] = 292{ 293 0x4e, 0x6f, 0x77, 0x20, 0x69, 0x73, 294 0x20, 0x74, 0x68, 0x65, 0x20, 0x74, 295 0x69, 0x6d, 0x65, 0x20, 0x66, 0x6f, 296 0x72, 0x20, 0x61, 0x6c, 0x6c, 0x20, 297}; 298static unsigned char cfb_cipher8[24] = { 299 0xf3, 0x1f, 0xda, 0x07, 0x01, 0x14, 300 0x62, 0xee, 0x18, 0x7f, 0x43, 0xd8, 301 0x0a, 0x7c, 0xd9, 0xb5, 0xb0, 0xd2, 302 0x90, 0xda, 0x6e, 0x5b, 0x9a, 0x87, 303}; 304static unsigned char cfb_cipher16[24] = { 305 0xF3, 0x09, 0x87, 0x87, 0x7F, 0x57, 306 0xF7, 0x3C, 0x36, 0xB6, 0xDB, 0x70, 307 0xD8, 0xD5, 0x34, 0x19, 0xD3, 0x86, 308 0xB2, 0x23, 0xB7, 0xB2, 0xAD, 0x1B, 309}; 310static unsigned char cfb_cipher32[24] = { 311 0xF3, 0x09, 0x62, 0x49, 0xA4, 0xDF, 312 0xA4, 0x9F, 0x33, 0xDC, 0x7B, 0xAD, 313 0x4C, 0xC8, 0x9F, 0x64, 0xE4, 0x53, 314 0xE5, 0xEC, 0x67, 0x20, 0xDA, 0xB6, 315}; 316static unsigned char cfb_cipher48[24] = { 317 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 318 0x30, 0xB5, 0x15, 0xEC, 0xBB, 0x85, 319 0x97, 0x5A, 0x13, 0x8C, 0x68, 0x60, 320 0xE2, 0x38, 0x34, 0x3C, 0xDC, 0x1F, 321}; 322static unsigned char cfb_cipher64[24] = { 323 0xF3, 0x09, 0x62, 0x49, 0xC7, 0xF4, 324 0x6E, 0x51, 0xA6, 0x9E, 0x83, 0x9B, 325 0x1A, 0x92, 0xF7, 0x84, 0x03, 0x46, 326 0x71, 0x33, 0x89, 0x8E, 0xA6, 0x22, 327}; 328 329static unsigned char ofb_key[8] = { 330 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 331}; 332static unsigned char ofb_iv[8] = { 333 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef, 334}; 335static unsigned char ofb_buf1[24], ofb_buf2[24], ofb_tmp[8]; 336static unsigned char ofb_cipher[24] = 337{ 338 0xf3, 0x09, 0x62, 0x49, 0xc7, 0xf4, 0x6e, 0x51, 339 0x35, 0xf2, 0x4a, 0x24, 0x2e, 0xeb, 0x3d, 0x3f, 340 0x3d, 0x6d, 0x5b, 0xe3, 0x25, 0x5a, 0xf8, 0xc3 341}; 342 343static DES_LONG cbc_cksum_ret = 0xB462FEF7L; 344static unsigned char cbc_cksum_data[8] = { 345 0x1D, 0x26, 0x93, 0x97, 0xf7, 0xfe, 0x62, 0xb4, 346}; 347 348static char * 349pt(unsigned char *p) 350{ 351 static char bufs[10][20]; 352 static int bnum = 0; 353 char *ret; 354 int i; 355 static const char *f = "0123456789ABCDEF"; 356 357 ret = &(bufs[bnum++][0]); 358 bnum %= 10; 359 for (i = 0; i < 8; i++) { 360 ret[i * 2] = f[(p[i] >> 4) & 0xf]; 361 ret[i * 2 + 1] = f[p[i] & 0xf]; 362 } 363 ret[16] = '\0'; 364 return (ret); 365} 366 367static void 368fail_cfb_buf(const char *msg, unsigned char *ptr) 369{ 370 char buf[1024]; 371 int i; 372 373 *buf = '\0'; 374 for (i = 0; i < 24; i += 8) { 375 char buf2[128]; 376 snprintf(buf2, sizeof(buf2), "%s /", pt(&(cfb_buf1[i]))); 377 strlcat(buf, buf2, sizeof(buf)); 378 } 379 380 atf_tc_fail_nonfatal("%s: %s", msg, buf); 381} 382 383#if !defined(LIBDES_LIT) 384static void 385cfb_test(int bits, unsigned char *cfb_cipher) 386{ 387 des_key_schedule ks; 388 389 des_set_key_checked(&cfb_key, ks); 390 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 391 des_cfb_encrypt(plain, cfb_buf1, bits, sizeof(plain), ks, &cfb_tmp, 392 DES_ENCRYPT); 393 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) 394 fail_cfb_buf("cfb_encrypt encrypt error", cfb_buf1); 395 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 396 des_cfb_encrypt(cfb_buf1, cfb_buf2, bits, sizeof(plain), ks, &cfb_tmp, 397 DES_DECRYPT); 398 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) 399 fail_cfb_buf("cfb_encrypt decrypt error", cfb_buf2); 400} 401#endif /* !defined(LIBDES_LIT) */ 402 403#if !defined(LIBDES_LIT) 404static void 405cfb64_test(unsigned char *cfb_cipher) 406{ 407 int n; 408 des_key_schedule ks; 409 410 des_set_key_checked(&cfb_key, ks); 411 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 412 n = 0; 413 des_cfb64_encrypt(plain, cfb_buf1, 12, ks, &cfb_tmp, &n, DES_ENCRYPT); 414 des_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), sizeof(plain) - 12, ks, 415 &cfb_tmp, &n, DES_ENCRYPT); 416 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) 417 fail_cfb_buf("cfb_encrypt encrypt error", cfb_buf1); 418 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 419 n = 0; 420 des_cfb64_encrypt(cfb_buf1, cfb_buf2, 17, ks, &cfb_tmp, &n, DES_DECRYPT); 421 des_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]), 422 sizeof(plain) - 17, ks, &cfb_tmp, &n, DES_DECRYPT); 423 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) 424 fail_cfb_buf("cfb_encrypt decrypt error", cfb_buf2); 425} 426#endif /* !defined(LIBDES_LIT) */ 427 428#if !defined(LIBDES_LIT) 429static void 430ede_cfb64_test(unsigned char *cfb_cipher) 431{ 432 int n; 433 des_key_schedule ks; 434 435 des_set_key_checked(&cfb_key, ks); 436 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 437 n = 0; 438 des_ede3_cfb64_encrypt(plain, cfb_buf1, 12, ks, ks, ks, &cfb_tmp, &n, 439 DES_ENCRYPT); 440 des_ede3_cfb64_encrypt(&(plain[12]), &(cfb_buf1[12]), 441 sizeof(plain) - 12, ks, ks, ks, 442 &cfb_tmp, &n, DES_ENCRYPT); 443 if (memcmp(cfb_cipher, cfb_buf1, sizeof(plain)) != 0) 444 fail_cfb_buf("ede_cfb_encrypt encrypt error", cfb_buf1); 445 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 446 n = 0; 447 des_ede3_cfb64_encrypt(cfb_buf1, cfb_buf2, (long) 17, ks, ks, ks, 448 &cfb_tmp, &n, DES_DECRYPT); 449 des_ede3_cfb64_encrypt(&(cfb_buf1[17]), &(cfb_buf2[17]), 450 sizeof(plain) - 17, ks, ks, ks, 451 &cfb_tmp, &n, DES_DECRYPT); 452 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) 453 fail_cfb_buf("ede_cfb_encrypt decrypt error", cfb_buf2); 454} 455#endif /* !defined(LIBDES_LIT) */ 456 457ATF_TC_WITHOUT_HEAD(cbcm); 458#if defined(NO_DESCBCM) 459ATF_TC_BODY(cbcm, tc) 460{ 461 atf_tc_skip("Test program built with NO_DESCBCM"); 462} 463#else /* defined(NO_DESCBM) */ 464ATF_TC_BODY(cbcm, tc) 465{ 466 int i, j; 467 des_cblock iv3, iv2; 468 unsigned char cbc_in[40], cbc_out[40]; 469 des_key_schedule ks, ks2, ks3; 470 471 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) { 472 atf_tc_fail_nonfatal("Key error %d\n", j); 473 } 474 if ((j = des_set_key_checked(&cbc2_key, ks2)) != 0) { 475 atf_tc_fail_nonfatal("Key error %d\n", j); 476 } 477 if ((j = des_set_key_checked(&cbc3_key, ks3)) != 0) { 478 atf_tc_fail_nonfatal("Key error %d\n", j); 479 } 480 memset(cbc_out, 0, 40); 481 memset(cbc_in, 0, 40); 482 i = strlen((char *) cbc_data) + 1; 483 /* i=((i+7)/8)*8; */ 484 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 485 memset(iv2, '\0', sizeof iv2); 486 487 des_ede3_cbcm_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3, &iv2, 488 DES_ENCRYPT); 489 des_ede3_cbcm_encrypt(&cbc_data[16], &cbc_out[16], i - 16, ks, ks2, ks3, 490 &iv3, &iv2, DES_ENCRYPT); 491 /* 492 * if (memcmp(cbc_out,cbc3_ok, (unsigned int)(strlen((char 493 * *)cbc_data)+1+7)/8*8) != 0) { printf("des_ede3_cbc_encrypt encrypt 494 * error\n"); err=1; } 495 */ 496 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 497 memset(iv2, '\0', sizeof iv2); 498 des_ede3_cbcm_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, &iv2, 499 DES_DECRYPT); 500 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) { 501 char buf[1024]; 502 int n; 503 504 *buf = '\0'; 505 for (n = 0; n < i; ++n) { 506 char buf2[16]; 507 snprintf(buf2, sizeof(buf2), " %02x", cbc_data[n]); 508 strlcat(buf, buf2, sizeof(buf)); 509 } 510 strlcat(buf, ", ", sizeof(buf)); 511 for (n = 0; n < i; ++n) { 512 char buf2[16]; 513 snprintf(buf2, sizeof(buf2), " %02x", cbc_in[n]); 514 strlcat(buf, buf2, sizeof(buf)); 515 } 516 517 atf_tc_fail_nonfatal("des_ede3_cbcm_encrypt decrypt error: %s", 518 buf); 519 } 520} 521#endif /* defined(NO_DESCBM) */ 522 523ATF_TC_WITHOUT_HEAD(ecb); 524ATF_TC_BODY(ecb, tc) 525{ 526 int i; 527 des_cblock in, out, outin; 528 des_key_schedule ks; 529 530 for (i = 0; i < NUM_TESTS; i++) { 531 des_set_key_unchecked(&key_data[i], ks); 532 memcpy(in, plain_data[i], 8); 533 memset(out, 0, 8); 534 memset(outin, 0, 8); 535 des_ecb_encrypt(&in, &out, ks, DES_ENCRYPT); 536 des_ecb_encrypt(&out, &outin, ks, DES_DECRYPT); 537 538 if (memcmp(out, cipher_data[i], 8) != 0) { 539 atf_tc_fail_nonfatal("Encryption error %2d\nk=%s p=%s " 540 "o=%s act=%s\n", i + 1, 541 pt(key_data[i]), pt(in), 542 pt(cipher_data[i]), pt(out)); 543 } 544 if (memcmp(in, outin, 8) != 0) { 545 atf_tc_fail_nonfatal("Decryption error %2d\nk=%s p=%s " 546 "o=%s act=%s\n", i + 1, 547 pt(key_data[i]), pt(out), pt(in), 548 pt(outin)); 549 } 550 } 551} 552 553ATF_TC_WITHOUT_HEAD(ede_ecb); 554#if defined(LIBDES_LIT) 555ATF_TC_BODY(ede_ecb, tc) 556{ 557 atf_tc_skip("Test program built with LIBDES_LIT"); 558} 559#else /* defined(LIBDES_LIT) */ 560ATF_TC_BODY(ede_ecb, tc) 561{ 562 int i; 563 des_cblock in, out, outin; 564 des_key_schedule ks, ks2, ks3; 565 566 for (i = 0; i < (NUM_TESTS - 1); i++) { 567 des_set_key_unchecked(&key_data[i], ks); 568 des_set_key_unchecked(&key_data[i + 1], ks2); 569 des_set_key_unchecked(&key_data[i + 2], ks3); 570 memcpy(in, plain_data[i], 8); 571 memset(out, 0, 8); 572 memset(outin, 0, 8); 573 des_ecb2_encrypt(&in, &out, ks, ks2, DES_ENCRYPT); 574 des_ecb2_encrypt(&out, &outin, ks, ks2, DES_DECRYPT); 575 576 if (memcmp(out, cipher_ecb2[i], 8) != 0) { 577 atf_tc_fail_nonfatal("Encryption error %2d\nk=%s p=%s o=%s act=%s\n", 578 i + 1, pt(key_data[i]), pt(in), pt(cipher_ecb2[i]), 579 pt(out)); 580 } 581 if (memcmp(in, outin, 8) != 0) { 582 atf_tc_fail_nonfatal("Decryption error %2d\nk=%s p=%s o=%s act=%s\n", 583 i + 1, pt(key_data[i]), pt(out), pt(in), pt(outin)); 584 } 585 } 586} 587#endif /* defined(LIBDES_LIT) */ 588 589ATF_TC_WITHOUT_HEAD(cbc); 590ATF_TC_BODY(cbc, tc) 591{ 592 int j; 593 des_cblock iv3; 594 des_key_schedule ks; 595 unsigned char cbc_in[40], cbc_out[40]; 596 597 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) 598 atf_tc_fail_nonfatal("Key error %d\n", j); 599 memset(cbc_out, 0, 40); 600 memset(cbc_in, 0, 40); 601 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 602 des_ncbc_encrypt(cbc_data, cbc_out, strlen((char *) cbc_data) + 1, ks, 603 &iv3, DES_ENCRYPT); 604 if (memcmp(cbc_out, cbc_ok, 32) != 0) 605 atf_tc_fail_nonfatal("cbc_encrypt encrypt error\n"); 606 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 607 des_ncbc_encrypt(cbc_out, cbc_in, strlen((char *) cbc_data) + 1, ks, 608 &iv3, DES_DECRYPT); 609 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data)) != 0) 610 atf_tc_fail_nonfatal("cbc_encrypt decrypt error\n"); 611} 612 613ATF_TC_WITHOUT_HEAD(desx_cbc); 614#if defined(LIBDES_LIT) 615ATF_TC_BODY(desx_cbc, tc) 616{ 617 atf_tc_skip("Test program built with LIBDES_LIT"); 618} 619#else /* defined(LIBDES_LIT) */ 620ATF_TC_BODY(desx_cbc, tc) 621{ 622 int j; 623 des_cblock iv3; 624 des_key_schedule ks; 625 unsigned char cbc_in[40], cbc_out[40]; 626 627 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) { 628 atf_tc_fail_nonfatal("Key error %d\n", j); 629 } 630 memset(cbc_out, 0, 40); 631 memset(cbc_in, 0, 40); 632 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 633 des_xcbc_encrypt(cbc_data, cbc_out, strlen((char *) cbc_data) + 1, ks, 634 &iv3, &cbc2_key, &cbc3_key, DES_ENCRYPT); 635 if (memcmp(cbc_out, xcbc_ok, 32) != 0) { 636 atf_tc_fail_nonfatal("des_xcbc_encrypt encrypt error\n"); 637 } 638 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 639 des_xcbc_encrypt(cbc_out, cbc_in, strlen((char *) cbc_data) + 1, ks, 640 &iv3, &cbc2_key, &cbc3_key, DES_DECRYPT); 641 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) { 642 atf_tc_fail_nonfatal("des_xcbc_encrypt decrypt error\n"); 643 } 644} 645#endif /* defined(LIBDES_LIT) */ 646 647ATF_TC_WITHOUT_HEAD(ede_cbc); 648ATF_TC_BODY(ede_cbc, tc) 649{ 650 int i, j; 651 des_cblock iv3; 652 des_key_schedule ks, ks2, ks3; 653 unsigned char cbc_in[40], cbc_out[40]; 654 655 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) 656 atf_tc_fail_nonfatal("Key error %d\n", j); 657 if ((j = des_set_key_checked(&cbc2_key, ks2)) != 0) 658 atf_tc_fail_nonfatal("Key error %d\n", j); 659 if ((j = des_set_key_checked(&cbc3_key, ks3)) != 0) 660 atf_tc_fail_nonfatal("Key error %d\n", j); 661 memset(cbc_out, 0, 40); 662 memset(cbc_in, 0, 40); 663 i = strlen((char *) cbc_data) + 1; 664 /* i=((i+7)/8)*8; */ 665 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 666 667 des_ede3_cbc_encrypt(cbc_data, cbc_out, 16L, ks, ks2, ks3, &iv3, 668 DES_ENCRYPT); 669 des_ede3_cbc_encrypt(&(cbc_data[16]), &(cbc_out[16]), i - 16, ks, ks2, 670 ks3, &iv3, DES_ENCRYPT); 671 if (memcmp(cbc_out, cbc3_ok, (unsigned int) 672 (strlen((char *) cbc_data) + 1 + 7) / 8 * 8) != 0) 673 atf_tc_fail_nonfatal("des_ede3_cbc_encrypt encrypt error\n"); 674 memcpy(iv3, cbc_iv, sizeof(cbc_iv)); 675 des_ede3_cbc_encrypt(cbc_out, cbc_in, i, ks, ks2, ks3, &iv3, 676 DES_DECRYPT); 677 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) 678 atf_tc_fail_nonfatal("des_ede3_cbc_encrypt decrypt error\n"); 679} 680 681ATF_TC_WITHOUT_HEAD(pcbc); 682#if defined(LIBDES_LIT) 683ATF_TC_BODY(pcbc, tc) 684{ 685 atf_tc_skip("Test program built with LIBDES_LIT"); 686} 687#else /* defined(LIBDES_LIT) */ 688ATF_TC_BODY(pcbc, tc) 689{ 690 int j; 691 unsigned char cbc_in[40], cbc_out[40]; 692 des_key_schedule ks; 693 694 if ((j = des_set_key_checked(&cbc_key, ks)) != 0) { 695 atf_tc_fail_nonfatal("Key error %d\n", j); 696 } 697 memset(cbc_out, 0, 40); 698 memset(cbc_in, 0, 40); 699 des_pcbc_encrypt(cbc_data, cbc_out, strlen((char *) cbc_data) + 1, ks, 700 &cbc_iv, DES_ENCRYPT); 701 if (memcmp(cbc_out, pcbc_ok, 32) != 0) { 702 atf_tc_fail_nonfatal("pcbc_encrypt encrypt error\n"); 703 } 704 des_pcbc_encrypt(cbc_out, cbc_in, strlen((char *) cbc_data) + 1, ks, &cbc_iv, 705 DES_DECRYPT); 706 if (memcmp(cbc_in, cbc_data, strlen((char *) cbc_data) + 1) != 0) { 707 atf_tc_fail_nonfatal("pcbc_encrypt decrypt error\n"); 708 } 709} 710#endif /* defined(LIBDES_LIT) */ 711 712ATF_TC_WITHOUT_HEAD(cfb); 713#if defined(LIBDES_LIT) 714ATF_TC_BODY(cfb, tc) 715{ 716 atf_tc_skip("Test program built with LIBDES_LIT"); 717} 718#else /* defined(LIBDES_LIT) */ 719ATF_TC_BODY(cfb, tc) 720{ 721 size_t i; 722 des_key_schedule ks; 723 724 printf("cfb8\n"); 725 cfb_test(8, cfb_cipher8); 726 printf("cfb16\n"); 727 cfb_test(16, cfb_cipher16); 728 printf("cfb32\n"); 729 cfb_test(32, cfb_cipher32); 730 printf("cfb48\n"); 731 cfb_test(48, cfb_cipher48); 732 printf("cfb64\n"); 733 cfb_test(64, cfb_cipher64); 734 735 printf("cfb64()\n"); 736 cfb64_test(cfb_cipher64); 737 738 des_set_key_checked(&cfb_key, ks); 739 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 740 for (i = 0; i < sizeof(plain); i++) 741 des_cfb_encrypt(&(plain[i]), &(cfb_buf1[i]), 742 8, 1, ks, &cfb_tmp, DES_ENCRYPT); 743 if (memcmp(cfb_cipher8, cfb_buf1, sizeof(plain)) != 0) 744 atf_tc_fail_nonfatal("cfb_encrypt small encrypt error\n"); 745 memcpy(cfb_tmp, cfb_iv, sizeof(cfb_iv)); 746 for (i = 0; i < sizeof(plain); i++) 747 des_cfb_encrypt(&(cfb_buf1[i]), &(cfb_buf2[i]), 748 8, 1, ks, &cfb_tmp, DES_DECRYPT); 749 if (memcmp(plain, cfb_buf2, sizeof(plain)) != 0) 750 atf_tc_fail_nonfatal("cfb_encrypt small decrypt error\n"); 751 printf("ede_cfb64()\n"); 752 ede_cfb64_test(cfb_cipher64); 753} 754#endif /* defined(LIBDES_LIT) */ 755 756ATF_TC_WITHOUT_HEAD(ofb); 757#if defined(LIBDES_LIT) 758ATF_TC_BODY(ofb, tc) 759{ 760 atf_tc_skip("Test program built with LIBDES_LIT"); 761} 762#else /* defined(LIBDES_LIT) */ 763ATF_TC_BODY(ofb, tc) 764{ 765 des_key_schedule ks; 766 767 des_set_key_checked(&ofb_key, ks); 768 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 769 des_ofb_encrypt(plain, ofb_buf1, 64, sizeof(plain) / 8, ks, &ofb_tmp); 770 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) { 771 atf_tc_fail_nonfatal("ofb_encrypt encrypt error: " 772 "%02X %02X %02X %02X %02X %02X %02X %02X, " 773 "%02X %02X %02X %02X %02X %02X %02X %02X", 774 ofb_buf1[8 + 0], ofb_buf1[8 + 1], 775 ofb_buf1[8 + 2], ofb_buf1[8 + 3], 776 ofb_buf1[8 + 4], ofb_buf1[8 + 5], 777 ofb_buf1[8 + 6], ofb_buf1[8 + 7], 778 ofb_buf1[8 + 0], ofb_cipher[8 + 1], 779 ofb_cipher[8 + 2], ofb_cipher[8 + 3], 780 ofb_buf1[8 + 4], ofb_cipher[8 + 5], 781 ofb_cipher[8 + 6], ofb_cipher[8 + 7]); 782 } 783 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 784 des_ofb_encrypt(ofb_buf1, ofb_buf2, 64, sizeof(ofb_buf1) / 8, ks, 785 &ofb_tmp); 786 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) { 787 atf_tc_fail_nonfatal("ofb_encrypt decrypt error: " 788 "%02X %02X %02X %02X %02X %02X %02X %02X, " 789 "%02X %02X %02X %02X %02X %02X %02X %02X", 790 ofb_buf2[8 + 0], ofb_buf2[8 + 1], 791 ofb_buf2[8 + 2], ofb_buf2[8 + 3], 792 ofb_buf2[8 + 4], ofb_buf2[8 + 5], 793 ofb_buf2[8 + 6], ofb_buf2[8 + 7], 794 plain[8 + 0], plain[8 + 1], 795 plain[8 + 2], plain[8 + 3], 796 plain[8 + 4], plain[8 + 5], 797 plain[8 + 6], plain[8 + 7]); 798 } 799} 800#endif /* defined(LIBDES_LIT) */ 801 802ATF_TC_WITHOUT_HEAD(ofb64); 803#if defined(LIBDES_LIT) 804ATF_TC_BODY(ofb64, tc) 805{ 806 atf_tc_skip("Test program built with LIBDES_LIT"); 807} 808#else /* defined(LIBDES_LIT) */ 809ATF_TC_BODY(ofb64, tc) 810{ 811 int num; 812 size_t i; 813 des_key_schedule ks; 814 815 des_set_key_checked(&ofb_key, ks); 816 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 817 memset(ofb_buf1, 0, sizeof(ofb_buf1)); 818 memset(ofb_buf2, 0, sizeof(ofb_buf1)); 819 num = 0; 820 for (i = 0; i < sizeof(plain); i++) { 821 des_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, &ofb_tmp, 822 &num); 823 } 824 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) { 825 atf_tc_fail_nonfatal("ofb64_encrypt encrypt error\n"); 826 } 827 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 828 num = 0; 829 des_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, &ofb_tmp, &num); 830 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) { 831 atf_tc_fail_nonfatal("ofb64_encrypt decrypt error\n"); 832 } 833} 834#endif /* defined(LIBDES_LIT) */ 835 836ATF_TC_WITHOUT_HEAD(ede_ofb64); 837#if defined(LIBDES_LIT) 838ATF_TC_BODY(ede_ofb64, tc) 839{ 840 atf_tc_skip("Test program built with LIBDES_LIT"); 841} 842#else /* defined(LIBDES_LIT) */ 843ATF_TC_BODY(ede_ofb64, tc) 844{ 845 int num; 846 size_t i; 847 des_key_schedule ks; 848 849 des_set_key_checked(&ofb_key, ks); 850 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 851 memset(ofb_buf1, 0, sizeof(ofb_buf1)); 852 memset(ofb_buf2, 0, sizeof(ofb_buf1)); 853 num = 0; 854 for (i = 0; i < sizeof(plain); i++) { 855 des_ede3_ofb64_encrypt(&(plain[i]), &(ofb_buf1[i]), 1, ks, ks, ks, 856 &ofb_tmp, &num); 857 } 858 if (memcmp(ofb_cipher, ofb_buf1, sizeof(ofb_buf1)) != 0) { 859 atf_tc_fail_nonfatal("ede_ofb64_encrypt encrypt error\n"); 860 } 861 memcpy(ofb_tmp, ofb_iv, sizeof(ofb_iv)); 862 num = 0; 863 des_ede3_ofb64_encrypt(ofb_buf1, ofb_buf2, sizeof(ofb_buf1), ks, 864 ks, ks, &ofb_tmp, &num); 865 if (memcmp(plain, ofb_buf2, sizeof(ofb_buf2)) != 0) { 866 atf_tc_fail_nonfatal("ede_ofb64_encrypt decrypt error\n"); 867 } 868} 869#endif /* defined(LIBDES_LIT) */ 870 871ATF_TC_WITHOUT_HEAD(cbc_cksum); 872#if defined(LIBDES_LIT) 873ATF_TC_BODY(cbc_cksum, tc) 874{ 875 atf_tc_skip("Test program built with LIBDES_LIT"); 876} 877#else /* defined(LIBDES_LIT) */ 878ATF_TC_BODY(cbc_cksum, tc) 879{ 880 unsigned char cret[8]; 881 des_key_schedule ks; 882 DES_LONG cs; 883 884 des_set_key_checked(&cbc_key, ks); 885 cs = des_cbc_cksum(cbc_data, &cret, strlen((char *) cbc_data), ks, &cbc_iv); 886 if (cs != cbc_cksum_ret) { 887 atf_tc_fail_nonfatal("bad return value (%08lX), should be %08lX\n", 888 (unsigned long) cs, (unsigned long) cbc_cksum_ret); 889 } 890 if (memcmp(cret, cbc_cksum_data, 8) != 0) { 891 atf_tc_fail_nonfatal("bad cbc_cksum block returned\n"); 892 } 893} 894#endif /* defined(LIBDES_LIT) */ 895 896ATF_TC_WITHOUT_HEAD(quad_cksum); 897#if defined(LIBDES_LIT) 898ATF_TC_BODY(quad_cksum, tc) 899{ 900 atf_tc_skip("Test program built with LIBDES_LIT"); 901} 902#else /* defined(LIBDES_LIT) */ 903ATF_TC_BODY(quad_cksum, tc) 904{ 905 DES_LONG cs, lqret[4]; 906 907 cs = quad_cksum(cbc_data, (des_cblock *) lqret, 908 (long) strlen((char *) cbc_data), 2, (des_cblock *) cbc_iv); 909 if (cs != 0x70d7a63aL) { 910 atf_tc_fail_nonfatal("quad_cksum error, ret %08lx should be 70d7a63a\n", 911 (unsigned long) cs); 912 } 913 if (lqret[0] != 0x327eba8dL) { 914 atf_tc_fail_nonfatal("quad_cksum error, out[0] %08lx is not %08lx\n", 915 (unsigned long) lqret[0], 0x327eba8dUL); 916 } 917 if (lqret[1] != 0x201a49ccL) { 918 atf_tc_fail_nonfatal("quad_cksum error, out[1] %08lx is not %08lx\n", 919 (unsigned long) lqret[1], 0x201a49ccUL); 920 } 921 if (lqret[2] != 0x70d7a63aL) { 922 atf_tc_fail_nonfatal("quad_cksum error, out[2] %08lx is not %08lx\n", 923 (unsigned long) lqret[2], 0x70d7a63aUL); 924 } 925 if (lqret[3] != 0x501c2c26L) { 926 atf_tc_fail_nonfatal("quad_cksum error, out[3] %08lx is not %08lx\n", 927 (unsigned long) lqret[3], 0x501c2c26UL); 928 } 929} 930#endif /* defined(LIBDES_LIT) */ 931 932ATF_TC_WITHOUT_HEAD(align); 933ATF_TC_BODY(align, tc) 934{ 935 int i; 936 unsigned char cbc_in[40], cbc_out[40]; 937 des_key_schedule ks; 938 939 printf("input word alignment test"); 940 for (i = 0; i < 4; i++) { 941 printf(" %d", i); 942 des_ncbc_encrypt(&(cbc_out[i]), cbc_in, 943 strlen((char *) cbc_data) + 1, ks, 944 &cbc_iv, DES_ENCRYPT); 945 } 946 947 printf("\noutput word alignment test"); 948 for (i = 0; i < 4; i++) { 949 printf(" %d", i); 950 des_ncbc_encrypt(cbc_out, &(cbc_in[i]), 951 strlen((char *) cbc_data) + 1, ks, 952 &cbc_iv, DES_ENCRYPT); 953 } 954} 955 956ATF_TC_WITHOUT_HEAD(fast_crypt); 957ATF_TC_BODY(fast_crypt, tc) 958{ 959 char *str; 960 961 str = crypt("testing", "ef"); 962 if (strcmp("efGnQx2725bI2", str) != 0) 963 atf_tc_fail_nonfatal("fast crypt error, %s should be efGnQx2725bI2\n", str); 964 str = crypt("bca76;23", "yA"); 965 if (strcmp("yA1Rp/1hZXIJk", str) != 0) 966 atf_tc_fail_nonfatal("fast crypt error, %s should be yA1Rp/1hZXIJk\n", str); 967} 968 969ATF_TP_ADD_TCS(tp) 970{ 971 972 ATF_TP_ADD_TC(tp, cbcm); 973 ATF_TP_ADD_TC(tp, ecb); 974 ATF_TP_ADD_TC(tp, ede_ecb); 975 ATF_TP_ADD_TC(tp, cbc); 976 ATF_TP_ADD_TC(tp, desx_cbc); 977 ATF_TP_ADD_TC(tp, ede_cbc); 978 ATF_TP_ADD_TC(tp, pcbc); 979 ATF_TP_ADD_TC(tp, cfb); 980 ATF_TP_ADD_TC(tp, ofb); 981 ATF_TP_ADD_TC(tp, ofb64); 982 ATF_TP_ADD_TC(tp, ede_ofb64); 983 ATF_TP_ADD_TC(tp, cbc_cksum); 984 ATF_TP_ADD_TC(tp, quad_cksum); 985 ATF_TP_ADD_TC(tp, align); 986 ATF_TP_ADD_TC(tp, fast_crypt); 987 988 return atf_no_error(); 989} 990