cipher-des.c

海思KEY驱动

/*
 * Sourcecode created by descore. Descore is under GPL and from 
 * Dana L. How <[e-mail]>.
 *
 * Modified by Raimar Falke <[e-mail]> for the Linux-Kernel.
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public License
 * as published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 */

#include <linux/string.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <asm/byteorder.h>
#include <linux/crypto.h>
#include <linux/wordops.h>

#ifdef MODULE_LICENSE
MODULE_LICENSE("GPL");
#endif
#ifdef MODULE_DESCRIPTION
MODULE_DESCRIPTION ("DES Cipher / CryptoAPI");
#endif

typedef u8 DesData[8];
typedef u32 DesKeys[32];

const static u32 des_keymap[] = {
 0x02080008, 0x02082000, 0x00002008, 0x00000000,
 0x02002000, 0x00080008, 0x02080000, 0x02082008,
 0x00000008, 0x02000000, 0x00082000, 0x00002008,
 0x00082008, 0x02002008, 0x02000008, 0x02080000,
 0x00002000, 0x00082008, 0x00080008, 0x02002000,
 0x02082008, 0x02000008, 0x00000000, 0x00082000,
 0x02000000, 0x00080000, 0x02002008, 0x02080008,
 0x00080000, 0x00002000, 0x02082000, 0x00000008,
 0x00080000, 0x00002000, 0x02000008, 0x02082008,
 0x00002008, 0x02000000, 0x00000000, 0x00082000,
 0x02080008, 0x02002008, 0x02002000, 0x00080008,
 0x02082000, 0x00000008, 0x00080008, 0x02002000,
 0x02082008, 0x00080000, 0x02080000, 0x02000008,
 0x00082000, 0x00002008, 0x02002008, 0x02080000,
 0x00000008, 0x02082000, 0x00082008, 0x00000000,
 0x02000000, 0x02080008, 0x00002000, 0x00082008,

 0x08000004, 0x00020004, 0x00000000, 0x08020200,
 0x00020004, 0x00000200, 0x08000204, 0x00020000,
 0x00000204, 0x08020204, 0x00020200, 0x08000000,
 0x08000200, 0x08000004, 0x08020000, 0x00020204,
 0x00020000, 0x08000204, 0x08020004, 0x00000000,
 0x00000200, 0x00000004, 0x08020200, 0x08020004,
 0x08020204, 0x08020000, 0x08000000, 0x00000204,
 0x00000004, 0x00020200, 0x00020204, 0x08000200,
 0x00000204, 0x08000000, 0x08000200, 0x00020204,
 0x08020200, 0x00020004, 0x00000000, 0x08000200,
 0x08000000, 0x00000200, 0x08020004, 0x00020000,
 0x00020004, 0x08020204, 0x00020200, 0x00000004,
 0x08020204, 0x00020200, 0x00020000, 0x08000204,
 0x08000004, 0x08020000, 0x00020204, 0x00000000,
 0x00000200, 0x08000004, 0x08000204, 0x08020200,
 0x08020000, 0x00000204, 0x00000004, 0x08020004,

 0x80040100, 0x01000100, 0x80000000, 0x81040100,
 0x00000000, 0x01040000, 0x81000100, 0x80040000,
 0x01040100, 0x81000000, 0x01000000, 0x80000100,
 0x81000000, 0x80040100, 0x00040000, 0x01000000,
 0x81040000, 0x00040100, 0x00000100, 0x80000000,
 0x00040100, 0x81000100, 0x01040000, 0x00000100,
 0x80000100, 0x00000000, 0x80040000, 0x01040100,
 0x01000100, 0x81040000, 0x81040100, 0x00040000,
 0x81040000, 0x80000100, 0x00040000, 0x81000000,
 0x00040100, 0x01000100, 0x80000000, 0x01040000,
 0x81000100, 0x00000000, 0x00000100, 0x80040000,
 0x00000000, 0x81040000, 0x01040100, 0x00000100,
 0x01000000, 0x81040100, 0x80040100, 0x00040000,
 0x81040100, 0x80000000, 0x01000100, 0x80040100,
 0x80040000, 0x00040100, 0x01040000, 0x81000100,
 0x80000100, 0x01000000, 0x81000000, 0x01040100,

 0x04010801, 0x00000000, 0x00010800, 0x04010000,
 0x04000001, 0x00000801, 0x04000800, 0x00010800,
 0x00000800, 0x04010001, 0x00000001, 0x04000800,
 0x00010001, 0x04010800, 0x04010000, 0x00000001,
 0x00010000, 0x04000801, 0x04010001, 0x00000800,
 0x00010801, 0x04000000, 0x00000000, 0x00010001,
 0x04000801, 0x00010801, 0x04010800, 0x04000001,
 0x04000000, 0x00010000, 0x00000801, 0x04010801,
 0x00010001, 0x04010800, 0x04000800, 0x00010801,
 0x04010801, 0x00010001, 0x04000001, 0x00000000,
 0x04000000, 0x00000801, 0x00010000, 0x04010001,
 0x00000800, 0x04000000, 0x00010801, 0x04000801,
 0x04010800, 0x00000800, 0x00000000, 0x04000001,
 0x00000001, 0x04010801, 0x00010800, 0x04010000,
 0x04010001, 0x00010000, 0x00000801, 0x04000800,
 0x04000801, 0x00000001, 0x04010000, 0x00010800,

 0x00000400, 0x00000020, 0x00100020, 0x40100000,
 0x40100420, 0x40000400, 0x00000420, 0x00000000,
 0x00100000, 0x40100020, 0x40000020, 0x00100400,
 0x40000000, 0x00100420, 0x00100400, 0x40000020,
 0x40100020, 0x00000400, 0x40000400, 0x40100420,
 0x00000000, 0x00100020, 0x40100000, 0x00000420,
 0x40100400, 0x40000420, 0x00100420, 0x40000000,
 0x40000420, 0x40100400, 0x00000020, 0x00100000,
 0x40000420, 0x00100400, 0x40100400, 0x40000020,
 0x00000400, 0x00000020, 0x00100000, 0x40100400,
 0x40100020, 0x40000420, 0x00000420, 0x00000000,
 0x00000020, 0x40100000, 0x40000000, 0x00100020,
 0x00000000, 0x40100020, 0x00100020, 0x00000420,
 0x40000020, 0x00000400, 0x40100420, 0x00100000,
 0x00100420, 0x40000000, 0x40000400, 0x40100420,
 0x40100000, 0x00100420, 0x00100400, 0x40000400,

 0x00800000, 0x00001000, 0x00000040, 0x00801042,
 0x00801002, 0x00800040, 0x00001042, 0x00801000,
 0x00001000, 0x00000002, 0x00800002, 0x00001040,
 0x00800042, 0x00801002, 0x00801040, 0x00000000,
 0x00001040, 0x00800000, 0x00001002, 0x00000042,
 0x00800040, 0x00001042, 0x00000000, 0x00800002,
 0x00000002, 0x00800042, 0x00801042, 0x00001002,
 0x00801000, 0x00000040, 0x00000042, 0x00801040,
 0x00801040, 0x00800042, 0x00001002, 0x00801000,
 0x00001000, 0x00000002, 0x00800002, 0x00800040,
 0x00800000, 0x00001040, 0x00801042, 0x00000000,
 0x00001042, 0x00800000, 0x00000040, 0x00001002,
 0x00800042, 0x00000040, 0x00000000, 0x00801042,
 0x00801002, 0x00801040, 0x00000042, 0x00001000,
 0x00001040, 0x00801002, 0x00800040, 0x00000042,
 0x00000002, 0x00001042, 0x00801000, 0x00800002,

 0x10400000, 0x00404010, 0x00000010, 0x10400010,
 0x10004000, 0x00400000, 0x10400010, 0x00004010,
 0x00400010, 0x00004000, 0x00404000, 0x10000000,
 0x10404010, 0x10000010, 0x10000000, 0x10404000,
 0x00000000, 0x10004000, 0x00404010, 0x00000010,
 0x10000010, 0x10404010, 0x00004000, 0x10400000,
 0x10404000, 0x00400010, 0x10004010, 0x00404000,
 0x00004010, 0x00000000, 0x00400000, 0x10004010,
 0x00404010, 0x00000010, 0x10000000, 0x00004000,
 0x10000010, 0x10004000, 0x00404000, 0x10400010,
 0x00000000, 0x00404010, 0x00004010, 0x10404000,
 0x10004000, 0x00400000, 0x10404010, 0x10000000,
 0x10004010, 0x10400000, 0x00400000, 0x10404010,
 0x00004000, 0x00400010, 0x10400010, 0x00004010,
 0x00400010, 0x00000000, 0x10404000, 0x10000010,
 0x10400000, 0x10004010, 0x00000010, 0x00404000,

 0x00208080, 0x00008000, 0x20200000, 0x20208080,
 0x00200000, 0x20008080, 0x20008000, 0x20200000,
 0x20008080, 0x00208080, 0x00208000, 0x20000080,
 0x20200080, 0x00200000, 0x00000000, 0x20008000,
 0x00008000, 0x20000000, 0x00200080, 0x00008080,
 0x20208080, 0x00208000, 0x20000080, 0x00200080,
 0x20000000, 0x00000080, 0x00008080, 0x20208000,
 0x00000080, 0x20200080, 0x20208000, 0x00000000,
 0x00000000, 0x20208080, 0x00200080, 0x20008000,
 0x00208080, 0x00008000, 0x20000080, 0x00200080,
 0x20208000, 0x00000080, 0x00008080, 0x20200000,
 0x20008080, 0x20000000, 0x20200000, 0x00208000,
 0x20208080, 0x00008080, 0x00208000, 0x20200080,
 0x00200000, 0x20000080, 0x20008000, 0x00000000,
 0x00008000, 0x00200000, 0x20200080, 0x00208080,
 0x20000000, 0x20208000, 0x00000080, 0x20008080,
};

