src/libpolarssl/arc4.c

   1 /*
   2  *  An implementation of the ARCFOUR algorithm
   3  *
   4  *  Copyright (C) 2006-2014, Brainspark B.V.
   5  *
   6  *  This file is part of PolarSSL (http://www.polarssl.org)
   7  *  Lead Maintainer: Paul Bakker <polarssl_maintainer at polarssl.org>
   8  *
   9  *  All rights reserved.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program 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 General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License along
  22  *  with this program; if not, write to the Free Software Foundation, Inc.,
  23  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  24  */
  25 /*
  26  *  The ARCFOUR algorithm was publicly disclosed on 94/09.
  27  *
  28  *  http://groups.google.com/group/sci.crypt/msg/10a300c9d21afca0
  29  */
  30
  31 #if !defined(POLARSSL_CONFIG_FILE)
  32 #include "config.h"
  33 #else
  34 #include POLARSSL_CONFIG_FILE
  35 #endif
  36
  37 #if defined(POLARSSL_ARC4_C)
  38
  39 #include "arc4.h"
  40
  41 #if defined(POLARSSL_PLATFORM_C)
  42 #include "platform.h"
  43 #else
  44 #define polarssl_printf printf
  45 #endif
  46
  47 #if !defined(POLARSSL_ARC4_ALT)
  48
  49 /*
  50  * ARC4 key schedule
  51  */
  52 void arc4_setup( arc4_context *ctx, const unsigned char *key,
  53                  unsigned int keylen )
  54 {
  55     int i, j, a;
  56     unsigned int k;
  57     unsigned char *m;
  58
  59     ctx->x = 0;
  60     ctx->y = 0;
  61     m = ctx->m;
  62
  63     for( i = 0; i < 256; i++ )
  64         m[i] = (unsigned char) i;
  65
  66     j = k = 0;
  67
  68     for( i = 0; i < 256; i++, k++ )
  69     {
  70         if( k >= keylen ) k = 0;
  71
  72         a = m[i];
  73         j = ( j + a + key[k] ) & 0xFF;
  74         m[i] = m[j];
  75         m[j] = (unsigned char) a;
  76     }
  77 }
  78
  79 /*
  80  * ARC4 cipher function
  81  */
  82 int arc4_crypt( arc4_context *ctx, size_t length, const unsigned char *input,
  83                 unsigned char *output )
  84 {
  85     int x, y, a, b;
  86     size_t i;
  87     unsigned char *m;
  88
  89     x = ctx->x;
  90     y = ctx->y;
  91     m = ctx->m;
  92
  93     for( i = 0; i < length; i++ )
  94     {
  95         x = ( x + 1 ) & 0xFF; a = m[x];
  96         y = ( y + a ) & 0xFF; b = m[y];
  97
  98         m[x] = (unsigned char) b;
  99         m[y] = (unsigned char) a;
 100
 101         output[i] = (unsigned char)
 102             ( input[i] ^ m[(unsigned char)( a + b )] );
 103     }
 104
 105     ctx->x = x;
 106     ctx->y = y;
 107
 108     return( 0 );
 109 }
 110
 111 #endif /* !POLARSSL_ARC4_ALT */
 112
 113 #if defined(POLARSSL_SELF_TEST)
 114
 115 #include <string.h>
 116 #include <stdio.h>
 117
 118 /*
 119  * ARC4 tests vectors as posted by Eric Rescorla in sep. 1994:
 120  *
 121  * http://groups.google.com/group/comp.security.misc/msg/10a300c9d21afca0
 122  */
 123 static const unsigned char arc4_test_key[3][8] =
 124 {
 125     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
 126     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
 127     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
 128 };
 129
 130 static const unsigned char arc4_test_pt[3][8] =
 131 {
 132     { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
 133     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
 134     { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
 135 };
 136
 137 static const unsigned char arc4_test_ct[3][8] =
 138 {
 139     { 0x75, 0xB7, 0x87, 0x80, 0x99, 0xE0, 0xC5, 0x96 },
 140     { 0x74, 0x94, 0xC2, 0xE7, 0x10, 0x4B, 0x08, 0x79 },
 141     { 0xDE, 0x18, 0x89, 0x41, 0xA3, 0x37, 0x5D, 0x3A }
 142 };
 143
 144 /*
 145  * Checkup routine
 146  */
 147 int arc4_self_test( int verbose )
 148 {
 149     int i;
 150     unsigned char ibuf[8];
 151     unsigned char obuf[8];
 152     arc4_context ctx;
 153
 154     for( i = 0; i < 3; i++ )
 155     {
 156         if( verbose != 0 )
 157             polarssl_printf( "  ARC4 test #%d: ", i + 1 );
 158
 159         memcpy( ibuf, arc4_test_pt[i], 8 );
 160
 161         arc4_setup( &ctx, arc4_test_key[i], 8 );
 162         arc4_crypt( &ctx, 8, ibuf, obuf );
 163
 164         if( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 )
 165         {
 166             if( verbose != 0 )
 167                 polarssl_printf( "failed\n" );
 168
 169             return( 1 );
 170         }
 171
 172         if( verbose != 0 )
 173             polarssl_printf( "passed\n" );
 174     }
 175
 176     if( verbose != 0 )
 177         polarssl_printf( "\n" );
 178
 179     return( 0 );
 180 }
 181
 182 #endif /* POLARSSL_SELF_TEST */
 183
 184 #endif /* POLARSSL_ARC4_C */