/src/openssl/crypto/des/set_key.c

Source (jump to first uncovered line)
/*
 * Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
 *
 * Licensed under the OpenSSL license (the "License").  You may not use
 * this file except in compliance with the License.  You can obtain a copy
 * in the file LICENSE in the source distribution or at
 * https://www.openssl.org/source/license.html
 */

/*-
 * set_key.c v 1.4 eay 24/9/91
 * 1.4 Speed up by 400% :-)
 * 1.3 added register declarations.
 * 1.2 unrolled make_key_sched a bit more
 * 1.1 added norm_expand_bits
 * 1.0 First working version
 */
#include <openssl/crypto.h>
#include "des_locl.h"

/* defaults to false */
OPENSSL_IMPLEMENT_GLOBAL(int, DES_check_key, 0)

static const unsigned char odd_parity[256] = {
    1, 1, 2, 2, 4, 4, 7, 7, 8, 8, 11, 11, 13, 13, 14, 14,
    16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
    32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
    49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
    64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
    81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
    97, 97, 98, 98, 100, 100, 103, 103, 104, 104, 107, 107, 109, 109, 110,
    110,
    112, 112, 115, 115, 117, 117, 118, 118, 121, 121, 122, 122, 124, 124, 127,
    127,
    128, 128, 131, 131, 133, 133, 134, 134, 137, 137, 138, 138, 140, 140, 143,
    143,
    145, 145, 146, 146, 148, 148, 151, 151, 152, 152, 155, 155, 157, 157, 158,
    158,
    161, 161, 162, 162, 164, 164, 167, 167, 168, 168, 171, 171, 173, 173, 174,
    174,
    176, 176, 179, 179, 181, 181, 182, 182, 185, 185, 186, 186, 188, 188, 191,
    191,
    193, 193, 194, 194, 196, 196, 199, 199, 200, 200, 203, 203, 205, 205, 206,
    206,
    208, 208, 211, 211, 213, 213, 214, 214, 217, 217, 218, 218, 220, 220, 223,
    223,
    224, 224, 227, 227, 229, 229, 230, 230, 233, 233, 234, 234, 236, 236, 239,
    239,
    241, 241, 242, 242, 244, 244, 247, 247, 248, 248, 251, 251, 253, 253, 254,
    254
};

void DES_set_odd_parity(DES_cblock *key)
{
    unsigned int i;

    for (i = 0; i < DES_KEY_SZ; i++)
        (*key)[i] = odd_parity[(*key)[i]];
}

int DES_check_key_parity(const_DES_cblock *key)
{
    unsigned int i;

    for (i = 0; i < DES_KEY_SZ; i++) {
        if ((*key)[i] != odd_parity[(*key)[i]])
            return 0;
    }
    return 1;
}

/*-
 * Weak and semi weak keys as taken from
 * %A D.W. Davies
 * %A W.L. Price
 * %T Security for Computer Networks
 * %I John Wiley & Sons
 * %D 1984
 */
