Return to arc4.c CVS log

Up to [Qemu by Fabrice Bellard] / qemu / roms / ipxe / src / crypto

Annotation of qemu/roms/ipxe/src/crypto/arc4.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * The ARC4 stream cipher.
        !             3:  *
        !             4:  * Copyright (c) 2009 Joshua Oreman <[email protected]>.
        !             5:  *
        !             6:  * This program is free software; you can redistribute it and/or
        !             7:  * modify it under the terms of the GNU General Public License as
        !             8:  * published by the Free Software Foundation; either version 2 of the
        !             9:  * License, or any later version.
        !            10:  *
        !            11:  * This program is distributed in the hope that it will be useful, but
        !            12:  * WITHOUT ANY WARRANTY; without even the implied warranty of
        !            13:  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
        !            14:  * General Public License for more details.
        !            15:  *
        !            16:  * You should have received a copy of the GNU General Public License
        !            17:  * along with this program; if not, write to the Free Software
        !            18:  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
        !            19:  */
        !            20: 
        !            21: FILE_LICENCE ( GPL2_OR_LATER );
        !            22: 
        !            23: #include <ipxe/crypto.h>
        !            24: #include <ipxe/arc4.h>
        !            25: 
        !            26: #define SWAP( ary, i, j )      \
        !            27:        ({ u8 temp = ary[i]; ary[i] = ary[j]; ary[j] = temp; })
        !            28: 
        !            29: /**
        !            30:  * Set ARC4 key
        !            31:  *
        !            32:  * @v ctxv     ARC4 encryption context
        !            33:  * @v keyv     Key to set
        !            34:  * @v keylen   Length of key
        !            35:  *
        !            36:  * If an initialisation vector is to be used, it should be prepended
        !            37:  * to the key; ARC4 does not implement the @c setiv function because
        !            38:  * there is no standard length for an initialisation vector in the
        !            39:  * cipher.
        !            40:  */
        !            41: static int arc4_setkey ( void *ctxv, const void *keyv, size_t keylen )
        !            42: {
        !            43:        struct arc4_ctx *ctx = ctxv;
        !            44:        const u8 *key = keyv;
        !            45:        u8 *S = ctx->state;
        !            46:        int i, j;
        !            47: 
        !            48:        for ( i = 0; i < 256; i++ ) {
        !            49:                S[i] = i;
        !            50:        }
        !            51: 
        !            52:        for ( i = j = 0; i < 256; i++ ) {
        !            53:                j = ( j + S[i] + key[i % keylen] ) & 0xff;
        !            54:                SWAP ( S, i, j );
        !            55:        }
        !            56: 
        !            57:        ctx->i = ctx->j = 0;
        !            58:        return 0;
        !            59: }
        !            60: 
        !            61: /**
        !            62:  * Perform ARC4 encryption or decryption
        !            63:  *
        !            64:  * @v ctxv     ARC4 encryption context
        !            65:  * @v srcv     Data to encrypt or decrypt
        !            66:  * @v dstv     Location to store encrypted or decrypted data
        !            67:  * @v len      Length of data to operate on
        !            68:  *
        !            69:  * ARC4 is a stream cipher that works by generating a stream of PRNG
        !            70:  * data based on the key, and XOR'ing it with the data to be
        !            71:  * encrypted. Since XOR is symmetric, encryption and decryption in
        !            72:  * ARC4 are the same operation.
        !            73:  *
        !            74:  * If you pass a @c NULL source or destination pointer, @a len
        !            75:  * keystream bytes will be consumed without encrypting any data.
        !            76:  */
        !            77: static void arc4_xor ( void *ctxv, const void *srcv, void *dstv,
        !            78:                       size_t len )
        !            79: {
        !            80:        struct arc4_ctx *ctx = ctxv;
        !            81:        const u8 *src = srcv;
        !            82:        u8 *dst = dstv;
        !            83:        u8 *S = ctx->state;
        !            84:        int i = ctx->i, j = ctx->j;
        !            85: 
        !            86:        while ( len-- ) {
        !            87:                i = ( i + 1 ) & 0xff;
        !            88:                j = ( j + S[i] ) & 0xff;
        !            89:                SWAP ( S, i, j );
        !            90:                if ( srcv && dstv )
        !            91:                        *dst++ = *src++ ^ S[(S[i] + S[j]) & 0xff];
        !            92:        }
        !            93: 
        !            94:        ctx->i = i;
        !            95:        ctx->j = j;
        !            96: }
        !            97: 
        !            98: static void arc4_setiv ( void *ctx __unused, const void *iv __unused )
        !            99: {
        !           100:        /* ARC4 does not use a fixed-length IV */
        !           101: }
        !           102: 
        !           103: 
        !           104: /**
        !           105:  * Perform ARC4 encryption or decryption, skipping initial keystream bytes
        !           106:  *
        !           107:  * @v key      ARC4 encryption key
        !           108:  * @v keylen   Key length
        !           109:  * @v skip     Number of bytes of keystream to skip
        !           110:  * @v src      Message to encrypt or decrypt
        !           111:  * @v msglen   Length of message
        !           112:  * @ret dst    Encrypted or decrypted message
        !           113:  */
        !           114: void arc4_skip ( const void *key, size_t keylen, size_t skip,
        !           115:                 const void *src, void *dst, size_t msglen )
        !           116: {
        !           117:        struct arc4_ctx ctx;
        !           118:        arc4_setkey ( &ctx, key, keylen );
        !           119:        arc4_xor ( &ctx, NULL, NULL, skip );
        !           120:        arc4_xor ( &ctx, src, dst, msglen );
        !           121: }
        !           122: 
        !           123: struct cipher_algorithm arc4_algorithm = {
        !           124:        .name = "ARC4",
        !           125:        .ctxsize = ARC4_CTX_SIZE,
        !           126:        .blocksize = 1,
        !           127:        .setkey = arc4_setkey,
        !           128:        .setiv = arc4_setiv,
        !           129:        .encrypt = arc4_xor,
        !           130:        .decrypt = arc4_xor,
        !           131: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.