sal/workben/t_cipher.c

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