#define NUM_WEAK_KEY    16
static const DES_cblock weak_keys[NUM_WEAK_KEY] = {
    /* weak keys */
    {0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
    {0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE},
    {0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
    {0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1},
    /* semi-weak keys */
    {0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE},
    {0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01},
    {0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1},
    {0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E},
    {0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1},
    {0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01},
    {0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE},
    {0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E},
    {0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E},
    {0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01},
    {0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
    {0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1}
};

int DES_is_weak_key(const_DES_cblock *key)
{
    int i;

    for (i = 0; i < NUM_WEAK_KEY; i++)
        if (memcmp(weak_keys[i], key, sizeof(DES_cblock)) == 0)
            return 1;
    return 0;
}

/*-
 * NOW DEFINED IN des_local.h
 * See ecb_encrypt.c for a pseudo description of these macros.
 * #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
 *      (b)^=(t),\
 *      (a)=((a)^((t)<<(n))))
 */

#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
        (a)=(a)^(t)^(t>>(16-(n))))

static const DES_LONG des_skb[8][64] = {
    {
     /* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
     0x00000000L, 0x00000010L, 0x20000000L, 0x20000010L,
     0x00010000L, 0x00010010L, 0x20010000L, 0x20010010L,
     0x00000800L, 0x00000810L, 0x20000800L, 0x20000810L,
     0x00010800L, 0x00010810L, 0x20010800L, 0x20010810L,
     0x00000020L, 0x00000030L, 0x20000020L, 0x20000030L,
     0x00010020L, 0x00010030L, 0x20010020L, 0x20010030L,
     0x00000820L, 0x00000830L, 0x20000820L, 0x20000830L,
     0x00010820L, 0x00010830L, 0x20010820L, 0x20010830L,
     0x00080000L, 0x00080010L, 0x20080000L, 0x20080010L,
     0x00090000L, 0x00090010L, 0x20090000L, 0x20090010L,
     0x00080800L, 0x00080810L, 0x20080800L, 0x20080810L,
     0x00090800L, 0x00090810L, 0x20090800L, 0x20090810L,
     0x00080020L, 0x00080030L, 0x20080020L, 0x20080030L,
     0x00090020L, 0x00090030L, 0x20090020L, 0x20090030L,
     0x00080820L, 0x00080830L, 0x20080820L, 0x20080830L,
     0x00090820L, 0x00090830L, 0x20090820L, 0x20090830L,
     },
    {
     /* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
     0x00000000L, 0x02000000L, 0x00002000L, 0x02002000L,
     0x00200000L, 0x02200000L, 0x00202000L, 0x02202000L,
     0x00000004L, 0x02000004L, 0x00002004L, 0x02002004L,
     0x00200004L, 0x02200004L, 0x00202004L, 0x02202004L,
     0x00000400L, 0x02000400L, 0x00002400L, 0x02002400L,
     0x00200400L, 0x02200400L, 0x00202400L, 0x02202400L,
     0x00000404L, 0x02000404L, 0x00002404L, 0x02002404L,
     0x00200404L, 0x02200404L, 0x00202404L, 0x02202404L,
     0x10000000L, 0x12000000L, 0x10002000L, 0x12002000L,
     0x10200000L, 0x12200000L, 0x10202000L, 0x12202000L,
     0x10000004L, 0x12000004L, 0x10002004L, 0x12002004L,
     0x10200004L, 0x12200004L, 0x10202004L, 0x12202004L,
     0x10000400L, 0x12000400L, 0x10002400L, 0x12002400L,
     0x10200400L, 0x12200400L, 0x10202400L, 0x12202400L,
     0x10000404L, 0x12000404L, 0x10002404L, 0x12002404L,
     0x10200404L, 0x12200404L, 0x10202404L, 0x12202404L,
     },
    {
     /* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
     0x00000000L, 0x00000001L, 0x00040000L, 0x00040001L,
     0x01000000L, 0x01000001L, 0x01040000L, 0x01040001L,
     0x00000002L, 0x00000003L, 0x00040002L, 0x00040003L,
     0x01000002L, 0x01000003L, 0x01040002L, 0x01040003L,
     0x00000200L, 0x00000201L, 0x00040200L, 0x00040201L,
     0x01000200L, 0x01000201L, 0x01040200L, 0x01040201L,
     0x00000202L, 0x00000203L, 0x00040202L, 0x00040203L,
     0x01000202L, 0x01000203L, 0x01040202L, 0x01040203L,
     0x08000000L, 0x08000001L, 0x08040000L, 0x08040001L,
     0x09000000L, 0x09000001L, 0x09040000L, 0x09040001L,
     0x08000002L, 0x08000003L, 0x08040002L, 0x08040003L,
     0x09000002L, 0x09000003L, 0x09040002L, 0x09040003L,
     0x08000200L, 0x08000201L, 0x08040200L, 0x08040201L,
     0x09000200L, 0x09000201L, 0x09040200L, 0x09040201L,
     0x08000202L, 0x08000203L, 0x08040202L, 0x08040203L,
     0x09000202L, 0x09000203L, 0x09040202L, 0x09040203L,
     },
    {
     /* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
     0x00000000L, 0x00100000L, 0x00000100L, 0x00100100L,
     0x00000008L, 0x00100008L, 0x00000108L, 0x00100108L,
     0x00001000L, 0x00101000L, 0x00001100L, 0x00101100L,
     0x00001008L, 0x00101008L, 0x00001108L, 0x00101108L,
     0x04000000L, 0x04100000L, 0x04000100L, 0x04100100L,
     0x04000008L, 0x04100008L, 0x04000108L, 0x04100108L,
     0x04001000L, 0x04101000L, 0x04001100L, 0x04101100L,
     0x04001008L, 0x04101008L, 0x04001108L, 0x04101108L,
     0x00020000L, 0x00120000L, 0x00020100L, 0x00120100L,
     0x00020008L, 0x00120008L, 0x00020108L, 0x00120108L,
     0x00021000L, 0x00121000L, 0x00021100L, 0x00121100L,
     0x00021008L, 0x00121008L, 0x00021108L, 0x00121108L,
     0x04020000L, 0x04120000L, 0x04020100L, 0x04120100L,
     0x04020008L, 0x04120008L, 0x04020108L, 0x04120108L,
     0x04021000L, 0x04121000L, 0x04021100L, 0x04121100L,
     0x04021008L, 0x04121008L, 0x04021108L, 0x04121108L,
     },
    {
     /* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
     0x00000000L, 0x10000000L, 0x00010000L, 0x10010000L,
     0x00000004L, 0x10000004L, 0x00010004L, 0x10010004L,
     0x20000000L, 0x30000000L, 0x20010000L, 0x30010000L,
     0x20000004L, 0x30000004L, 0x20010004L, 0x30010004L,
     0x00100000L, 0x10100000L, 0x00110000L, 0x10110000L,
     0x00100004L, 0x10100004L, 0x00110004L, 0x10110004L,
     0x20100000L, 0x30100000L, 0x20110000L, 0x30110000L,
     0x20100004L, 0x30100004L, 0x20110004L, 0x30110004L,
     0x00001000L, 0x10001000L, 0x00011000L, 0x10011000L,
     0x00001004L, 0x10001004L, 0x00011004L, 0x10011004L,
     0x20001000L, 0x30001000L, 0x20011000L, 0x30011000L,
     0x20001004L, 0x30001004L, 0x20011004L, 0x30011004L,
     0x00101000L, 0x10101000L, 0x00111000L, 0x10111000L,
     0x00101004L, 0x10101004L, 0x00111004L, 0x10111004L,
     0x20101000L, 0x30101000L, 0x20111000L, 0x30111000L,
     0x20101004L, 0x30101004L, 0x20111004L, 0x30111004L,
     },
    {
     /* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
     0x00000000L, 0x08000000L, 0x00000008L, 0x08000008L,
     0x00000400L, 0x08000400L, 0x00000408L, 0x08000408L,
     0x00020000L, 0x08020000L, 0x00020008L, 0x08020008L,
     0x00020400L, 0x08020400L, 0x00020408L, 0x08020408L,
     0x00000001L, 0x08000001L, 0x00000009L, 0x08000009L,
     0x00000401L, 0x08000401L, 0x00000409L, 0x08000409L,
     0x00020001L, 0x08020001L, 0x00020009L, 0x08020009L,
     0x00020401L, 0x08020401L, 0x00020409L, 0x08020409L,
     0x02000000L, 0x0A000000L, 0x02000008L, 0x0A000008L,
     0x02000400L, 0x0A000400L, 0x02000408L, 0x0A000408L,
     0x02020000L, 0x0A020000L, 0x02020008L, 0x0A020008L,
     0x02020400L, 0x0A020400L, 0x02020408L, 0x0A020408L,
     0x02000001L, 0x0A000001L, 0x02000009L, 0x0A000009L,
     0x02000401L, 0x0A000401L, 0x02000409L, 0x0A000409L,
     0x02020001L, 0x0A020001L, 0x02020009L, 0x0A020009L,
     0x02020401L, 0x0A020401L, 0x02020409L, 0x0A020409L,
     },
    {
     /* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
     0x00000000L, 0x00000100L, 0x00080000L, 0x00080100L,
     0x01000000L, 0x01000100L, 0x01080000L, 0x01080100L,
     0x00000010L, 0x00000110L, 0x00080010L, 0x00080110L,
     0x01000010L, 0x01000110L, 0x01080010L, 0x01080110L,
     0x00200000L, 0x00200100L, 0x00280000L, 0x00280100L,
     0x01200000L, 0x01200100L, 0x01280000L, 0x01280100L,
     0x00200010L, 0x00200110L, 0x00280010L, 0x00280110L,
     0x01200010L, 0x01200110L, 0x01280010L, 0x01280110L,
     0x00000200L, 0x00000300L, 0x00080200L, 0x00080300L,
     0x01000200L, 0x01000300L, 0x01080200L, 0x01080300L,
     0x00000210L, 0x00000310L, 0x00080210L, 0x00080310L,
     0x01000210L, 0x01000310L, 0x01080210L, 0x01080310L,
     0x00200200L, 0x00200300L, 0x00280200L, 0x00280300L,
     0x01200200L, 0x01200300L, 0x01280200L, 0x01280300L,
     0x00200210L, 0x00200310L, 0x00280210L, 0x00280310L,
     0x01200210L, 0x01200310L, 0x01280210L, 0x01280310L,
     },
    {
     /* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
     0x00000000L, 0x04000000L, 0x00040000L, 0x04040000L,
     0x00000002L, 0x04000002L, 0x00040002L, 0x04040002L,
     0x00002000L, 0x04002000L, 0x00042000L, 0x04042000L,
     0x00002002L, 0x04002002L, 0x00042002L, 0x04042002L,
     0x00000020L, 0x04000020L, 0x00040020L, 0x04040020L,
     0x00000022L, 0x04000022L, 0x00040022L, 0x04040022L,
     0x00002020L, 0x04002020L, 0x00042020L, 0x04042020L,
     0x00002022L, 0x04002022L, 0x00042022L, 0x04042022L,
     0x00000800L, 0x04000800L, 0x00040800L, 0x04040800L,
     0x00000802L, 0x04000802L, 0x00040802L, 0x04040802L,
     0x00002800L, 0x04002800L, 0x00042800L, 0x04042800L,
     0x00002802L, 0x04002802L, 0x00042802L, 0x04042802L,
     0x00000820L, 0x04000820L, 0x00040820L, 0x04040820L,
     0x00000822L, 0x04000822L, 0x00040822L, 0x04040822L,
     0x00002820L, 0x04002820L, 0x00042820L, 0x04042820L,
     0x00002822L, 0x04002822L, 0x00042822L, 0x04042822L,
     }
};

int DES_set_key(const_DES_cblock *key, DES_key_schedule *schedule)
{
    if (DES_check_key) {
        return DES_set_key_checked(key, schedule);
    } else {
        DES_set_key_unchecked(key, schedule);
        return 0;
    }
}

/*-
 * return 0 if key parity is odd (correct),
 * return -1 if key parity error,
 * return -2 if illegal weak key.
 */
int DES_set_key_checked(const_DES_cblock *key, DES_key_schedule *schedule)
{
    if (!DES_check_key_parity(key))
        return -1;
    if (DES_is_weak_key(key))
        return -2;
    DES_set_key_unchecked(key, schedule);
    return 0;
}

void DES_set_key_unchecked(const_DES_cblock *key, DES_key_schedule *schedule)
{
    static const int shifts2[16] =
        { 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 };
    register DES_LONG c, d, t, s, t2;
    register const unsigned char *in;
    register DES_LONG *k;
    register int i;

#ifdef OPENBSD_DEV_CRYPTO
    memcpy(schedule->key, key, sizeof(schedule->key));
    schedule->session = NULL;
#endif
    k = &schedule->ks->deslong[0];
    in = &(*key)[0];

    c2l(in, c);
    c2l(in, d);

    /*
     * do PC1 in 47 simple operations. Thanks to John Fletcher
     * for the inspiration.
     */
    PERM_OP(d, c, t, 4, 0x0f0f0f0fL);
    HPERM_OP(c, t, -2, 0xcccc0000L);
    HPERM_OP(d, t, -2, 0xcccc0000L);
    PERM_OP(d, c, t, 1, 0x55555555L);
    PERM_OP(c, d, t, 8, 0x00ff00ffL);
    PERM_OP(d, c, t, 1, 0x55555555L);
    d = (((d & 0x000000ffL) << 16L) | (d & 0x0000ff00L) |
         ((d & 0x00ff0000L) >> 16L) | ((c & 0xf0000000L) >> 4L));
    c &= 0x0fffffffL;

    for (i = 0; i < ITERATIONS; i++) {
        if (shifts2[i]) {
            c = ((c >> 2L) | (c << 26L));
            d = ((d >> 2L) | (d << 26L));
        } else {
            c = ((c >> 1L) | (c << 27L));
            d = ((d >> 1L) | (d << 27L));
        }
        c &= 0x0fffffffL;
        d &= 0x0fffffffL;
        /*
         * could be a few less shifts but I am to lazy at this point in time
         * to investigate
         */
        s = des_skb[0][(c) & 0x3f] |
            des_skb[1][((c >> 6L) & 0x03) | ((c >> 7L) & 0x3c)] |
            des_skb[2][((c >> 13L) & 0x0f) | ((c >> 14L) & 0x30)] |
            des_skb[3][((c >> 20L) & 0x01) | ((c >> 21L) & 0x06) |
                       ((c >> 22L) & 0x38)];
        t = des_skb[4][(d) & 0x3f] |
            des_skb[5][((d >> 7L) & 0x03) | ((d >> 8L) & 0x3c)] |
            des_skb[6][(d >> 15L) & 0x3f] |
            des_skb[7][((d >> 21L) & 0x0f) | ((d >> 22L) & 0x30)];

        /* table contained 0213 4657 */
        t2 = ((t << 16L) | (s & 0x0000ffffL)) & 0xffffffffL;
        *(k++) = ROTATE(t2, 30) & 0xffffffffL;

        t2 = ((s >> 16L) | (t & 0xffff0000L));
        *(k++) = ROTATE(t2, 26) & 0xffffffffL;
    }
}

int DES_key_sched(const_DES_cblock *key, DES_key_schedule *schedule)
{
    return DES_set_key(key, schedule);
}

Coverage Report

Created: 2018-08-29 13:53

Line	Count	Source (jump to first uncovered line)
1		/*
2		* Copyright 1995-2016 The OpenSSL Project Authors. All Rights Reserved.
3		*
4		* Licensed under the OpenSSL license (the "License"). You may not use
5		* this file except in compliance with the License. You can obtain a copy
6		* in the file LICENSE in the source distribution or at
7		* https://www.openssl.org/source/license.html
8		*/
9
10		/*-
11		* set_key.c v 1.4 eay 24/9/91
12		* 1.4 Speed up by 400% :-)
13		* 1.3 added register declarations.
14		* 1.2 unrolled make_key_sched a bit more
15		* 1.1 added norm_expand_bits
16		* 1.0 First working version
17		*/
18		#include <openssl/crypto.h>
19		#include "des_locl.h"
20
21		/* defaults to false */
22		OPENSSL_IMPLEMENT_GLOBAL(int, DES_check_key, 0)
23
24		static const unsigned char odd_parity[256] = {
25		1, 1, 2, 2, 4, 4, 7, 7, 8, 8, 11, 11, 13, 13, 14, 14,
26		16, 16, 19, 19, 21, 21, 22, 22, 25, 25, 26, 26, 28, 28, 31, 31,
27		32, 32, 35, 35, 37, 37, 38, 38, 41, 41, 42, 42, 44, 44, 47, 47,
28		49, 49, 50, 50, 52, 52, 55, 55, 56, 56, 59, 59, 61, 61, 62, 62,
29		64, 64, 67, 67, 69, 69, 70, 70, 73, 73, 74, 74, 76, 76, 79, 79,
30		81, 81, 82, 82, 84, 84, 87, 87, 88, 88, 91, 91, 93, 93, 94, 94,
31		97, 97, 98, 98, 100, 100, 103, 103, 104, 104, 107, 107, 109, 109, 110,
32		110,
33		112, 112, 115, 115, 117, 117, 118, 118, 121, 121, 122, 122, 124, 124, 127,
34		127,
35		128, 128, 131, 131, 133, 133, 134, 134, 137, 137, 138, 138, 140, 140, 143,
36		143,
37		145, 145, 146, 146, 148, 148, 151, 151, 152, 152, 155, 155, 157, 157, 158,
38		158,
39		161, 161, 162, 162, 164, 164, 167, 167, 168, 168, 171, 171, 173, 173, 174,
40		174,
41		176, 176, 179, 179, 181, 181, 182, 182, 185, 185, 186, 186, 188, 188, 191,
42		191,
43		193, 193, 194, 194, 196, 196, 199, 199, 200, 200, 203, 203, 205, 205, 206,
44		206,
45		208, 208, 211, 211, 213, 213, 214, 214, 217, 217, 218, 218, 220, 220, 223,
46		223,
47		224, 224, 227, 227, 229, 229, 230, 230, 233, 233, 234, 234, 236, 236, 239,
48		239,
49		241, 241, 242, 242, 244, 244, 247, 247, 248, 248, 251, 251, 253, 253, 254,
50		254
51		};
52
53		void DES_set_odd_parity(DES_cblock *key)
54	0	{
55	0	unsigned int i;
56	0
57	0	for (i = 0; i < DES_KEY_SZ; i++)
58	0	(key)[i] = odd_parity[(key)[i]];
59	0	}
60
61		int DES_check_key_parity(const_DES_cblock *key)
62	0	{
63	0	unsigned int i;
64	0
65	0	for (i = 0; i < DES_KEY_SZ; i++) {
66	0	if ((key)[i] != odd_parity[(key)[i]])
67	0	return 0;
68	0	}
69	0	return 1;
70	0	}
71
72		/*-
73		* Weak and semi weak keys as taken from
74		* %A D.W. Davies
75		* %A W.L. Price
76		* %T Security for Computer Networks
77		* %I John Wiley & Sons
78		* %D 1984
79		*/
80	0	#define NUM_WEAK_KEY 16
81		static const DES_cblock weak_keys[NUM_WEAK_KEY] = {
82		/* weak keys */
83		{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01},
84		{0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE},
85		{0x1F, 0x1F, 0x1F, 0x1F, 0x0E, 0x0E, 0x0E, 0x0E},
86		{0xE0, 0xE0, 0xE0, 0xE0, 0xF1, 0xF1, 0xF1, 0xF1},
87		/* semi-weak keys */
88		{0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE},
89		{0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01, 0xFE, 0x01},
90		{0x1F, 0xE0, 0x1F, 0xE0, 0x0E, 0xF1, 0x0E, 0xF1},
91		{0xE0, 0x1F, 0xE0, 0x1F, 0xF1, 0x0E, 0xF1, 0x0E},
92		{0x01, 0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1},
93		{0xE0, 0x01, 0xE0, 0x01, 0xF1, 0x01, 0xF1, 0x01},
94		{0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E, 0xFE},
95		{0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x0E, 0xFE, 0x0E},
96		{0x01, 0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E},
97		{0x1F, 0x01, 0x1F, 0x01, 0x0E, 0x01, 0x0E, 0x01},
98		{0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1, 0xFE},
99		{0xFE, 0xE0, 0xFE, 0xE0, 0xFE, 0xF1, 0xFE, 0xF1}
100		};
101
102		int DES_is_weak_key(const_DES_cblock *key)
103	0	{
104	0	int i;
105	0
106	0	for (i = 0; i < NUM_WEAK_KEY; i++)
107	0	if (memcmp(weak_keys[i], key, sizeof(DES_cblock)) == 0)
108	0	return 1;
109	0	return 0;
110	0	}
111
112		/*-
113		* NOW DEFINED IN des_local.h
114		* See ecb_encrypt.c for a pseudo description of these macros.
115		* #define PERM_OP(a,b,t,n,m) ((t)=((((a)>>(n))^(b))&(m)),\
116		* (b)^=(t),\
117		* (a)=((a)^((t)<<(n))))
118		*/
119
120	0	#define HPERM_OP(a,t,n,m) ((t)=((((a)<<(16-(n)))^(a))&(m)),\
121	0	(a)=(a)^(t)^(t>>(16-(n))))
122
123		static const DES_LONG des_skb[8][64] = {
124		{
125		/* for C bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
126		0x00000000L, 0x00000010L, 0x20000000L, 0x20000010L,
127		0x00010000L, 0x00010010L, 0x20010000L, 0x20010010L,
128		0x00000800L, 0x00000810L, 0x20000800L, 0x20000810L,
129		0x00010800L, 0x00010810L, 0x20010800L, 0x20010810L,
130		0x00000020L, 0x00000030L, 0x20000020L, 0x20000030L,
131		0x00010020L, 0x00010030L, 0x20010020L, 0x20010030L,
132		0x00000820L, 0x00000830L, 0x20000820L, 0x20000830L,
133		0x00010820L, 0x00010830L, 0x20010820L, 0x20010830L,
134		0x00080000L, 0x00080010L, 0x20080000L, 0x20080010L,
135		0x00090000L, 0x00090010L, 0x20090000L, 0x20090010L,
136		0x00080800L, 0x00080810L, 0x20080800L, 0x20080810L,
137		0x00090800L, 0x00090810L, 0x20090800L, 0x20090810L,
138		0x00080020L, 0x00080030L, 0x20080020L, 0x20080030L,
139		0x00090020L, 0x00090030L, 0x20090020L, 0x20090030L,
140		0x00080820L, 0x00080830L, 0x20080820L, 0x20080830L,
141		0x00090820L, 0x00090830L, 0x20090820L, 0x20090830L,
142		},
143		{
144		/* for C bits (numbered as per FIPS 46) 7 8 10 11 12 13 */
145		0x00000000L, 0x02000000L, 0x00002000L, 0x02002000L,
146		0x00200000L, 0x02200000L, 0x00202000L, 0x02202000L,
147		0x00000004L, 0x02000004L, 0x00002004L, 0x02002004L,
148		0x00200004L, 0x02200004L, 0x00202004L, 0x02202004L,
149		0x00000400L, 0x02000400L, 0x00002400L, 0x02002400L,
150		0x00200400L, 0x02200400L, 0x00202400L, 0x02202400L,
151		0x00000404L, 0x02000404L, 0x00002404L, 0x02002404L,
152		0x00200404L, 0x02200404L, 0x00202404L, 0x02202404L,
153		0x10000000L, 0x12000000L, 0x10002000L, 0x12002000L,
154		0x10200000L, 0x12200000L, 0x10202000L, 0x12202000L,
155		0x10000004L, 0x12000004L, 0x10002004L, 0x12002004L,
156		0x10200004L, 0x12200004L, 0x10202004L, 0x12202004L,
157		0x10000400L, 0x12000400L, 0x10002400L, 0x12002400L,
158		0x10200400L, 0x12200400L, 0x10202400L, 0x12202400L,
159		0x10000404L, 0x12000404L, 0x10002404L, 0x12002404L,
160		0x10200404L, 0x12200404L, 0x10202404L, 0x12202404L,
161		},
162		{
163		/* for C bits (numbered as per FIPS 46) 14 15 16 17 19 20 */
164		0x00000000L, 0x00000001L, 0x00040000L, 0x00040001L,
165		0x01000000L, 0x01000001L, 0x01040000L, 0x01040001L,
166		0x00000002L, 0x00000003L, 0x00040002L, 0x00040003L,
167		0x01000002L, 0x01000003L, 0x01040002L, 0x01040003L,
168		0x00000200L, 0x00000201L, 0x00040200L, 0x00040201L,
169		0x01000200L, 0x01000201L, 0x01040200L, 0x01040201L,
170		0x00000202L, 0x00000203L, 0x00040202L, 0x00040203L,
171		0x01000202L, 0x01000203L, 0x01040202L, 0x01040203L,
172		0x08000000L, 0x08000001L, 0x08040000L, 0x08040001L,
173		0x09000000L, 0x09000001L, 0x09040000L, 0x09040001L,
174		0x08000002L, 0x08000003L, 0x08040002L, 0x08040003L,
175		0x09000002L, 0x09000003L, 0x09040002L, 0x09040003L,
176		0x08000200L, 0x08000201L, 0x08040200L, 0x08040201L,
177		0x09000200L, 0x09000201L, 0x09040200L, 0x09040201L,
178		0x08000202L, 0x08000203L, 0x08040202L, 0x08040203L,
179		0x09000202L, 0x09000203L, 0x09040202L, 0x09040203L,
180		},
181		{
182		/* for C bits (numbered as per FIPS 46) 21 23 24 26 27 28 */
183		0x00000000L, 0x00100000L, 0x00000100L, 0x00100100L,
184		0x00000008L, 0x00100008L, 0x00000108L, 0x00100108L,
185		0x00001000L, 0x00101000L, 0x00001100L, 0x00101100L,
186		0x00001008L, 0x00101008L, 0x00001108L, 0x00101108L,
187		0x04000000L, 0x04100000L, 0x04000100L, 0x04100100L,
188		0x04000008L, 0x04100008L, 0x04000108L, 0x04100108L,
189		0x04001000L, 0x04101000L, 0x04001100L, 0x04101100L,
190		0x04001008L, 0x04101008L, 0x04001108L, 0x04101108L,
191		0x00020000L, 0x00120000L, 0x00020100L, 0x00120100L,
192		0x00020008L, 0x00120008L, 0x00020108L, 0x00120108L,
193		0x00021000L, 0x00121000L, 0x00021100L, 0x00121100L,
194		0x00021008L, 0x00121008L, 0x00021108L, 0x00121108L,
195		0x04020000L, 0x04120000L, 0x04020100L, 0x04120100L,
196		0x04020008L, 0x04120008L, 0x04020108L, 0x04120108L,
197		0x04021000L, 0x04121000L, 0x04021100L, 0x04121100L,
198		0x04021008L, 0x04121008L, 0x04021108L, 0x04121108L,
199		},
200		{
201		/* for D bits (numbered as per FIPS 46) 1 2 3 4 5 6 */
202		0x00000000L, 0x10000000L, 0x00010000L, 0x10010000L,
203		0x00000004L, 0x10000004L, 0x00010004L, 0x10010004L,
204		0x20000000L, 0x30000000L, 0x20010000L, 0x30010000L,
205		0x20000004L, 0x30000004L, 0x20010004L, 0x30010004L,
206		0x00100000L, 0x10100000L, 0x00110000L, 0x10110000L,
207		0x00100004L, 0x10100004L, 0x00110004L, 0x10110004L,
208		0x20100000L, 0x30100000L, 0x20110000L, 0x30110000L,
209		0x20100004L, 0x30100004L, 0x20110004L, 0x30110004L,
210		0x00001000L, 0x10001000L, 0x00011000L, 0x10011000L,
211		0x00001004L, 0x10001004L, 0x00011004L, 0x10011004L,
212		0x20001000L, 0x30001000L, 0x20011000L, 0x30011000L,
213		0x20001004L, 0x30001004L, 0x20011004L, 0x30011004L,
214		0x00101000L, 0x10101000L, 0x00111000L, 0x10111000L,
215		0x00101004L, 0x10101004L, 0x00111004L, 0x10111004L,
216		0x20101000L, 0x30101000L, 0x20111000L, 0x30111000L,
217		0x20101004L, 0x30101004L, 0x20111004L, 0x30111004L,
218		},
219		{
220		/* for D bits (numbered as per FIPS 46) 8 9 11 12 13 14 */
221		0x00000000L, 0x08000000L, 0x00000008L, 0x08000008L,
222		0x00000400L, 0x08000400L, 0x00000408L, 0x08000408L,
223		0x00020000L, 0x08020000L, 0x00020008L, 0x08020008L,
224		0x00020400L, 0x08020400L, 0x00020408L, 0x08020408L,
225		0x00000001L, 0x08000001L, 0x00000009L, 0x08000009L,
226		0x00000401L, 0x08000401L, 0x00000409L, 0x08000409L,
227		0x00020001L, 0x08020001L, 0x00020009L, 0x08020009L,
228		0x00020401L, 0x08020401L, 0x00020409L, 0x08020409L,
229		0x02000000L, 0x0A000000L, 0x02000008L, 0x0A000008L,
230		0x02000400L, 0x0A000400L, 0x02000408L, 0x0A000408L,
231		0x02020000L, 0x0A020000L, 0x02020008L, 0x0A020008L,
232		0x02020400L, 0x0A020400L, 0x02020408L, 0x0A020408L,
233		0x02000001L, 0x0A000001L, 0x02000009L, 0x0A000009L,
234		0x02000401L, 0x0A000401L, 0x02000409L, 0x0A000409L,
235		0x02020001L, 0x0A020001L, 0x02020009L, 0x0A020009L,
236		0x02020401L, 0x0A020401L, 0x02020409L, 0x0A020409L,
237		},
238		{
239		/* for D bits (numbered as per FIPS 46) 16 17 18 19 20 21 */
240		0x00000000L, 0x00000100L, 0x00080000L, 0x00080100L,
241		0x01000000L, 0x01000100L, 0x01080000L, 0x01080100L,
242		0x00000010L, 0x00000110L, 0x00080010L, 0x00080110L,
243		0x01000010L, 0x01000110L, 0x01080010L, 0x01080110L,
244		0x00200000L, 0x00200100L, 0x00280000L, 0x00280100L,
245		0x01200000L, 0x01200100L, 0x01280000L, 0x01280100L,
246		0x00200010L, 0x00200110L, 0x00280010L, 0x00280110L,
247		0x01200010L, 0x01200110L, 0x01280010L, 0x01280110L,
248		0x00000200L, 0x00000300L, 0x00080200L, 0x00080300L,
249		0x01000200L, 0x01000300L, 0x01080200L, 0x01080300L,
250		0x00000210L, 0x00000310L, 0x00080210L, 0x00080310L,
251		0x01000210L, 0x01000310L, 0x01080210L, 0x01080310L,
252		0x00200200L, 0x00200300L, 0x00280200L, 0x00280300L,
253		0x01200200L, 0x01200300L, 0x01280200L, 0x01280300L,
254		0x00200210L, 0x00200310L, 0x00280210L, 0x00280310L,
255		0x01200210L, 0x01200310L, 0x01280210L, 0x01280310L,
256		},
257		{
258		/* for D bits (numbered as per FIPS 46) 22 23 24 25 27 28 */
259		0x00000000L, 0x04000000L, 0x00040000L, 0x04040000L,
260		0x00000002L, 0x04000002L, 0x00040002L, 0x04040002L,
261		0x00002000L, 0x04002000L, 0x00042000L, 0x04042000L,
262		0x00002002L, 0x04002002L, 0x00042002L, 0x04042002L,
263		0x00000020L, 0x04000020L, 0x00040020L, 0x04040020L,
264		0x00000022L, 0x04000022L, 0x00040022L, 0x04040022L,
265		0x00002020L, 0x04002020L, 0x00042020L, 0x04042020L,
266		0x00002022L, 0x04002022L, 0x00042022L, 0x04042022L,
267		0x00000800L, 0x04000800L, 0x00040800L, 0x04040800L,
268		0x00000802L, 0x04000802L, 0x00040802L, 0x04040802L,
269		0x00002800L, 0x04002800L, 0x00042800L, 0x04042800L,
270		0x00002802L, 0x04002802L, 0x00042802L, 0x04042802L,
271		0x00000820L, 0x04000820L, 0x00040820L, 0x04040820L,
272		0x00000822L, 0x04000822L, 0x00040822L, 0x04040822L,
273		0x00002820L, 0x04002820L, 0x00042820L, 0x04042820L,
274		0x00002822L, 0x04002822L, 0x00042822L, 0x04042822L,
275		}
276		};
277
278		int DES_set_key(const_DES_cblock key, DES_key_schedule schedule)
279	0	{
280	0	if (DES_check_key) {
281	0	return DES_set_key_checked(key, schedule);
282	0	} else {
283	0	DES_set_key_unchecked(key, schedule);
284	0	return 0;
285	0	}
286	0	}
287
288		/*-
289		* return 0 if key parity is odd (correct),
290		* return -1 if key parity error,
291		* return -2 if illegal weak key.
292		*/
293		int DES_set_key_checked(const_DES_cblock key, DES_key_schedule schedule)
294	0	{
295	0	if (!DES_check_key_parity(key))
296	0	return -1;
297	0	if (DES_is_weak_key(key))
298	0	return -2;
299	0	DES_set_key_unchecked(key, schedule);
300	0	return 0;
301	0	}
302
303		void DES_set_key_unchecked(const_DES_cblock key, DES_key_schedule schedule)
304	0	{
305	0	static const int shifts2[16] =
306	0	{ 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 0 };
307	0	register DES_LONG c, d, t, s, t2;
308	0	register const unsigned char *in;
309	0	register DES_LONG *k;
310	0	register int i;
311	0
312		#ifdef OPENBSD_DEV_CRYPTO
313		memcpy(schedule->key, key, sizeof(schedule->key));
314		schedule->session = NULL;
315		#endif
316		k = &schedule->ks->deslong[0];
317	0	in = &(*key)[0];
318	0
319	0	c2l(in, c);
320	0	c2l(in, d);
321	0
322	0	/*
323	0	* do PC1 in 47 simple operations. Thanks to John Fletcher
324	0	* for the inspiration.
325	0	*/
326	0	PERM_OP(d, c, t, 4, 0x0f0f0f0fL);
327	0	HPERM_OP(c, t, -2, 0xcccc0000L);
328	0	HPERM_OP(d, t, -2, 0xcccc0000L);
329	0	PERM_OP(d, c, t, 1, 0x55555555L);
330	0	PERM_OP(c, d, t, 8, 0x00ff00ffL);
331	0	PERM_OP(d, c, t, 1, 0x55555555L);
332	0	d = (((d & 0x000000ffL) << 16L) \| (d & 0x0000ff00L) \|
333	0	((d & 0x00ff0000L) >> 16L) \| ((c & 0xf0000000L) >> 4L));
334	0	c &= 0x0fffffffL;
335	0
336	0	for (i = 0; i < ITERATIONS; i++) {
337	0	if (shifts2[i]) {
338	0	c = ((c >> 2L) \| (c << 26L));
339	0	d = ((d >> 2L) \| (d << 26L));
340	0	} else {
341	0	c = ((c >> 1L) \| (c << 27L));
342	0	d = ((d >> 1L) \| (d << 27L));
343	0	}
344	0	c &= 0x0fffffffL;
345	0	d &= 0x0fffffffL;
346	0	/*
347	0	* could be a few less shifts but I am to lazy at this point in time
348	0	* to investigate
349	0	*/
350	0	s = des_skb[0][(c) & 0x3f] \|
351	0	des_skb[1][((c >> 6L) & 0x03) \| ((c >> 7L) & 0x3c)] \|
352	0	des_skb[2][((c >> 13L) & 0x0f) \| ((c >> 14L) & 0x30)] \|
353	0	des_skb[3][((c >> 20L) & 0x01) \| ((c >> 21L) & 0x06) \|
354	0	((c >> 22L) & 0x38)];
355	0	t = des_skb[4][(d) & 0x3f] \|
356	0	des_skb[5][((d >> 7L) & 0x03) \| ((d >> 8L) & 0x3c)] \|
357	0	des_skb[6][(d >> 15L) & 0x3f] \|
358	0	des_skb[7][((d >> 21L) & 0x0f) \| ((d >> 22L) & 0x30)];
359	0
360	0	/* table contained 0213 4657 */
361	0	t2 = ((t << 16L) \| (s & 0x0000ffffL)) & 0xffffffffL;
362	0	*(k++) = ROTATE(t2, 30) & 0xffffffffL;
363	0
364	0	t2 = ((s >> 16L) \| (t & 0xffff0000L));
365	0	*(k++) = ROTATE(t2, 26) & 0xffffffffL;
366	0	}
367	0	}
368
369		int DES_key_sched(const_DES_cblock key, DES_key_schedule schedule)
370	0	{
371	0	return DES_set_key(key, schedule);
372	0	}