arc4.c 4.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201
  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 "mbedtls/platform_util.h"
  34. #include <string.h>
  35. #if defined(MBEDTLS_SELF_TEST)
  36. #if defined(MBEDTLS_PLATFORM_C)
  37. #include "mbedtls/platform.h"
  38. #else
  39. #include <stdio.h>
  40. #define mbedtls_printf printf
  41. #endif /* MBEDTLS_PLATFORM_C */
  42. #endif /* MBEDTLS_SELF_TEST */
  43. #if !defined(MBEDTLS_ARC4_ALT)
  44. void mbedtls_arc4_init( mbedtls_arc4_context *ctx )
  45. {
  46. memset( ctx, 0, sizeof( mbedtls_arc4_context ) );
  47. }
  48. void mbedtls_arc4_free( mbedtls_arc4_context *ctx )
  49. {
  50. if( ctx == NULL )
  51. return;
  52. mbedtls_platform_zeroize( ctx, sizeof( mbedtls_arc4_context ) );
  53. }
  54. /*
  55. * ARC4 key schedule
  56. */
  57. void mbedtls_arc4_setup( mbedtls_arc4_context *ctx, const unsigned char *key,
  58. unsigned int keylen )
  59. {
  60. int i, j, a;
  61. unsigned int k;
  62. unsigned char *m;
  63. ctx->x = 0;
  64. ctx->y = 0;
  65. m = ctx->m;
  66. for( i = 0; i < 256; i++ )
  67. m[i] = (unsigned char) i;
  68. j = k = 0;
  69. for( i = 0; i < 256; i++, k++ )
  70. {
  71. if( k >= keylen ) k = 0;
  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. * ARC4 cipher function
  80. */
  81. int mbedtls_arc4_crypt( mbedtls_arc4_context *ctx, size_t length, const unsigned char *input,
  82. unsigned char *output )
  83. {
  84. int x, y, a, b;
  85. size_t i;
  86. unsigned char *m;
  87. x = ctx->x;
  88. y = ctx->y;
  89. m = ctx->m;
  90. for( i = 0; i < length; i++ )
  91. {
  92. x = ( x + 1 ) & 0xFF; a = m[x];
  93. y = ( y + a ) & 0xFF; b = m[y];
  94. m[x] = (unsigned char) b;
  95. m[y] = (unsigned char) a;
  96. output[i] = (unsigned char)
  97. ( input[i] ^ m[(unsigned char)( a + b )] );
  98. }
  99. ctx->x = x;
  100. ctx->y = y;
  101. return( 0 );
  102. }
  103. #endif /* !MBEDTLS_ARC4_ALT */
  104. #if defined(MBEDTLS_SELF_TEST)
  105. /*
  106. * ARC4 tests vectors as posted by Eric Rescorla in sep. 1994:
  107. *
  108. * http://groups.google.com/group/comp.security.misc/msg/10a300c9d21afca0
  109. */
  110. static const unsigned char arc4_test_key[3][8] =
  111. {
  112. { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  113. { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  114. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
  115. };
  116. static const unsigned char arc4_test_pt[3][8] =
  117. {
  118. { 0x01, 0x23, 0x45, 0x67, 0x89, 0xAB, 0xCD, 0xEF },
  119. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 },
  120. { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }
  121. };
  122. static const unsigned char arc4_test_ct[3][8] =
  123. {
  124. { 0x75, 0xB7, 0x87, 0x80, 0x99, 0xE0, 0xC5, 0x96 },
  125. { 0x74, 0x94, 0xC2, 0xE7, 0x10, 0x4B, 0x08, 0x79 },
  126. { 0xDE, 0x18, 0x89, 0x41, 0xA3, 0x37, 0x5D, 0x3A }
  127. };
  128. /*
  129. * Checkup routine
  130. */
  131. int mbedtls_arc4_self_test( int verbose )
  132. {
  133. int i, ret = 0;
  134. unsigned char ibuf[8];
  135. unsigned char obuf[8];
  136. mbedtls_arc4_context ctx;
  137. mbedtls_arc4_init( &ctx );
  138. for( i = 0; i < 3; i++ )
  139. {
  140. if( verbose != 0 )
  141. mbedtls_printf( " ARC4 test #%d: ", i + 1 );
  142. memcpy( ibuf, arc4_test_pt[i], 8 );
  143. mbedtls_arc4_setup( &ctx, arc4_test_key[i], 8 );
  144. mbedtls_arc4_crypt( &ctx, 8, ibuf, obuf );
  145. if( memcmp( obuf, arc4_test_ct[i], 8 ) != 0 )
  146. {
  147. if( verbose != 0 )
  148. mbedtls_printf( "failed\n" );
  149. ret = 1;
  150. goto exit;
  151. }
  152. if( verbose != 0 )
  153. mbedtls_printf( "passed\n" );
  154. }
  155. if( verbose != 0 )
  156. mbedtls_printf( "\n" );
  157. exit:
  158. mbedtls_arc4_free( &ctx );
  159. return( ret );
  160. }
  161. #endif /* MBEDTLS_SELF_TEST */
  162. #endif /* MBEDTLS_ARC4_C */