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 static sal_uInt8 cbc_key[16] =
 134 {
 135     0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef,
 136     0xf0, 0xe1, 0xd2, 0xc3, 0xb4, 0xa5, 0x96, 0x87
 137 };
 138 static sal_uInt8 cbc_iv[8] =
 139 {
 140     0xfe, 0xdc, 0xba, 0x98, 0x76, 0x54, 0x32, 0x10
 141 };
 142
 143 static sal_Char cbc_data[40] = "7654321 Now is the time for ";
 144
 145 static sal_uInt8 arcfour_key[6][30] =
 146 {
 147     { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 148     { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 149     { 8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 150     { 4, 0xef, 0x01, 0x23, 0x45 },
 151     { 8, 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef },
 152     { 4, 0xef, 0x01, 0x23, 0x45 }
 153 };
 154 static sal_uInt8 arcfour_data_len[6] =
 155 {
 156     8, 8, 8, 20, 28, 10
 157 };
 158 static sal_uInt8 arcfour_data[6][30] =
 159 {
 160     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 0xff },
 161     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
 162     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff },
 163     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 164       0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 165       0x00, 0x00, 0x00, 0x00, 0xff },
 166     { 0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
 167       0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
 168       0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0,
 169       0x12, 0x34, 0x56, 0x78, 0xff },
 170     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 171       0x00, 0x00, 0xff }
 172 };
 173
 174 #if OSL_DEBUG_LEVEL > 0
 175 static sal_uInt8 ecb_ok[32] =
 176 {
 177     0x2A, 0xFD, 0x7D, 0xAA, 0x60, 0x62, 0x6B, 0xA3,
 178     0x86, 0x16, 0x46, 0x8C, 0xC2, 0x9C, 0xF6, 0xE1,
 179     0x29, 0x1E, 0x81, 0x7C, 0xC7, 0x40, 0x98, 0x2D,
 180     0x6F, 0x87, 0xAC, 0x5F, 0x17, 0x1A, 0xAB, 0xEA
 181 };
 182 static sal_uInt8 cbc_ok[32] =
 183 {
 184     0x6B, 0x77, 0xB4, 0xD6, 0x30, 0x06, 0xDE, 0xE6,
 185     0x05, 0xB1, 0x56, 0xE2, 0x74, 0x03, 0x97, 0x93,
 186     0x58, 0xDE, 0xB9, 0xE7, 0x15, 0x46, 0x16, 0xD9,
 187     0x59, 0xF1, 0x65, 0x2B, 0xD5, 0xFF, 0x92, 0xCC
 188 };
 189 static sal_uInt8 cfb_ok[] =
 190 {
 191     0xE7, 0x32, 0x14, 0xA2, 0x82, 0x21, 0x39, 0xCA,
 192     0xF2, 0x6E, 0xCF, 0x6D, 0x2E, 0xB9, 0xE7, 0x6E,
 193     0x3D, 0xA3, 0xDE, 0x04, 0xD1, 0x51, 0x72, 0x00,
 194     0x51, 0x9D, 0x57, 0xA6, 0xC3
 195 };
 196 static sal_uInt8 arcfour_ok[6][30] =
 197 {
 198     { 0x75, 0xb7, 0x87, 0x80, 0x99, 0xe0, 0xc5, 0x96, 0x00},
 199     { 0x74, 0x94, 0xc2, 0xe7, 0x10, 0x4b, 0x08, 0x79, 0x00},
 200     { 0xde, 0x18, 0x89, 0x41, 0xa3, 0x37, 0x5d, 0x3a, 0x00},
 201     { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
 202       0xbd, 0x61, 0x5a, 0x11, 0x62, 0xe1, 0xc7, 0xba,
 203       0x36, 0xb6, 0x78, 0x58, 0x00 },
 204     { 0x66, 0xa0, 0x94, 0x9f, 0x8a, 0xf7, 0xd6, 0x89,
 205       0x1f, 0x7f, 0x83, 0x2b, 0xa8, 0x33, 0xc0, 0x0c,
 206       0x89, 0x2e, 0xbe, 0x30, 0x14, 0x3c, 0xe2, 0x87,
 207       0x40, 0x01, 0x1e, 0xcf, 0x00 },
 208     { 0xd6, 0xa1, 0x41, 0xa7, 0xec, 0x3c, 0x38, 0xdf,
 209       0xbd, 0x61, 0x00}
 210 };
 211 #endif
 212
 213 int SAL_CALL main (void)
 214 {
 215     rtlCipher cipher;
 216
 217     /* ECB */
 218     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeECB);
 219     OSL_ASSERT(cipher != 0);
 220     if (cipher != 0)
 221     {
 222         rtlCipherError result;
 223         sal_uInt8      ecb_in[40], ecb_out[40];
 224         sal_uInt32     length = strlen(cbc_data) + 1;
 225
 226         result = rtl_cipher_init (
 227             cipher, rtl_Cipher_DirectionBoth,
 228             cbc_key, sizeof(cbc_key), NULL, 0);
 229         OSL_ASSERT(result == rtl_Cipher_E_None);
 230
 231         memset (ecb_out, 0, sizeof(ecb_out));
 232         result = rtl_cipher_encode (
 233             cipher, cbc_data, length, ecb_out, sizeof(ecb_out));
 234         OSL_ASSERT(result == rtl_Cipher_E_None);
 235         OSL_ASSERT(memcmp (ecb_out, ecb_ok, sizeof(ecb_ok)) == 0);
 236
 237         memset (ecb_in,  0, sizeof(ecb_in));
 238         result = rtl_cipher_decode (
 239             cipher, ecb_out, length, ecb_in, sizeof(ecb_in));
 240         OSL_ASSERT(result == rtl_Cipher_E_None);
 241         OSL_ASSERT(memcmp (ecb_in, cbc_data, length) == 0);
 242
 243         rtl_cipher_destroy (cipher);
 244     }
 245
 246     /* CBC */
 247     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeCBC);
 248     OSL_ASSERT(cipher != 0);
 249     if (cipher != 0)
 250     {
 251         rtlCipherError result;
 252         sal_uInt8      cbc_in[40], cbc_out[40];
 253         sal_uInt32     length = strlen(cbc_data) + 1;
 254
 255         result = rtl_cipher_init (
 256             cipher, rtl_Cipher_DirectionEncode,
 257             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 258         OSL_ASSERT(result == rtl_Cipher_E_None);
 259
 260         memset (cbc_out, 0, sizeof(cbc_out));
 261         result = rtl_cipher_encode (
 262             cipher, cbc_data, length, cbc_out, sizeof(cbc_out));
 263         OSL_ASSERT(result == rtl_Cipher_E_None);
 264         OSL_ASSERT(memcmp (cbc_out, cbc_ok, sizeof(cbc_ok)) == 0);
 265
 266         result = rtl_cipher_init (
 267             cipher, rtl_Cipher_DirectionDecode,
 268             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 269         OSL_ASSERT(result == rtl_Cipher_E_None);
 270
 271         memset (cbc_in,  0, sizeof(cbc_in));
 272         result = rtl_cipher_decode (
 273             cipher, cbc_out, length, cbc_in, sizeof(cbc_in));
 274         OSL_ASSERT(result == rtl_Cipher_E_None);
 275         OSL_ASSERT(memcmp (cbc_in, cbc_data, length) == 0);
 276
 277         rtl_cipher_destroy (cipher);
 278      }
 279
 280     /* CFB */
 281     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmBF, rtl_Cipher_ModeStream);
 282     OSL_ASSERT(cipher != 0);
 283     if (cipher != 0)
 284     {
 285         rtlCipherError result;
 286         sal_uInt8      cfb_in[40], cfb_out[40];
 287         sal_uInt32     length = strlen(cbc_data) + 1;
 288
 289         result = rtl_cipher_init (
 290             cipher, rtl_Cipher_DirectionEncode,
 291             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 292         OSL_ASSERT(result == rtl_Cipher_E_None);
 293
 294         memset (cfb_out, 0, sizeof(cfb_out));
 295         result = rtl_cipher_encode (
 296             cipher, cbc_data, length, cfb_out, sizeof(cfb_out));
 297         OSL_ASSERT(result == rtl_Cipher_E_None);
 298         OSL_ASSERT(memcmp (cfb_out, cfb_ok, sizeof(cfb_ok)) == 0);
 299
 300         result = rtl_cipher_init (
 301             cipher, rtl_Cipher_DirectionDecode,
 302             cbc_key, sizeof(cbc_key), cbc_iv, sizeof(cbc_iv));
 303         OSL_ASSERT(result == rtl_Cipher_E_None);
 304
 305         memset (cfb_in,  0, sizeof(cfb_in));
 306         result = rtl_cipher_decode (
 307             cipher, cfb_out, length, cfb_in, sizeof(cfb_in));
 308         OSL_ASSERT(result == rtl_Cipher_E_None);
 309         OSL_ASSERT(memcmp (cfb_in, cbc_data, length) == 0);
 310
 311         rtl_cipher_destroy (cipher);
 312     }
 313
 314     /* ARCFOUR */
 315     cipher = rtl_cipher_create (rtl_Cipher_AlgorithmARCFOUR, rtl_Cipher_ModeStream);
 316     OSL_ASSERT(cipher != 0);
 317     if (cipher != 0)
 318     {
 319         rtlCipherError result;
 320         sal_uInt8      arcfour_out[40];
 321         sal_Size       length;
 322         int            i, n;
 323
 324         n = SAL_N_ELEMENTS(arcfour_data_len);
 325         for (i = 0; i < n; i++)
 326         {
 327             length = arcfour_data_len[i];
 328
 329             result = rtl_cipher_init (
 330                 cipher, rtl_Cipher_DirectionBoth,
 331                 &(arcfour_key[i][1]), arcfour_key[i][0], 0, 0);
 332             OSL_ASSERT(result == rtl_Cipher_E_None);
 333
 334             memset (arcfour_out, 0, sizeof(arcfour_out));
 335             result = rtl_cipher_encode (
 336                 cipher, &(arcfour_data[i][0]), length,
 337                 arcfour_out, sizeof(arcfour_out));
 338             OSL_ASSERT(result == rtl_Cipher_E_None);
 339             OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[i], length) == 0);
 340         }
 341
 342         n = arcfour_data_len[3];
 343         for (i = 1; i < n; i++)
 344         {
 345             length = i;
 346
 347             result = rtl_cipher_init (
 348                 cipher, rtl_Cipher_DirectionBoth,
 349                 &(arcfour_key[3][1]), arcfour_key[3][0], 0, 0);
 350             OSL_ASSERT(result == rtl_Cipher_E_None);
 351
 352             memset (arcfour_out, 0, sizeof(arcfour_out));
 353             result = rtl_cipher_encode (
 354                 cipher, &(arcfour_data[3][0]), length,
 355                 arcfour_out, sizeof(arcfour_out));
 356             OSL_ASSERT(result == rtl_Cipher_E_None);
 357             OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[3], length) == 0);
 358             OSL_ASSERT(arcfour_out[length] == 0);
 359         }
 360
 361         n = arcfour_data_len[3];
 362         for (i = 1; i < n; i++)
 363         {
 364             length = i;
 365
 366             result = rtl_cipher_init (
 367                 cipher, rtl_Cipher_DirectionBoth,
 368                 &(arcfour_key[3][1]), arcfour_key[3][0], 0, 0);
 369             OSL_ASSERT(result == rtl_Cipher_E_None);
 370
 371             memset (arcfour_out, 0, sizeof(arcfour_out));
 372             result = rtl_cipher_encode (
 373                 cipher, &(arcfour_data[3][0]), length,
 374                 &(arcfour_out[0]), sizeof(arcfour_out));
 375             OSL_ASSERT(result == rtl_Cipher_E_None);
 376
 377             result = rtl_cipher_encode (
 378                 cipher, &(arcfour_data[3][length]), n - length,
 379                 &(arcfour_out[length]), sizeof(arcfour_out) - length);
 380             OSL_ASSERT(result == rtl_Cipher_E_None);
 381
 382             OSL_ASSERT(memcmp (arcfour_out, arcfour_ok[3], length) == 0);
 383         }
 384
 385         rtl_cipher_destroy (cipher);
 386     }
 387
 388     /* Done */
 389     return 0;
 390 }
 391
 392 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */