sal/workben/t_cipher.c

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19 #include <sal/types.h>
  20 #include <sal/macros.h>
  21 #include <osl/diagnose.h>
  22 #include <rtl/cipher.h>
  23
  24 #include <stdio.h>
  25 #include <string.h>
  26
  27 #define NUM_VARIABLE_KEY_TESTS  34
  28 #define NUM_SET_KEY_TESTS       24
  29
  30 /* plaintext bytes -- left halves */
  31 unsigned long plaintext_l[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
  32    0x00000000l, 0xFFFFFFFFl, 0x10000000l, 0x11111111l, 0x11111111l,
  33    0x01234567l, 0x00000000l, 0x01234567l, 0x01A1D6D0l, 0x5CD54CA8l,
  34    0x0248D438l, 0x51454B58l, 0x42FD4430l, 0x059B5E08l, 0x0756D8E0l,
  35    0x762514B8l, 0x3BDD1190l, 0x26955F68l, 0x164D5E40l, 0x6B056E18l,
  36    0x004BD6EFl, 0x480D3900l, 0x437540C8l, 0x072D43A0l, 0x02FE5577l,
  37    0x1D9D5C50l, 0x30553228l, 0x01234567l, 0x01234567l, 0x01234567l,
  38    0xFFFFFFFFl, 0x00000000l, 0x00000000l, 0xFFFFFFFFl, 0xFEDCBA98l,
  39    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  40    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  41    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  42    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l,
  43    0xFEDCBA98l, 0xFEDCBA98l, 0xFEDCBA98l };
  44
  45 /* plaintext bytes -- right halves */
  46 unsigned long plaintext_r[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
  47    0x00000000l, 0xFFFFFFFFl, 0x00000001l, 0x11111111l, 0x11111111l,
  48    0x89ABCDEFl, 0x00000000l, 0x89ABCDEFl, 0x39776742l, 0x3DEF57DAl,
  49    0x06F67172l, 0x2DDF440Al, 0x59577FA2l, 0x51CF143Al, 0x774761D2l,
  50    0x29BF486Al, 0x49372802l, 0x35AF609Al, 0x4F275232l, 0x759F5CCAl,
  51    0x09176062l, 0x6EE762F2l, 0x698F3CFAl, 0x77075292l, 0x8117F12Al,
  52    0x18F728C2l, 0x6D6F295Al, 0x89ABCDEFl, 0x89ABCDEFl, 0x89ABCDEFl,
  53    0xFFFFFFFFl, 0x00000000l, 0x00000000l, 0xFFFFFFFFl, 0x76543210l,
  54    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  55    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  56    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  57    0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l, 0x76543210l,
  58    0x76543210l, 0x76543210l, 0x76543210l };
  59
  60 /* key bytes for variable key tests */
  61 unsigned char variable_key[NUM_VARIABLE_KEY_TESTS][8] = {
  62    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  63    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
  64    { 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  65    { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
  66    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  67    { 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11 },
  68    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  69    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 },
  70    { 0x7C, 0xA1, 0x10, 0x45, 0x4A, 0x1A, 0x6E, 0x57 },
  71    { 0x01, 0x31, 0xD9, 0x61, 0x9D, 0xC1, 0x37, 0x6E },
  72    { 0x07, 0xA1, 0x13, 0x3E, 0x4A, 0x0B, 0x26, 0x86 },
  73    { 0x38, 0x49, 0x67, 0x4C, 0x26, 0x02, 0x31, 0x9E },
  74    { 0x04, 0xB9, 0x15, 0xBA, 0x43, 0xFE, 0xB5, 0xB6 },
  75    { 0x01, 0x13, 0xB9, 0x70, 0xFD, 0x34, 0xF2, 0xCE },
  76    { 0x01, 0x70, 0xF1, 0x75, 0x46, 0x8F, 0xB5, 0xE6 },
  77    { 0x43, 0x29, 0x7F, 0xAD, 0x38, 0xE3, 0x73, 0xFE },
  78    { 0x07, 0xA7, 0x13, 0x70, 0x45, 0xDA, 0x2A, 0x16 },
  79    { 0x04, 0x68, 0x91, 0x04, 0xC2, 0xFD, 0x3B, 0x2F },
  80    { 0x37, 0xD0, 0x6B, 0xB5, 0x16, 0xCB, 0x75, 0x46 },
  81    { 0x1F, 0x08, 0x26, 0x0D, 0x1A, 0xC2, 0x46, 0x5E },
  82    { 0x58, 0x40, 0x23, 0x64, 0x1A, 0xBA, 0x61, 0x76 },
  83    { 0x02, 0x58, 0x16, 0x16, 0x46, 0x29, 0xB0, 0x07 },
  84    { 0x49, 0x79, 0x3E, 0xBC, 0x79, 0xB3, 0x25, 0x8F },
  85    { 0x4F, 0xB0, 0x5E, 0x15, 0x15, 0xAB, 0x73, 0xA7 },
  86    { 0x49, 0xE9, 0x5D, 0x6D, 0x4C, 0xA2, 0x29, 0xBF },
  87    { 0x01, 0x83, 0x10, 0xDC, 0x40, 0x9B, 0x26, 0xD6 },
  88    { 0x1C, 0x58, 0x7F, 0x1C, 0x13, 0x92, 0x4F, 0xEF },
  89    { 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
  90    { 0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E },
  91    { 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE },
  92    { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  93    { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF },
  94    { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  95    { 0xFE, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x10 }};
  96
  97 /* key bytes for set key tests */
  98 unsigned char set_key[24] = {
  99    0xF0, 0xE1, 0xD2, 0xC3, 0xB4, 0xA5, 0x96, 0x87,
 100    0x78, 0x69, 0x5A, 0x4B, 0x3C, 0x2D, 0x1E, 0x0F,
 101    0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77 };
 102
 103 /* ciphertext bytes -- left halves */
 104 unsigned long ciphertext_l[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
 105    0x4EF99745l, 0x51866FD5l, 0x7D856F9Al, 0x2466DD87l, 0x61F9C380l,
 106    0x7D0CC630l, 0x4EF99745l, 0x0ACEAB0Fl, 0x59C68245l, 0xB1B8CC0Bl,
 107    0x1730E577l, 0xA25E7856l, 0x353882B1l, 0x48F4D088l, 0x432193B7l,
 108    0x13F04154l, 0x2EEDDA93l, 0xD887E039l, 0x5F99D04Fl, 0x4A057A3Bl,
 109    0x452031C1l, 0x7555AE39l, 0x53C55F9Cl, 0x7A8E7BFAl, 0xCF9C5D7Al,
 110    0xD1ABB290l, 0x55CB3774l, 0xFA34EC48l, 0xA7907951l, 0xC39E072Dl,
 111    0x014933E0l, 0xF21E9A77l, 0x24594688l, 0x6B5C5A9Cl, 0xF9AD597Cl,
 112    0xE91D21C1l, 0xE9C2B70Al, 0xBE1E6394l, 0xB39E4448l, 0x9457AA83l,
 113    0x8BB77032l, 0xE87A244El, 0x15750E7Al, 0x122BA70Bl, 0x3A833C9Al,
 114    0x9409DA87l, 0x884F8062l, 0x1F85031Cl, 0x79D9373Al, 0x93142887l,
 115    0x03429E83l, 0xA4299E27l, 0xAFD5AED1l, 0x10851C0El, 0xE6F51ED7l,
 116    0x64A6E14Al, 0x80C7D7D4l, 0x05044B62l };
 117
 118 /* ciphertext bytes -- right halves */
 119 unsigned long ciphertext_r[NUM_VARIABLE_KEY_TESTS + NUM_SET_KEY_TESTS] = {
 120    0x6198DD78l, 0xB85ECB8Al, 0x613063F2l, 0x8B963C9Dl, 0x2281B096l,
 121    0xAFDA1EC7l, 0x6198DD78l, 0xC6A0A28Dl, 0xEB05282Bl, 0x250F09A0l,
 122    0x8BEA1DA4l, 0xCF2651EBl, 0x09CE8F1Al, 0x4C379918l, 0x8951FC98l,
 123    0xD69D1AE5l, 0xFFD39C79l, 0x3C2DA6E3l, 0x5B163969l, 0x24D3977Bl,
 124    0xE4FADA8El, 0xF59B87BDl, 0xB49FC019l, 0x937E89A3l, 0x4986ADB5l,
 125    0x658BC778l, 0xD13EF201l, 0x47B268B2l, 0x08EA3CAEl, 0x9FAC631Dl,
 126    0xCDAFF6E4l, 0xB71C49BCl, 0x5754369Al, 0x5D9E0A5Al, 0x49DB005El,
 127    0xD961A6D6l, 0x1BC65CF3l, 0x08640F05l, 0x1BDB1E6El, 0xB1928C0Dl,
 128    0xF960629Dl, 0x2CC85E82l, 0x4F4EC577l, 0x3AB64AE0l, 0xFFC537F6l,
 129    0xA90F6BF2l, 0x5060B8B4l, 0x19E11968l, 0x714CA34Fl, 0xEE3BE15Cl,
 130    0x8CE2D14Bl, 0x469FF67Bl, 0xC1BC96A8l, 0x3858DA9Fl, 0x9B9DB21Fl,
 131    0xFD36B46Fl, 0x5A5479ADl, 0xFA52D080l };
 132
 133
 134 static sal_uInt8 cbc_key[16] =
 135 {
 136     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
 137     0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
 138 };
 139 static sal_uInt8 cbc_iv[8] =
 140 {
 141     0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
 142 };
 143
 144 static sal_Char cbc_data[40] = "7654321 Now is the time for ";
 145
 146 static sal_uInt8 arcfour_key[6][30] =
 147 {
 148     { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 149     { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 150     { 8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 151     { 4, 0xef, 0x01, 0x23, 0x45 },
 152     { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 153     { 4, 0xef, 0x01, 0x23, 0x45 }
 154 };
 155 static sal_uInt8 arcfour_data_len[6] =
 156 {
 157     8, 8, 8, 20, 28, 10
 158 };
 159 static sal_uInt8 arcfour_data[6][30] =
 160 {
 161     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff },
 162     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
 163     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
 164     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 165       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 166       0x00, 0x00, 0x00, 0x00, 0xff },
 167     { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
 168       0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
 169       0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
 170       0x12, 0x34, 0x56, 0x78, 0xff },
 171     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 172       0x00, 0x00, 0xff }
 173 };
 174
 175 #if OSL_DEBUG_LEVEL > 0
 176 static sal_uInt8 ecb_ok[32] =
 177 {
 178     0x2A, 0xFD, 0x7D, 0xAA, 0x60, 0x62, 0x6B, 0xA3,
 179     0x86, 0x16, 0x46, 0x8C, 0xC2, 0x9C, 0xF6, 0xE1,
 180     0x29, 0x1E, 0x81, 0x7C, 0xC7, 0x40, 0x98, 0x2D,
 181     0x6F, 0x87, 0xAC, 0x5F, 0x17, 0x1A, 0xAB, 0xEA
 182 };
 183 static sal_uInt8 cbc_ok[32] =
 184 {
 185     0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
 186     0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
 187     0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
 188     0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
 189 };
 190 static sal_uInt8 cfb_ok[] =
 191 {
 192     0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
 193     0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
 194     0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
 195     0x51, 0x9D, 0x57, 0xA6, 0xC3
 196 };
 197 static sal_uInt8 arcfour_ok[6][30] =
 198 {
 199     { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96, 0x00},
 200     { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79, 0x00},
 201     { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a, 0x00},
 202     { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
 203       0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
 204       0x36, 0xb6, 0x78, 0x58, 0x00 },
 205     { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
 206       0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
 207       0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
 208       0x40, 0x01, 0x1e, 0xcf, 0x00 },
 209     { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
 210       0xbd, 0x61, 0x00}
 211 };
 212 #endif
 213
 214 int SAL_CALL main (void)
 215 {
 216     rtlCipher cipher;
 217
 218     /* ECB */
 219     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 220     OSL_ASSERT(cipher != 0);
 221     if (cipher != 0)
 222     {
 223         rtlCipherError result;
 224         sal_uInt8      ecb_in[40], ecb_out[40];
 225         sal_uInt32     length = strlen(cbc_data) + 1;
 226
 227         result = rtl_cipher_init (
 228             cipher, rtl_Cipher_DirectionBoth,
 229             cbc_key, sizeof(cbc_key), NULL, 0);
 230         OSL_ASSERT(result == rtl_Cipher_E_None);
 231
 232         memset (ecb_out, 0, sizeof(ecb_out));
 233         result = rtl_cipher_encode (
 234             cipher, cbc_data, length, ecb_out, sizeof(ecb_out));
 235         OSL_ASSERT(result == rtl_Cipher_E_None);
 236         OSL_ASSERT(memcmp (ecb_out, ecb_ok, sizeof(ecb_ok)) == 0);
 237
 238         memset (ecb_in,  0, sizeof(ecb_in));
 239         result = rtl_cipher_decode (
 240             cipher, ecb_out, length, ecb_in, sizeof(ecb_in));
 241         OSL_ASSERT(result == rtl_Cipher_E_None);
 242         OSL_ASSERT(memcmp (ecb_in, cbc_data, length) == 0);
 243
 244         rtl_cipher_destroy (cipher);
 245     }
 246
 247     /* CBC */
 248     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeCBC);
 249     OSL_ASSERT(cipher != 0);
 250     if (cipher != 0)
 251     {
 252         rtlCipherError result;
 253         sal_uInt8      cbc_in[40], cbc_out[40];
 254         sal_uInt32     length = strlen(cbc_data) + 1;
 255
 256         result = rtl_cipher_init (
 257             cipher, rtl_Cipher_DirectionEncode,
 258             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 259         OSL_ASSERT(result == rtl_Cipher_E_None);
 260
 261         memset (cbc_out, 0, sizeof(cbc_out));
 262         result = rtl_cipher_encode (
 263             cipher, cbc_data, length, cbc_out, sizeof(cbc_out));
 264         OSL_ASSERT(result == rtl_Cipher_E_None);
 265         OSL_ASSERT(memcmp (cbc_out, cbc_ok, sizeof(cbc_ok)) == 0);
 266
 267         result = rtl_cipher_init (
 268             cipher, rtl_Cipher_DirectionDecode,
 269             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 270         OSL_ASSERT(result == rtl_Cipher_E_None);
 271
 272         memset (cbc_in,  0, sizeof(cbc_in));
 273         result = rtl_cipher_decode (
 274             cipher, cbc_out, length, cbc_in, sizeof(cbc_in));
 275         OSL_ASSERT(result == rtl_Cipher_E_None);
 276         OSL_ASSERT(memcmp (cbc_in, cbc_data, length) == 0);
 277
 278         rtl_cipher_destroy (cipher);
 279      }
 280
 281     /* CFB */
 282     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream);
 283     OSL_ASSERT(cipher != 0);
 284     if (cipher != 0)
 285     {
 286         rtlCipherError result;
 287         sal_uInt8      cfb_in[40], cfb_out[40];
 288         sal_uInt32     length = strlen(cbc_data) + 1;
 289
 290         result = rtl_cipher_init (
 291             cipher, rtl_Cipher_DirectionEncode,
 292             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 293         OSL_ASSERT(result == rtl_Cipher_E_None);
 294
 295         memset (cfb_out, 0, sizeof(cfb_out));
 296         result = rtl_cipher_encode (
 297             cipher, cbc_data, length, cfb_out, sizeof(cfb_out));
 298         OSL_ASSERT(result == rtl_Cipher_E_None);
 299         OSL_ASSERT(memcmp (cfb_out, cfb_ok, sizeof(cfb_ok)) == 0);
 300
 301         result = rtl_cipher_init (
 302             cipher, rtl_Cipher_DirectionDecode,
 303             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 304         OSL_ASSERT(result == rtl_Cipher_E_None);
 305
 306         memset (cfb_in,  0, sizeof(cfb_in));
 307         result = rtl_cipher_decode (
 308             cipher, cfb_out, length, cfb_in, sizeof(cfb_in));
 309         OSL_ASSERT(result == rtl_Cipher_E_None);
 310         OSL_ASSERT(memcmp (cfb_in, cbc_data, length) == 0);
 311
 312         rtl_cipher_destroy (cipher);
 313     }
 314
 315     /* ARCFOUR */
 316     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmARCFOUR, rtl_Cipher_ModeStream);
 317     OSL_ASSERT(cipher != 0);
 318     if (cipher != 0)
 319     {
 320         rtlCipherError result;
 321         sal_uInt8      arcfour_out[40];
 322         sal_Size       length;
 323         int            i, n;
 324
 325         n = SAL_N_ELEMENTS(arcfour_data_len);
 326         for (i = 0; i < n; i++)
 327         {
 328             length = arcfour_data_len[i];
 329
 330             result = rtl_cipher_init (
 331                 cipher, rtl_Cipher_DirectionBoth,
 332                 &(arcfour_key[i][1]), arcfour_key[i][0], 0, 0);
 333             OSL_ASSERT(result == rtl_Cipher_E_None);
 334
 335             memset (arcfour_out, 0, sizeof(arcfour_out));
 336             result = rtl_cipher_encode (
 337                 cipher, &(arcfour_data[i][0]), length,
 338                 arcfour_out, sizeof(arcfour_out));
 339             OSL_ASSERT(result == rtl_Cipher_E_None);
 340             OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[i], length) == 0);
 341         }
 342
 343         n = arcfour_data_len[3];
 344         for (i = 1; i < n; i++)
 345         {
 346             length = i;
 347
 348             result = rtl_cipher_init (
 349                 cipher, rtl_Cipher_DirectionBoth,
 350                 &(arcfour_key[3][1]), arcfour_key[3][0], 0, 0);
 351             OSL_ASSERT(result == rtl_Cipher_E_None);
 352
 353             memset (arcfour_out, 0, sizeof(arcfour_out));
 354             result = rtl_cipher_encode (
 355                 cipher, &(arcfour_data[3][0]), length,
 356                 arcfour_out, sizeof(arcfour_out));
 357             OSL_ASSERT(result == rtl_Cipher_E_None);
 358             OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[3], length) == 0);
 359             OSL_ASSERT(arcfour_out[length] == 0);
 360         }
 361
 362         n = arcfour_data_len[3];
 363         for (i = 1; i < n; i++)
 364         {
 365             length = i;
 366
 367             result = rtl_cipher_init (
 368                 cipher, rtl_Cipher_DirectionBoth,
 369                 &(arcfour_key[3][1]), arcfour_key[3][0], 0, 0);
 370             OSL_ASSERT(result == rtl_Cipher_E_None);
 371
 372             memset (arcfour_out, 0, sizeof(arcfour_out));
 373             result = rtl_cipher_encode (
 374                 cipher, &(arcfour_data[3][0]), length,
 375                 &(arcfour_out[0]), sizeof(arcfour_out));
 376             OSL_ASSERT(result == rtl_Cipher_E_None);
 377
 378             result = rtl_cipher_encode (
 379                 cipher, &(arcfour_data[3][length]), n - length,
 380                 &(arcfour_out[length]), sizeof(arcfour_out) - length);
 381             OSL_ASSERT(result == rtl_Cipher_E_None);
 382
 383             OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[3], length) == 0);
 384         }
 385
 386         rtl_cipher_destroy (cipher);
 387     }
 388
 389     /* Done */
 390     return 0;
 391 }
 392
 393 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */