The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

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

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

    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 
   53 struct 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)                                        \
   59 do {                                                            \
   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)                                          \
   67 do {                                                            \
   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)
   77 static 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))
  114 static 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)
  151 static 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)
  188 static 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)                                          \
  227 do {                                                                    \
  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  */
  236 static 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  */
  268 static 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  */
  303 static 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 
  392 static 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 
  407 static int __init fcrypt_mod_init(void)
  408 {
  409         return crypto_register_alg(&fcrypt_alg);
  410 }
  411 
  412 static void __exit fcrypt_mod_fini(void)
  413 {
  414         crypto_unregister_alg(&fcrypt_alg);
  415 }
  416 
  417 module_init(fcrypt_mod_init);
  418 module_exit(fcrypt_mod_fini);
  419 
  420 MODULE_LICENSE("Dual BSD/GPL");
  421 MODULE_DESCRIPTION("FCrypt Cipher Algorithm");
  422 MODULE_AUTHOR("David Howells <dhowells@redhat.com>");

Cache object: 5f85c2d01906dd3c9fbf7183a294d446


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.