"Fossies" - the Fresh Open Source Software Archive

Member "john-1.9.0/src/BF_std.c" (5 Mar 2015, 32667 Bytes) of package /linux/privat/john-1.9.0.tar.xz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "BF_std.c" see the Fossies "Dox" file reference documentation and the latest Fossies "Diffs" side-by-side code changes report: 1.8.0_vs_1.9.0.

    1 /*
    2  * This file is part of John the Ripper password cracker,
    3  * Copyright (c) 1996-2001,2008,2010,2011,2013,2015 by Solar Designer
    4  *
    5  * Redistribution and use in source and binary forms, with or without
    6  * modification, are permitted.
    7  *
    8  * There's ABSOLUTELY NO WARRANTY, express or implied.
    9  *
   10  * A public domain version of this code, with reentrant and crypt(3)
   11  * interfaces added, but optimizations specific to password cracking
   12  * removed, is available at:
   13  *
   14  *  http://www.openwall.com/crypt/
   15  *
   16  * This implementation is compatible with OpenBSD bcrypt.c (version 2a)
   17  * by Niels Provos <provos at citi.umich.edu>, and uses some of his
   18  * ideas. The password hashing algorithm was designed by David Mazieres
   19  * <dm at lcs.mit.edu>.
   20  *
   21  * There's a paper on the algorithm that explains its design decisions:
   22  *
   23  *  http://www.usenix.org/events/usenix99/provos.html
   24  *
   25  * Some of the tricks in BF_ROUND might be inspired by Eric Young's
   26  * Blowfish library (I can't be sure if I would think of something if I
   27  * hadn't seen his code).
   28  */
   29 
   30 #include <stdlib.h>
   31 #include <string.h>
   32 
   33 #include "arch.h"
   34 #include "common.h"
   35 #include "BF_std.h"
   36 
   37 BF_binary BF_out[BF_N];
   38 
   39 /* Number of Blowfish rounds, this is also hardcoded into a few places */
   40 #define BF_ROUNDS           16
   41 
   42 typedef BF_word BF_key[BF_ROUNDS + 2];
   43 
   44 struct BF_ctx {
   45     BF_word S[4][0x100];
   46     BF_key P;
   47 };
   48 
   49 #if BF_N > 1
   50 #define INDICES             [BF_N]
   51 #define INDEX               [index]
   52 #define INDEX0              [index]
   53 #define for_each_index() \
   54     for (index = 0; index < BF_N; index++)
   55 #else
   56 #define INDICES
   57 #define INDEX
   58 #define INDEX0              [0]
   59 #define for_each_index()
   60 #endif
   61 
   62 #if BF_X2 == 3
   63 #if BF_mt > 1
   64 #define INDEX2              [lindex]
   65 #else
   66 #define INDEX2              [index]
   67 #endif
   68 #elif BF_X2
   69 #if BF_mt > 1
   70 #define INDEX2              [index & 1]
   71 #else
   72 #define INDEX2              [index]
   73 #endif
   74 #else
   75 #define INDEX2
   76 #endif
   77 
   78 #if BF_mt > 1
   79 #if BF_X2 == 3
   80 #define for_each_t() \
   81     for (t = 0; t < n; t += 3)
   82 #define for_each_ti() \
   83     for (index = t, lindex = 0; lindex < 3; index++, lindex++)
   84 #elif BF_X2
   85 #define for_each_t() \
   86     for (t = 0; t < n; t += 2)
   87 #define for_each_ti() \
   88     for (index = t; index <= t + 1; index++)
   89 #else
   90 #define for_each_t() \
   91     for (t = 0; t < n; t++)
   92 #define for_each_ti() \
   93     index = t;
   94 #endif
   95 #else
   96 #define for_each_t()
   97 #define for_each_ti() \
   98     for_each_index()
   99 #endif
  100 
  101 #if BF_mt == 1
  102 /* Current Blowfish context */
  103 #if BF_ASM
  104 extern
  105 #else
  106 static
  107 #endif
  108 struct BF_ctx CC_CACHE_ALIGN BF_current INDICES;
  109 #endif
  110 
  111 /* Current Blowfish key */
  112 static BF_key CC_CACHE_ALIGN BF_exp_key INDICES;
  113 #if defined(__linux__) && defined(__sparc__)
  114 static BF_key BF_init_key INDICES;
  115 #else
  116 static BF_key CC_CACHE_ALIGN BF_init_key INDICES;
  117 #endif
  118 
  119 /*
  120  * Magic IV for 64 Blowfish encryptions that we do at the end.
  121  * The string is "OrpheanBeholderScryDoubt" on big-endian.
  122  */
  123 static BF_word BF_magic_w[6] = {
  124     0x4F727068, 0x65616E42, 0x65686F6C,
  125     0x64657253, 0x63727944, 0x6F756274
  126 };
  127 
  128 /*
  129  * P-box and S-box tables initialized with digits of Pi.
  130  */
  131 static struct BF_ctx BF_init_state = {
  132     {
  133         {
  134             0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
  135             0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
  136             0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
  137             0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
  138             0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
  139             0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
  140             0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
  141             0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
  142             0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
  143             0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
  144             0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
  145             0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
  146             0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
  147             0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
  148             0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
  149             0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
  150             0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
  151             0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
  152             0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
  153             0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
  154             0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
  155             0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
  156             0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
  157             0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
  158             0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
  159             0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
  160             0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
  161             0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
  162             0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
  163             0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
  164             0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
  165             0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
  166             0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
  167             0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
  168             0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
  169             0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
  170             0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
  171             0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
  172             0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
  173             0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
  174             0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
  175             0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
  176             0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
  177             0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
  178             0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
  179             0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
  180             0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
  181             0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
  182             0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
  183             0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
  184             0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
  185             0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
  186             0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
  187             0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
  188             0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
  189             0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
  190             0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
  191             0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
  192             0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
  193             0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
  194             0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
  195             0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
  196             0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
  197             0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a
  198         }, {
  199             0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
  200             0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
  201             0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
  202             0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
  203             0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
  204             0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
  205             0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
  206             0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
  207             0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
  208             0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
  209             0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
  210             0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
  211             0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
  212             0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
  213             0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
  214             0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
  215             0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
  216             0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
  217             0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
  218             0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
  219             0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
  220             0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
  221             0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
  222             0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
  223             0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
  224             0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
  225             0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
  226             0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
  227             0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
  228             0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
  229             0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
  230             0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
  231             0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
  232             0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
  233             0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
  234             0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
  235             0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
  236             0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
  237             0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
  238             0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
  239             0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
  240             0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
  241             0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
  242             0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
  243             0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
  244             0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
  245             0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
  246             0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
  247             0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
  248             0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
  249             0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
  250             0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
  251             0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
  252             0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
  253             0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
  254             0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
  255             0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
  256             0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
  257             0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
  258             0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
  259             0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
  260             0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
  261             0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
  262             0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7
  263         }, {
  264             0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
  265             0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
  266             0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
  267             0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
  268             0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
  269             0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
  270             0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
  271             0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
  272             0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
  273             0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
  274             0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
  275             0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
  276             0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
  277             0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
  278             0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
  279             0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
  280             0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
  281             0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
  282             0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
  283             0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
  284             0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
  285             0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
  286             0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
  287             0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
  288             0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
  289             0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
  290             0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
  291             0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
  292             0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
  293             0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
  294             0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
  295             0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
  296             0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
  297             0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
  298             0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
  299             0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
  300             0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
  301             0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
  302             0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
  303             0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
  304             0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
  305             0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
  306             0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
  307             0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
  308             0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
  309             0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
  310             0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
  311             0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
  312             0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
  313             0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
  314             0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
  315             0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
  316             0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
  317             0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
  318             0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
  319             0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
  320             0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
  321             0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
  322             0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
  323             0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
  324             0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
  325             0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
  326             0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
  327             0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0
  328         }, {
  329             0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
  330             0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
  331             0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
  332             0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
  333             0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
  334             0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
  335             0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
  336             0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
  337             0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
  338             0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
  339             0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
  340             0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
  341             0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
  342             0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
  343             0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
  344             0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
  345             0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
  346             0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
  347             0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
  348             0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
  349             0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
  350             0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
  351             0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
  352             0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
  353             0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
  354             0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
  355             0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
  356             0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
  357             0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
  358             0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
  359             0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
  360             0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
  361             0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
  362             0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
  363             0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
  364             0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
  365             0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
  366             0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
  367             0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
  368             0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
  369             0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
  370             0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
  371             0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
  372             0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
  373             0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
  374             0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
  375             0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
  376             0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
  377             0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
  378             0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
  379             0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
  380             0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
  381             0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
  382             0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
  383             0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
  384             0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
  385             0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
  386             0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
  387             0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
  388             0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
  389             0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
  390             0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
  391             0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
  392             0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
  393         }
  394     }, {
  395         0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
  396         0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
  397         0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
  398         0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
  399         0x9216d5d9, 0x8979fb1b
  400     }
  401 };
  402 
  403 /*
  404  * Same charset, different order -- can't use the common.c table here.
  405  */
  406 unsigned char BF_atoi64[0x80] = {
  407     64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  408     64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
  409     64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 1,
  410     54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 64, 64, 64, 64, 64,
  411     64, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
  412     17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 64, 64, 64, 64, 64,
  413     64, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
  414     43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 64, 64, 64, 64, 64
  415 };
  416 
  417 #if ARCH_LITTLE_ENDIAN
  418 
  419 static void BF_swap(BF_word *x, int count)
  420 {
  421     BF_word tmp;
  422 
  423     do {
  424         tmp = *x;
  425         tmp = (tmp << 16) | (tmp >> 16);
  426         *x++ = ((tmp & 0x00FF00FF) << 8) | ((tmp >> 8) & 0x00FF00FF);
  427     } while (--count);
  428 }
  429 
  430 #else
  431 
  432 #define BF_swap(x, count)
  433 
  434 #endif
  435 
  436 #if BF_SCALE
  437 /* Architectures that can shift addresses left by 2 bits with no extra cost */
  438 #define BF_ROUND(ctx, L, R, N, tmp1, tmp2, tmp3, tmp4) \
  439     tmp1 = L & 0xFF; \
  440     tmp2 = L >> 8; \
  441     tmp2 &= 0xFF; \
  442     tmp3 = L >> 16; \
  443     tmp3 &= 0xFF; \
  444     tmp4 = L >> 24; \
  445     tmp1 = ctx.S[3][tmp1]; \
  446     tmp2 = ctx.S[2][tmp2]; \
  447     tmp3 = ctx.S[1][tmp3]; \
  448     tmp3 += ctx.S[0][tmp4]; \
  449     tmp3 ^= tmp2; \
  450     R ^= ctx.P[N + 1]; \
  451     tmp3 += tmp1; \
  452     R ^= tmp3;
  453 #else
  454 /* Architectures with no complicated addressing modes supported */
  455 #define BF_INDEX(S, i) \
  456     (*((BF_word *)(((unsigned char *)S) + (i))))
  457 #define BF_ROUND(ctx, L, R, N, tmp1, tmp2, tmp3, tmp4) \
  458     tmp1 = L & 0xFF; \
  459     tmp1 <<= 2; \
  460     tmp2 = L >> 6; \
  461     tmp2 &= 0x3FC; \
  462     tmp3 = L >> 14; \
  463     tmp3 &= 0x3FC; \
  464     tmp4 = L >> 22; \
  465     tmp4 &= 0x3FC; \
  466     tmp1 = BF_INDEX(ctx.S[3], tmp1); \
  467     tmp2 = BF_INDEX(ctx.S[2], tmp2); \
  468     tmp3 = BF_INDEX(ctx.S[1], tmp3); \
  469     tmp3 += BF_INDEX(ctx.S[0], tmp4); \
  470     tmp3 ^= tmp2; \
  471     R ^= ctx.P[N + 1]; \
  472     tmp3 += tmp1; \
  473     R ^= tmp3;
  474 #endif
  475 
  476 /*
  477  * Encrypt one block, BF_ROUNDS is hardcoded here.
  478  */
  479 #define BF_ENCRYPT(ctx, L, R) \
  480     L ^= ctx.P[0]; \
  481     BF_ROUND(ctx, L, R, 0, u1, u2, u3, u4); \
  482     BF_ROUND(ctx, R, L, 1, u1, u2, u3, u4); \
  483     BF_ROUND(ctx, L, R, 2, u1, u2, u3, u4); \
  484     BF_ROUND(ctx, R, L, 3, u1, u2, u3, u4); \
  485     BF_ROUND(ctx, L, R, 4, u1, u2, u3, u4); \
  486     BF_ROUND(ctx, R, L, 5, u1, u2, u3, u4); \
  487     BF_ROUND(ctx, L, R, 6, u1, u2, u3, u4); \
  488     BF_ROUND(ctx, R, L, 7, u1, u2, u3, u4); \
  489     BF_ROUND(ctx, L, R, 8, u1, u2, u3, u4); \
  490     BF_ROUND(ctx, R, L, 9, u1, u2, u3, u4); \
  491     BF_ROUND(ctx, L, R, 10, u1, u2, u3, u4); \
  492     BF_ROUND(ctx, R, L, 11, u1, u2, u3, u4); \
  493     BF_ROUND(ctx, L, R, 12, u1, u2, u3, u4); \
  494     BF_ROUND(ctx, R, L, 13, u1, u2, u3, u4); \
  495     BF_ROUND(ctx, L, R, 14, u1, u2, u3, u4); \
  496     BF_ROUND(ctx, R, L, 15, u1, u2, u3, u4); \
  497     u4 = R; \
  498     R = L; \
  499     L = u4 ^ ctx.P[BF_ROUNDS + 1];
  500 
  501 #if BF_ASM
  502 
  503 extern void (*BF_body)(void);
  504 
  505 #else
  506 
  507 #if BF_X2 == 3
  508 /*
  509  * Encrypt three blocks in parallel.  BF_ROUNDS is hardcoded here.
  510  */
  511 #define BF_ENCRYPT2 \
  512     L0 ^= BF_current[0].P[0]; \
  513     L1 ^= BF_current[1].P[0]; \
  514     L2 ^= BF_current[2].P[0]; \
  515     BF_ROUND(BF_current[0], L0, R0, 0, u1, u2, u3, u4); \
  516     BF_ROUND(BF_current[1], L1, R1, 0, v1, v2, v3, v4); \
  517     BF_ROUND(BF_current[2], L2, R2, 0, w1, w2, w3, w4); \
  518     BF_ROUND(BF_current[0], R0, L0, 1, u1, u2, u3, u4); \
  519     BF_ROUND(BF_current[1], R1, L1, 1, v1, v2, v3, v4); \
  520     BF_ROUND(BF_current[2], R2, L2, 1, w1, w2, w3, w4); \
  521     BF_ROUND(BF_current[0], L0, R0, 2, u1, u2, u3, u4); \
  522     BF_ROUND(BF_current[1], L1, R1, 2, v1, v2, v3, v4); \
  523     BF_ROUND(BF_current[2], L2, R2, 2, w1, w2, w3, w4); \
  524     BF_ROUND(BF_current[0], R0, L0, 3, u1, u2, u3, u4); \
  525     BF_ROUND(BF_current[1], R1, L1, 3, v1, v2, v3, v4); \
  526     BF_ROUND(BF_current[2], R2, L2, 3, w1, w2, w3, w4); \
  527     BF_ROUND(BF_current[0], L0, R0, 4, u1, u2, u3, u4); \
  528     BF_ROUND(BF_current[1], L1, R1, 4, v1, v2, v3, v4); \
  529     BF_ROUND(BF_current[2], L2, R2, 4, w1, w2, w3, w4); \
  530     BF_ROUND(BF_current[0], R0, L0, 5, u1, u2, u3, u4); \
  531     BF_ROUND(BF_current[1], R1, L1, 5, v1, v2, v3, v4); \
  532     BF_ROUND(BF_current[2], R2, L2, 5, w1, w2, w3, w4); \
  533     BF_ROUND(BF_current[0], L0, R0, 6, u1, u2, u3, u4); \
  534     BF_ROUND(BF_current[1], L1, R1, 6, v1, v2, v3, v4); \
  535     BF_ROUND(BF_current[2], L2, R2, 6, w1, w2, w3, w4); \
  536     BF_ROUND(BF_current[0], R0, L0, 7, u1, u2, u3, u4); \
  537     BF_ROUND(BF_current[1], R1, L1, 7, v1, v2, v3, v4); \
  538     BF_ROUND(BF_current[2], R2, L2, 7, w1, w2, w3, w4); \
  539     BF_ROUND(BF_current[0], L0, R0, 8, u1, u2, u3, u4); \
  540     BF_ROUND(BF_current[1], L1, R1, 8, v1, v2, v3, v4); \
  541     BF_ROUND(BF_current[2], L2, R2, 8, w1, w2, w3, w4); \
  542     BF_ROUND(BF_current[0], R0, L0, 9, u1, u2, u3, u4); \
  543     BF_ROUND(BF_current[1], R1, L1, 9, v1, v2, v3, v4); \
  544     BF_ROUND(BF_current[2], R2, L2, 9, w1, w2, w3, w4); \
  545     BF_ROUND(BF_current[0], L0, R0, 10, u1, u2, u3, u4); \
  546     BF_ROUND(BF_current[1], L1, R1, 10, v1, v2, v3, v4); \
  547     BF_ROUND(BF_current[2], L2, R2, 10, w1, w2, w3, w4); \
  548     BF_ROUND(BF_current[0], R0, L0, 11, u1, u2, u3, u4); \
  549     BF_ROUND(BF_current[1], R1, L1, 11, v1, v2, v3, v4); \
  550     BF_ROUND(BF_current[2], R2, L2, 11, w1, w2, w3, w4); \
  551     BF_ROUND(BF_current[0], L0, R0, 12, u1, u2, u3, u4); \
  552     BF_ROUND(BF_current[1], L1, R1, 12, v1, v2, v3, v4); \
  553     BF_ROUND(BF_current[2], L2, R2, 12, w1, w2, w3, w4); \
  554     BF_ROUND(BF_current[0], R0, L0, 13, u1, u2, u3, u4); \
  555     BF_ROUND(BF_current[1], R1, L1, 13, v1, v2, v3, v4); \
  556     BF_ROUND(BF_current[2], R2, L2, 13, w1, w2, w3, w4); \
  557     BF_ROUND(BF_current[0], L0, R0, 14, u1, u2, u3, u4); \
  558     BF_ROUND(BF_current[1], L1, R1, 14, v1, v2, v3, v4); \
  559     BF_ROUND(BF_current[2], L2, R2, 14, w1, w2, w3, w4); \
  560     BF_ROUND(BF_current[0], R0, L0, 15, u1, u2, u3, u4); \
  561     BF_ROUND(BF_current[1], R1, L1, 15, v1, v2, v3, v4); \
  562     BF_ROUND(BF_current[2], R2, L2, 15, w1, w2, w3, w4); \
  563     u4 = R0; \
  564     v4 = R1; \
  565     w4 = R2; \
  566     R0 = L0; \
  567     R1 = L1; \
  568     R2 = L2; \
  569     L0 = u4 ^ BF_current[0].P[BF_ROUNDS + 1]; \
  570     L1 = v4 ^ BF_current[1].P[BF_ROUNDS + 1]; \
  571     L2 = w4 ^ BF_current[2].P[BF_ROUNDS + 1];
  572 
  573 #define BF_body() \
  574     L0 = R0 = L1 = R1 = L2 = R2 = 0; \
  575     ptr = BF_current[0].P; \
  576     do { \
  577         BF_ENCRYPT2; \
  578         *ptr = L0; \
  579         *(ptr + 1) = R0; \
  580         *(ptr + (BF_current[1].P - BF_current[0].P)) = L1; \
  581         *(ptr + (BF_current[1].P - BF_current[0].P) + 1) = R1; \
  582         *(ptr + (BF_current[2].P - BF_current[0].P)) = L2; \
  583         *(ptr + (BF_current[2].P - BF_current[0].P) + 1) = R2; \
  584         ptr += 2; \
  585     } while (ptr < &BF_current[0].P[BF_ROUNDS + 2]); \
  586 \
  587     ptr = BF_current[0].S[0]; \
  588     do { \
  589         ptr += 2; \
  590         BF_ENCRYPT2; \
  591         *(ptr - 2) = L0; \
  592         *(ptr - 1) = R0; \
  593         *(ptr - 2 + (BF_current[1].S[0] - BF_current[0].S[0])) = L1; \
  594         *(ptr - 1 + (BF_current[1].S[0] - BF_current[0].S[0])) = R1; \
  595         *(ptr - 2 + (BF_current[2].S[0] - BF_current[0].S[0])) = L2; \
  596         *(ptr - 1 + (BF_current[2].S[0] - BF_current[0].S[0])) = R2; \
  597     } while (ptr < &BF_current[0].S[3][0xFF]);
  598 #elif BF_X2
  599 /*
  600  * Encrypt two blocks in parallel.  BF_ROUNDS is hardcoded here.
  601  */
  602 #define BF_ENCRYPT2 \
  603     L0 ^= BF_current[0].P[0]; \
  604     L1 ^= BF_current[1].P[0]; \
  605     BF_ROUND(BF_current[0], L0, R0, 0, u1, u2, u3, u4); \
  606     BF_ROUND(BF_current[1], L1, R1, 0, v1, v2, v3, v4); \
  607     BF_ROUND(BF_current[0], R0, L0, 1, u1, u2, u3, u4); \
  608     BF_ROUND(BF_current[1], R1, L1, 1, v1, v2, v3, v4); \
  609     BF_ROUND(BF_current[0], L0, R0, 2, u1, u2, u3, u4); \
  610     BF_ROUND(BF_current[1], L1, R1, 2, v1, v2, v3, v4); \
  611     BF_ROUND(BF_current[0], R0, L0, 3, u1, u2, u3, u4); \
  612     BF_ROUND(BF_current[1], R1, L1, 3, v1, v2, v3, v4); \
  613     BF_ROUND(BF_current[0], L0, R0, 4, u1, u2, u3, u4); \
  614     BF_ROUND(BF_current[1], L1, R1, 4, v1, v2, v3, v4); \
  615     BF_ROUND(BF_current[0], R0, L0, 5, u1, u2, u3, u4); \
  616     BF_ROUND(BF_current[1], R1, L1, 5, v1, v2, v3, v4); \
  617     BF_ROUND(BF_current[0], L0, R0, 6, u1, u2, u3, u4); \
  618     BF_ROUND(BF_current[1], L1, R1, 6, v1, v2, v3, v4); \
  619     BF_ROUND(BF_current[0], R0, L0, 7, u1, u2, u3, u4); \
  620     BF_ROUND(BF_current[1], R1, L1, 7, v1, v2, v3, v4); \
  621     BF_ROUND(BF_current[0], L0, R0, 8, u1, u2, u3, u4); \
  622     BF_ROUND(BF_current[1], L1, R1, 8, v1, v2, v3, v4); \
  623     BF_ROUND(BF_current[0], R0, L0, 9, u1, u2, u3, u4); \
  624     BF_ROUND(BF_current[1], R1, L1, 9, v1, v2, v3, v4); \
  625     BF_ROUND(BF_current[0], L0, R0, 10, u1, u2, u3, u4); \
  626     BF_ROUND(BF_current[1], L1, R1, 10, v1, v2, v3, v4); \
  627     BF_ROUND(BF_current[0], R0, L0, 11, u1, u2, u3, u4); \
  628     BF_ROUND(BF_current[1], R1, L1, 11, v1, v2, v3, v4); \
  629     BF_ROUND(BF_current[0], L0, R0, 12, u1, u2, u3, u4); \
  630     BF_ROUND(BF_current[1], L1, R1, 12, v1, v2, v3, v4); \
  631     BF_ROUND(BF_current[0], R0, L0, 13, u1, u2, u3, u4); \
  632     BF_ROUND(BF_current[1], R1, L1, 13, v1, v2, v3, v4); \
  633     BF_ROUND(BF_current[0], L0, R0, 14, u1, u2, u3, u4); \
  634     BF_ROUND(BF_current[1], L1, R1, 14, v1, v2, v3, v4); \
  635     BF_ROUND(BF_current[0], R0, L0, 15, u1, u2, u3, u4); \
  636     BF_ROUND(BF_current[1], R1, L1, 15, v1, v2, v3, v4); \
  637     u4 = R0; \
  638     v4 = R1; \
  639     R0 = L0; \
  640     R1 = L1; \
  641     L0 = u4 ^ BF_current[0].P[BF_ROUNDS + 1]; \
  642     L1 = v4 ^ BF_current[1].P[BF_ROUNDS + 1];
  643 
  644 #define BF_body() \
  645     L0 = R0 = L1 = R1 = 0; \
  646     ptr = BF_current[0].P; \
  647     do { \
  648         BF_ENCRYPT2; \
  649         *ptr = L0; \
  650         *(ptr + 1) = R0; \
  651         *(ptr + (BF_current[1].P - BF_current[0].P)) = L1; \
  652         *(ptr + (BF_current[1].P - BF_current[0].P) + 1) = R1; \
  653         ptr += 2; \
  654     } while (ptr < &BF_current[0].P[BF_ROUNDS + 2]); \
  655 \
  656     ptr = BF_current[0].S[0]; \
  657     do { \
  658         ptr += 2; \
  659         BF_ENCRYPT2; \
  660         *(ptr - 2) = L0; \
  661         *(ptr - 1) = R0; \
  662         *(ptr - 2 + (BF_current[1].S[0] - BF_current[0].S[0])) = L1; \
  663         *(ptr - 1 + (BF_current[1].S[0] - BF_current[0].S[0])) = R1; \
  664     } while (ptr < &BF_current[0].S[3][0xFF]);
  665 #else
  666 #define BF_body() \
  667     L0 = R0 = 0; \
  668     ptr = BF_current.P; \
  669     do { \
  670         BF_ENCRYPT(BF_current, L0, R0); \
  671         *ptr = L0; \
  672         *(ptr + 1) = R0; \
  673         ptr += 2; \
  674     } while (ptr < &BF_current.P[BF_ROUNDS + 2]); \
  675 \
  676     ptr = BF_current.S[0]; \
  677     do { \
  678         ptr += 2; \
  679         BF_ENCRYPT(BF_current, L0, R0); \
  680         *(ptr - 2) = L0; \
  681         *(ptr - 1) = R0; \
  682     } while (ptr < &BF_current.S[3][0xFF]);
  683 #endif
  684 
  685 #endif
  686 
  687 void BF_std_set_key(char *key, int index, int sign_extension_bug)
  688 {
  689     char *ptr = key;
  690     int i, j;
  691     BF_word tmp;
  692 
  693     for (i = 0; i < BF_ROUNDS + 2; i++) {
  694         tmp = 0;
  695         for (j = 0; j < 4; j++) {
  696             tmp <<= 8;
  697             if (sign_extension_bug)
  698                 tmp |= (int)(signed char)*ptr;
  699             else
  700                 tmp |= (unsigned char)*ptr;
  701 
  702             if (!*ptr) ptr = key; else ptr++;
  703         }
  704 
  705         BF_exp_key INDEX[i] = tmp;
  706         BF_init_key INDEX[i] = BF_init_state.P[i] ^ tmp;
  707     }
  708 }
  709 
  710 void BF_std_crypt(BF_salt *salt, int n)
  711 {
  712 #if BF_mt > 1
  713     int t;
  714 #endif
  715 
  716 #if BF_mt > 1 && defined(_OPENMP)
  717 #pragma omp parallel for default(none) private(t) shared(n, BF_init_state, BF_init_key, BF_exp_key, salt, BF_magic_w, BF_out)
  718 #endif
  719     for_each_t() {
  720 #if BF_mt > 1
  721 #if BF_X2 == 3
  722         struct BF_ctx BF_current[3];
  723 #elif BF_X2
  724         struct BF_ctx BF_current[2];
  725 #else
  726         struct BF_ctx BF_current;
  727 #endif
  728 #endif
  729 
  730         BF_word L0, R0;
  731         BF_word u1, u2, u3, u4;
  732 #if BF_X2
  733         BF_word L1, R1;
  734         BF_word v1, v2, v3, v4;
  735 #if BF_X2 == 3
  736         BF_word L2, R2;
  737         BF_word w1, w2, w3, w4;
  738 #endif
  739 #endif
  740         BF_word *ptr;
  741         BF_word count;
  742 #if BF_N > 1
  743         int index;
  744 #endif
  745 #if BF_X2 == 3 && BF_mt > 1
  746         int lindex;
  747 #endif
  748 
  749         for_each_ti() {
  750             int i;
  751 
  752             memcpy(BF_current INDEX2.S,
  753                 BF_init_state.S, sizeof(BF_current INDEX2.S));
  754             memcpy(BF_current INDEX2.P,
  755                 BF_init_key INDEX, sizeof(BF_current INDEX2.P));
  756 
  757             L0 = R0 = 0;
  758             for (i = 0; i < BF_ROUNDS + 2; i += 2) {
  759                 L0 ^= salt->salt[i & 2];
  760                 R0 ^= salt->salt[(i & 2) + 1];
  761                 BF_ENCRYPT(BF_current INDEX2, L0, R0);
  762                 BF_current INDEX2.P[i] = L0;
  763                 BF_current INDEX2.P[i + 1] = R0;
  764             }
  765 
  766             ptr = BF_current INDEX2.S[0];
  767             do {
  768                 ptr += 4;
  769                 L0 ^= salt->salt[(BF_ROUNDS + 2) & 3];
  770                 R0 ^= salt->salt[(BF_ROUNDS + 3) & 3];
  771                 BF_ENCRYPT(BF_current INDEX2, L0, R0);
  772                 *(ptr - 4) = L0;
  773                 *(ptr - 3) = R0;
  774 
  775                 L0 ^= salt->salt[(BF_ROUNDS + 4) & 3];
  776                 R0 ^= salt->salt[(BF_ROUNDS + 5) & 3];
  777                 BF_ENCRYPT(BF_current INDEX2, L0, R0);
  778                 *(ptr - 2) = L0;
  779                 *(ptr - 1) = R0;
  780             } while (ptr < &BF_current INDEX2.S[3][0xFF]);
  781         }
  782 
  783         count = 1 << salt->rounds;
  784         do {
  785             for_each_ti() {
  786                 BF_current INDEX2.P[0] ^= BF_exp_key INDEX[0];
  787                 BF_current INDEX2.P[1] ^= BF_exp_key INDEX[1];
  788                 BF_current INDEX2.P[2] ^= BF_exp_key INDEX[2];
  789                 BF_current INDEX2.P[3] ^= BF_exp_key INDEX[3];
  790                 BF_current INDEX2.P[4] ^= BF_exp_key INDEX[4];
  791                 BF_current INDEX2.P[5] ^= BF_exp_key INDEX[5];
  792                 BF_current INDEX2.P[6] ^= BF_exp_key INDEX[6];
  793                 BF_current INDEX2.P[7] ^= BF_exp_key INDEX[7];
  794                 BF_current INDEX2.P[8] ^= BF_exp_key INDEX[8];
  795                 BF_current INDEX2.P[9] ^= BF_exp_key INDEX[9];
  796                 BF_current INDEX2.P[10] ^= BF_exp_key INDEX[10];
  797                 BF_current INDEX2.P[11] ^= BF_exp_key INDEX[11];
  798                 BF_current INDEX2.P[12] ^= BF_exp_key INDEX[12];
  799                 BF_current INDEX2.P[13] ^= BF_exp_key INDEX[13];
  800                 BF_current INDEX2.P[14] ^= BF_exp_key INDEX[14];
  801                 BF_current INDEX2.P[15] ^= BF_exp_key INDEX[15];
  802                 BF_current INDEX2.P[16] ^= BF_exp_key INDEX[16];
  803                 BF_current INDEX2.P[17] ^= BF_exp_key INDEX[17];
  804             }
  805 
  806             BF_body();
  807 
  808             u1 = salt->salt[0];
  809             u2 = salt->salt[1];
  810             u3 = salt->salt[2];
  811             u4 = salt->salt[3];
  812             for_each_ti() {
  813                 BF_current INDEX2.P[0] ^= u1;
  814                 BF_current INDEX2.P[1] ^= u2;
  815                 BF_current INDEX2.P[2] ^= u3;
  816                 BF_current INDEX2.P[3] ^= u4;
  817                 BF_current INDEX2.P[4] ^= u1;
  818                 BF_current INDEX2.P[5] ^= u2;
  819                 BF_current INDEX2.P[6] ^= u3;
  820                 BF_current INDEX2.P[7] ^= u4;
  821                 BF_current INDEX2.P[8] ^= u1;
  822                 BF_current INDEX2.P[9] ^= u2;
  823                 BF_current INDEX2.P[10] ^= u3;
  824                 BF_current INDEX2.P[11] ^= u4;
  825                 BF_current INDEX2.P[12] ^= u1;
  826                 BF_current INDEX2.P[13] ^= u2;
  827                 BF_current INDEX2.P[14] ^= u3;
  828                 BF_current INDEX2.P[15] ^= u4;
  829                 BF_current INDEX2.P[16] ^= u1;
  830                 BF_current INDEX2.P[17] ^= u2;
  831             }
  832 
  833             BF_body();
  834         } while (--count);
  835 
  836 #if BF_mt == 1
  837         for_each_ti() {
  838             L0 = BF_magic_w[0];
  839             R0 = BF_magic_w[1];
  840 
  841             count = 64;
  842             do {
  843                 BF_ENCRYPT(BF_current INDEX, L0, R0);
  844             } while (--count);
  845 
  846             BF_out INDEX0[0] = L0;
  847             BF_out INDEX0[1] = R0;
  848         }
  849 #else
  850         for_each_ti() {
  851             BF_word L, R;
  852             BF_word u1, u2, u3, u4;
  853             BF_word count;
  854             int i;
  855 
  856             memcpy(&BF_out[index], &BF_magic_w,
  857                 sizeof(BF_out[index]));
  858 
  859             count = 64;
  860             do
  861             for (i = 0; i < 6; i += 2) {
  862                 L = BF_out[index][i];
  863                 R = BF_out[index][i + 1];
  864                 BF_ENCRYPT(BF_current INDEX2, L, R);
  865                 BF_out[index][i] = L;
  866                 BF_out[index][i + 1] = R;
  867             } while (--count);
  868 
  869 /* This has to be bug-compatible with the original implementation :-) */
  870             BF_out[index][5] &= ~(BF_word)0xFF;
  871         }
  872 #endif
  873     }
  874 }
  875 
  876 #if BF_mt == 1
  877 void BF_std_crypt_exact(int index)
  878 {
  879     BF_word L, R;
  880     BF_word u1, u2, u3, u4;
  881     BF_word count;
  882     int i;
  883 
  884     memcpy(&BF_out[index][2], &BF_magic_w[2], sizeof(BF_word) * 4);
  885 
  886     count = 64;
  887     do
  888     for (i = 2; i < 6; i += 2) {
  889         L = BF_out[index][i];
  890         R = BF_out[index][i + 1];
  891         BF_ENCRYPT(BF_current INDEX, L, R);
  892         BF_out[index][i] = L;
  893         BF_out[index][i + 1] = R;
  894     } while (--count);
  895 
  896 /* This has to be bug-compatible with the original implementation :-) */
  897     BF_out[index][5] &= ~(BF_word)0xFF;
  898 }
  899 #endif
  900 
  901 /*
  902  * I'm not doing any error checking in the routines below since the
  903  * ciphertext should have already been checked to be fmt_BF.valid().
  904  */
  905 
  906 static void BF_decode(BF_word *dst, char *src, int size)
  907 {
  908     unsigned char *dptr = (unsigned char *)dst;
  909     unsigned char *end = dptr + size;
  910     unsigned char *sptr = (unsigned char *)src;
  911     unsigned int c1, c2, c3, c4;
  912 
  913     do {
  914         c1 = BF_atoi64[ARCH_INDEX(*sptr++)];
  915         c2 = BF_atoi64[ARCH_INDEX(*sptr++)];
  916         *dptr++ = (c1 << 2) | ((c2 & 0x30) >> 4);
  917         if (dptr >= end) break;
  918 
  919         c3 = BF_atoi64[ARCH_INDEX(*sptr++)];
  920         *dptr++ = ((c2 & 0x0F) << 4) | ((c3 & 0x3C) >> 2);
  921         if (dptr >= end) break;
  922 
  923         c4 = BF_atoi64[ARCH_INDEX(*sptr++)];
  924         *dptr++ = ((c3 & 0x03) << 6) | c4;
  925     } while (dptr < end);
  926 }
  927 
  928 void *BF_std_get_salt(char *ciphertext)
  929 {
  930     static BF_salt salt;
  931 
  932     BF_decode(salt.salt, &ciphertext[7], 16);
  933     BF_swap(salt.salt, 4);
  934 
  935     salt.rounds = atoi(&ciphertext[4]);
  936 
  937 /*
  938  * 'a' is ambiguous due to past bugs, but for password cracking we treat it the
  939  * same as 'y' (if a hash is known to be affected by the sign extension bug, it
  940  * should be explicitly marked with 'x' instead of 'a').
  941  *
  942  * 'b' is in fact the same as 'y'.
  943  */
  944     if (ciphertext[2] == 'a' || ciphertext[2] == 'b')
  945         salt.subtype = 'y';
  946     else
  947         salt.subtype = ciphertext[2];
  948 
  949     return &salt;
  950 }
  951 
  952 void *BF_std_get_binary(char *ciphertext)
  953 {
  954     static BF_binary binary;
  955 
  956     binary[5] = 0;
  957     BF_decode(binary, &ciphertext[29], 23);
  958     BF_swap(binary, 6);
  959     binary[5] &= ~(BF_word)0xFF;
  960 
  961     return &binary;
  962 }