arc4.c 4.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205
  1. /*
  2. * An implementation of the ARCFOUR algorithm
  3. *
  4. * Copyright (C) 2006-2015, ARM Limited, All Rights Reserved
  5. * SPDX-License-Identifier: Apache-2.0
  6. *
  7. * Licensed under the Apache License, Version 2.0 (the "License"); you may
  8. * not use this file except in compliance with the License.
  9. * You may obtain a copy of the License at
  10. *
  11. * http://www.apache.org/licenses/LICENSE-2.0
  12. *
  13. * Unless required by applicable law or agreed to in writing, software
  14. * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15. * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16. * See the License for the specific language governing permissions and
  17. * limitations under the License.
  18. *
  19. * This file is part of mbed TLS (https://tls.mbed.org)
  20. */
  21. /*
  22. * The ARCFOUR algorithm was publicly disclosed on 94/09.
  23. *
  24. * http://groups.google.com/group/sci.crypt/msg/10a300c9d21afca0
  25. */
  26. #if !defined(MBEDTLS_CONFIG_FILE)
  27. #include "mbedtls/config.h"
  28. #else
  29. #include MBEDTLS_CONFIG_FILE
  30. #endif
  31. #if defined(MBEDTLS_ARC4_C)
  32. #include "mbedtls/arc4.h"
  33. #include <string.h>
  34. #if defined(MBEDTLS_SELF_TEST)
  35. #if defined(MBEDTLS_PLATFORM_C)
  36. #include "mbedtls/platform.h"
  37. #else
  38. #include <stdio.h>
  39. #define mbedtls_printf printf
  40. #endif /* MBEDTLS_PLATFORM_C */
  41. #endif /* MBEDTLS_SELF_TEST */
  42. #if !defined(MBEDTLS_ARC4_ALT)
  43. /* Implementation that should never be optimized out by the compiler */
  44. static void mbedtls_zeroize( void *v, size_t n ) {
  45. volatile unsigned char *p = (unsigned char*)v; while( n-- ) *p++ = 0;
  46. }
  47. void mbedtls_arc4_init( mbedtls_arc4_context *ctx )
  48. {
  49. memset( ctx, 0, sizeof( mbedtls_arc4_context ) );
  50. }
  51. void mbedtls_arc4_free( mbedtls_arc4_context *ctx )
  52. {
  53. if( ctx == NULL )
  54. return;
  55. mbedtls_zeroize( ctx, sizeof( mbedtls_arc4_context ) );
  56. }
  57. /*
  58. * ARC4 key schedule
  59. */
  60. void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
  61. unsigned int keylen )
  62. {
  63. int i, j, a;
  64. unsigned int k;
  65. unsigned char *m;
  66. ctx->x = 0;
  67. ctx->y = 0;
  68. m = ctx->m;
  69. for( i = 0; i < 256; i++ )
  70. m[i] = (unsigned char) i;
  71. j = k = 0;
  72. for( i = 0; i < 256; i++, k++ )
  73. {
  74. if( k >= keylen ) k = 0;
  75. a = m[i];
  76. j = ( j + a + key[k] ) & 0xFF;
  77. m[i] = m[j];
  78. m[j] = (unsigned char) a;
  79. }
  80. }
  81. /*
  82. * ARC4 cipher function
  83. */
  84. int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned char *input,
  85. unsigned char *output )
  86. {
  87. int x, y, a, b;
  88. size_t i;
  89. unsigned char *m;
  90. x = ctx->x;
  91. y = ctx->y;
  92. m = ctx->m;
  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. m[x] = (unsigned char) b;
  98. m[y] = (unsigned char) a;
  99. output[i] = (unsigned char)
  100. ( input[i] ^ m[(unsigned char)( a + b )] );
  101. }
  102. ctx->x = x;
  103. ctx->y = y;
  104. return( 0 );
  105. }
  106. #endif /* !MBEDTLS_ARC4_ALT */
  107. #if defined(MBEDTLS_SELF_TEST)
  108. /*
  109. * ARC4 tests vectors as posted by Eric Rescorla in sep. 1994:
  110. *
  111. * http://groups.google.com/group/comp.security.misc/msg/10a300c9d21afca0
  112. */
  113. static const unsigned char arc4_test_key[3][8] =
  114. {
  115. { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  116. { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  117. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
  118. };
  119. static const unsigned char arc4_test_pt[3][8] =
  120. {
  121. { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  122. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  123. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
  124. };
  125. static const unsigned char arc4_test_ct[3][8] =
  126. {
  127. { 0x75, 0xB7, 0x87, 0x80, 0x99, 0xE0, 0xC5, 0x96 },
  128. { 0x74, 0x94, 0xC2, 0xE7, 0x10, 0x4B, 0x08, 0x79 },
  129. { 0xDE, 0x18, 0x89, 0x41, 0xA3, 0x37, 0x5D, 0x3A }
  130. };
  131. /*
  132. * Checkup routine
  133. */
  134. int mbedtls_arc4_self_test( int verbose )
  135. {
  136. int i, ret = 0;
  137. unsigned char ibuf[8];
  138. unsigned char obuf[8];
  139. mbedtls_arc4_context ctx;
  140. mbedtls_arc4_init( &ctx );
  141. for( i = 0; i < 3; i++ )
  142. {
  143. if( verbose != 0 )
  144. mbedtls_printf( " ARC4 test #%d: ", i + 1 );
  145. memcpy( ibuf, arc4_test_pt[i], 8 );
  146. mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 );
  147. mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf );
  148. if( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 )
  149. {
  150. if( verbose != 0 )
  151. mbedtls_printf( "failed\n" );
  152. ret = 1;
  153. goto exit;
  154. }
  155. if( verbose != 0 )
  156. mbedtls_printf( "passed\n" );
  157. }
  158. if( verbose != 0 )
  159. mbedtls_printf( "\n" );
  160. exit:
  161. mbedtls_arc4_free( &ctx );
  162. return( ret );
  163. }
  164. #endif /* MBEDTLS_SELF_TEST */
  165. #endif /* MBEDTLS_ARC4_C */