const static u8 rotors[] = {
 34, 13,  5, 46, 47, 18, 32, 41, 11, 53, 33, 20,
 14, 36, 30, 24, 49,  2, 15, 37, 42, 50,  0, 21,
 38, 48,  6, 26, 39,  4, 52, 25, 12, 27, 31, 40,
  1, 17, 28, 29, 23, 51, 35,  7,  3, 22,  9, 43,

 41, 20, 12, 53, 54, 25, 39, 48, 18, 31, 40, 27,
 21, 43, 37,  0,  1,  9, 22, 44, 49,  2,  7, 28,
 45, 55, 13, 33, 46, 11,  6, 32, 19, 34, 38, 47,
  8, 24, 35, 36, 30,  3, 42, 14, 10, 29, 16, 50,

 55, 34, 26, 38, 11, 39, 53,  5, 32, 45, 54, 41,
 35,  2, 51, 14, 15, 23, 36,  3,  8, 16, 21, 42,
  6, 12, 27, 47, 31, 25, 20, 46, 33, 48, 52,  4,
 22,  7, 49, 50, 44, 17,  1, 28, 24, 43, 30,  9,

 12, 48, 40, 52, 25, 53, 38, 19, 46,  6, 11, 55,
 49, 16, 10, 28, 29, 37, 50, 17, 22, 30, 35,  1,
 20, 26, 41,  4, 45, 39, 34, 31, 47,  5, 13, 18,
 36, 21,  8,  9,  3,  0, 15, 42,  7,  2, 44, 23,

 26,  5, 54, 13, 39, 38, 52, 33, 31, 20, 25, 12,
  8, 30, 24, 42, 43, 51,  9,  0, 36, 44, 49, 15,
 34, 40, 55, 18,  6, 53, 48, 45,  4, 19, 27, 32,
 50, 35, 22, 23, 17, 14, 29,  1, 21, 16,  3, 37,

 40, 19, 11, 27, 53, 52, 13, 47, 45, 34, 39, 26,
 22, 44,  7,  1,  2, 10, 23, 14, 50,  3,  8, 29,
 48, 54, 12, 32, 20, 38,  5,  6, 18, 33, 41, 46,
  9, 49, 36, 37,  0, 28, 43, 15, 35, 30, 17, 51,

 54, 33, 25, 41, 38, 13, 27,  4,  6, 48, 53, 40,
 36,  3, 21, 15, 16, 24, 37, 28,  9, 17, 22, 43,
  5, 11, 26, 46, 34, 52, 19, 20, 32, 47, 55, 31,
 23,  8, 50, 51, 14, 42,  2, 29, 49, 44,  0, 10,

 11, 47, 39, 55, 52, 27, 41, 18, 20,  5, 38, 54,
 50, 17, 35, 29, 30,  7, 51, 42, 23,  0, 36,  2,
 19, 25, 40, 31, 48, 13, 33, 34, 46,  4, 12, 45,
 37, 22,  9, 10, 28,  1, 16, 43,  8,  3, 14, 24,

 18, 54, 46,  5,  6, 34, 48, 25, 27, 12, 45,  4,
  2, 24, 42, 36, 37, 14,  3, 49, 30,  7, 43,  9,
 26, 32, 47, 38, 55, 20, 40, 41, 53, 11, 19, 52,
 44, 29, 16, 17, 35,  8, 23, 50, 15, 10, 21,  0,

 32, 11, 31, 19, 20, 48,  5, 39, 41, 26,  6, 18,
 16,  7,  1, 50, 51, 28, 17,  8, 44, 21,  2, 23,
 40, 46,  4, 52, 12, 34, 54, 55, 38, 25, 33, 13,
  3, 43, 30,  0, 49, 22, 37,  9, 29, 24, 35, 14,

 46, 25, 45, 33, 34,  5, 19, 53, 55, 40, 20, 32,
 30, 21, 15,  9, 10, 42,  0, 22,  3, 35, 16, 37,
 54, 31, 18, 13, 26, 48, 11, 12, 52, 39, 47, 27,
 17,  2, 44, 14,  8, 36, 51, 23, 43,  7, 49, 28,

 31, 39,  6, 47, 48, 19, 33, 38, 12, 54, 34, 46,
 44, 35, 29, 23, 24,  1, 14, 36, 17, 49, 30, 51,
 11, 45, 32, 27, 40,  5, 25, 26, 13, 53,  4, 41,
  0, 16,  3, 28, 22, 50, 10, 37,  2, 21,  8, 42,

 45, 53, 20,  4,  5, 33, 47, 52, 26, 11, 48, 31,
  3, 49, 43, 37,  7, 15, 28, 50,  0,  8, 44, 10,
 25,  6, 46, 41, 54, 19, 39, 40, 27, 38, 18, 55,
 14, 30, 17, 42, 36,  9, 24, 51, 16, 35, 22,  1,

  6, 38, 34, 18, 19, 47,  4, 13, 40, 25,  5, 45,
 17,  8,  2, 51, 21, 29, 42,  9, 14, 22,  3, 24,
 39, 20, 31, 55, 11, 33, 53, 54, 41, 52, 32, 12,
 28, 44,  0,  1, 50, 23,  7, 10, 30, 49, 36, 15,

 20, 52, 48, 32, 33,  4, 18, 27, 54, 39, 19,  6,
  0, 22, 16, 10, 35, 43,  1, 23, 28, 36, 17,  7,
 53, 34, 45, 12, 25, 47, 38, 11, 55, 13, 46, 26,
 42,  3, 14, 15,  9, 37, 21, 24, 44,  8, 50, 29,

 27,  6, 55, 39, 40, 11, 25, 34,  4, 46, 26, 13,
  7, 29, 23, 17, 42, 50,  8, 30, 35, 43, 24, 14,
 31, 41, 52, 19, 32, 54, 45, 18,  5, 20, 53, 33,
 49, 10, 21, 22, 16, 44, 28,  0, 51, 15,  2, 36,
};

