linux/crypto/fcrypt.c
<<
>>
Prefs 
   1/* FCrypt encryption algorithm
   2 *
   3 * Copyright (C) 2006 Red Hat, Inc. All Rights Reserved.
   4 * Written by David Howells (dhowells@redhat.com)
   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
   8 * as published by the Free Software Foundation; either version
   9 * 2 of the License, or (at your option) any later version.
  10 *
  11 * Based on code:
  12 *
  13 * Copyright (c) 1995 - 2000 Kungliga Tekniska Högskolan
  14 * (Royal Institute of Technology, Stockholm, Sweden).
  15 * All rights reserved.
  16 *
  17 * Redistribution and use in source and binary forms, with or without
  18 * modification, are permitted provided that the following conditions
  19 * are met:
  20 *
  21 * 1. Redistributions of source code must retain the above copyright
  22 *    notice, this list of conditions and the following disclaimer.
  23 *
  24 * 2. Redistributions in binary form must reproduce the above copyright
  25 *    notice, this list of conditions and the following disclaimer in the
  26 *    documentation and/or other materials provided with the distribution.
  27 *
  28 * 3. Neither the name of the Institute nor the names of its contributors
  29 *    may be used to endorse or promote products derived from this software
  30 *    without specific prior written permission.
  31 *
  32 * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  33 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  34 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  35 * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  36 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  37 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  38 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  39 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  40 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  41 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  42 * SUCH DAMAGE.
  43 */
  44
  45#include <asm/byteorder.h>
  46#include <linux/bitops.h>
  47#include <linux/init.h>
  48#include <linux/module.h>
  49#include <linux/crypto.h>
  50
  51#define ROUNDS 16
  52
  53struct fcrypt_ctx {
  54        __be32 sched[ROUNDS];
  55};
  56
  57/* Rotate right two 32 bit numbers as a 56 bit number */
  58#define ror56(hi, lo, n)                                        \
  59do {                                                            \
  60        u32 t = lo & ((1 << n) - 1);                            \
  61        lo = (lo >> n) | ((hi & ((1 << n) - 1)) << (32 - n));   \
  62        hi = (hi >> n) | (t << (24-n));                         \
  63} while (0)
  64
  65/* Rotate right one 64 bit number as a 56 bit number */
  66#define ror56_64(k, n)                                          \
  67do {                                                            \
  68        k = (k >> n) | ((k & ((1 << n) - 1)) << (56 - n));      \
  69} while (0)
  70
  71/*
  72 * Sboxes for Feistel network derived from
  73 * /afs/transarc.com/public/afsps/afs.rel31b.export-src/rxkad/sboxes.h
  74 */
  75#undef Z
  76#define Z(x) cpu_to_be32(x << 3)
  77static const __be32 sbox0[256] = {
  78        Z(0xea), Z(0x7f), Z(0xb2), Z(0x64), Z(0x9d), Z(0xb0), Z(0xd9), Z(0x11),
  79        Z(0xcd), Z(0x86), Z(0x86), Z(0x91), Z(0x0a), Z(0xb2), Z(0x93), Z(0x06),
  80        Z(0x0e), Z(0x06), Z(0xd2), Z(0x65), Z(0x73), Z(0xc5), Z(0x28), Z(0x60),
  81        Z(0xf2), Z(0x20), Z(0xb5), Z(0x38), Z(0x7e), Z(0xda), Z(0x9f), Z(0xe3),
  82        Z(0xd2), Z(0xcf), Z(0xc4), Z(0x3c), Z(0x61), Z(0xff), Z(0x4a), Z(0x4a),
  83        Z(0x35), Z(0xac), Z(0xaa), Z(0x5f), Z(0x2b), Z(0xbb), Z(0xbc), Z(0x53),
  84        Z(0x4e), Z(0x9d), Z(0x78), Z(0xa3), Z(0xdc), Z(0x09), Z(0x32), Z(0x10),
  85        Z(0xc6), Z(0x6f), Z(0x66), Z(0xd6), Z(0xab), Z(0xa9), Z(0xaf), Z(0xfd),
  86        Z(0x3b), Z(0x95), Z(0xe8), Z(0x34), Z(0x9a), Z(0x81), Z(0x72), Z(0x80),
  87        Z(0x9c), Z(0xf3), Z(0xec), Z(0xda), Z(0x9f), Z(0x26), Z(0x76), Z(0x15),
  88        Z(0x3e), Z(0x55), Z(0x4d), Z(0xde), Z(0x84), Z(0xee), Z(0xad), Z(0xc7),
  89        Z(0xf1), Z(0x6b), Z(0x3d), Z(0xd3), Z(0x04), Z(0x49), Z(0xaa), Z(0x24),
  90        Z(0x0b), Z(0x8a), Z(0x83), Z(0xba), Z(0xfa), Z(0x85), Z(0xa0), Z(0xa8),
  91        Z(0xb1), Z(0xd4), Z(0x01), Z(0xd8), Z(0x70), Z(0x64), Z(0xf0), Z(0x51),
  92        Z(0xd2), Z(0xc3), Z(0xa7), Z(0x75), Z(0x8c), Z(0xa5), Z(0x64), Z(0xef),
  93        Z(0x10), Z(0x4e), Z(0xb7), Z(0xc6), Z(0x61), Z(0x03), Z(0xeb), Z(0x44),
  94        Z(0x3d), Z(0xe5), Z(0xb3), Z(0x5b), Z(0xae), Z(0xd5), Z(0xad), Z(0x1d),
  95        Z(0xfa), Z(0x5a), Z(0x1e), Z(0x33), Z(0xab), Z(0x93), Z(0xa2), Z(0xb7),
  96        Z(0xe7), Z(0xa8), Z(0x45), Z(0xa4), Z(0xcd), Z(0x29), Z(0x63), Z(0x44),
  97        Z(0xb6), Z(0x69), Z(0x7e), Z(0x2e), Z(0x62), Z(0x03), Z(0xc8), Z(0xe0),
  98        Z(0x17), Z(0xbb), Z(0xc7), Z(0xf3), Z(0x3f), Z(0x36), Z(0xba), Z(0x71),
  99        Z(0x8e), Z(0x97), Z(0x65), Z(0x60), Z(0x69), Z(0xb6), Z(0xf6), Z(0xe6),
 100        Z(0x6e), Z(0xe0), Z(0x81), Z(0x59), Z(0xe8), Z(0xaf), Z(0xdd), Z(0x95),
 101        Z(0x22), Z(0x99), Z(0xfd), Z(0x63), Z(0x19), Z(0x74), Z(0x61), Z(0xb1),
 102        Z(0xb6), Z(0x5b), Z(0xae), Z(0x54), Z(0xb3), Z(0x70), Z(0xff), Z(0xc6),
 103        Z(0x3b), Z(0x3e), Z(0xc1), Z(0xd7), Z(0xe1), Z(0x0e), Z(0x76), Z(0xe5),
 104        Z(0x36), Z(0x4f), Z(0x59), Z(0xc7), Z(0x08), Z(0x6e), Z(0x82), Z(0xa6),
 105        Z(0x93), Z(0xc4), Z(0xaa), Z(0x26), Z(0x49), Z(0xe0), Z(0x21), Z(0x64),
 106        Z(0x07), Z(0x9f), Z(0x64), Z(0x81), Z(0x9c), Z(0xbf), Z(0xf9), Z(0xd1),
 107        Z(0x43), Z(0xf8), Z(0xb6), Z(0xb9), Z(0xf1), Z(0x24), Z(0x75), Z(0x03),
 108        Z(0xe4), Z(0xb0), Z(0x99), Z(0x46), Z(0x3d), Z(0xf5), Z(0xd1), Z(0x39),
 109        Z(0x72), Z(0x12), Z(0xf6), Z(0xba), Z(0x0c), Z(0x0d), Z(0x42), Z(0x2e)
 110};
 111
 112#undef Z
 113#define Z(x) cpu_to_be32((x << 27) | (x >> 5))
 114static const __be32 sbox1[256] = {
 115        Z(0x77), Z(0x14), Z(0xa6), Z(0xfe), Z(0xb2), Z(0x5e), Z(0x8c), Z(0x3e),
 116        Z(0x67), Z(0x6c), Z(0xa1), Z(0x0d), Z(0xc2), Z(0xa2), Z(0xc1), Z(0x85),
 117        Z(0x6c), Z(0x7b), Z(0x67), Z(0xc6), Z(0x23), Z(0xe3), Z(0xf2), Z(0x89),
 118        Z(0x50), Z(0x9c), Z(0x03), Z(0xb7), Z(0x73), Z(0xe6), Z(0xe1), Z(0x39),
 119        Z(0x31), Z(0x2c), Z(0x27), Z(0x9f), Z(0xa5), Z(0x69), Z(0x44), Z(0xd6),
 120        Z(0x23), Z(0x83), Z(0x98), Z(0x7d), Z(0x3c), Z(0xb4), Z(0x2d), Z(0x99),
 121        Z(0x1c), Z(0x1f), Z(0x8c), Z(0x20), Z(0x03), Z(0x7c), Z(0x5f), Z(0xad),
 122        Z(0xf4), Z(0xfa), Z(0x95), Z(0xca), Z(0x76), Z(0x44), Z(0xcd), Z(0xb6),
 123        Z(0xb8), Z(0xa1), Z(0xa1), Z(0xbe), Z(0x9e), Z(0x54), Z(0x8f), Z(0x0b),
 124        Z(0x16), Z(0x74), Z(0x31), Z(0x8a), Z(0x23), Z(0x17), Z(0x04), Z(0xfa),
 125        Z(0x79), Z(0x84), Z(0xb1), Z(0xf5), Z(0x13), Z(0xab), Z(0xb5), Z(0x2e),
 126        Z(0xaa), Z(0x0c), Z(0x60), Z(0x6b), Z(0x5b), Z(0xc4), Z(0x4b), Z(0xbc),
 127        Z(0xe2), Z(0xaf), Z(0x45), Z(0x73), Z(0xfa), Z(0xc9), Z(0x49), Z(0xcd),
 128        Z(0x00), Z(0x92), Z(0x7d), Z(0x97), Z(0x7a), Z(0x18), Z(0x60), Z(0x3d),
 129        Z(0xcf), Z(0x5b), Z(0xde), Z(0xc6), Z(0xe2), Z(0xe6), Z(0xbb), Z(0x8b),
 130        Z(0x06), Z(0xda), Z(0x08), Z(0x15), Z(0x1b), Z(0x88), Z(0x6a), Z(0x17),
 131        Z(0x89), Z(0xd0), Z(0xa9), Z(0xc1), Z(0xc9), Z(0x70), Z(0x6b), Z(0xe5),
 132        Z(0x43), Z(0xf4), Z(0x68), Z(0xc8), Z(0xd3), Z(0x84), Z(0x28), Z(0x0a),
 133        Z(0x52), Z(0x66), Z(0xa3), Z(0xca), Z(0xf2), Z(0xe3), Z(0x7f), Z(0x7a),
 134        Z(0x31), Z(0xf7), Z(0x88), Z(0x94), Z(0x5e), Z(0x9c), Z(0x63), Z(0xd5),
 135        Z(0x24), Z(0x66), Z(0xfc), Z(0xb3), Z(0x57), Z(0x25), Z(0xbe), Z(0x89),
 136        Z(0x44), Z(0xc4), Z(0xe0), Z(0x8f), Z(0x23), Z(0x3c), Z(0x12), Z(0x52),
 137        Z(0xf5), Z(0x1e), Z(0xf4), Z(0xcb), Z(0x18), Z(0x33), Z(0x1f), Z(0xf8),
 138        Z(0x69), Z(0x10), Z(0x9d), Z(0xd3), Z(0xf7), Z(0x28), Z(0xf8), Z(0x30),
 139        Z(0x05), Z(0x5e), Z(0x32), Z(0xc0), Z(0xd5), Z(0x19), Z(0xbd), Z(0x45),
 140        Z(0x8b), Z(0x5b), Z(0xfd), Z(0xbc), Z(0xe2), Z(0x5c), Z(0xa9), Z(0x96),
 141        Z(0xef), Z(0x70), Z(0xcf), Z(0xc2), Z(0x2a), Z(0xb3), Z(0x61), Z(0xad),
 142        Z(0x80), Z(0x48), Z(0x81), Z(0xb7), Z(0x1d), Z(0x43), Z(0xd9), Z(0xd7),
 143        Z(0x45), Z(0xf0), Z(0xd8), Z(0x8a), Z(0x59), Z(0x7c), Z(0x57), Z(0xc1),
 144        Z(0x79), Z(0xc7), Z(0x34), Z(0xd6), Z(0x43), Z(0xdf), Z(0xe4), Z(0x78),
 145        Z(0x16), Z(0x06), Z(0xda), Z(0x92), Z(0x76), Z(0x51), Z(0xe1), Z(0xd4),
 146        Z(0x70), Z(0x03), Z(0xe0), Z(0x2f), Z(0x96), Z(0x91), Z(0x82), Z(0x80)
 147};
 148
 149#undef Z
 150#define Z(x) cpu_to_be32(x << 11)
 151static const __be32 sbox2[256] = {
 152        Z(0xf0), Z(0x37), Z(0x24), Z(0x53), Z(0x2a), Z(0x03), Z(0x83), Z(0x86),
 153        Z(0xd1), Z(0xec), Z(0x50), Z(0xf0), Z(0x42), Z(0x78), Z(0x2f), Z(0x6d),
 154        Z(0xbf), Z(0x80), Z(0x87), Z(0x27), Z(0x95), Z(0xe2), Z(0xc5), Z(0x5d),
 155        Z(0xf9), Z(0x6f), Z(0xdb), Z(0xb4), Z(0x65), Z(0x6e), Z(0xe7), Z(0x24),
 156        Z(0xc8), Z(0x1a), Z(0xbb), Z(0x49), Z(0xb5), Z(0x0a), Z(0x7d), Z(0xb9),
 157        Z(0xe8), Z(0xdc), Z(0xb7), Z(0xd9), Z(0x45), Z(0x20), Z(0x1b), Z(0xce),
 158        Z(0x59), Z(0x9d), Z(0x6b), Z(0xbd), Z(0x0e), Z(0x8f), Z(0xa3), Z(0xa9),
 159        Z(0xbc), Z(0x74), Z(0xa6), Z(0xf6), Z(0x7f), Z(0x5f), Z(0xb1), Z(0x68),
 160        Z(0x84), Z(0xbc), Z(0xa9), Z(0xfd), Z(0x55), Z(0x50), Z(0xe9), Z(0xb6),
 161        Z(0x13), Z(0x5e), Z(0x07), Z(0xb8), Z(0x95), Z(0x02), Z(0xc0), Z(0xd0),
 162        Z(0x6a), Z(0x1a), Z(0x85), Z(0xbd), Z(0xb6), Z(0xfd), Z(0xfe), Z(0x17),
 163        Z(0x3f), Z(0x09), Z(0xa3), Z(0x8d), Z(0xfb), Z(0xed), Z(0xda), Z(0x1d),
 164        Z(0x6d), Z(0x1c), Z(0x6c), Z(0x01), Z(0x5a), Z(0xe5), Z(0x71), Z(0x3e),
 165        Z(0x8b), Z(0x6b), Z(0xbe), Z(0x29), Z(0xeb), Z(0x12), Z(0x19), Z(0x34),
 166        Z(0xcd), Z(0xb3), Z(0xbd), Z(0x35), Z(0xea), Z(0x4b), Z(0xd5), Z(0xae),
 167        Z(0x2a), Z(0x79), Z(0x5a), Z(0xa5), Z(0x32), Z(0x12), Z(0x7b), Z(0xdc),
 168        Z(0x2c), Z(0xd0), Z(0x22), Z(0x4b), Z(0xb1), Z(0x85), Z(0x59), Z(0x80),
 169        Z(0xc0), Z(0x30), Z(0x9f), Z(0x73), Z(0xd3), Z(0x14), Z(0x48), Z(0x40),
 170        Z(0x07), Z(0x2d), Z(0x8f), Z(0x80), Z(0x0f), Z(0xce), Z(0x0b), Z(0x5e),
 171        Z(0xb7), Z(0x5e), Z(0xac), Z(0x24), Z(0x94), Z(0x4a), Z(0x18), Z(0x15),
 172        Z(0x05), Z(0xe8), Z(0x02), Z(0x77), Z(0xa9), Z(0xc7), Z(0x40), Z(0x45),
 173        Z(0x89), Z(0xd1), Z(0xea), Z(0xde), Z(0x0c), Z(0x79), Z(0x2a), Z(0x99),
 174        Z(0x6c), Z(0x3e), Z(0x95), Z(0xdd), Z(0x8c), Z(0x7d), Z(0xad), Z(0x6f),
 175        Z(0xdc), Z(0xff), Z(0xfd), Z(0x62), Z(0x47), Z(0xb3), Z(0x21), Z(0x8a),
 176        Z(0xec), Z(0x8e), Z(0x19), Z(0x18), Z(0xb4), Z(0x6e), Z(0x3d), Z(0xfd),
 177        Z(0x74), Z(0x54), Z(0x1e), Z(0x04), Z(0x85), Z(0xd8), Z(0xbc), Z(0x1f),
 178        Z(0x56), Z(0xe7), Z(0x3a), Z(0x56), Z(0x67), Z(0xd6), Z(0xc8), Z(0xa5),
 179        Z(0xf3), Z(0x8e), Z(0xde), Z(0xae), Z(0x37), Z(0x49), Z(0xb7), Z(0xfa),
 180        Z(0xc8), Z(0xf4), Z(0x1f), Z(0xe0), Z(0x2a), Z(0x9b), Z(0x15), Z(0xd1),
 181        Z(0x34), Z(0x0e), Z(0xb5), Z(0xe0), Z(0x44), Z(0x78), Z(0x84), Z(0x59),
 182        Z(0x56), Z(0x68), Z(0x77), Z(0xa5), Z(0x14), Z(0x06), Z(0xf5), Z(0x2f),
 183        Z(0x8c), Z(0x8a), Z(0x73), Z(0x80), Z(0x76), Z(0xb4), Z(0x10), Z(0x86)
 184};
 185
 186#undef Z
 187#define Z(x) cpu_to_be32(x << 19)
 188static const __be32 sbox3[256] = {
 189        Z(0xa9), Z(0x2a), Z(0x48), Z(0x51), Z(0x84), Z(0x7e), Z(0x49), Z(0xe2),
 190        Z(0xb5), Z(0xb7), Z(0x42), Z(0x33), Z(0x7d), Z(0x5d), Z(0xa6), Z(0x12),
 191        Z(0x44), Z(0x48), Z(0x6d), Z(0x28), Z(0xaa), Z(0x20), Z(0x6d), Z(0x57),
 192        Z(0xd6), Z(0x6b), Z(0x5d), Z(0x72), Z(0xf0), Z(0x92), Z(0x5a), Z(0x1b),
 193        Z(0x53), Z(0x80), Z(0x24), Z(0x70), Z(0x9a), Z(0xcc), Z(0xa7), Z(0x66),
 194        Z(0xa1), Z(0x01), Z(0xa5), Z(0x41), Z(0x97), Z(0x41), Z(0x31), Z(0x82),
 195        Z(0xf1), Z(0x14), Z(0xcf), Z(0x53), Z(0x0d), Z(0xa0), Z(0x10), Z(0xcc),
 196        Z(0x2a), Z(0x7d), Z(0xd2), Z(0xbf), Z(0x4b), Z(0x1a), Z(0xdb), Z(0x16),
 197        Z(0x47), Z(0xf6), Z(0x51), Z(0x36), Z(0xed), Z(0xf3), Z(0xb9), Z(0x1a),
 198        Z(0xa7), Z(0xdf), Z(0x29), Z(0x43), Z(0x01), Z(0x54), Z(0x70), Z(0xa4),
 199        Z(0xbf), Z(0xd4), Z(0x0b), Z(0x53), Z(0x44), Z(0x60), Z(0x9e), Z(0x23),
 200        Z(0xa1), Z(0x18), Z(0x68), Z(0x4f), Z(0xf0), Z(0x2f), Z(0x82), Z(0xc2),
 201        Z(0x2a), Z(0x41), Z(0xb2), Z(0x42), Z(0x0c), Z(0xed), Z(0x0c), Z(0x1d),
 202        Z(0x13), Z(0x3a), Z(0x3c), Z(0x6e), Z(0x35), Z(0xdc), Z(0x60), Z(0x65),
 203        Z(0x85), Z(0xe9), Z(0x64), Z(0x02), Z(0x9a), Z(0x3f), Z(0x9f), Z(0x87),
 204        Z(0x96), Z(0xdf), Z(0xbe), Z(0xf2), Z(0xcb), Z(0xe5), Z(0x6c), Z(0xd4),
 205        Z(0x5a), Z(0x83), Z(0xbf), Z(0x92), Z(0x1b), Z(0x94), Z(0x00), Z(0x42),
 206        Z(0xcf), Z(0x4b), Z(0x00), Z(0x75), Z(0xba), Z(0x8f), Z(0x76), Z(0x5f),
 207        Z(0x5d), Z(0x3a), Z(0x4d), Z(0x09), Z(0x12), Z(0x08), Z(0x38), Z(0x95),
 208        Z(0x17), Z(0xe4), Z(0x01), Z(0x1d), Z(0x4c), Z(0xa9), Z(0xcc), Z(0x85),
 209        Z(0x82), Z(0x4c), Z(0x9d), Z(0x2f), Z(0x3b), Z(0x66), Z(0xa1), Z(0x34),
 210        Z(0x10), Z(0xcd), Z(0x59), Z(0x89), Z(0xa5), Z(0x31), Z(0xcf), Z(0x05),
 211        Z(0xc8), Z(0x84), Z(0xfa), Z(0xc7), Z(0xba), Z(0x4e), Z(0x8b), Z(0x1a),
 212        Z(0x19), Z(0xf1), Z(0xa1), Z(0x3b), Z(0x18), Z(0x12), Z(0x17), Z(0xb0),
 213        Z(0x98), Z(0x8d), Z(0x0b), Z(0x23), Z(0xc3), Z(0x3a), Z(0x2d), Z(0x20),
 214        Z(0xdf), Z(0x13), Z(0xa0), Z(0xa8), Z(0x4c), Z(0x0d), Z(0x6c), Z(0x2f),
 215        Z(0x47), Z(0x13), Z(0x13), Z(0x52), Z(0x1f), Z(0x2d), Z(0xf5), Z(0x79),
 216        Z(0x3d), Z(0xa2), Z(0x54), Z(0xbd), Z(0x69), Z(0xc8), Z(0x6b), Z(0xf3),
 217        Z(0x05), Z(0x28), Z(0xf1), Z(0x16), Z(0x46), Z(0x40), Z(0xb0), Z(0x11),
 218        Z(0xd3), Z(0xb7), Z(0x95), Z(0x49), Z(0xcf), Z(0xc3), Z(0x1d), Z(0x8f),
 219        Z(0xd8), Z(0xe1), Z(0x73), Z(0xdb), Z(0xad), Z(0xc8), Z(0xc9), Z(0xa9),
 220        Z(0xa1), Z(0xc2), Z(0xc5), Z(0xe3), Z(0xba), Z(0xfc), Z(0x0e), Z(0x25)
 221};
 222
 223/*
 224 * This is a 16 round Feistel network with permutation F_ENCRYPT
 225 */
 226#define F_ENCRYPT(R, L, sched)                                          \
 227do {                                                                    \
 228        union lc4 { __be32 l; u8 c[4]; } u;                             \
 229        u.l = sched ^ R;                                                \
 230        L ^= sbox0[u.c[0]] ^ sbox1[u.c[1]] ^ sbox2[u.c[2]] ^ sbox3[u.c[3]]; \
 231} while (0)
 232
 233/*
 234 * encryptor
 235 */
 236static void fcrypt_encrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 237{
 238        const struct fcrypt_ctx *ctx = crypto_tfm_ctx(tfm);
 239        struct {
 240                __be32 l, r;
 241        } X;
 242
 243        memcpy(&X, src, sizeof(X));
 244
 245        F_ENCRYPT(X.r, X.l, ctx->sched[0x0]);
 246        F_ENCRYPT(X.l, X.r, ctx->sched[0x1]);
 247        F_ENCRYPT(X.r, X.l, ctx->sched[0x2]);
 248        F_ENCRYPT(X.l, X.r, ctx->sched[0x3]);
 249        F_ENCRYPT(X.r, X.l, ctx->sched[0x4]);
 250        F_ENCRYPT(X.l, X.r, ctx->sched[0x5]);
 251        F_ENCRYPT(X.r, X.l, ctx->sched[0x6]);
 252        F_ENCRYPT(X.l, X.r, ctx->sched[0x7]);
 253        F_ENCRYPT(X.r, X.l, ctx->sched[0x8]);
 254        F_ENCRYPT(X.l, X.r, ctx->sched[0x9]);
 255        F_ENCRYPT(X.r, X.l, ctx->sched[0xa]);
 256        F_ENCRYPT(X.l, X.r, ctx->sched[0xb]);
 257        F_ENCRYPT(X.r, X.l, ctx->sched[0xc]);
 258        F_ENCRYPT(X.l, X.r, ctx->sched[0xd]);
 259        F_ENCRYPT(X.r, X.l, ctx->sched[0xe]);
 260        F_ENCRYPT(X.l, X.r, ctx->sched[0xf]);
 261
 262        memcpy(dst, &X, sizeof(X));
 263}
 264
 265/*
 266 * decryptor
 267 */
 268static void fcrypt_decrypt(struct crypto_tfm *tfm, u8 *dst, const u8 *src)
 269{
 270        const struct fcrypt_ctx *ctx = crypto_tfm_ctx(tfm);
 271        struct {
 272                __be32 l, r;
 273        } X;
 274
 275        memcpy(&X, src, sizeof(X));
 276
 277        F_ENCRYPT(X.l, X.r, ctx->sched[0xf]);
 278        F_ENCRYPT(X.r, X.l, ctx->sched[0xe]);
 279        F_ENCRYPT(X.l, X.r, ctx->sched[0xd]);
 280        F_ENCRYPT(X.r, X.l, ctx->sched[0xc]);
 281        F_ENCRYPT(X.l, X.r, ctx->sched[0xb]);
 282        F_ENCRYPT(X.r, X.l, ctx->sched[0xa]);
 283        F_ENCRYPT(X.l, X.r, ctx->sched[0x9]);
 284        F_ENCRYPT(X.r, X.l, ctx->sched[0x8]);
 285        F_ENCRYPT(X.l, X.r, ctx->sched[0x7]);
 286        F_ENCRYPT(X.r, X.l, ctx->sched[0x6]);
 287        F_ENCRYPT(X.l, X.r, ctx->sched[0x5]);
 288        F_ENCRYPT(X.r, X.l, ctx->sched[0x4]);
 289        F_ENCRYPT(X.l, X.r, ctx->sched[0x3]);
 290        F_ENCRYPT(X.r, X.l, ctx->sched[0x2]);
 291        F_ENCRYPT(X.l, X.r, ctx->sched[0x1]);
 292        F_ENCRYPT(X.r, X.l, ctx->sched[0x0]);
 293
 294        memcpy(dst, &X, sizeof(X));
 295}
 296
 297/*
 298 * Generate a key schedule from key, the least significant bit in each key byte
 299 * is parity and shall be ignored. This leaves 56 significant bits in the key
 300 * to scatter over the 16 key schedules. For each schedule extract the low
 301 * order 32 bits and use as schedule, then rotate right by 11 bits.
 302 */
 303static int fcrypt_setkey(struct crypto_tfm *tfm, const u8 *key, unsigned int keylen)
 304{
 305        struct fcrypt_ctx *ctx = crypto_tfm_ctx(tfm);
 306
 307#if BITS_PER_LONG == 64  /* the 64-bit version can also be used for 32-bit
 308                          * kernels - it seems to be faster but the code is
 309                          * larger */
 310
 311        u64 k;  /* k holds all 56 non-parity bits */
 312
 313        /* discard the parity bits */
 314        k = (*key++) >> 1;
 315        k <<= 7;
 316        k |= (*key++) >> 1;
 317        k <<= 7;
 318        k |= (*key++) >> 1;
 319        k <<= 7;
 320        k |= (*key++) >> 1;
 321        k <<= 7;
 322        k |= (*key++) >> 1;
 323        k <<= 7;
 324        k |= (*key++) >> 1;
 325        k <<= 7;
 326        k |= (*key++) >> 1;
 327        k <<= 7;
 328        k |= (*key) >> 1;
 329
 330        /* Use lower 32 bits for schedule, rotate by 11 each round (16 times) */
 331        ctx->sched[0x0] = cpu_to_be32(k); ror56_64(k, 11);
 332        ctx->sched[0x1] = cpu_to_be32(k); ror56_64(k, 11);
 333        ctx->sched[0x2] = cpu_to_be32(k); ror56_64(k, 11);
 334        ctx->sched[0x3] = cpu_to_be32(k); ror56_64(k, 11);
 335        ctx->sched[0x4] = cpu_to_be32(k); ror56_64(k, 11);
 336        ctx->sched[0x5] = cpu_to_be32(k); ror56_64(k, 11);
 337        ctx->sched[0x6] = cpu_to_be32(k); ror56_64(k, 11);
 338        ctx->sched[0x7] = cpu_to_be32(k); ror56_64(k, 11);
 339        ctx->sched[0x8] = cpu_to_be32(k); ror56_64(k, 11);
 340        ctx->sched[0x9] = cpu_to_be32(k); ror56_64(k, 11);
 341        ctx->sched[0xa] = cpu_to_be32(k); ror56_64(k, 11);
 342        ctx->sched[0xb] = cpu_to_be32(k); ror56_64(k, 11);
 343        ctx->sched[0xc] = cpu_to_be32(k); ror56_64(k, 11);
 344        ctx->sched[0xd] = cpu_to_be32(k); ror56_64(k, 11);
 345        ctx->sched[0xe] = cpu_to_be32(k); ror56_64(k, 11);
 346        ctx->sched[0xf] = cpu_to_be32(k);
 347
 348        return 0;
 349#else
 350        u32 hi, lo;             /* hi is upper 24 bits and lo lower 32, total 56 */
 351
 352        /* discard the parity bits */
 353        lo = (*key++) >> 1;
 354        lo <<= 7;
 355        lo |= (*key++) >> 1;
 356        lo <<= 7;
 357        lo |= (*key++) >> 1;
 358        lo <<= 7;
 359        lo |= (*key++) >> 1;
 360        hi = lo >> 4;
 361        lo &= 0xf;
 362        lo <<= 7;
 363        lo |= (*key++) >> 1;
 364        lo <<= 7;
 365        lo |= (*key++) >> 1;
 366        lo <<= 7;
 367        lo |= (*key++) >> 1;
 368        lo <<= 7;
 369        lo |= (*key) >> 1;
 370
 371        /* Use lower 32 bits for schedule, rotate by 11 each round (16 times) */
 372        ctx->sched[0x0] = cpu_to_be32(lo); ror56(hi, lo, 11);
 373        ctx->sched[0x1] = cpu_to_be32(lo); ror56(hi, lo, 11);
 374        ctx->sched[0x2] = cpu_to_be32(lo); ror56(hi, lo, 11);
 375        ctx->sched[0x3] = cpu_to_be32(lo); ror56(hi, lo, 11);
 376        ctx->sched[0x4] = cpu_to_be32(lo); ror56(hi, lo, 11);
 377        ctx->sched[0x5] = cpu_to_be32(lo); ror56(hi, lo, 11);
 378        ctx->sched[0x6] = cpu_to_be32(lo); ror56(hi, lo, 11);
 379        ctx->sched[0x7] = cpu_to_be32(lo); ror56(hi, lo, 11);
 380        ctx->sched[0x8] = cpu_to_be32(lo); ror56(hi, lo, 11);
 381        ctx->sched[0x9] = cpu_to_be32(lo); ror56(hi, lo, 11);
 382        ctx->sched[0xa] = cpu_to_be32(lo); ror56(hi, lo, 11);
 383        ctx->sched[0xb] = cpu_to_be32(lo); ror56(hi, lo, 11);
 384        ctx->sched[0xc] = cpu_to_be32(lo); ror56(hi, lo, 11);
 385        ctx->sched[0xd] = cpu_to_be32(lo); ror56(hi, lo, 11);
 386        ctx->sched[0xe] = cpu_to_be32(lo); ror56(hi, lo, 11);
 387        ctx->sched[0xf] = cpu_to_be32(lo);
 388        return 0;
 389#endif
 390}
 391
 392static struct crypto_alg fcrypt_alg = {
 393        .cra_name               =       "fcrypt",
 394        .cra_flags              =       CRYPTO_ALG_TYPE_CIPHER,
 395        .cra_blocksize          =       8,
 396        .cra_ctxsize            =       sizeof(struct fcrypt_ctx),
 397        .cra_module             =       THIS_MODULE,
 398        .cra_alignmask          =       3,
 399        .cra_u                  =       { .cipher = {
 400        .cia_min_keysize        =       8,
 401        .cia_max_keysize        =       8,
 402        .cia_setkey             =       fcrypt_setkey,
 403        .cia_encrypt            =       fcrypt_encrypt,
 404        .cia_decrypt            =       fcrypt_decrypt } }
 405};
 406
 407static int __init fcrypt_mod_init(void)
 408{
 409        return crypto_register_alg(&fcrypt_alg);
 410}
 411
 412static void __exit fcrypt_mod_fini(void)
 413{
 414        crypto_unregister_alg(&fcrypt_alg);
 415}
 416
 417module_init(fcrypt_mod_init);
 418module_exit(fcrypt_mod_fini);
 419
 420MODULE_LICENSE("Dual BSD/GPL");
 421MODULE_DESCRIPTION("FCrypt Cipher Algorithm");
 422MODULE_AUTHOR("David Howells <dhowells@redhat.com>");
 423
Hosted by Missing Link Electronics. The original LXR software by the LXR community, this experimental version by lxr@linux.no.