OpenSolaris_b135/common/crypto/des/des_impl.c
/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* or http://www.opensolaris.org/os/licensing.
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2009 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/ddi.h>
#include <sys/sysmacros.h>
#include <sys/strsun.h>
#include <sys/crypto/spi.h>
#include <modes/modes.h>
#include <sys/crypto/common.h>
#include "des_impl.h"
#ifndef _KERNEL
#include <strings.h>
#include <stdlib.h>
#endif /* !_KERNEL */
#if defined(__i386) || defined(__amd64)
#include <sys/byteorder.h>
#define UNALIGNED_POINTERS_PERMITTED
#endif
/* EXPORT DELETE START */
typedef struct keysched_s {
uint64_t ksch_encrypt[16];
uint64_t ksch_decrypt[16];
} keysched_t;
typedef struct keysched3_s {
uint64_t ksch_encrypt[48];
uint64_t ksch_decrypt[48];
} keysched3_t;
static void fix_des_parity(uint64_t *);
#ifndef sun4u
static const uint64_t sbox_table[8][64]=
{
/* BEGIN CSTYLED */
{
0x0000140140020000ULL, 0x0000000000000000ULL, 0x0000000140000000ULL, 0x0000140140020020ULL,
0x0000140140000020ULL, 0x0000000140020020ULL, 0x0000000000000020ULL, 0x0000000140000000ULL,
0x0000000000020000ULL, 0x0000140140020000ULL, 0x0000140140020020ULL, 0x0000000000020000ULL,
0x0000140000020020ULL, 0x0000140140000020ULL, 0x0000140000000000ULL, 0x0000000000000020ULL,
0x0000000000020020ULL, 0x0000140000020000ULL, 0x0000140000020000ULL, 0x0000000140020000ULL,
0x0000000140020000ULL, 0x0000140140000000ULL, 0x0000140140000000ULL, 0x0000140000020020ULL,
0x0000000140000020ULL, 0x0000140000000020ULL, 0x0000140000000020ULL, 0x0000000140000020ULL,
0x0000000000000000ULL, 0x0000000000020020ULL, 0x0000000140020020ULL, 0x0000140000000000ULL,
0x0000000140000000ULL, 0x0000140140020020ULL, 0x0000000000000020ULL, 0x0000140140000000ULL,
0x0000140140020000ULL, 0x0000140000000000ULL, 0x0000140000000000ULL, 0x0000000000020000ULL,
0x0000140140000020ULL, 0x0000000140000000ULL, 0x0000000140020000ULL, 0x0000140000000020ULL,
0x0000000000020000ULL, 0x0000000000000020ULL, 0x0000140000020020ULL, 0x0000000140020020ULL,
0x0000140140020020ULL, 0x0000000140000020ULL, 0x0000140140000000ULL, 0x0000140000020020ULL,
0x0000140000000020ULL, 0x0000000000020020ULL, 0x0000000140020020ULL, 0x0000140140020000ULL,
0x0000000000020020ULL, 0x0000140000020000ULL, 0x0000140000020000ULL, 0x0000000000000000ULL,
0x0000000140000020ULL, 0x0000000140020000ULL, 0x0000000000000000ULL, 0x0000140140000020ULL
},
{
0x2000005020000500ULL, 0x2000000020000000ULL, 0x0000000020000000ULL, 0x0000005020000500ULL,
0x0000005000000000ULL, 0x0000000000000500ULL, 0x2000005000000500ULL, 0x2000000020000500ULL,
0x2000000000000500ULL, 0x2000005020000500ULL, 0x2000005020000000ULL, 0x2000000000000000ULL,
0x2000000020000000ULL, 0x0000005000000000ULL, 0x0000000000000500ULL, 0x2000005000000500ULL,
0x0000005020000000ULL, 0x0000005000000500ULL, 0x2000000020000500ULL, 0x0000000000000000ULL,
0x2000000000000000ULL, 0x0000000020000000ULL, 0x0000005020000500ULL, 0x2000005000000000ULL,
0x0000005000000500ULL, 0x2000000000000500ULL, 0x0000000000000000ULL, 0x0000005020000000ULL,
0x0000000020000500ULL, 0x2000005020000000ULL, 0x2000005000000000ULL, 0x0000000020000500ULL,
0x0000000000000000ULL, 0x0000005020000500ULL, 0x2000005000000500ULL, 0x0000005000000000ULL,
0x2000000020000500ULL, 0x2000005000000000ULL, 0x2000005020000000ULL, 0x0000000020000000ULL,
0x2000005000000000ULL, 0x2000000020000000ULL, 0x0000000000000500ULL, 0x2000005020000500ULL,
0x0000005020000500ULL, 0x0000000000000500ULL, 0x0000000020000000ULL, 0x2000000000000000ULL,
0x0000000020000500ULL, 0x2000005020000000ULL, 0x0000005000000000ULL, 0x2000000000000500ULL,
0x0000005000000500ULL, 0x2000000020000500ULL, 0x2000000000000500ULL, 0x0000005000000500ULL,
0x0000005020000000ULL, 0x0000000000000000ULL, 0x2000000020000000ULL, 0x0000000020000500ULL,
0x2000000000000000ULL, 0x2000005000000500ULL, 0x2000005020000500ULL, 0x0000005020000000ULL
},
{
0x0000000000014040ULL, 0x0000800280014000ULL, 0x0000000000000000ULL, 0x0000800280000040ULL,
0x0000800000014000ULL, 0x0000000000000000ULL, 0x0000000280014040ULL, 0x0000800000014000ULL,
0x0000000280000040ULL, 0x0000800000000040ULL, 0x0000800000000040ULL, 0x0000000280000000ULL,
0x0000800280014040ULL, 0x0000000280000040ULL, 0x0000800280000000ULL, 0x0000000000014040ULL,
0x0000800000000000ULL, 0x0000000000000040ULL, 0x0000800280014000ULL, 0x0000000000014000ULL,
0x0000000280014000ULL, 0x0000800280000000ULL, 0x0000800280000040ULL, 0x0000000280014040ULL,
0x0000800000014040ULL, 0x0000000280014000ULL, 0x0000000280000000ULL, 0x0000800000014040ULL,
0x0000000000000040ULL, 0x0000800280014040ULL, 0x0000000000014000ULL, 0x0000800000000000ULL,
0x0000800280014000ULL, 0x0000800000000000ULL, 0x0000000280000040ULL, 0x0000000000014040ULL,
0x0000000280000000ULL, 0x0000800280014000ULL, 0x0000800000014000ULL, 0x0000000000000000ULL,
0x0000000000014000ULL, 0x0000000280000040ULL, 0x0000800280014040ULL, 0x0000800000014000ULL,
0x0000800000000040ULL, 0x0000000000014000ULL, 0x0000000000000000ULL, 0x0000800280000040ULL,
0x0000800000014040ULL, 0x0000000280000000ULL, 0x0000800000000000ULL, 0x0000800280014040ULL,
0x0000000000000040ULL, 0x0000000280014040ULL, 0x0000000280014000ULL, 0x0000800000000040ULL,
0x0000800280000000ULL, 0x0000800000014040ULL, 0x0000000000014040ULL, 0x0000800280000000ULL,
0x0000000280014040ULL, 0x0000000000000040ULL, 0x0000800280000040ULL, 0x0000000280014000ULL
},
{
0x4000020008100008ULL, 0x4000000008101008ULL, 0x4000000008101008ULL, 0x0000000000001000ULL,
0x0000020008101000ULL, 0x4000020000001008ULL, 0x4000020000000008ULL, 0x4000000008100008ULL,
0x0000000000000000ULL, 0x0000020008100000ULL, 0x0000020008100000ULL, 0x4000020008101008ULL,
0x4000000000001008ULL, 0x0000000000000000ULL, 0x0000020000001000ULL, 0x4000020000000008ULL,
0x4000000000000008ULL, 0x0000000008100000ULL, 0x0000020000000000ULL, 0x4000020008100008ULL,
0x0000000000001000ULL, 0x0000020000000000ULL, 0x4000000008100008ULL, 0x0000000008101000ULL,
0x4000020000001008ULL, 0x4000000000000008ULL, 0x0000000008101000ULL, 0x0000020000001000ULL,
0x0000000008100000ULL, 0x0000020008101000ULL, 0x4000020008101008ULL, 0x4000000000001008ULL,
0x0000020000001000ULL, 0x4000020000000008ULL, 0x0000020008100000ULL, 0x4000020008101008ULL,
0x4000000000001008ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0000020008100000ULL,
0x0000000008101000ULL, 0x0000020000001000ULL, 0x4000020000001008ULL, 0x4000000000000008ULL,
0x4000020008100008ULL, 0x4000000008101008ULL, 0x4000000008101008ULL, 0x0000000000001000ULL,
0x4000020008101008ULL, 0x4000000000001008ULL, 0x4000000000000008ULL, 0x0000000008100000ULL,
0x4000020000000008ULL, 0x4000000008100008ULL, 0x0000020008101000ULL, 0x4000020000001008ULL,
0x4000000008100008ULL, 0x0000000008101000ULL, 0x0000020000000000ULL, 0x4000020008100008ULL,
0x0000000000001000ULL, 0x0000020000000000ULL, 0x0000000008100000ULL, 0x0000020008101000ULL
},
{
0x000000000000a000ULL, 0x000028080000a000ULL, 0x0000280800000000ULL, 0x100028000000a000ULL,
0x0000000800000000ULL, 0x000000000000a000ULL, 0x1000000000000000ULL, 0x0000280800000000ULL,
0x100000080000a000ULL, 0x0000000800000000ULL, 0x000028000000a000ULL, 0x100000080000a000ULL,
0x100028000000a000ULL, 0x1000280800000000ULL, 0x000000080000a000ULL, 0x1000000000000000ULL,
0x0000280000000000ULL, 0x1000000800000000ULL, 0x1000000800000000ULL, 0x0000000000000000ULL,
0x100000000000a000ULL, 0x100028080000a000ULL, 0x100028080000a000ULL, 0x000028000000a000ULL,
0x1000280800000000ULL, 0x100000000000a000ULL, 0x0000000000000000ULL, 0x1000280000000000ULL,
0x000028080000a000ULL, 0x0000280000000000ULL, 0x1000280000000000ULL, 0x000000080000a000ULL,
0x0000000800000000ULL, 0x100028000000a000ULL, 0x000000000000a000ULL, 0x0000280000000000ULL,
0x1000000000000000ULL, 0x0000280800000000ULL, 0x100028000000a000ULL, 0x100000080000a000ULL,
0x000028000000a000ULL, 0x1000000000000000ULL, 0x1000280800000000ULL, 0x000028080000a000ULL,
0x100000080000a000ULL, 0x000000000000a000ULL, 0x0000280000000000ULL, 0x1000280800000000ULL,
0x100028080000a000ULL, 0x000000080000a000ULL, 0x1000280000000000ULL, 0x100028080000a000ULL,
0x0000280800000000ULL, 0x0000000000000000ULL, 0x1000000800000000ULL, 0x1000280000000000ULL,
0x000000080000a000ULL, 0x000028000000a000ULL, 0x100000000000a000ULL, 0x0000000800000000ULL,
0x0000000000000000ULL, 0x1000000800000000ULL, 0x000028080000a000ULL, 0x100000000000a000ULL
},
{
0x0802000000000280ULL, 0x0802010000000000ULL, 0x0000000010000000ULL, 0x0802010010000280ULL,
0x0802010000000000ULL, 0x0000000000000280ULL, 0x0802010010000280ULL, 0x0000010000000000ULL,
0x0802000010000000ULL, 0x0000010010000280ULL, 0x0000010000000000ULL, 0x0802000000000280ULL,
0x0000010000000280ULL, 0x0802000010000000ULL, 0x0802000000000000ULL, 0x0000000010000280ULL,
0x0000000000000000ULL, 0x0000010000000280ULL, 0x0802000010000280ULL, 0x0000000010000000ULL,
0x0000010010000000ULL, 0x0802000010000280ULL, 0x0000000000000280ULL, 0x0802010000000280ULL,
0x0802010000000280ULL, 0x0000000000000000ULL, 0x0000010010000280ULL, 0x0802010010000000ULL,
0x0000000010000280ULL, 0x0000010010000000ULL, 0x0802010010000000ULL, 0x0802000000000000ULL,
0x0802000010000000ULL, 0x0000000000000280ULL, 0x0802010000000280ULL, 0x0000010010000000ULL,
0x0802010010000280ULL, 0x0000010000000000ULL, 0x0000000010000280ULL, 0x0802000000000280ULL,
0x0000010000000000ULL, 0x0802000010000000ULL, 0x0802000000000000ULL, 0x0000000010000280ULL,
0x0802000000000280ULL, 0x0802010010000280ULL, 0x0000010010000000ULL, 0x0802010000000000ULL,
0x0000010010000280ULL, 0x0802010010000000ULL, 0x0000000000000000ULL, 0x0802010000000280ULL,
0x0000000000000280ULL, 0x0000000010000000ULL, 0x0802010000000000ULL, 0x0000010010000280ULL,
0x0000000010000000ULL, 0x0000010000000280ULL, 0x0802000010000280ULL, 0x0000000000000000ULL,
0x0802010010000000ULL, 0x0802000000000000ULL, 0x0000010000000280ULL, 0x0802000010000280ULL
},
{
0x000000a000000000ULL, 0x800040a000000010ULL, 0x8000400000040010ULL, 0x0000000000000000ULL,
0x0000000000040000ULL, 0x8000400000040010ULL, 0x800000a000040010ULL, 0x000040a000040000ULL,
0x800040a000040010ULL, 0x000000a000000000ULL, 0x0000000000000000ULL, 0x8000400000000010ULL,
0x8000000000000010ULL, 0x0000400000000000ULL, 0x800040a000000010ULL, 0x8000000000040010ULL,
0x0000400000040000ULL, 0x800000a000040010ULL, 0x800000a000000010ULL, 0x0000400000040000ULL,
0x8000400000000010ULL, 0x000040a000000000ULL, 0x000040a000040000ULL, 0x800000a000000010ULL,
0x000040a000000000ULL, 0x0000000000040000ULL, 0x8000000000040010ULL, 0x800040a000040010ULL,
0x000000a000040000ULL, 0x8000000000000010ULL, 0x0000400000000000ULL, 0x000000a000040000ULL,
0x0000400000000000ULL, 0x000000a000040000ULL, 0x000000a000000000ULL, 0x8000400000040010ULL,
0x8000400000040010ULL, 0x800040a000000010ULL, 0x800040a000000010ULL, 0x8000000000000010ULL,
0x800000a000000010ULL, 0x0000400000000000ULL, 0x0000400000040000ULL, 0x000000a000000000ULL,
0x000040a000040000ULL, 0x8000000000040010ULL, 0x800000a000040010ULL, 0x000040a000040000ULL,
0x8000000000040010ULL, 0x8000400000000010ULL, 0x800040a000040010ULL, 0x000040a000000000ULL,
0x000000a000040000ULL, 0x0000000000000000ULL, 0x8000000000000010ULL, 0x800040a000040010ULL,
0x0000000000000000ULL, 0x800000a000040010ULL, 0x000040a000000000ULL, 0x0000000000040000ULL,
0x8000400000000010ULL, 0x0000400000040000ULL, 0x0000000000040000ULL, 0x800000a000000010ULL
},
{
0x0401000004080800ULL, 0x0000000004080000ULL, 0x0000000400000000ULL, 0x0401000404080800ULL,
0x0401000000000000ULL, 0x0401000004080800ULL, 0x0000000000000800ULL, 0x0401000000000000ULL,
0x0000000400000800ULL, 0x0401000400000000ULL, 0x0401000404080800ULL, 0x0000000404080000ULL,
0x0401000404080000ULL, 0x0000000404080800ULL, 0x0000000004080000ULL, 0x0000000000000800ULL,
0x0401000400000000ULL, 0x0401000000000800ULL, 0x0401000004080000ULL, 0x0000000004080800ULL,
0x0000000404080000ULL, 0x0000000400000800ULL, 0x0401000400000800ULL, 0x0401000404080000ULL,
0x0000000004080800ULL, 0x0000000000000000ULL, 0x0000000000000000ULL, 0x0401000400000800ULL,
0x0401000000000800ULL, 0x0401000004080000ULL, 0x0000000404080800ULL, 0x0000000400000000ULL,
0x0000000404080800ULL, 0x0000000400000000ULL, 0x0401000404080000ULL, 0x0000000004080000ULL,
0x0000000000000800ULL, 0x0401000400000800ULL, 0x0000000004080000ULL, 0x0000000404080800ULL,
0x0401000004080000ULL, 0x0000000000000800ULL, 0x0401000000000800ULL, 0x0401000400000000ULL,
0x0401000400000800ULL, 0x0401000000000000ULL, 0x0000000400000000ULL, 0x0401000004080800ULL,
0x0000000000000000ULL, 0x0401000404080800ULL, 0x0000000400000800ULL, 0x0401000000000800ULL,
0x0401000400000000ULL, 0x0401000004080000ULL, 0x0401000004080800ULL, 0x0000000000000000ULL,
0x0401000404080800ULL, 0x0000000404080000ULL, 0x0000000404080000ULL, 0x0000000004080800ULL,
0x0000000004080800ULL, 0x0000000400000800ULL, 0x0401000000000000ULL, 0x0401000404080000ULL
}
/* END CSTYLED */
};
static const uint64_t ip_table[2][256]=
{
/* BEGIN CSTYLED */
{
0x0000000000000000ULL, 0x0000000000000400ULL, 0x0080000000000280ULL, 0x0080000000000680ULL,
0x0000000000400000ULL, 0x0000000000400400ULL, 0x0080000000400280ULL, 0x0080000000400680ULL,
0x0000000000280000ULL, 0x0000000000280400ULL, 0x0080000000280280ULL, 0x0080000000280680ULL,
0x0000000000680000ULL, 0x0000000000680400ULL, 0x0080000000680280ULL, 0x0080000000680680ULL,
0x0000000400000000ULL, 0x0000000400000400ULL, 0x0080000400000280ULL, 0x0080000400000680ULL,
0x0000000400400000ULL, 0x0000000400400400ULL, 0x0080000400400280ULL, 0x0080000400400680ULL,
0x0000000400280000ULL, 0x0000000400280400ULL, 0x0080000400280280ULL, 0x0080000400280680ULL,
0x0000000400680000ULL, 0x0000000400680400ULL, 0x0080000400680280ULL, 0x0080000400680680ULL,
0x0000000280000000ULL, 0x0000000280000400ULL, 0x0080000280000280ULL, 0x0080000280000680ULL,
0x0000000280400000ULL, 0x0000000280400400ULL, 0x0080000280400280ULL, 0x0080000280400680ULL,
0x0000000280280000ULL, 0x0000000280280400ULL, 0x0080000280280280ULL, 0x0080000280280680ULL,
0x0000000280680000ULL, 0x0000000280680400ULL, 0x0080000280680280ULL, 0x0080000280680680ULL,
0x0000000680000000ULL, 0x0000000680000400ULL, 0x0080000680000280ULL, 0x0080000680000680ULL,
0x0000000680400000ULL, 0x0000000680400400ULL, 0x0080000680400280ULL, 0x0080000680400680ULL,
0x0000000680280000ULL, 0x0000000680280400ULL, 0x0080000680280280ULL, 0x0080000680280680ULL,
0x0000000680680000ULL, 0x0000000680680400ULL, 0x0080000680680280ULL, 0x0080000680680680ULL,
0x0000400000000000ULL, 0x0000400000000400ULL, 0x0080400000000280ULL, 0x0080400000000680ULL,
0x0000400000400000ULL, 0x0000400000400400ULL, 0x0080400000400280ULL, 0x0080400000400680ULL,
0x0000400000280000ULL, 0x0000400000280400ULL, 0x0080400000280280ULL, 0x0080400000280680ULL,
0x0000400000680000ULL, 0x0000400000680400ULL, 0x0080400000680280ULL, 0x0080400000680680ULL,
0x0000400400000000ULL, 0x0000400400000400ULL, 0x0080400400000280ULL, 0x0080400400000680ULL,
0x0000400400400000ULL, 0x0000400400400400ULL, 0x0080400400400280ULL, 0x0080400400400680ULL,
0x0000400400280000ULL, 0x0000400400280400ULL, 0x0080400400280280ULL, 0x0080400400280680ULL,
0x0000400400680000ULL, 0x0000400400680400ULL, 0x0080400400680280ULL, 0x0080400400680680ULL,
0x0000400280000000ULL, 0x0000400280000400ULL, 0x0080400280000280ULL, 0x0080400280000680ULL,
0x0000400280400000ULL, 0x0000400280400400ULL, 0x0080400280400280ULL, 0x0080400280400680ULL,
0x0000400280280000ULL, 0x0000400280280400ULL, 0x0080400280280280ULL, 0x0080400280280680ULL,
0x0000400280680000ULL, 0x0000400280680400ULL, 0x0080400280680280ULL, 0x0080400280680680ULL,
0x0000400680000000ULL, 0x0000400680000400ULL, 0x0080400680000280ULL, 0x0080400680000680ULL,
0x0000400680400000ULL, 0x0000400680400400ULL, 0x0080400680400280ULL, 0x0080400680400680ULL,
0x0000400680280000ULL, 0x0000400680280400ULL, 0x0080400680280280ULL, 0x0080400680280680ULL,
0x0000400680680000ULL, 0x0000400680680400ULL, 0x0080400680680280ULL, 0x0080400680680680ULL,
0x0000280000000000ULL, 0x0000280000000400ULL, 0x0080280000000280ULL, 0x0080280000000680ULL,
0x0000280000400000ULL, 0x0000280000400400ULL, 0x0080280000400280ULL, 0x0080280000400680ULL,
0x0000280000280000ULL, 0x0000280000280400ULL, 0x0080280000280280ULL, 0x0080280000280680ULL,
0x0000280000680000ULL, 0x0000280000680400ULL, 0x0080280000680280ULL, 0x0080280000680680ULL,
0x0000280400000000ULL, 0x0000280400000400ULL, 0x0080280400000280ULL, 0x0080280400000680ULL,
0x0000280400400000ULL, 0x0000280400400400ULL, 0x0080280400400280ULL, 0x0080280400400680ULL,
0x0000280400280000ULL, 0x0000280400280400ULL, 0x0080280400280280ULL, 0x0080280400280680ULL,
0x0000280400680000ULL, 0x0000280400680400ULL, 0x0080280400680280ULL, 0x0080280400680680ULL,
0x0000280280000000ULL, 0x0000280280000400ULL, 0x0080280280000280ULL, 0x0080280280000680ULL,
0x0000280280400000ULL, 0x0000280280400400ULL, 0x0080280280400280ULL, 0x0080280280400680ULL,
0x0000280280280000ULL, 0x0000280280280400ULL, 0x0080280280280280ULL, 0x0080280280280680ULL,
0x0000280280680000ULL, 0x0000280280680400ULL, 0x0080280280680280ULL, 0x0080280280680680ULL,
0x0000280680000000ULL, 0x0000280680000400ULL, 0x0080280680000280ULL, 0x0080280680000680ULL,
0x0000280680400000ULL, 0x0000280680400400ULL, 0x0080280680400280ULL, 0x0080280680400680ULL,
0x0000280680280000ULL, 0x0000280680280400ULL, 0x0080280680280280ULL, 0x0080280680280680ULL,
0x0000280680680000ULL, 0x0000280680680400ULL, 0x0080280680680280ULL, 0x0080280680680680ULL,
0x0000680000000000ULL, 0x0000680000000400ULL, 0x0080680000000280ULL, 0x0080680000000680ULL,
0x0000680000400000ULL, 0x0000680000400400ULL, 0x0080680000400280ULL, 0x0080680000400680ULL,
0x0000680000280000ULL, 0x0000680000280400ULL, 0x0080680000280280ULL, 0x0080680000280680ULL,
0x0000680000680000ULL, 0x0000680000680400ULL, 0x0080680000680280ULL, 0x0080680000680680ULL,
0x0000680400000000ULL, 0x0000680400000400ULL, 0x0080680400000280ULL, 0x0080680400000680ULL,
0x0000680400400000ULL, 0x0000680400400400ULL, 0x0080680400400280ULL, 0x0080680400400680ULL,
0x0000680400280000ULL, 0x0000680400280400ULL, 0x0080680400280280ULL, 0x0080680400280680ULL,
0x0000680400680000ULL, 0x0000680400680400ULL, 0x0080680400680280ULL, 0x0080680400680680ULL,
0x0000680280000000ULL, 0x0000680280000400ULL, 0x0080680280000280ULL, 0x0080680280000680ULL,
0x0000680280400000ULL, 0x0000680280400400ULL, 0x0080680280400280ULL, 0x0080680280400680ULL,
0x0000680280280000ULL, 0x0000680280280400ULL, 0x0080680280280280ULL, 0x0080680280280680ULL,
0x0000680280680000ULL, 0x0000680280680400ULL, 0x0080680280680280ULL, 0x0080680280680680ULL,
0x0000680680000000ULL, 0x0000680680000400ULL, 0x0080680680000280ULL, 0x0080680680000680ULL,
0x0000680680400000ULL, 0x0000680680400400ULL, 0x0080680680400280ULL, 0x0080680680400680ULL,
0x0000680680280000ULL, 0x0000680680280400ULL, 0x0080680680280280ULL, 0x0080680680280680ULL,
0x0000680680680000ULL, 0x0000680680680400ULL, 0x0080680680680280ULL, 0x0080680680680680ULL
},
{
0x0000000000000000ULL, 0x0000000000005000ULL, 0x0000000000000800ULL, 0x0000000000005800ULL,
0x0000000005000000ULL, 0x0000000005005000ULL, 0x0000000005000800ULL, 0x0000000005005800ULL,
0x0000000000800000ULL, 0x0000000000805000ULL, 0x0000000000800800ULL, 0x0000000000805800ULL,
0x0000000005800000ULL, 0x0000000005805000ULL, 0x0000000005800800ULL, 0x0000000005805800ULL,
0x0000005000000000ULL, 0x0000005000005000ULL, 0x0000005000000800ULL, 0x0000005000005800ULL,
0x0000005005000000ULL, 0x0000005005005000ULL, 0x0000005005000800ULL, 0x0000005005005800ULL,
0x0000005000800000ULL, 0x0000005000805000ULL, 0x0000005000800800ULL, 0x0000005000805800ULL,
0x0000005005800000ULL, 0x0000005005805000ULL, 0x0000005005800800ULL, 0x0000005005805800ULL,
0x0000000800000000ULL, 0x0000000800005000ULL, 0x0000000800000800ULL, 0x0000000800005800ULL,
0x0000000805000000ULL, 0x0000000805005000ULL, 0x0000000805000800ULL, 0x0000000805005800ULL,
0x0000000800800000ULL, 0x0000000800805000ULL, 0x0000000800800800ULL, 0x0000000800805800ULL,
0x0000000805800000ULL, 0x0000000805805000ULL, 0x0000000805800800ULL, 0x0000000805805800ULL,
0x0000005800000000ULL, 0x0000005800005000ULL, 0x0000005800000800ULL, 0x0000005800005800ULL,
0x0000005805000000ULL, 0x0000005805005000ULL, 0x0000005805000800ULL, 0x0000005805005800ULL,
0x0000005800800000ULL, 0x0000005800805000ULL, 0x0000005800800800ULL, 0x0000005800805800ULL,
0x0000005805800000ULL, 0x0000005805805000ULL, 0x0000005805800800ULL, 0x0000005805805800ULL,
0x0005000000000004ULL, 0x0005000000005004ULL, 0x0005000000000804ULL, 0x0005000000005804ULL,
0x0005000005000004ULL, 0x0005000005005004ULL, 0x0005000005000804ULL, 0x0005000005005804ULL,
0x0005000000800004ULL, 0x0005000000805004ULL, 0x0005000000800804ULL, 0x0005000000805804ULL,
0x0005000005800004ULL, 0x0005000005805004ULL, 0x0005000005800804ULL, 0x0005000005805804ULL,
0x0005005000000004ULL, 0x0005005000005004ULL, 0x0005005000000804ULL, 0x0005005000005804ULL,
0x0005005005000004ULL, 0x0005005005005004ULL, 0x0005005005000804ULL, 0x0005005005005804ULL,
0x0005005000800004ULL, 0x0005005000805004ULL, 0x0005005000800804ULL, 0x0005005000805804ULL,
0x0005005005800004ULL, 0x0005005005805004ULL, 0x0005005005800804ULL, 0x0005005005805804ULL,
0x0005000800000004ULL, 0x0005000800005004ULL, 0x0005000800000804ULL, 0x0005000800005804ULL,
0x0005000805000004ULL, 0x0005000805005004ULL, 0x0005000805000804ULL, 0x0005000805005804ULL,
0x0005000800800004ULL, 0x0005000800805004ULL, 0x0005000800800804ULL, 0x0005000800805804ULL,
0x0005000805800004ULL, 0x0005000805805004ULL, 0x0005000805800804ULL, 0x0005000805805804ULL,
0x0005005800000004ULL, 0x0005005800005004ULL, 0x0005005800000804ULL, 0x0005005800005804ULL,
0x0005005805000004ULL, 0x0005005805005004ULL, 0x0005005805000804ULL, 0x0005005805005804ULL,
0x0005005800800004ULL, 0x0005005800805004ULL, 0x0005005800800804ULL, 0x0005005800805804ULL,
0x0005005805800004ULL, 0x0005005805805004ULL, 0x0005005805800804ULL, 0x0005005805805804ULL,
0x0000800000000000ULL, 0x0000800000005000ULL, 0x0000800000000800ULL, 0x0000800000005800ULL,
0x0000800005000000ULL, 0x0000800005005000ULL, 0x0000800005000800ULL, 0x0000800005005800ULL,
0x0000800000800000ULL, 0x0000800000805000ULL, 0x0000800000800800ULL, 0x0000800000805800ULL,
0x0000800005800000ULL, 0x0000800005805000ULL, 0x0000800005800800ULL, 0x0000800005805800ULL,
0x0000805000000000ULL, 0x0000805000005000ULL, 0x0000805000000800ULL, 0x0000805000005800ULL,
0x0000805005000000ULL, 0x0000805005005000ULL, 0x0000805005000800ULL, 0x0000805005005800ULL,
0x0000805000800000ULL, 0x0000805000805000ULL, 0x0000805000800800ULL, 0x0000805000805800ULL,
0x0000805005800000ULL, 0x0000805005805000ULL, 0x0000805005800800ULL, 0x0000805005805800ULL,
0x0000800800000000ULL, 0x0000800800005000ULL, 0x0000800800000800ULL, 0x0000800800005800ULL,
0x0000800805000000ULL, 0x0000800805005000ULL, 0x0000800805000800ULL, 0x0000800805005800ULL,
0x0000800800800000ULL, 0x0000800800805000ULL, 0x0000800800800800ULL, 0x0000800800805800ULL,
0x0000800805800000ULL, 0x0000800805805000ULL, 0x0000800805800800ULL, 0x0000800805805800ULL,
0x0000805800000000ULL, 0x0000805800005000ULL, 0x0000805800000800ULL, 0x0000805800005800ULL,
0x0000805805000000ULL, 0x0000805805005000ULL, 0x0000805805000800ULL, 0x0000805805005800ULL,
0x0000805800800000ULL, 0x0000805800805000ULL, 0x0000805800800800ULL, 0x0000805800805800ULL,
0x0000805805800000ULL, 0x0000805805805000ULL, 0x0000805805800800ULL, 0x0000805805805800ULL,
0x0005800000000004ULL, 0x0005800000005004ULL, 0x0005800000000804ULL, 0x0005800000005804ULL,
0x0005800005000004ULL, 0x0005800005005004ULL, 0x0005800005000804ULL, 0x0005800005005804ULL,
0x0005800000800004ULL, 0x0005800000805004ULL, 0x0005800000800804ULL, 0x0005800000805804ULL,
0x0005800005800004ULL, 0x0005800005805004ULL, 0x0005800005800804ULL, 0x0005800005805804ULL,
0x0005805000000004ULL, 0x0005805000005004ULL, 0x0005805000000804ULL, 0x0005805000005804ULL,
0x0005805005000004ULL, 0x0005805005005004ULL, 0x0005805005000804ULL, 0x0005805005005804ULL,
0x0005805000800004ULL, 0x0005805000805004ULL, 0x0005805000800804ULL, 0x0005805000805804ULL,
0x0005805005800004ULL, 0x0005805005805004ULL, 0x0005805005800804ULL, 0x0005805005805804ULL,
0x0005800800000004ULL, 0x0005800800005004ULL, 0x0005800800000804ULL, 0x0005800800005804ULL,
0x0005800805000004ULL, 0x0005800805005004ULL, 0x0005800805000804ULL, 0x0005800805005804ULL,
0x0005800800800004ULL, 0x0005800800805004ULL, 0x0005800800800804ULL, 0x0005800800805804ULL,
0x0005800805800004ULL, 0x0005800805805004ULL, 0x0005800805800804ULL, 0x0005800805805804ULL,
0x0005805800000004ULL, 0x0005805800005004ULL, 0x0005805800000804ULL, 0x0005805800005804ULL,
0x0005805805000004ULL, 0x0005805805005004ULL, 0x0005805805000804ULL, 0x0005805805005804ULL,
0x0005805800800004ULL, 0x0005805800805004ULL, 0x0005805800800804ULL, 0x0005805800805804ULL,
0x0005805805800004ULL, 0x0005805805805004ULL, 0x0005805805800804ULL, 0x0005805805805804ULL
}
/* END CSTYLED */
};
static const uint32_t fp_table[256]=
{
0x00000000, 0x80000000, 0x00800000, 0x80800000,
0x00008000, 0x80008000, 0x00808000, 0x80808000,
0x00000080, 0x80000080, 0x00800080, 0x80800080,
0x00008080, 0x80008080, 0x00808080, 0x80808080,
0x40000000, 0xc0000000, 0x40800000, 0xc0800000,
0x40008000, 0xc0008000, 0x40808000, 0xc0808000,
0x40000080, 0xc0000080, 0x40800080, 0xc0800080,
0x40008080, 0xc0008080, 0x40808080, 0xc0808080,
0x00400000, 0x80400000, 0x00c00000, 0x80c00000,
0x00408000, 0x80408000, 0x00c08000, 0x80c08000,
0x00400080, 0x80400080, 0x00c00080, 0x80c00080,
0x00408080, 0x80408080, 0x00c08080, 0x80c08080,
0x40400000, 0xc0400000, 0x40c00000, 0xc0c00000,
0x40408000, 0xc0408000, 0x40c08000, 0xc0c08000,
0x40400080, 0xc0400080, 0x40c00080, 0xc0c00080,
0x40408080, 0xc0408080, 0x40c08080, 0xc0c08080,
0x00004000, 0x80004000, 0x00804000, 0x80804000,
0x0000c000, 0x8000c000, 0x0080c000, 0x8080c000,
0x00004080, 0x80004080, 0x00804080, 0x80804080,
0x0000c080, 0x8000c080, 0x0080c080, 0x8080c080,
0x40004000, 0xc0004000, 0x40804000, 0xc0804000,
0x4000c000, 0xc000c000, 0x4080c000, 0xc080c000,
0x40004080, 0xc0004080, 0x40804080, 0xc0804080,
0x4000c080, 0xc000c080, 0x4080c080, 0xc080c080,
0x00404000, 0x80404000, 0x00c04000, 0x80c04000,
0x0040c000, 0x8040c000, 0x00c0c000, 0x80c0c000,
0x00404080, 0x80404080, 0x00c04080, 0x80c04080,
0x0040c080, 0x8040c080, 0x00c0c080, 0x80c0c080,
0x40404000, 0xc0404000, 0x40c04000, 0xc0c04000,
0x4040c000, 0xc040c000, 0x40c0c000, 0xc0c0c000,
0x40404080, 0xc0404080, 0x40c04080, 0xc0c04080,
0x4040c080, 0xc040c080, 0x40c0c080, 0xc0c0c080,
0x00000040, 0x80000040, 0x00800040, 0x80800040,
0x00008040, 0x80008040, 0x00808040, 0x80808040,
0x000000c0, 0x800000c0, 0x008000c0, 0x808000c0,
0x000080c0, 0x800080c0, 0x008080c0, 0x808080c0,
0x40000040, 0xc0000040, 0x40800040, 0xc0800040,
0x40008040, 0xc0008040, 0x40808040, 0xc0808040,
0x400000c0, 0xc00000c0, 0x408000c0, 0xc08000c0,
0x400080c0, 0xc00080c0, 0x408080c0, 0xc08080c0,
0x00400040, 0x80400040, 0x00c00040, 0x80c00040,
0x00408040, 0x80408040, 0x00c08040, 0x80c08040,
0x004000c0, 0x804000c0, 0x00c000c0, 0x80c000c0,
0x004080c0, 0x804080c0, 0x00c080c0, 0x80c080c0,
0x40400040, 0xc0400040, 0x40c00040, 0xc0c00040,
0x40408040, 0xc0408040, 0x40c08040, 0xc0c08040,
0x404000c0, 0xc04000c0, 0x40c000c0, 0xc0c000c0,
0x404080c0, 0xc04080c0, 0x40c080c0, 0xc0c080c0,
0x00004040, 0x80004040, 0x00804040, 0x80804040,
0x0000c040, 0x8000c040, 0x0080c040, 0x8080c040,
0x000040c0, 0x800040c0, 0x008040c0, 0x808040c0,
0x0000c0c0, 0x8000c0c0, 0x0080c0c0, 0x8080c0c0,
0x40004040, 0xc0004040, 0x40804040, 0xc0804040,
0x4000c040, 0xc000c040, 0x4080c040, 0xc080c040,
0x400040c0, 0xc00040c0, 0x408040c0, 0xc08040c0,
0x4000c0c0, 0xc000c0c0, 0x4080c0c0, 0xc080c0c0,
0x00404040, 0x80404040, 0x00c04040, 0x80c04040,
0x0040c040, 0x8040c040, 0x00c0c040, 0x80c0c040,
0x004040c0, 0x804040c0, 0x00c040c0, 0x80c040c0,
0x0040c0c0, 0x8040c0c0, 0x00c0c0c0, 0x80c0c0c0,
0x40404040, 0xc0404040, 0x40c04040, 0xc0c04040,
0x4040c040, 0xc040c040, 0x40c0c040, 0xc0c0c040,
0x404040c0, 0xc04040c0, 0x40c040c0, 0xc0c040c0,
0x4040c0c0, 0xc040c0c0, 0x40c0c0c0, 0xc0c0c0c0
};
static const uint64_t all_a = 0xaaaaaaaaaaaaaaaaULL;
static const uint64_t all_5 = 0x5555555555555555ULL;
static const uint64_t top_1 = 0xfc000000000000ULL;
static const uint64_t mid_4 = 0x3fffffc000000ULL;
static const uint64_t low_3 = 0x3ffff00ULL;
static void
des_ip(uint64_t *l, uint64_t *r, uint64_t pt)
{
uint64_t a, b;
a = pt & all_a;
b = pt & all_5;
a = a | (a << 7);
b = b | (b >> 7);
b = (ip_table[0][(b >> 48) & 255ULL]) |
(ip_table[1][(b >> 32) & 255ULL]) |
(ip_table[0][(b >> 16) & 255ULL] << 6) |
(ip_table[1][b & 255ULL] << 6);
a = (ip_table[0][(a >> 56) & 255]) |
(ip_table[1][(a >> 40) & 255]) |
(ip_table[0][(a >> 24) & 255] << 6) |
(ip_table[1][(a >> 8) & 255] << 6);
*l = ((b & top_1) << 8) |
(b & mid_4) |
((b & low_3) >> 5);
*r = ((a & top_1) << 8) |
(a & mid_4) |
((a & low_3) >> 5);
}
static uint64_t
des_fp(uint64_t l, uint64_t r)
{
uint32_t upper, lower;
lower = fp_table[((l >> 55) & 240) | ((r >> 59) & 15)] |
(fp_table[((l >> 35) & 240) | ((r>>39) & 15)] >> 2) |
(fp_table[((l >> 23) & 240) | ((r >> 27) & 15)] >> 4) |
(fp_table[((l >> 6) & 240) | ((r >> 10) & 15)] >> 6);
upper = fp_table[((l >> 41) & 240) | ((r >> 45) & 15)] |
(fp_table[((l >> 29) & 240) | ((r >> 33) & 15)] >> 2) |
(fp_table[((l >> 12) & 240) | ((r >> 16) & 15)] >> 4) |
(fp_table[(l & 240) | (r >> 4) & 15] >> 6);
return ((((uint64_t)upper) << 32) | (uint64_t)lower);
}
uint64_t
des_crypt_impl(uint64_t *ks, uint64_t block, int one_or_three)
{
int i, j;
uint64_t l, r, t;
des_ip(&l, &r, block);
for (j = 0; j < one_or_three; j++) {
for (i = j * 16; i < (j + 1) * 16; i++) {
t = r ^ ks[i];
t = sbox_table[0][t >> 58] |
sbox_table[1][(t >> 44) & 63] |
sbox_table[2][(t >> 38) & 63] |
sbox_table[3][(t >> 32) & 63] |
sbox_table[4][(t >> 26) & 63] |
sbox_table[5][(t >> 15) & 63] |
sbox_table[6][(t >> 9) & 63] |
sbox_table[7][(t >> 3) & 63];
t = t^l;
l = r;
r = t;
}
r = l;
l = t;
}
return (des_fp(l, r));
}
#endif /* !sun4u */
/* EXPORT DELETE END */
int
des3_crunch_block(const void *cookie, const uint8_t block[DES_BLOCK_LEN],
uint8_t out_block[DES_BLOCK_LEN], boolean_t decrypt)
{
/* EXPORT DELETE START */
keysched3_t *ksch = (keysched3_t *)cookie;
/*
* The code below, that is always executed on LITTLE_ENDIAN machines,
* reverses bytes in the block. On BIG_ENDIAN, the same code
* copies the block without reversing bytes.
*/
#ifdef _BIG_ENDIAN
if (IS_P2ALIGNED(block, sizeof (uint64_t)) &&
IS_P2ALIGNED(out_block, sizeof (uint64_t))) {
if (decrypt == B_TRUE)
/* LINTED */
*(uint64_t *)out_block = des_crypt_impl(
ksch->ksch_decrypt, /* LINTED */
*(uint64_t *)block, 3);
else
/* LINTED */
*(uint64_t *)out_block = des_crypt_impl(
ksch->ksch_encrypt, /* LINTED */
*(uint64_t *)block, 3);
} else
#endif /* _BIG_ENDIAN */
{
uint64_t tmp;
#ifdef UNALIGNED_POINTERS_PERMITTED
tmp = htonll(*(uint64_t *)(void *)&block[0]);
#else
tmp = (((uint64_t)block[0] << 56) | ((uint64_t)block[1] << 48) |
((uint64_t)block[2] << 40) | ((uint64_t)block[3] << 32) |
((uint64_t)block[4] << 24) | ((uint64_t)block[5] << 16) |
((uint64_t)block[6] << 8) | (uint64_t)block[7]);
#endif /* UNALIGNED_POINTERS_PERMITTED */
if (decrypt == B_TRUE)
tmp = des_crypt_impl(ksch->ksch_decrypt, tmp, 3);
else
tmp = des_crypt_impl(ksch->ksch_encrypt, tmp, 3);
#ifdef UNALIGNED_POINTERS_PERMITTED
*(uint64_t *)(void *)&out_block[0] = htonll(tmp);
#else
out_block[0] = tmp >> 56;
out_block[1] = tmp >> 48;
out_block[2] = tmp >> 40;
out_block[3] = tmp >> 32;
out_block[4] = tmp >> 24;
out_block[5] = tmp >> 16;
out_block[6] = tmp >> 8;
out_block[7] = (uint8_t)tmp;
#endif /* UNALIGNED_POINTERS_PERMITTED */
}
/* EXPORT DELETE END */
return (CRYPTO_SUCCESS);
}
int
des_crunch_block(const void *cookie, const uint8_t block[DES_BLOCK_LEN],
uint8_t out_block[DES_BLOCK_LEN], boolean_t decrypt)
{
/* EXPORT DELETE START */
keysched_t *ksch = (keysched_t *)cookie;
/*
* The code below, that is always executed on LITTLE_ENDIAN machines,
* reverses bytes in the block. On BIG_ENDIAN, the same code
* copies the block without reversing bytes.
*/
#ifdef _BIG_ENDIAN
if (IS_P2ALIGNED(block, sizeof (uint64_t)) &&
IS_P2ALIGNED(out_block, sizeof (uint64_t))) {
if (decrypt == B_TRUE)
/* LINTED */
*(uint64_t *)out_block = des_crypt_impl(
ksch->ksch_decrypt, /* LINTED */
*(uint64_t *)block, 1);
else
/* LINTED */
*(uint64_t *)out_block = des_crypt_impl(
ksch->ksch_encrypt, /* LINTED */
*(uint64_t *)block, 1);
} else
#endif /* _BIG_ENDIAN */
{
uint64_t tmp;
#ifdef UNALIGNED_POINTERS_PERMITTED
tmp = htonll(*(uint64_t *)(void *)&block[0]);
#else
tmp = (((uint64_t)block[0] << 56) | ((uint64_t)block[1] << 48) |
((uint64_t)block[2] << 40) | ((uint64_t)block[3] << 32) |
((uint64_t)block[4] << 24) | ((uint64_t)block[5] << 16) |
((uint64_t)block[6] << 8) | (uint64_t)block[7]);
#endif /* UNALIGNED_POINTERS_PERMITTED */
if (decrypt == B_TRUE)
tmp = des_crypt_impl(ksch->ksch_decrypt, tmp, 1);
else
tmp = des_crypt_impl(ksch->ksch_encrypt, tmp, 1);
#ifdef UNALIGNED_POINTERS_PERMITTED
*(uint64_t *)(void *)&out_block[0] = htonll(tmp);
#else
out_block[0] = tmp >> 56;
out_block[1] = tmp >> 48;
out_block[2] = tmp >> 40;
out_block[3] = tmp >> 32;
out_block[4] = tmp >> 24;
out_block[5] = tmp >> 16;
out_block[6] = tmp >> 8;
out_block[7] = (uint8_t)tmp;
#endif /* UNALIGNED_POINTERS_PERMITTED */
}
/* EXPORT DELETE END */
return (CRYPTO_SUCCESS);
}
static boolean_t
keycheck(uint8_t *key, uint8_t *corrected_key)
{
/* EXPORT DELETE START */
uint64_t key_so_far;
uint_t i;
/*
* Table of weak and semi-weak keys. Fortunately, weak keys are
* endian-independent, and some semi-weak keys can be paired up in
* endian-opposite order. Since keys are stored as uint64_t's,
* use the ifdef _LITTLE_ENDIAN where appropriate.
*/
static uint64_t des_weak_keys[] = {
/* Really weak keys. Byte-order independent values. */
0x0101010101010101ULL,
0x1f1f1f1f0e0e0e0eULL,
0xe0e0e0e0f1f1f1f1ULL,
0xfefefefefefefefeULL,
/* Semi-weak (and a few possibly-weak) keys. */
/* Byte-order independent semi-weak keys. */
0x01fe01fe01fe01feULL, 0xfe01fe01fe01fe01ULL,
/* Byte-order dependent semi-weak keys. */
#ifdef _LITTLE_ENDIAN
0xf10ef10ee01fe01fULL, 0x0ef10ef11fe01fe0ULL,
0x01f101f101e001e0ULL, 0xf101f101e001e001ULL,
0x0efe0efe1ffe1ffeULL, 0xfe0efe0efe1ffe1fULL,
0x010e010e011f011fULL, 0x0e010e011f011f01ULL,
0xf1fef1fee0fee0feULL, 0xfef1fef1fee0fee0ULL,
#else /* Big endian */
0x1fe01fe00ef10ef1ULL, 0xe01fe01ff10ef10eULL,
0x01e001e001f101f1ULL, 0xe001e001f101f101ULL,
0x1ffe1ffe0efe0efeULL, 0xfe1ffe1ffe0efe0eULL,
0x011f011f010e010eULL, 0x1f011f010e010e01ULL,
0xe0fee0fef1fef1feULL, 0xfee0fee0fef1fef1ULL,
#endif /* _LITTLE_ENDIAN */
/* We'll save the other possibly-weak keys for the future. */
};
if (key == NULL)
return (B_FALSE);
#ifdef UNALIGNED_POINTERS_PERMITTED
key_so_far = htonll(*(uint64_t *)(void *)&key[0]);
#else
/*
* The code below reverses the bytes on LITTLE_ENDIAN machines.
* On BIG_ENDIAN, the same code copies without reversing
* the bytes.
*/
key_so_far = (((uint64_t)key[0] << 56) | ((uint64_t)key[1] << 48) |
((uint64_t)key[2] << 40) | ((uint64_t)key[3] << 32) |
((uint64_t)key[4] << 24) | ((uint64_t)key[5] << 16) |
((uint64_t)key[6] << 8) | (uint64_t)key[7]);
#endif /* UNALIGNED_POINTERS_PERMITTED */
/*
* Fix parity.
*/
fix_des_parity(&key_so_far);
/* Do weak key check itself. */
for (i = 0; i < (sizeof (des_weak_keys) / sizeof (uint64_t)); i++)
if (key_so_far == des_weak_keys[i]) {
return (B_FALSE);
}
if (corrected_key != NULL) {
#ifdef UNALIGNED_POINTERS_PERMITTED
*(uint64_t *)(void *)&corrected_key[0] = htonll(key_so_far);
#else
/*
* The code below reverses the bytes on LITTLE_ENDIAN machines.
* On BIG_ENDIAN, the same code copies without reversing
* the bytes.
*/
corrected_key[0] = key_so_far >> 56;
corrected_key[1] = key_so_far >> 48;
corrected_key[2] = key_so_far >> 40;
corrected_key[3] = key_so_far >> 32;
corrected_key[4] = key_so_far >> 24;
corrected_key[5] = key_so_far >> 16;
corrected_key[6] = key_so_far >> 8;
corrected_key[7] = (uint8_t)key_so_far;
#endif /* UNALIGNED_POINTERS_PERMITTED */
}
/* EXPORT DELETE END */
return (B_TRUE);
}
static boolean_t
des23_keycheck(uint8_t *key, uint8_t *corrected_key, boolean_t des3)
{
/* EXPORT DELETE START */
uint64_t aligned_key[DES3_KEYSIZE / sizeof (uint64_t)];
uint64_t key_so_far, scratch, *currentkey;
uint_t j, num_weakkeys = 0;
uint8_t keysize = DES3_KEYSIZE;
uint8_t checks = 3;
if (key == NULL) {
return (B_FALSE);
}
if (des3 == B_FALSE) {
keysize = DES2_KEYSIZE;
checks = 2;
}
if (!IS_P2ALIGNED(key, sizeof (uint64_t))) {
bcopy(key, aligned_key, keysize);
currentkey = (uint64_t *)aligned_key;
} else {
/* LINTED */
currentkey = (uint64_t *)key;
}
for (j = 0; j < checks; j++) {
key_so_far = currentkey[j];
if (!keycheck((uint8_t *)&key_so_far, (uint8_t *)&scratch)) {
if (++num_weakkeys > 1) {
return (B_FALSE);
}
/*
* We found a weak key, but since
* we've only found one weak key,
* we can not reject the whole 3DES
* set of keys as weak.
*
* Break from the weak key loop
* (since this DES key is weak) and
* continue on.
*/
}
currentkey[j] = scratch;
}
/*
* Perform key equivalence checks, now that parity is properly set.
* 1st and 2nd keys must be unique, the 3rd key can be the same as
* the 1st key for the 2 key variant of 3DES.
*/
if (currentkey[0] == currentkey[1] || currentkey[1] == currentkey[2])
return (B_FALSE);
if (corrected_key != NULL) {
bcopy(currentkey, corrected_key, keysize);
}
/* EXPORT DELETE END */
return (B_TRUE);
}
boolean_t
des_keycheck(uint8_t *key, des_strength_t strength, uint8_t *corrected_key)
{
if (strength == DES) {
return (keycheck(key, corrected_key));
} else if (strength == DES2) {
return (des23_keycheck(key, corrected_key, B_FALSE));
} else if (strength == DES3) {
return (des23_keycheck(key, corrected_key, B_TRUE));
} else {
return (B_FALSE);
}
}
void
des_parity_fix(uint8_t *key, des_strength_t strength, uint8_t *corrected_key)
{
/* EXPORT DELETE START */
uint64_t aligned_key[DES3_KEYSIZE / sizeof (uint64_t)];
uint8_t *paritied_key;
uint64_t key_so_far;
int i = 0, offset = 0;
if (strength == DES)
bcopy(key, aligned_key, DES_KEYSIZE);
else
bcopy(key, aligned_key, DES3_KEYSIZE);
paritied_key = (uint8_t *)aligned_key;
while (strength > i) {
offset = 8 * i;
#ifdef UNALIGNED_POINTERS_PERMITTED
key_so_far = htonll(*(uint64_t *)(void *)&paritied_key[offset]);
#else
key_so_far = (((uint64_t)paritied_key[offset + 0] << 56) |
((uint64_t)paritied_key[offset + 1] << 48) |
((uint64_t)paritied_key[offset + 2] << 40) |
((uint64_t)paritied_key[offset + 3] << 32) |
((uint64_t)paritied_key[offset + 4] << 24) |
((uint64_t)paritied_key[offset + 5] << 16) |
((uint64_t)paritied_key[offset + 6] << 8) |
(uint64_t)paritied_key[offset + 7]);
#endif /* UNALIGNED_POINTERS_PERMITTED */
fix_des_parity(&key_so_far);
#ifdef UNALIGNED_POINTERS_PERMITTED
*(uint64_t *)(void *)&paritied_key[offset] = htonll(key_so_far);
#else
paritied_key[offset + 0] = key_so_far >> 56;
paritied_key[offset + 1] = key_so_far >> 48;
paritied_key[offset + 2] = key_so_far >> 40;
paritied_key[offset + 3] = key_so_far >> 32;
paritied_key[offset + 4] = key_so_far >> 24;
paritied_key[offset + 5] = key_so_far >> 16;
paritied_key[offset + 6] = key_so_far >> 8;
paritied_key[offset + 7] = (uint8_t)key_so_far;
#endif /* UNALIGNED_POINTERS_PERMITTED */
i++;
}
bcopy(paritied_key, corrected_key, DES_KEYSIZE * strength);
/* EXPORT DELETE END */
}
/*
* Initialize key schedule for DES, DES2, and DES3
*/
void
des_init_keysched(uint8_t *cipherKey, des_strength_t strength, void *ks)
{
/* EXPORT DELETE START */
uint64_t *encryption_ks;
uint64_t *decryption_ks;
uint64_t keysched[48];
uint64_t key_uint64[3];
uint64_t tmp;
uint_t keysize, i, j;
switch (strength) {
case DES:
keysize = DES_KEYSIZE;
encryption_ks = ((keysched_t *)ks)->ksch_encrypt;
decryption_ks = ((keysched_t *)ks)->ksch_decrypt;
break;
case DES2:
keysize = DES2_KEYSIZE;
encryption_ks = ((keysched3_t *)ks)->ksch_encrypt;
decryption_ks = ((keysched3_t *)ks)->ksch_decrypt;
break;
case DES3:
keysize = DES3_KEYSIZE;
encryption_ks = ((keysched3_t *)ks)->ksch_encrypt;
decryption_ks = ((keysched3_t *)ks)->ksch_decrypt;
}
/*
* The code below, that is always executed on LITTLE_ENDIAN machines,
* reverses every 8 bytes in the key. On BIG_ENDIAN, the same code
* copies the key without reversing bytes.
*/
#ifdef _BIG_ENDIAN
if (IS_P2ALIGNED(cipherKey, sizeof (uint64_t))) {
for (i = 0, j = 0; j < keysize; i++, j += 8) {
/* LINTED: pointer alignment */
key_uint64[i] = *((uint64_t *)&cipherKey[j]);
}
} else
#endif /* _BIG_ENDIAN */
{
for (i = 0, j = 0; j < keysize; i++, j += 8) {
#ifdef UNALIGNED_POINTERS_PERMITTED
key_uint64[i] =
htonll(*(uint64_t *)(void *)&cipherKey[j]);
#else
key_uint64[i] = (((uint64_t)cipherKey[j] << 56) |
((uint64_t)cipherKey[j + 1] << 48) |
((uint64_t)cipherKey[j + 2] << 40) |
((uint64_t)cipherKey[j + 3] << 32) |
((uint64_t)cipherKey[j + 4] << 24) |
((uint64_t)cipherKey[j + 5] << 16) |
((uint64_t)cipherKey[j + 6] << 8) |
(uint64_t)cipherKey[j + 7]);
#endif /* UNALIGNED_POINTERS_PERMITTED */
}
}
switch (strength) {
case DES:
des_ks(keysched, key_uint64[0]);
break;
case DES2:
/* DES2 is just DES3 with the first and third keys the same */
bcopy(key_uint64, key_uint64 + 2, DES_KEYSIZE);
/* FALLTHRU */
case DES3:
des_ks(keysched, key_uint64[0]);
des_ks(keysched + 16, key_uint64[1]);
for (i = 0; i < 8; i++) {
tmp = keysched[16+i];
keysched[16+i] = keysched[31-i];
keysched[31-i] = tmp;
}
des_ks(keysched+32, key_uint64[2]);
keysize = DES3_KEYSIZE;
}
/* save the encryption keyschedule */
bcopy(keysched, encryption_ks, keysize * 16);
/* reverse the key schedule */
for (i = 0; i < keysize; i++) {
tmp = keysched[i];
keysched[i] = keysched[2 * keysize - 1 - i];
keysched[2 * keysize -1 -i] = tmp;
}
/* save the decryption keyschedule */
bcopy(keysched, decryption_ks, keysize * 16);
/* EXPORT DELETE END */
}
/*
* Allocate key schedule.
*/
/*ARGSUSED*/
void *
des_alloc_keysched(size_t *keysched_size, des_strength_t strength, int kmflag)
{
void *keysched;
/* EXPORT DELETE START */
size_t size;
switch (strength) {
case DES:
size = sizeof (keysched_t);
break;
case DES2:
case DES3:
size = sizeof (keysched3_t);
}
#ifdef _KERNEL
keysched = (keysched_t *)kmem_alloc(size, kmflag);
#else /* !_KERNEL */
keysched = (keysched_t *)malloc(size);
#endif /* _KERNEL */
if (keysched == NULL)
return (NULL);
if (keysched_size != NULL)
*keysched_size = size;
/* EXPORT DELETE END */
return (keysched);
}
/*
* Replace the LSB of each byte by the xor of the other
* 7 bits. The tricky thing is that the original contents of the LSBs
* are nullified by including them twice in the xor computation.
*/
static void
fix_des_parity(uint64_t *keyp)
{
/* EXPORT DELETE START */
uint64_t k = *keyp;
k ^= k >> 1;
k ^= k >> 2;
k ^= k >> 4;
*keyp ^= (k & 0x0101010101010101ULL);
*keyp ^= 0x0101010101010101ULL;
/* EXPORT DELETE END */
}
void
des_copy_block(uint8_t *in, uint8_t *out)
{
if (IS_P2ALIGNED(in, sizeof (uint32_t)) &&
IS_P2ALIGNED(out, sizeof (uint32_t))) {
/* LINTED: pointer alignment */
*(uint32_t *)&out[0] = *(uint32_t *)&in[0];
/* LINTED: pointer alignment */
*(uint32_t *)&out[4] = *(uint32_t *)&in[4];
} else {
DES_COPY_BLOCK(in, out);
}
}
/* XOR block of data into dest */
void
des_xor_block(uint8_t *data, uint8_t *dst)
{
if (IS_P2ALIGNED(dst, sizeof (uint32_t)) &&
IS_P2ALIGNED(data, sizeof (uint32_t))) {
/* LINTED: pointer alignment */
*(uint32_t *)&dst[0] ^=
/* LINTED: pointer alignment */
*(uint32_t *)&data[0];
/* LINTED: pointer alignment */
*(uint32_t *)&dst[4] ^=
/* LINTED: pointer alignment */
*(uint32_t *)&data[4];
} else {
DES_XOR_BLOCK(data, dst);
}
}
int
des_encrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
{
return (des_crunch_block(keysched, in, out, B_FALSE));
}
int
des3_encrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
{
return (des3_crunch_block(keysched, in, out, B_FALSE));
}
int
des_decrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
{
return (des_crunch_block(keysched, in, out, B_TRUE));
}
int
des3_decrypt_block(const void *keysched, const uint8_t *in, uint8_t *out)
{
return (des3_crunch_block(keysched, in, out, B_TRUE));
}
/*
* Encrypt multiple blocks of data according to mode.
*/
int
des_encrypt_contiguous_blocks(void *ctx, char *data, size_t length,
crypto_data_t *out)
{
des_ctx_t *des_ctx = ctx;
int rv;
if (des_ctx->dc_flags & DES3_STRENGTH) {
if (des_ctx->dc_flags & CBC_MODE) {
rv = cbc_encrypt_contiguous_blocks(ctx, data,
length, out, DES_BLOCK_LEN, des3_encrypt_block,
des_copy_block, des_xor_block);
} else {
rv = ecb_cipher_contiguous_blocks(ctx, data, length,
out, DES_BLOCK_LEN, des3_encrypt_block);
}
} else {
if (des_ctx->dc_flags & CBC_MODE) {
rv = cbc_encrypt_contiguous_blocks(ctx, data,
length, out, DES_BLOCK_LEN, des_encrypt_block,
des_copy_block, des_xor_block);
} else {
rv = ecb_cipher_contiguous_blocks(ctx, data, length,
out, DES_BLOCK_LEN, des_encrypt_block);
}
}
return (rv);
}
/*
* Decrypt multiple blocks of data according to mode.
*/
int
des_decrypt_contiguous_blocks(void *ctx, char *data, size_t length,
crypto_data_t *out)
{
des_ctx_t *des_ctx = ctx;
int rv;
if (des_ctx->dc_flags & DES3_STRENGTH) {
if (des_ctx->dc_flags & CBC_MODE) {
rv = cbc_decrypt_contiguous_blocks(ctx, data,
length, out, DES_BLOCK_LEN, des3_decrypt_block,
des_copy_block, des_xor_block);
} else {
rv = ecb_cipher_contiguous_blocks(ctx, data, length,
out, DES_BLOCK_LEN, des3_decrypt_block);
if (rv == CRYPTO_DATA_LEN_RANGE)
rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
}
} else {
if (des_ctx->dc_flags & CBC_MODE) {
rv = cbc_decrypt_contiguous_blocks(ctx, data,
length, out, DES_BLOCK_LEN, des_decrypt_block,
des_copy_block, des_xor_block);
} else {
rv = ecb_cipher_contiguous_blocks(ctx, data, length,
out, DES_BLOCK_LEN, des_decrypt_block);
if (rv == CRYPTO_DATA_LEN_RANGE)
rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
}
}
return (rv);
}