sal/workben/t_cipher.c

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