FreeBSD/Linux Kernel Cross Reference
sys/crypto/rc4/rc4.c

     /*
      * rc4.c
      *
      * Copyright (c) 1996-2000 Whistle Communications, Inc.
      * All rights reserved.
      * 
      * Subject to the following obligations and disclaimer of warranty, use and
      * redistribution of this software, in source or object code forms, with or
      * without modifications are expressly permitted by Whistle Communications;
     * provided, however, that:
     * 1. Any and all reproductions of the source or object code must include the
     *    copyright notice above and the following disclaimer of warranties; and
     * 2. No rights are granted, in any manner or form, to use Whistle
     *    Communications, Inc. trademarks, including the mark "WHISTLE
     *    COMMUNICATIONS" on advertising, endorsements, or otherwise except as
     *    such appears in the above copyright notice or in the software.
     * 
     * THIS SOFTWARE IS BEING PROVIDED BY WHISTLE COMMUNICATIONS "AS IS", AND
     * TO THE MAXIMUM EXTENT PERMITTED BY LAW, WHISTLE COMMUNICATIONS MAKES NO
     * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING THIS SOFTWARE,
     * INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED WARRANTIES OF
     * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, OR NON-INFRINGEMENT.
     * WHISTLE COMMUNICATIONS DOES NOT WARRANT, GUARANTEE, OR MAKE ANY
     * REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS OF THE USE OF THIS
     * SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY, RELIABILITY OR OTHERWISE.
     * IN NO EVENT SHALL WHISTLE COMMUNICATIONS BE LIABLE FOR ANY DAMAGES
     * RESULTING FROM OR ARISING OUT OF ANY USE OF THIS SOFTWARE, INCLUDING
     * WITHOUT LIMITATION, ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY,
     * PUNITIVE, OR CONSEQUENTIAL DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR
     * SERVICES, LOSS OF USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY
     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
     * THIS SOFTWARE, EVEN IF WHISTLE COMMUNICATIONS IS ADVISED OF THE POSSIBILITY
     * OF SUCH DAMAGE.
     */
    
    #include <sys/cdefs.h>
    __FBSDID("$FreeBSD$");
    
    #include <sys/param.h>
    #include <sys/kernel.h>
    #include <sys/module.h>
    #include <sys/types.h>
    #include <crypto/rc4/rc4.h>
    
    static __inline void
    swap_bytes(u_char *a, u_char *b)
    {
            u_char temp;
    
            temp = *a;
            *a = *b;
            *b = temp;
    }
    
    /*
     * Initialize an RC4 state buffer using the supplied key,
     * which can have arbitrary length.
     */
    void
    rc4_init(struct rc4_state *const state, const u_char *key, int keylen)
    {
            u_char j;
            int i, k;
    
            /* Initialize state with identity permutation */
            for (i = 0; i < 256; i++)
                    state->perm[i] = (u_char)i; 
            state->index1 = 0;
            state->index2 = 0;
      
            /* Randomize the permutation using key data */
            for (j = i = k = 0; i < 256; i++) {
                    j += state->perm[i] + key[k]; 
                    swap_bytes(&state->perm[i], &state->perm[j]);
                    if (++k >= keylen)
                            k = 0;
            }
    }
    
    /*
     * Encrypt some data using the supplied RC4 state buffer.
     * The input and output buffers may be the same buffer.
     * Since RC4 is a stream cypher, this function is used
     * for both encryption and decryption.
     */
    void
    rc4_crypt(struct rc4_state *const state,
            const u_char *inbuf, u_char *outbuf, int buflen)
    {
            int i;
            u_char j;
    
            for (i = 0; i < buflen; i++) {
    
                    /* Update modification indicies */
                    state->index1++;
                    state->index2 += state->perm[state->index1];
    
                   /* Modify permutation */
                   swap_bytes(&state->perm[state->index1],
                       &state->perm[state->index2]);
   
                   /* Encrypt/decrypt next byte */
                   j = state->perm[state->index1] + state->perm[state->index2];
                   outbuf[i] = inbuf[i] ^ state->perm[j];
           }
   }
   
   static int
   rc4_modevent(module_t mod, int type, void *unused)
   {
           switch (type) {
           case MOD_LOAD:
                   return 0;
           case MOD_UNLOAD:
                   return 0;
           }
           return EINVAL;
   }
   
   static moduledata_t rc4_mod = {
           "rc4",
           rc4_modevent,
           0
   };
   DECLARE_MODULE(rc4, rc4_mod, SI_SUB_DRIVERS, SI_ORDER_FIRST);
   MODULE_VERSION(rc4, 1);

Cache object: 4485a523079b486b162d8b8a5ab7ae6d