usr/src/common/crypto/blowfish/blowfish_impl.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 /*
  27  * Blowfish encryption/decryption and keyschedule code.
  28  */
  29
  30 #include <sys/types.h>
  31 #include <sys/systm.h>
  32 #include <sys/ddi.h>
  33 #include <sys/sysmacros.h>
  34 #include <sys/strsun.h>
  35 #include <sys/note.h>
  36 #include <sys/byteorder.h>
  37 #include <sys/crypto/spi.h>
  38 #include <modes/modes.h>
  39 #include <sys/crypto/common.h>
  40 #include "blowfish_impl.h"
  41
  42 #ifdef _KERNEL
  43
  44 #define BLOWFISH_ASSERT(x)      ASSERT(x)
  45
  46 #else /* !_KERNEL */
  47
  48 #include <strings.h>
  49 #include <stdlib.h>
  50 #define BLOWFISH_ASSERT(x)
  51 #endif /* _KERNEL */
  52
  53 #if defined(__i386) || defined(__amd64)
  54 #include <sys/byteorder.h>
  55 #define UNALIGNED_POINTERS_PERMITTED
  56 #endif
  57
  58 /*
  59  * Blowfish initial P box and S boxes, derived from the hex digits of PI.
  60  *
  61  * NOTE:  S boxes are placed into one large array.
  62  */
  63 static const uint32_t init_P[] = {
  64         0x243f6a88U, 0x85a308d3U, 0x13198a2eU,
  65         0x03707344U, 0xa4093822U, 0x299f31d0U,
  66         0x082efa98U, 0xec4e6c89U, 0x452821e6U,
  67         0x38d01377U, 0xbe5466cfU, 0x34e90c6cU,
  68         0xc0ac29b7U, 0xc97c50ddU, 0x3f84d5b5U,
  69         0xb5470917U, 0x9216d5d9U, 0x8979fb1bU
  70 };
  71
  72 static const uint32_t init_S[] = {
  73         /* S-Box 0. */
  74         0xd1310ba6U, 0x98dfb5acU, 0x2ffd72dbU, 0xd01adfb7U,
  75         0xb8e1afedU, 0x6a267e96U, 0xba7c9045U, 0xf12c7f99U,
  76         0x24a19947U, 0xb3916cf7U, 0x0801f2e2U, 0x858efc16U,
  77         0x636920d8U, 0x71574e69U, 0xa458fea3U, 0xf4933d7eU,
  78         0x0d95748fU, 0x728eb658U, 0x718bcd58U, 0x82154aeeU,
  79         0x7b54a41dU, 0xc25a59b5U, 0x9c30d539U, 0x2af26013U,
  80         0xc5d1b023U, 0x286085f0U, 0xca417918U, 0xb8db38efU,
  81         0x8e79dcb0U, 0x603a180eU, 0x6c9e0e8bU, 0xb01e8a3eU,
  82         0xd71577c1U, 0xbd314b27U, 0x78af2fdaU, 0x55605c60U,
  83         0xe65525f3U, 0xaa55ab94U, 0x57489862U, 0x63e81440U,
  84         0x55ca396aU, 0x2aab10b6U, 0xb4cc5c34U, 0x1141e8ceU,
  85         0xa15486afU, 0x7c72e993U, 0xb3ee1411U, 0x636fbc2aU,
  86         0x2ba9c55dU, 0x741831f6U, 0xce5c3e16U, 0x9b87931eU,
  87         0xafd6ba33U, 0x6c24cf5cU, 0x7a325381U, 0x28958677U,
  88         0x3b8f4898U, 0x6b4bb9afU, 0xc4bfe81bU, 0x66282193U,
  89         0x61d809ccU, 0xfb21a991U, 0x487cac60U, 0x5dec8032U,
  90         0xef845d5dU, 0xe98575b1U, 0xdc262302U, 0xeb651b88U,
  91         0x23893e81U, 0xd396acc5U, 0x0f6d6ff3U, 0x83f44239U,
  92         0x2e0b4482U, 0xa4842004U, 0x69c8f04aU, 0x9e1f9b5eU,
  93         0x21c66842U, 0xf6e96c9aU, 0x670c9c61U, 0xabd388f0U,
  94         0x6a51a0d2U, 0xd8542f68U, 0x960fa728U, 0xab5133a3U,
  95         0x6eef0b6cU, 0x137a3be4U, 0xba3bf050U, 0x7efb2a98U,
  96         0xa1f1651dU, 0x39af0176U, 0x66ca593eU, 0x82430e88U,
  97         0x8cee8619U, 0x456f9fb4U, 0x7d84a5c3U, 0x3b8b5ebeU,
  98         0xe06f75d8U, 0x85c12073U, 0x401a449fU, 0x56c16aa6U,
  99         0x4ed3aa62U, 0x363f7706U, 0x1bfedf72U, 0x429b023dU,
 100         0x37d0d724U, 0xd00a1248U, 0xdb0fead3U, 0x49f1c09bU,
 101         0x075372c9U, 0x80991b7bU, 0x25d479d8U, 0xf6e8def7U,
 102         0xe3fe501aU, 0xb6794c3bU, 0x976ce0bdU, 0x04c006baU,
 103         0xc1a94fb6U, 0x409f60c4U, 0x5e5c9ec2U, 0x196a2463U,
 104         0x68fb6fafU, 0x3e6c53b5U, 0x1339b2ebU, 0x3b52ec6fU,
 105         0x6dfc511fU, 0x9b30952cU, 0xcc814544U, 0xaf5ebd09U,
 106         0xbee3d004U, 0xde334afdU, 0x660f2807U, 0x192e4bb3U,
 107         0xc0cba857U, 0x45c8740fU, 0xd20b5f39U, 0xb9d3fbdbU,
 108         0x5579c0bdU, 0x1a60320aU, 0xd6a100c6U, 0x402c7279U,
 109         0x679f25feU, 0xfb1fa3ccU, 0x8ea5e9f8U, 0xdb3222f8U,
 110         0x3c7516dfU, 0xfd616b15U, 0x2f501ec8U, 0xad0552abU,
 111         0x323db5faU, 0xfd238760U, 0x53317b48U, 0x3e00df82U,
 112         0x9e5c57bbU, 0xca6f8ca0U, 0x1a87562eU, 0xdf1769dbU,
 113         0xd542a8f6U, 0x287effc3U, 0xac6732c6U, 0x8c4f5573U,
 114         0x695b27b0U, 0xbbca58c8U, 0xe1ffa35dU, 0xb8f011a0U,
 115         0x10fa3d98U, 0xfd2183b8U, 0x4afcb56cU, 0x2dd1d35bU,
 116         0x9a53e479U, 0xb6f84565U, 0xd28e49bcU, 0x4bfb9790U,
 117         0xe1ddf2daU, 0xa4cb7e33U, 0x62fb1341U, 0xcee4c6e8U,
 118         0xef20cadaU, 0x36774c01U, 0xd07e9efeU, 0x2bf11fb4U,
 119         0x95dbda4dU, 0xae909198U, 0xeaad8e71U, 0x6b93d5a0U,
 120         0xd08ed1d0U, 0xafc725e0U, 0x8e3c5b2fU, 0x8e7594b7U,
 121         0x8ff6e2fbU, 0xf2122b64U, 0x8888b812U, 0x900df01cU,
 122         0x4fad5ea0U, 0x688fc31cU, 0xd1cff191U, 0xb3a8c1adU,
 123         0x2f2f2218U, 0xbe0e1777U, 0xea752dfeU, 0x8b021fa1U,
 124         0xe5a0cc0fU, 0xb56f74e8U, 0x18acf3d6U, 0xce89e299U,
 125         0xb4a84fe0U, 0xfd13e0b7U, 0x7cc43b81U, 0xd2ada8d9U,
 126         0x165fa266U, 0x80957705U, 0x93cc7314U, 0x211a1477U,
 127         0xe6ad2065U, 0x77b5fa86U, 0xc75442f5U, 0xfb9d35cfU,
 128         0xebcdaf0cU, 0x7b3e89a0U, 0xd6411bd3U, 0xae1e7e49U,
 129         0x00250e2dU, 0x2071b35eU, 0x226800bbU, 0x57b8e0afU,
 130         0x2464369bU, 0xf009b91eU, 0x5563911dU, 0x59dfa6aaU,
 131         0x78c14389U, 0xd95a537fU, 0x207d5ba2U, 0x02e5b9c5U,
 132         0x83260376U, 0x6295cfa9U, 0x11c81968U, 0x4e734a41U,
 133         0xb3472dcaU, 0x7b14a94aU, 0x1b510052U, 0x9a532915U,
 134         0xd60f573fU, 0xbc9bc6e4U, 0x2b60a476U, 0x81e67400U,
 135         0x08ba6fb5U, 0x571be91fU, 0xf296ec6bU, 0x2a0dd915U,
 136         0xb6636521U, 0xe7b9f9b6U, 0xff34052eU, 0xc5855664U,
 137         0x53b02d5dU, 0xa99f8fa1U, 0x08ba4799U, 0x6e85076aU,
 138
 139         /* S-Box 1. */
 140         0x4b7a70e9U, 0xb5b32944U, 0xdb75092eU, 0xc4192623U,
 141         0xad6ea6b0U, 0x49a7df7dU, 0x9cee60b8U, 0x8fedb266U,
 142         0xecaa8c71U, 0x699a17ffU, 0x5664526cU, 0xc2b19ee1U,
 143         0x193602a5U, 0x75094c29U, 0xa0591340U, 0xe4183a3eU,
 144         0x3f54989aU, 0x5b429d65U, 0x6b8fe4d6U, 0x99f73fd6U,
 145         0xa1d29c07U, 0xefe830f5U, 0x4d2d38e6U, 0xf0255dc1U,
 146         0x4cdd2086U, 0x8470eb26U, 0x6382e9c6U, 0x021ecc5eU,
 147         0x09686b3fU, 0x3ebaefc9U, 0x3c971814U, 0x6b6a70a1U,
 148         0x687f3584U, 0x52a0e286U, 0xb79c5305U, 0xaa500737U,
 149         0x3e07841cU, 0x7fdeae5cU, 0x8e7d44ecU, 0x5716f2b8U,
 150         0xb03ada37U, 0xf0500c0dU, 0xf01c1f04U, 0x0200b3ffU,
 151         0xae0cf51aU, 0x3cb574b2U, 0x25837a58U, 0xdc0921bdU,
 152         0xd19113f9U, 0x7ca92ff6U, 0x94324773U, 0x22f54701U,
 153         0x3ae5e581U, 0x37c2dadcU, 0xc8b57634U, 0x9af3dda7U,
 154         0xa9446146U, 0x0fd0030eU, 0xecc8c73eU, 0xa4751e41U,
 155         0xe238cd99U, 0x3bea0e2fU, 0x3280bba1U, 0x183eb331U,
 156         0x4e548b38U, 0x4f6db908U, 0x6f420d03U, 0xf60a04bfU,
 157         0x2cb81290U, 0x24977c79U, 0x5679b072U, 0xbcaf89afU,
 158         0xde9a771fU, 0xd9930810U, 0xb38bae12U, 0xdccf3f2eU,
 159         0x5512721fU, 0x2e6b7124U, 0x501adde6U, 0x9f84cd87U,
 160         0x7a584718U, 0x7408da17U, 0xbc9f9abcU, 0xe94b7d8cU,
 161         0xec7aec3aU, 0xdb851dfaU, 0x63094366U, 0xc464c3d2U,
 162         0xef1c1847U, 0x3215d908U, 0xdd433b37U, 0x24c2ba16U,
 163         0x12a14d43U, 0x2a65c451U, 0x50940002U, 0x133ae4ddU,
 164         0x71dff89eU, 0x10314e55U, 0x81ac77d6U, 0x5f11199bU,
 165         0x043556f1U, 0xd7a3c76bU, 0x3c11183bU, 0x5924a509U,
 166         0xf28fe6edU, 0x97f1fbfaU, 0x9ebabf2cU, 0x1e153c6eU,
 167         0x86e34570U, 0xeae96fb1U, 0x860e5e0aU, 0x5a3e2ab3U,
 168         0x771fe71cU, 0x4e3d06faU, 0x2965dcb9U, 0x99e71d0fU,
 169         0x803e89d6U, 0x5266c825U, 0x2e4cc978U, 0x9c10b36aU,
 170         0xc6150ebaU, 0x94e2ea78U, 0xa5fc3c53U, 0x1e0a2df4U,
 171         0xf2f74ea7U, 0x361d2b3dU, 0x1939260fU, 0x19c27960U,
 172         0x5223a708U, 0xf71312b6U, 0xebadfe6eU, 0xeac31f66U,
 173         0xe3bc4595U, 0xa67bc883U, 0xb17f37d1U, 0x018cff28U,
 174         0xc332ddefU, 0xbe6c5aa5U, 0x65582185U, 0x68ab9802U,
 175         0xeecea50fU, 0xdb2f953bU, 0x2aef7dadU, 0x5b6e2f84U,
 176         0x1521b628U, 0x29076170U, 0xecdd4775U, 0x619f1510U,
 177         0x13cca830U, 0xeb61bd96U, 0x0334fe1eU, 0xaa0363cfU,
 178         0xb5735c90U, 0x4c70a239U, 0xd59e9e0bU, 0xcbaade14U,
 179         0xeecc86bcU, 0x60622ca7U, 0x9cab5cabU, 0xb2f3846eU,
 180         0x648b1eafU, 0x19bdf0caU, 0xa02369b9U, 0x655abb50U,
 181         0x40685a32U, 0x3c2ab4b3U, 0x319ee9d5U, 0xc021b8f7U,
 182         0x9b540b19U, 0x875fa099U, 0x95f7997eU, 0x623d7da8U,
 183         0xf837889aU, 0x97e32d77U, 0x11ed935fU, 0x16681281U,
 184         0x0e358829U, 0xc7e61fd6U, 0x96dedfa1U, 0x7858ba99U,
 185         0x57f584a5U, 0x1b227263U, 0x9b83c3ffU, 0x1ac24696U,
 186         0xcdb30aebU, 0x532e3054U, 0x8fd948e4U, 0x6dbc3128U,
 187         0x58ebf2efU, 0x34c6ffeaU, 0xfe28ed61U, 0xee7c3c73U,
 188         0x5d4a14d9U, 0xe864b7e3U, 0x42105d14U, 0x203e13e0U,
 189         0x45eee2b6U, 0xa3aaabeaU, 0xdb6c4f15U, 0xfacb4fd0U,
 190         0xc742f442U, 0xef6abbb5U, 0x654f3b1dU, 0x41cd2105U,
 191         0xd81e799eU, 0x86854dc7U, 0xe44b476aU, 0x3d816250U,
 192         0xcf62a1f2U, 0x5b8d2646U, 0xfc8883a0U, 0xc1c7b6a3U,
 193         0x7f1524c3U, 0x69cb7492U, 0x47848a0bU, 0x5692b285U,
 194         0x095bbf00U, 0xad19489dU, 0x1462b174U, 0x23820e00U,
 195         0x58428d2aU, 0x0c55f5eaU, 0x1dadf43eU, 0x233f7061U,
 196         0x3372f092U, 0x8d937e41U, 0xd65fecf1U, 0x6c223bdbU,
 197         0x7cde3759U, 0xcbee7460U, 0x4085f2a7U, 0xce77326eU,
 198         0xa6078084U, 0x19f8509eU, 0xe8efd855U, 0x61d99735U,
 199         0xa969a7aaU, 0xc50c06c2U, 0x5a04abfcU, 0x800bcadcU,
 200         0x9e447a2eU, 0xc3453484U, 0xfdd56705U, 0x0e1e9ec9U,
 201         0xdb73dbd3U, 0x105588cdU, 0x675fda79U, 0xe3674340U,
 202         0xc5c43465U, 0x713e38d8U, 0x3d28f89eU, 0xf16dff20U,
 203         0x153e21e7U, 0x8fb03d4aU, 0xe6e39f2bU, 0xdb83adf7U,
 204
 205         /* S-Box 2. */
 206         0xe93d5a68U, 0x948140f7U, 0xf64c261cU, 0x94692934U,
 207         0x411520f7U, 0x7602d4f7U, 0xbcf46b2eU, 0xd4a20068U,
 208         0xd4082471U, 0x3320f46aU, 0x43b7d4b7U, 0x500061afU,
 209         0x1e39f62eU, 0x97244546U, 0x14214f74U, 0xbf8b8840U,
 210         0x4d95fc1dU, 0x96b591afU, 0x70f4ddd3U, 0x66a02f45U,
 211         0xbfbc09ecU, 0x03bd9785U, 0x7fac6dd0U, 0x31cb8504U,
 212         0x96eb27b3U, 0x55fd3941U, 0xda2547e6U, 0xabca0a9aU,
 213         0x28507825U, 0x530429f4U, 0x0a2c86daU, 0xe9b66dfbU,
 214         0x68dc1462U, 0xd7486900U, 0x680ec0a4U, 0x27a18deeU,
 215         0x4f3ffea2U, 0xe887ad8cU, 0xb58ce006U, 0x7af4d6b6U,
 216         0xaace1e7cU, 0xd3375fecU, 0xce78a399U, 0x406b2a42U,
 217         0x20fe9e35U, 0xd9f385b9U, 0xee39d7abU, 0x3b124e8bU,
 218         0x1dc9faf7U, 0x4b6d1856U, 0x26a36631U, 0xeae397b2U,
 219         0x3a6efa74U, 0xdd5b4332U, 0x6841e7f7U, 0xca7820fbU,
 220         0xfb0af54eU, 0xd8feb397U, 0x454056acU, 0xba489527U,
 221         0x55533a3aU, 0x20838d87U, 0xfe6ba9b7U, 0xd096954bU,
 222         0x55a867bcU, 0xa1159a58U, 0xcca92963U, 0x99e1db33U,
 223         0xa62a4a56U, 0x3f3125f9U, 0x5ef47e1cU, 0x9029317cU,
 224         0xfdf8e802U, 0x04272f70U, 0x80bb155cU, 0x05282ce3U,
 225         0x95c11548U, 0xe4c66d22U, 0x48c1133fU, 0xc70f86dcU,
 226         0x07f9c9eeU, 0x41041f0fU, 0x404779a4U, 0x5d886e17U,
 227         0x325f51ebU, 0xd59bc0d1U, 0xf2bcc18fU, 0x41113564U,
 228         0x257b7834U, 0x602a9c60U, 0xdff8e8a3U, 0x1f636c1bU,
 229         0x0e12b4c2U, 0x02e1329eU, 0xaf664fd1U, 0xcad18115U,
 230         0x6b2395e0U, 0x333e92e1U, 0x3b240b62U, 0xeebeb922U,
 231         0x85b2a20eU, 0xe6ba0d99U, 0xde720c8cU, 0x2da2f728U,
 232         0xd0127845U, 0x95b794fdU, 0x647d0862U, 0xe7ccf5f0U,
 233         0x5449a36fU, 0x877d48faU, 0xc39dfd27U, 0xf33e8d1eU,
 234         0x0a476341U, 0x992eff74U, 0x3a6f6eabU, 0xf4f8fd37U,
 235         0xa812dc60U, 0xa1ebddf8U, 0x991be14cU, 0xdb6e6b0dU,
 236         0xc67b5510U, 0x6d672c37U, 0x2765d43bU, 0xdcd0e804U,
 237         0xf1290dc7U, 0xcc00ffa3U, 0xb5390f92U, 0x690fed0bU,
 238         0x667b9ffbU, 0xcedb7d9cU, 0xa091cf0bU, 0xd9155ea3U,
 239         0xbb132f88U, 0x515bad24U, 0x7b9479bfU, 0x763bd6ebU,
 240         0x37392eb3U, 0xcc115979U, 0x8026e297U, 0xf42e312dU,
 241         0x6842ada7U, 0xc66a2b3bU, 0x12754cccU, 0x782ef11cU,
 242         0x6a124237U, 0xb79251e7U, 0x06a1bbe6U, 0x4bfb6350U,
 243         0x1a6b1018U, 0x11caedfaU, 0x3d25bdd8U, 0xe2e1c3c9U,
 244         0x44421659U, 0x0a121386U, 0xd90cec6eU, 0xd5abea2aU,
 245         0x64af674eU, 0xda86a85fU, 0xbebfe988U, 0x64e4c3feU,
 246         0x9dbc8057U, 0xf0f7c086U, 0x60787bf8U, 0x6003604dU,
 247         0xd1fd8346U, 0xf6381fb0U, 0x7745ae04U, 0xd736fcccU,
 248         0x83426b33U, 0xf01eab71U, 0xb0804187U, 0x3c005e5fU,
 249         0x77a057beU, 0xbde8ae24U, 0x55464299U, 0xbf582e61U,
 250         0x4e58f48fU, 0xf2ddfda2U, 0xf474ef38U, 0x8789bdc2U,
 251         0x5366f9c3U, 0xc8b38e74U, 0xb475f255U, 0x46fcd9b9U,
 252         0x7aeb2661U, 0x8b1ddf84U, 0x846a0e79U, 0x915f95e2U,
 253         0x466e598eU, 0x20b45770U, 0x8cd55591U, 0xc902de4cU,
 254         0xb90bace1U, 0xbb8205d0U, 0x11a86248U, 0x7574a99eU,
 255         0xb77f19b6U, 0xe0a9dc09U, 0x662d09a1U, 0xc4324633U,
 256         0xe85a1f02U, 0x09f0be8cU, 0x4a99a025U, 0x1d6efe10U,
 257         0x1ab93d1dU, 0x0ba5a4dfU, 0xa186f20fU, 0x2868f169U,
 258         0xdcb7da83U, 0x573906feU, 0xa1e2ce9bU, 0x4fcd7f52U,
 259         0x50115e01U, 0xa70683faU, 0xa002b5c4U, 0x0de6d027U,
 260         0x9af88c27U, 0x773f8641U, 0xc3604c06U, 0x61a806b5U,
 261         0xf0177a28U, 0xc0f586e0U, 0x006058aaU, 0x30dc7d62U,
 262         0x11e69ed7U, 0x2338ea63U, 0x53c2dd94U, 0xc2c21634U,
 263         0xbbcbee56U, 0x90bcb6deU, 0xebfc7da1U, 0xce591d76U,
 264         0x6f05e409U, 0x4b7c0188U, 0x39720a3dU, 0x7c927c24U,
 265         0x86e3725fU, 0x724d9db9U, 0x1ac15bb4U, 0xd39eb8fcU,
 266         0xed545578U, 0x08fca5b5U, 0xd83d7cd3U, 0x4dad0fc4U,
 267         0x1e50ef5eU, 0xb161e6f8U, 0xa28514d9U, 0x6c51133cU,
 268         0x6fd5c7e7U, 0x56e14ec4U, 0x362abfceU, 0xddc6c837U,
 269         0xd79a3234U, 0x92638212U, 0x670efa8eU, 0x406000e0U,
 270
 271         /* S-Box 3. */
 272         0x3a39ce37U, 0xd3faf5cfU, 0xabc27737U, 0x5ac52d1bU,
 273         0x5cb0679eU, 0x4fa33742U, 0xd3822740U, 0x99bc9bbeU,
 274         0xd5118e9dU, 0xbf0f7315U, 0xd62d1c7eU, 0xc700c47bU,
 275         0xb78c1b6bU, 0x21a19045U, 0xb26eb1beU, 0x6a366eb4U,
 276         0x5748ab2fU, 0xbc946e79U, 0xc6a376d2U, 0x6549c2c8U,
 277         0x530ff8eeU, 0x468dde7dU, 0xd5730a1dU, 0x4cd04dc6U,
 278         0x2939bbdbU, 0xa9ba4650U, 0xac9526e8U, 0xbe5ee304U,
 279         0xa1fad5f0U, 0x6a2d519aU, 0x63ef8ce2U, 0x9a86ee22U,
 280         0xc089c2b8U, 0x43242ef6U, 0xa51e03aaU, 0x9cf2d0a4U,
 281         0x83c061baU, 0x9be96a4dU, 0x8fe51550U, 0xba645bd6U,
 282         0x2826a2f9U, 0xa73a3ae1U, 0x4ba99586U, 0xef5562e9U,
 283         0xc72fefd3U, 0xf752f7daU, 0x3f046f69U, 0x77fa0a59U,
 284         0x80e4a915U, 0x87b08601U, 0x9b09e6adU, 0x3b3ee593U,
 285         0xe990fd5aU, 0x9e34d797U, 0x2cf0b7d9U, 0x022b8b51U,
 286         0x96d5ac3aU, 0x017da67dU, 0xd1cf3ed6U, 0x7c7d2d28U,
 287         0x1f9f25cfU, 0xadf2b89bU, 0x5ad6b472U, 0x5a88f54cU,
 288         0xe029ac71U, 0xe019a5e6U, 0x47b0acfdU, 0xed93fa9bU,
 289         0xe8d3c48dU, 0x283b57ccU, 0xf8d56629U, 0x79132e28U,
 290         0x785f0191U, 0xed756055U, 0xf7960e44U, 0xe3d35e8cU,
 291         0x15056dd4U, 0x88f46dbaU, 0x03a16125U, 0x0564f0bdU,
 292         0xc3eb9e15U, 0x3c9057a2U, 0x97271aecU, 0xa93a072aU,
 293         0x1b3f6d9bU, 0x1e6321f5U, 0xf59c66fbU, 0x26dcf319U,
 294         0x7533d928U, 0xb155fdf5U, 0x03563482U, 0x8aba3cbbU,
 295         0x28517711U, 0xc20ad9f8U, 0xabcc5167U, 0xccad925fU,
 296         0x4de81751U, 0x3830dc8eU, 0x379d5862U, 0x9320f991U,
 297         0xea7a90c2U, 0xfb3e7bceU, 0x5121ce64U, 0x774fbe32U,
 298         0xa8b6e37eU, 0xc3293d46U, 0x48de5369U, 0x6413e680U,
 299         0xa2ae0810U, 0xdd6db224U, 0x69852dfdU, 0x09072166U,
 300         0xb39a460aU, 0x6445c0ddU, 0x586cdecfU, 0x1c20c8aeU,
 301         0x5bbef7ddU, 0x1b588d40U, 0xccd2017fU, 0x6bb4e3bbU,
 302         0xdda26a7eU, 0x3a59ff45U, 0x3e350a44U, 0xbcb4cdd5U,
 303         0x72eacea8U, 0xfa6484bbU, 0x8d6612aeU, 0xbf3c6f47U,
 304         0xd29be463U, 0x542f5d9eU, 0xaec2771bU, 0xf64e6370U,
 305         0x740e0d8dU, 0xe75b1357U, 0xf8721671U, 0xaf537d5dU,
 306         0x4040cb08U, 0x4eb4e2ccU, 0x34d2466aU, 0x0115af84U,
 307         0xe1b00428U, 0x95983a1dU, 0x06b89fb4U, 0xce6ea048U,
 308         0x6f3f3b82U, 0x3520ab82U, 0x011a1d4bU, 0x277227f8U,
 309         0x611560b1U, 0xe7933fdcU, 0xbb3a792bU, 0x344525bdU,
 310         0xa08839e1U, 0x51ce794bU, 0x2f32c9b7U, 0xa01fbac9U,
 311         0xe01cc87eU, 0xbcc7d1f6U, 0xcf0111c3U, 0xa1e8aac7U,
 312         0x1a908749U, 0xd44fbd9aU, 0xd0dadecbU, 0xd50ada38U,
 313         0x0339c32aU, 0xc6913667U, 0x8df9317cU, 0xe0b12b4fU,
 314         0xf79e59b7U, 0x43f5bb3aU, 0xf2d519ffU, 0x27d9459cU,
 315         0xbf97222cU, 0x15e6fc2aU, 0x0f91fc71U, 0x9b941525U,
 316         0xfae59361U, 0xceb69cebU, 0xc2a86459U, 0x12baa8d1U,
 317         0xb6c1075eU, 0xe3056a0cU, 0x10d25065U, 0xcb03a442U,
 318         0xe0ec6e0eU, 0x1698db3bU, 0x4c98a0beU, 0x3278e964U,
 319         0x9f1f9532U, 0xe0d392dfU, 0xd3a0342bU, 0x8971f21eU,
 320         0x1b0a7441U, 0x4ba3348cU, 0xc5be7120U, 0xc37632d8U,
 321         0xdf359f8dU, 0x9b992f2eU, 0xe60b6f47U, 0x0fe3f11dU,
 322         0xe54cda54U, 0x1edad891U, 0xce6279cfU, 0xcd3e7e6fU,
 323         0x1618b166U, 0xfd2c1d05U, 0x848fd2c5U, 0xf6fb2299U,
 324         0xf523f357U, 0xa6327623U, 0x93a83531U, 0x56cccd02U,
 325         0xacf08162U, 0x5a75ebb5U, 0x6e163697U, 0x88d273ccU,
 326         0xde966292U, 0x81b949d0U, 0x4c50901bU, 0x71c65614U,
 327         0xe6c6c7bdU, 0x327a140aU, 0x45e1d006U, 0xc3f27b9aU,
 328         0xc9aa53fdU, 0x62a80f00U, 0xbb25bfe2U, 0x35bdd2f6U,
 329         0x71126905U, 0xb2040222U, 0xb6cbcf7cU, 0xcd769c2bU,
 330         0x53113ec0U, 0x1640e3d3U, 0x38abbd60U, 0x2547adf0U,
 331         0xba38209cU, 0xf746ce76U, 0x77afa1c5U, 0x20756060U,
 332         0x85cbfe4eU, 0x8ae88dd8U, 0x7aaaf9b0U, 0x4cf9aa7eU,
 333         0x1948c25cU, 0x02fb8a8cU, 0x01c36ae4U, 0xd6ebe1f9U,
 334         0x90d4f869U, 0xa65cdea0U, 0x3f09252dU, 0xc208e69fU,
 335         0xb74e6132U, 0xce77e25bU, 0x578fdfe3U, 0x3ac372e6U,
 336 };
 337
 338 typedef struct keysched_s {
 339         uint32_t ksch_S[1024];  /* The 4 S boxes are 256 32-bit words. */
 340         uint32_t ksch_P[18];    /* P box is 18 32-bit words. */
 341 } keysched_t;
 342
 343 /*
 344  * Since ROUND() is a macro, make sure that the things inside can be
 345  * evaluated more than once.  Especially when calling F().
 346  * Assume the presence of local variables:
 347  *
 348  *      uint32_t *P;
 349  *      uint32_t *S;
 350  *      uint32_t tmp;
 351  *
 352  *
 353  * And to Microsoft interview survivors out there, perhaps I should do the
 354  * XOR swap trick, or at least #ifdef (__i386) the tmp = ... = tmp; stuff.
 355  */
 356
 357 #define F(word) \
 358         (((S[(word >> 24) & 0xff] + S[256 + ((word >> 16) & 0xff)]) ^ \
 359                 S[512 + ((word >> 8) & 0xff)]) + S[768 + (word & 0xff)])
 360
 361 #define ROUND(left, right, i) \
 362         (left) ^= P[i]; \
 363         (right) ^= F((left)); \
 364         tmp = (left); \
 365         (left) = (right); \
 366         (right) = tmp;
 367
 368 /*
 369  * Encrypt a block of data.  Because of addition operations, convert blocks
 370  * to their big-endian representation, even on Intel boxen.
 371  */
 372 /* ARGSUSED */
 373 int
 374 blowfish_encrypt_block(const void *cookie, const uint8_t *block,
 375     uint8_t *out_block)
 376 {
 377         keysched_t *ksch = (keysched_t *)cookie;
 378
 379         uint32_t left, right, tmp;
 380         uint32_t *P = ksch->ksch_P;
 381         uint32_t *S = ksch->ksch_S;
 382 #ifdef _BIG_ENDIAN
 383         uint32_t *b32;
 384
 385         if (IS_P2ALIGNED(block, sizeof (uint32_t))) {
 386                 /* LINTED:  pointer alignment */
 387                 b32 = (uint32_t *)block;
 388                 left = b32[0];
 389                 right = b32[1];
 390         } else
 391 #endif
 392         {
 393         /*
 394          * Read input block and place in left/right in big-endian order.
 395          */
 396 #ifdef UNALIGNED_POINTERS_PERMITTED
 397         left = htonl(*(uint32_t *)(void *)&block[0]);
 398         right = htonl(*(uint32_t *)(void *)&block[4]);
 399 #else
 400         left = ((uint32_t)block[0] << 24)
 401             | ((uint32_t)block[1] << 16)
 402             | ((uint32_t)block[2] << 8)
 403             | (uint32_t)block[3];
 404         right = ((uint32_t)block[4] << 24)
 405             | ((uint32_t)block[5] << 16)
 406             | ((uint32_t)block[6] << 8)
 407             | (uint32_t)block[7];
 408 #endif  /* UNALIGNED_POINTERS_PERMITTED */
 409         }
 410
 411         ROUND(left, right, 0);
 412         ROUND(left, right, 1);
 413         ROUND(left, right, 2);
 414         ROUND(left, right, 3);
 415         ROUND(left, right, 4);
 416         ROUND(left, right, 5);
 417         ROUND(left, right, 6);
 418         ROUND(left, right, 7);
 419         ROUND(left, right, 8);
 420         ROUND(left, right, 9);
 421         ROUND(left, right, 10);
 422         ROUND(left, right, 11);
 423         ROUND(left, right, 12);
 424         ROUND(left, right, 13);
 425         ROUND(left, right, 14);
 426         ROUND(left, right, 15);
 427
 428         tmp = left;
 429         left = right;
 430         right = tmp;
 431         right ^= P[16];
 432         left ^= P[17];
 433
 434 #ifdef _BIG_ENDIAN
 435         if (IS_P2ALIGNED(out_block, sizeof (uint32_t))) {
 436                 /* LINTED:  pointer alignment */
 437                 b32 = (uint32_t *)out_block;
 438                 b32[0] = left;
 439                 b32[1] = right;
 440         } else
 441 #endif
 442         {
 443                 /* Put the block back into the user's block with final swap */
 444 #ifdef UNALIGNED_POINTERS_PERMITTED
 445                 *(uint32_t *)(void *)&out_block[0] = htonl(left);
 446                 *(uint32_t *)(void *)&out_block[4] = htonl(right);
 447 #else
 448                 out_block[0] = left >> 24;
 449                 out_block[1] = left >> 16;
 450                 out_block[2] = left >> 8;
 451                 out_block[3] = left;
 452                 out_block[4] = right >> 24;
 453                 out_block[5] = right >> 16;
 454                 out_block[6] = right >> 8;
 455                 out_block[7] = right;
 456 #endif  /* UNALIGNED_POINTERS_PERMITTED */
 457         }
 458         return (CRYPTO_SUCCESS);
 459 }
 460
 461 /*
 462  * Decrypt a block of data.  Because of addition operations, convert blocks
 463  * to their big-endian representation, even on Intel boxen.
 464  * It should look like the blowfish_encrypt_block() operation
 465  * except for the order in which the S/P boxes are accessed.
 466  */
 467 /* ARGSUSED */
 468 int
 469 blowfish_decrypt_block(const void *cookie, const uint8_t *block,
 470     uint8_t *out_block)
 471 {
 472         keysched_t *ksch = (keysched_t *)cookie;
 473
 474         uint32_t left, right, tmp;
 475         uint32_t *P = ksch->ksch_P;
 476         uint32_t *S = ksch->ksch_S;
 477 #ifdef _BIG_ENDIAN
 478         uint32_t *b32;
 479
 480         if (IS_P2ALIGNED(block, sizeof (uint32_t))) {
 481                 /* LINTED:  pointer alignment */
 482                 b32 = (uint32_t *)block;
 483                 left = b32[0];
 484                 right = b32[1];
 485         } else
 486 #endif
 487         {
 488         /*
 489          * Read input block and place in left/right in big-endian order.
 490          */
 491 #ifdef UNALIGNED_POINTERS_PERMITTED
 492         left = htonl(*(uint32_t *)(void *)&block[0]);
 493         right = htonl(*(uint32_t *)(void *)&block[4]);
 494 #else
 495         left = ((uint32_t)block[0] << 24)
 496             | ((uint32_t)block[1] << 16)
 497             | ((uint32_t)block[2] << 8)
 498             | (uint32_t)block[3];
 499         right = ((uint32_t)block[4] << 24)
 500             | ((uint32_t)block[5] << 16)
 501             | ((uint32_t)block[6] << 8)
 502             | (uint32_t)block[7];
 503 #endif  /* UNALIGNED_POINTERS_PERMITTED */
 504         }
 505
 506         ROUND(left, right, 17);
 507         ROUND(left, right, 16);
 508         ROUND(left, right, 15);
 509         ROUND(left, right, 14);
 510         ROUND(left, right, 13);
 511         ROUND(left, right, 12);
 512         ROUND(left, right, 11);
 513         ROUND(left, right, 10);
 514         ROUND(left, right, 9);
 515         ROUND(left, right, 8);
 516         ROUND(left, right, 7);
 517         ROUND(left, right, 6);
 518         ROUND(left, right, 5);
 519         ROUND(left, right, 4);
 520         ROUND(left, right, 3);
 521         ROUND(left, right, 2);
 522
 523         tmp = left;
 524         left = right;
 525         right = tmp;
 526         right ^= P[1];
 527         left ^= P[0];
 528
 529 #ifdef _BIG_ENDIAN
 530         if (IS_P2ALIGNED(out_block, sizeof (uint32_t))) {
 531                 /* LINTED:  pointer alignment */
 532                 b32 = (uint32_t *)out_block;
 533                 b32[0] = left;
 534                 b32[1] = right;
 535         } else
 536 #endif
 537         {
 538         /* Put the block back into the user's block with final swap */
 539 #ifdef UNALIGNED_POINTERS_PERMITTED
 540                 *(uint32_t *)(void *)&out_block[0] = htonl(left);
 541                 *(uint32_t *)(void *)&out_block[4] = htonl(right);
 542 #else
 543                 out_block[0] = left >> 24;
 544                 out_block[1] = left >> 16;
 545                 out_block[2] = left >> 8;
 546                 out_block[3] = left;
 547                 out_block[4] = right >> 24;
 548                 out_block[5] = right >> 16;
 549                 out_block[6] = right >> 8;
 550                 out_block[7] = right;
 551 #endif  /* UNALIGNED_POINTERS_PERMITTED */
 552         }
 553         return (CRYPTO_SUCCESS);
 554 }
 555
 556 static void
 557 bitrepeat(uint8_t *pattern, uint_t len_bytes, uint_t len_bits, uint8_t *dst,
 558     uint_t dst_len_bytes)
 559 {
 560         uint8_t *current = dst;
 561         uint_t bitsleft = CRYPTO_BYTES2BITS(dst_len_bytes);
 562         uint_t bitoffset = 0;
 563         uint_t currentbits;
 564         int i;
 565
 566         BLOWFISH_ASSERT(CRYPTO_BITS2BYTES(len_bits) == len_bytes);
 567
 568         bzero(dst, dst_len_bytes);
 569
 570         while (bitsleft != 0) {
 571                 if (bitsleft >= len_bits) {
 572                         currentbits = len_bits;
 573
 574                         for (i = 0; i < len_bytes; i++) {
 575                                 if (currentbits >= 8) {
 576                                         *current++ |= pattern[i] >> bitoffset;
 577                                         *current |= pattern[i] << 8 - bitoffset;
 578                                         currentbits -= 8;
 579                                 } else {
 580                                         *current |= pattern[i] >> bitoffset;
 581                                         bitoffset = bitoffset + currentbits;
 582                                         bitoffset &= 0x7;
 583                                         if (bitoffset == 0)
 584                                                 current++;
 585                                 }
 586                         }
 587                         bitsleft -= len_bits;
 588                 } else {
 589                         currentbits = bitsleft;
 590
 591                         for (i = 0; i < len_bytes && bitsleft != 0; i++) {
 592                                 if (currentbits >= 8 &&
 593                                     current < dst + dst_len_bytes) {
 594                                         *current++ |= pattern[i] >> bitoffset;
 595                                         *current |= pattern[i] << 8 - bitoffset;
 596                                         currentbits -= 8;
 597                                         bitsleft -= 8;
 598                                 } else {
 599                                         *current |= pattern[i] >> bitoffset;
 600                                         bitsleft -= bitoffset;
 601                                         bitoffset = bitoffset + currentbits;
 602                                         bitoffset &= 0x7;
 603                                         if (bitoffset == 0)
 604                                                 current++;
 605                                         currentbits = 0;
 606                                 }
 607                         }
 608                         bitsleft = 0;
 609                 }
 610         }
 611 }
 612
 613 /*
 614  * Initialize key schedules for Blowfish.
 615  */
 616 void
 617 blowfish_init_keysched(uint8_t *key, uint_t bits, void *keysched)
 618 {
 619         keysched_t *newbie = keysched;
 620         uint32_t *P = newbie->ksch_P;
 621         uint32_t *S = newbie->ksch_S;
 622         uint32_t *initp;
 623         uint32_t tmpblock[] = {0, 0};
 624         uint8_t *rawkeybytes = (uint8_t *)P;
 625         int i, slop, copylen;
 626         uintptr_t bytesleft;
 627         uint_t len;
 628
 629         len = CRYPTO_BITS2BYTES(bits);
 630
 631         if ((bits & 0x7) != 0) {
 632                 /*
 633                  * Really slow case, bits aren't on a byte boundary.
 634                  * Keep track of individual bits copied over.  :-P
 635                  */
 636                 bitrepeat(key, len, bits, rawkeybytes, 72);
 637         } else {
 638                 slop = 72 % len;
 639
 640                 /* Someone gave us a nice amount (i.e. div by 8) of bits */
 641                 while (rawkeybytes != (uint8_t *)(P + 18)) {
 642                         bytesleft =
 643                             (uintptr_t)(P + 18) - (uintptr_t)rawkeybytes;
 644                         copylen = (bytesleft >= len) ? len : slop;
 645                         bcopy(key, rawkeybytes, copylen);
 646                         rawkeybytes += copylen;
 647                 }
 648         }
 649
 650         for (i = 0; i < 18; i++)
 651                 P[i] = ntohl(P[i]) ^ init_P[i];
 652
 653         /* Go bcopy go!  (Hope that Ultra's bcopy is faster than me!) */
 654         bcopy(init_S, S, sizeof (init_S));
 655
 656         /*
 657          * When initializing P and S boxes, store the results of a single
 658          * encrypt-block operation in "host order", which on little-endian
 659          * means byte-swapping.  Fortunately, the ntohl() function does this
 660          * quite nicely, and it a NOP on big-endian machine.
 661          */
 662         initp = P;
 663         for (i = 0; i < 9; i++) {
 664                 (void) blowfish_encrypt_block(newbie, (uint8_t *)tmpblock,
 665                     (uint8_t *)tmpblock);
 666                 *initp++ = ntohl(tmpblock[0]);
 667                 *initp++ = ntohl(tmpblock[1]);
 668         }
 669
 670         initp = S;
 671         for (i = 0; i < 512; i++) {
 672                 (void) blowfish_encrypt_block(newbie, (uint8_t *)tmpblock,
 673                     (uint8_t *)tmpblock);
 674                 *initp++ = ntohl(tmpblock[0]);
 675                 *initp++ = ntohl(tmpblock[1]);
 676         }
 677 }
 678
 679 /*
 680  * Allocate key schedule for Blowfish.
 681  */
 682 /* ARGSUSED */
 683 void *
 684 blowfish_alloc_keysched(size_t *size, int kmflag)
 685 {
 686         keysched_t *keysched;
 687
 688 #ifdef _KERNEL
 689         keysched = (keysched_t *)kmem_alloc(sizeof (keysched_t), kmflag);
 690 #else
 691         keysched = (keysched_t *)malloc(sizeof (keysched_t));
 692 #endif /* _KERNEL */
 693         if (keysched != NULL) {
 694                 *size = sizeof (keysched_t);
 695                 return (keysched);
 696         }
 697
 698         return (NULL);
 699 }
 700
 701 void
 702 blowfish_copy_block(uint8_t *in, uint8_t *out)
 703 {
 704         if (IS_P2ALIGNED(in, sizeof (uint32_t)) &&
 705             IS_P2ALIGNED(out, sizeof (uint32_t))) {
 706                 /* LINTED: pointer alignment */
 707                 *(uint32_t *)&out[0] = *(uint32_t *)&in[0];
 708                 /* LINTED: pointer alignment */
 709                 *(uint32_t *)&out[4] = *(uint32_t *)&in[4];
 710         } else {
 711                 BLOWFISH_COPY_BLOCK(in, out);
 712         }
 713 }
 714
 715 /* XOR block of data into dest */
 716 void
 717 blowfish_xor_block(uint8_t *data, uint8_t *dst)
 718 {
 719         if (IS_P2ALIGNED(dst, sizeof (uint32_t)) &&
 720             IS_P2ALIGNED(data, sizeof (uint32_t))) {
 721                 /* LINTED: pointer alignment */
 722                 *(uint32_t *)&dst[0] ^= *(uint32_t *)&data[0];
 723                 /* LINTED: pointer alignment */
 724                 *(uint32_t *)&dst[4] ^= *(uint32_t *)&data[4];
 725         } else {
 726                 BLOWFISH_XOR_BLOCK(data, dst);
 727         }
 728 }
 729
 730 /*
 731  * Encrypt multiple blocks of data according to mode.
 732  */
 733 int
 734 blowfish_encrypt_contiguous_blocks(void *ctx, char *data, size_t length,
 735     crypto_data_t *out)
 736 {
 737         blowfish_ctx_t *blowfish_ctx = ctx;
 738         int rv;
 739
 740         if (blowfish_ctx->bc_flags & CBC_MODE) {
 741                 rv = cbc_encrypt_contiguous_blocks(ctx, data, length, out,
 742                     BLOWFISH_BLOCK_LEN, blowfish_encrypt_block,
 743                     blowfish_copy_block, blowfish_xor_block);
 744         } else {
 745                 rv = ecb_cipher_contiguous_blocks(ctx, data, length, out,
 746                     BLOWFISH_BLOCK_LEN, blowfish_encrypt_block);
 747         }
 748         return (rv);
 749 }
 750
 751 /*
 752  * Decrypt multiple blocks of data according to mode.
 753  */
 754 int
 755 blowfish_decrypt_contiguous_blocks(void *ctx, char *data, size_t length,
 756     crypto_data_t *out)
 757 {
 758         blowfish_ctx_t *blowfish_ctx = ctx;
 759         int rv;
 760
 761         if (blowfish_ctx->bc_flags & CBC_MODE) {
 762                 rv = cbc_decrypt_contiguous_blocks(ctx, data, length, out,
 763                     BLOWFISH_BLOCK_LEN, blowfish_decrypt_block,
 764                     blowfish_copy_block, blowfish_xor_block);
 765         } else {
 766                 rv = ecb_cipher_contiguous_blocks(ctx, data, length, out,
 767                     BLOWFISH_BLOCK_LEN, blowfish_decrypt_block);
 768                 if (rv == CRYPTO_DATA_LEN_RANGE)
 769                         rv = CRYPTO_ENCRYPTED_DATA_LEN_RANGE;
 770         }
 771         return (rv);
 772 }