const static u8 parity[] = {
8,1,0,8,0,8,8,0,0,8,8,0,8,0,2,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,3,
0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,
0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,
8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,
0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,
8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,
8,0,0,8,0,8,8,0,0,8,8,0,8,0,0,8,0,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,
4,8,8,0,8,0,0,8,8,0,0,8,0,8,8,0,8,5,0,8,0,8,8,0,0,8,8,0,8,0,6,8,
};

/* set up the method list from the key */

static int des_set_key(struct cipher_context *cx, 
		       const u8 *key, int key_len, int atomic)
{
    register u32 n, w;
    register u8 *b0, *b1;
    u8 bits0[56], bits1[56];
    u32 *method;

    if (key_len != 8)
      return -EINVAL; /* unsupported key length */

    cx->key_length = key_len;

    method = (u32 *) cx->keyinfo;

#if defined(CIPHER_DES_PARITY_CHECK)
    /* check for bad parity and weak keys */
    n  = parity[key[0]]; n <<= 4;
    n |= parity[key[1]]; n <<= 4;
    n |= parity[key[2]]; n <<= 4;
    n |= parity[key[3]]; n <<= 4;
    n |= parity[key[4]]; n <<= 4;
    n |= parity[key[5]]; n <<= 4;
    n |= parity[key[6]]; n <<= 4;
    n |= parity[key[7]];
    w  = 0X88888888L;
    /* report bad parity in key */
    if ( n & w )
        return -1;

    /* report a weak or semi-weak key */
    if ( !((n - (w >> 3)) & w) ) {  /* 1 in 10^10 keys passes this test */
        if ( n < 0X41415151 ) {
            if ( n < 0X31312121 ) {
                if ( n < 0X14141515 ) {
                    /* 01 01 01 01 01 01 01 01 */
                    if ( n == 0X11111111 ) return -2;
                    /* 01 1F 01 1F 01 0E 01 0E */
                    if ( n == 0X13131212 ) return -2;
                } else {
                    /* 01 E0 01 E0 01 F1 01 F1 */
                    if ( n == 0X14141515 ) return -2;
                    /* 01 FE 01 FE 01 FE 01 FE */
                    if ( n == 0X16161616 ) return -2;
                }
            } else {
                if ( n < 0X34342525 ) {
                    /* 1F 01 1F 01 0E 01 0E 01 */
                    if ( n == 0X31312121 ) return -2;
                    /* 1F 1F 1F 1F 0E 0E 0E 0E */   /* ? */
                    if ( n == 0X33332222 ) return -2;
                } else {
                    /* 1F E0 1F E0 0E F1 0E F1 */
                    if ( n == 0X34342525 ) return -2;
                    /* 1F FE 1F FE 0E FE 0E FE */
                    if ( n == 0X36362626 ) return -2;
                }
            }
        } else {
            if ( n < 0X61616161 ) {
                if ( n < 0X44445555 ) {
                    /* E0 01 E0 01 F1 01 F1 01 */
                    if ( n == 0X41415151 ) return -2;
                    /* E0 1F E0 1F F1 0E F1 0E */
                    if ( n == 0X43435252 ) return -2;
                } else {
                    /* E0 E0 E0 E0 F1 F1 F1 F1 */   /* ? */
                    if ( n == 0X44445555 ) return -2;
                    /* E0 FE E0 FE F1 FE F1 FE */
                    if ( n == 0X46465656 ) return -2;
                }
            } else {
                if ( n < 0X64646565 ) {
                    /* FE 01 FE 01 FE 01 FE 01 */
                    if ( n == 0X61616161 ) return -2;
                    /* FE 1F FE 1F FE 0E FE 0E */
                    if ( n == 0X63636262 ) return -2;
                } else {
                    /* FE E0 FE E0 FE F1 FE F1 */
                    if ( n == 0X64646565 ) return -2;
                    /* FE FE FE FE FE FE FE FE */
                    if ( n == 0X66666666 ) return -2;
                }
            }
        }
    }
#endif /* CIPHER_DES_PARITY_CHECK */

    /* explode the bits */
    n = 56;
    b0 = bits0;
    b1 = bits1;
    do {
        w = (256 | *key++) << 2;
        do {
            --n;
            b1[n] = 8 & w;
            w >>= 1;
            b0[n] = 4 & w;
        } while ( w >= 16 );
    } while ( n );

    /* put the bits in the correct places */
    n = 16;
    key = rotors;
    do {
        w   = (b1[key[ 0   ]] | b0[key[ 1   ]]) << 4;
        w  |= (b1[key[ 2   ]] | b0[key[ 3   ]]) << 2;
        w  |=  b1[key[ 4   ]] | b0[key[ 5   ]];
        w <<= 8;
        w  |= (b1[key[ 6   ]] | b0[key[ 7   ]]) << 4;
        w  |= (b1[key[ 8   ]] | b0[key[ 9   ]]) << 2;
        w  |=  b1[key[10   ]] | b0[key[11   ]];
        w <<= 8;
        w  |= (b1[key[12   ]] | b0[key[13   ]]) << 4;
        w  |= (b1[key[14   ]] | b0[key[15   ]]) << 2;
        w  |=  b1[key[16   ]] | b0[key[17   ]];
        w <<= 8;
        w  |= (b1[key[18   ]] | b0[key[19   ]]) << 4;
        w  |= (b1[key[20   ]] | b0[key[21   ]]) << 2;
        w  |=  b1[key[22   ]] | b0[key[23   ]];

        method[0] = w;

        w   = (b1[key[ 0+24]] | b0[key[ 1+24]]) << 4;
        w  |= (b1[key[ 2+24]] | b0[key[ 3+24]]) << 2;
        w  |=  b1[key[ 4+24]] | b0[key[ 5+24]];
        w <<= 8;
        w  |= (b1[key[ 6+24]] | b0[key[ 7+24]]) << 4;
        w  |= (b1[key[ 8+24]] | b0[key[ 9+24]]) << 2;
        w  |=  b1[key[10+24]] | b0[key[11+24]];
        w <<= 8;
        w  |= (b1[key[12+24]] | b0[key[13+24]]) << 4;
        w  |= (b1[key[14+24]] | b0[key[15+24]]) << 2;
        w  |=  b1[key[16+24]] | b0[key[17+24]];
        w <<= 8;
        w  |= (b1[key[18+24]] | b0[key[19+24]]) << 4;