001    /*
002     * Licensed to the Apache Software Foundation (ASF) under one or more
003     * contributor license agreements.  See the NOTICE file distributed with
004     * this work for additional information regarding copyright ownership.
005     * The ASF licenses this file to You under the Apache License, Version 2.0
006     * (the "License"); you may not use this file except in compliance with
007     * the License.  You may obtain a copy of the License at
008     *
009     *      http://www.apache.org/licenses/LICENSE-2.0
010     *
011     * Unless required by applicable law or agreed to in writing, software
012     * distributed under the License is distributed on an "AS IS" BASIS,
013     * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014     * See the License for the specific language governing permissions and
015     * limitations under the License.
016     */
017    package org.apache.commons.codec.digest;
018    
019    import java.util.Random;
020    
021    import org.apache.commons.codec.Charsets;
022    
023    /**
024     * Unix crypt(3) algorithm implementation.
025     * <p>
026     * This class only implements the traditional 56 bit DES based algorithm. Please use DigestUtils.crypt() for a method
027     * that distinguishes between all the algorithms supported in the current glibc's crypt().
028     * <p>
029     * The Java implementation was taken from the JetSpeed Portal project (see
030     * org.apache.jetspeed.services.security.ldap.UnixCrypt).
031     * <p>
032     * This class is slightly incompatible if the given salt contains characters that are not part of the allowed range
033     * [a-zA-Z0-9./].
034     * <p>
035     * This class is immutable and thread-safe.
036     *
037     * @version $Id: UnixCrypt.html 889935 2013-12-11 05:05:13Z ggregory $
038     * @since 1.7
039     */
040    public class UnixCrypt {
041    
042        private static final int CON_SALT[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
043                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 5, 6,
044                7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
045                34, 35, 36, 37, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53,
046                54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 0, 0, 0, 0, 0 };
047    
048        private static final int COV2CHAR[] = { 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 65, 66, 67, 68, 69, 70,
049                71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 97, 98, 99, 100, 101, 102,
050                103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122 };
051    
052        private static final char SALT_CHARS[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789./"
053                .toCharArray();
054    
055        private static final boolean SHIFT2[] = { false, false, true, true, true, true, true, true, false, true, true,
056                true, true, true, true, false };
057    
058        private static final int SKB[][] = {
059                { 0, 16, 0x20000000, 0x20000010, 0x10000, 0x10010, 0x20010000, 0x20010010, 2048, 2064, 0x20000800,
060                        0x20000810, 0x10800, 0x10810, 0x20010800, 0x20010810, 32, 48, 0x20000020, 0x20000030, 0x10020,
061                        0x10030, 0x20010020, 0x20010030, 2080, 2096, 0x20000820, 0x20000830, 0x10820, 0x10830, 0x20010820,
062                        0x20010830, 0x80000, 0x80010, 0x20080000, 0x20080010, 0x90000, 0x90010, 0x20090000, 0x20090010,
063                        0x80800, 0x80810, 0x20080800, 0x20080810, 0x90800, 0x90810, 0x20090800, 0x20090810, 0x80020,
064                        0x80030, 0x20080020, 0x20080030, 0x90020, 0x90030, 0x20090020, 0x20090030, 0x80820, 0x80830,
065                        0x20080820, 0x20080830, 0x90820, 0x90830, 0x20090820, 0x20090830 },
066                { 0, 0x2000000, 8192, 0x2002000, 0x200000, 0x2200000, 0x202000, 0x2202000, 4, 0x2000004, 8196, 0x2002004,
067                        0x200004, 0x2200004, 0x202004, 0x2202004, 1024, 0x2000400, 9216, 0x2002400, 0x200400, 0x2200400,
068                        0x202400, 0x2202400, 1028, 0x2000404, 9220, 0x2002404, 0x200404, 0x2200404, 0x202404, 0x2202404,
069                        0x10000000, 0x12000000, 0x10002000, 0x12002000, 0x10200000, 0x12200000, 0x10202000, 0x12202000,
070                        0x10000004, 0x12000004, 0x10002004, 0x12002004, 0x10200004, 0x12200004, 0x10202004, 0x12202004,
071                        0x10000400, 0x12000400, 0x10002400, 0x12002400, 0x10200400, 0x12200400, 0x10202400, 0x12202400,
072                        0x10000404, 0x12000404, 0x10002404, 0x12002404, 0x10200404, 0x12200404, 0x10202404, 0x12202404 },
073                { 0, 1, 0x40000, 0x40001, 0x1000000, 0x1000001, 0x1040000, 0x1040001, 2, 3, 0x40002, 0x40003, 0x1000002,
074                        0x1000003, 0x1040002, 0x1040003, 512, 513, 0x40200, 0x40201, 0x1000200, 0x1000201, 0x1040200,
075                        0x1040201, 514, 515, 0x40202, 0x40203, 0x1000202, 0x1000203, 0x1040202, 0x1040203, 0x8000000,
076                        0x8000001, 0x8040000, 0x8040001, 0x9000000, 0x9000001, 0x9040000, 0x9040001, 0x8000002, 0x8000003,
077                        0x8040002, 0x8040003, 0x9000002, 0x9000003, 0x9040002, 0x9040003, 0x8000200, 0x8000201, 0x8040200,
078                        0x8040201, 0x9000200, 0x9000201, 0x9040200, 0x9040201, 0x8000202, 0x8000203, 0x8040202, 0x8040203,
079                        0x9000202, 0x9000203, 0x9040202, 0x9040203 },
080                { 0, 0x100000, 256, 0x100100, 8, 0x100008, 264, 0x100108, 4096, 0x101000, 4352, 0x101100, 4104, 0x101008,
081                        4360, 0x101108, 0x4000000, 0x4100000, 0x4000100, 0x4100100, 0x4000008, 0x4100008, 0x4000108,
082                        0x4100108, 0x4001000, 0x4101000, 0x4001100, 0x4101100, 0x4001008, 0x4101008, 0x4001108, 0x4101108,
083                        0x20000, 0x120000, 0x20100, 0x120100, 0x20008, 0x120008, 0x20108, 0x120108, 0x21000, 0x121000,
084                        0x21100, 0x121100, 0x21008, 0x121008, 0x21108, 0x121108, 0x4020000, 0x4120000, 0x4020100,
085                        0x4120100, 0x4020008, 0x4120008, 0x4020108, 0x4120108, 0x4021000, 0x4121000, 0x4021100, 0x4121100,
086                        0x4021008, 0x4121008, 0x4021108, 0x4121108 },
087                { 0, 0x10000000, 0x10000, 0x10010000, 4, 0x10000004, 0x10004, 0x10010004, 0x20000000, 0x30000000,
088                        0x20010000, 0x30010000, 0x20000004, 0x30000004, 0x20010004, 0x30010004, 0x100000, 0x10100000,
089                        0x110000, 0x10110000, 0x100004, 0x10100004, 0x110004, 0x10110004, 0x20100000, 0x30100000,
090                        0x20110000, 0x30110000, 0x20100004, 0x30100004, 0x20110004, 0x30110004, 4096, 0x10001000, 0x11000,
091                        0x10011000, 4100, 0x10001004, 0x11004, 0x10011004, 0x20001000, 0x30001000, 0x20011000, 0x30011000,
092                        0x20001004, 0x30001004, 0x20011004, 0x30011004, 0x101000, 0x10101000, 0x111000, 0x10111000,
093                        0x101004, 0x10101004, 0x111004, 0x10111004, 0x20101000, 0x30101000, 0x20111000, 0x30111000,
094                        0x20101004, 0x30101004, 0x20111004, 0x30111004 },
095                { 0, 0x8000000, 8, 0x8000008, 1024, 0x8000400, 1032, 0x8000408, 0x20000, 0x8020000, 0x20008, 0x8020008,
096                        0x20400, 0x8020400, 0x20408, 0x8020408, 1, 0x8000001, 9, 0x8000009, 1025, 0x8000401, 1033,
097                        0x8000409, 0x20001, 0x8020001, 0x20009, 0x8020009, 0x20401, 0x8020401, 0x20409, 0x8020409,
098                        0x2000000, 0xa000000, 0x2000008, 0xa000008, 0x2000400, 0xa000400, 0x2000408, 0xa000408, 0x2020000,
099                        0xa020000, 0x2020008, 0xa020008, 0x2020400, 0xa020400, 0x2020408, 0xa020408, 0x2000001, 0xa000001,
100                        0x2000009, 0xa000009, 0x2000401, 0xa000401, 0x2000409, 0xa000409, 0x2020001, 0xa020001, 0x2020009,
101                        0xa020009, 0x2020401, 0xa020401, 0x2020409, 0xa020409 },
102                { 0, 256, 0x80000, 0x80100, 0x1000000, 0x1000100, 0x1080000, 0x1080100, 16, 272, 0x80010, 0x80110,
103                        0x1000010, 0x1000110, 0x1080010, 0x1080110, 0x200000, 0x200100, 0x280000, 0x280100, 0x1200000,
104                        0x1200100, 0x1280000, 0x1280100, 0x200010, 0x200110, 0x280010, 0x280110, 0x1200010, 0x1200110,
105                        0x1280010, 0x1280110, 512, 768, 0x80200, 0x80300, 0x1000200, 0x1000300, 0x1080200, 0x1080300, 528,
106                        784, 0x80210, 0x80310, 0x1000210, 0x1000310, 0x1080210, 0x1080310, 0x200200, 0x200300, 0x280200,
107                        0x280300, 0x1200200, 0x1200300, 0x1280200, 0x1280300, 0x200210, 0x200310, 0x280210, 0x280310,
108                        0x1200210, 0x1200310, 0x1280210, 0x1280310 },
109                { 0, 0x4000000, 0x40000, 0x4040000, 2, 0x4000002, 0x40002, 0x4040002, 8192, 0x4002000, 0x42000, 0x4042000,
110                        8194, 0x4002002, 0x42002, 0x4042002, 32, 0x4000020, 0x40020, 0x4040020, 34, 0x4000022, 0x40022,
111                        0x4040022, 8224, 0x4002020, 0x42020, 0x4042020, 8226, 0x4002022, 0x42022, 0x4042022, 2048,
112                        0x4000800, 0x40800, 0x4040800, 2050, 0x4000802, 0x40802, 0x4040802, 10240, 0x4002800, 0x42800,
113                        0x4042800, 10242, 0x4002802, 0x42802, 0x4042802, 2080, 0x4000820, 0x40820, 0x4040820, 2082,
114                        0x4000822, 0x40822, 0x4040822, 10272, 0x4002820, 0x42820, 0x4042820, 10274, 0x4002822, 0x42822,
115                        0x4042822 } };
116    
117        private static final int SPTRANS[][] = {
118                { 0x820200, 0x20000, 0x80800000, 0x80820200, 0x800000, 0x80020200, 0x80020000, 0x80800000, 0x80020200,
119                        0x820200, 0x820000, 0x80000200, 0x80800200, 0x800000, 0, 0x80020000, 0x20000, 0x80000000,
120                        0x800200, 0x20200, 0x80820200, 0x820000, 0x80000200, 0x800200, 0x80000000, 512, 0x20200,
121                        0x80820000, 512, 0x80800200, 0x80820000, 0, 0, 0x80820200, 0x800200, 0x80020000, 0x820200,
122                        0x20000, 0x80000200, 0x800200, 0x80820000, 512, 0x20200, 0x80800000, 0x80020200, 0x80000000,
123                        0x80800000, 0x820000, 0x80820200, 0x20200, 0x820000, 0x80800200, 0x800000, 0x80000200, 0x80020000,
124                        0, 0x20000, 0x800000, 0x80800200, 0x820200, 0x80000000, 0x80820000, 512, 0x80020200 },
125                { 0x10042004, 0, 0x42000, 0x10040000, 0x10000004, 8196, 0x10002000, 0x42000, 8192, 0x10040004, 4,
126                        0x10002000, 0x40004, 0x10042000, 0x10040000, 4, 0x40000, 0x10002004, 0x10040004, 8192, 0x42004,
127                        0x10000000, 0, 0x40004, 0x10002004, 0x42004, 0x10042000, 0x10000004, 0x10000000, 0x40000, 8196,
128                        0x10042004, 0x40004, 0x10042000, 0x10002000, 0x42004, 0x10042004, 0x40004, 0x10000004, 0,
129                        0x10000000, 8196, 0x40000, 0x10040004, 8192, 0x10000000, 0x42004, 0x10002004, 0x10042000, 8192, 0,
130                        0x10000004, 4, 0x10042004, 0x42000, 0x10040000, 0x10040004, 0x40000, 8196, 0x10002000, 0x10002004,
131                        4, 0x10040000, 0x42000 },
132                { 0x41000000, 0x1010040, 64, 0x41000040, 0x40010000, 0x1000000, 0x41000040, 0x10040, 0x1000040, 0x10000,
133                        0x1010000, 0x40000000, 0x41010040, 0x40000040, 0x40000000, 0x41010000, 0, 0x40010000, 0x1010040,
134                        64, 0x40000040, 0x41010040, 0x10000, 0x41000000, 0x41010000, 0x1000040, 0x40010040, 0x1010000,
135                        0x10040, 0, 0x1000000, 0x40010040, 0x1010040, 64, 0x40000000, 0x10000, 0x40000040, 0x40010000,
136                        0x1010000, 0x41000040, 0, 0x1010040, 0x10040, 0x41010000, 0x40010000, 0x1000000, 0x41010040,
137                        0x40000000, 0x40010040, 0x41000000, 0x1000000, 0x41010040, 0x10000, 0x1000040, 0x41000040,
138                        0x10040, 0x1000040, 0, 0x41010000, 0x40000040, 0x41000000, 0x40010040, 64, 0x1010000 },
139                { 0x100402, 0x4000400, 2, 0x4100402, 0, 0x4100000, 0x4000402, 0x100002, 0x4100400, 0x4000002, 0x4000000,
140                        1026, 0x4000002, 0x100402, 0x100000, 0x4000000, 0x4100002, 0x100400, 1024, 2, 0x100400, 0x4000402,
141                        0x4100000, 1024, 1026, 0, 0x100002, 0x4100400, 0x4000400, 0x4100002, 0x4100402, 0x100000,
142                        0x4100002, 1026, 0x100000, 0x4000002, 0x100400, 0x4000400, 2, 0x4100000, 0x4000402, 0, 1024,
143                        0x100002, 0, 0x4100002, 0x4100400, 1024, 0x4000000, 0x4100402, 0x100402, 0x100000, 0x4100402, 2,
144                        0x4000400, 0x100402, 0x100002, 0x100400, 0x4100000, 0x4000402, 1026, 0x4000000, 0x4000002,
145                        0x4100400 },
146                { 0x2000000, 16384, 256, 0x2004108, 0x2004008, 0x2000100, 16648, 0x2004000, 16384, 8, 0x2000008, 16640,
147                        0x2000108, 0x2004008, 0x2004100, 0, 16640, 0x2000000, 16392, 264, 0x2000100, 16648, 0, 0x2000008,
148                        8, 0x2000108, 0x2004108, 16392, 0x2004000, 256, 264, 0x2004100, 0x2004100, 0x2000108, 16392,
149                        0x2004000, 16384, 8, 0x2000008, 0x2000100, 0x2000000, 16640, 0x2004108, 0, 16648, 0x2000000, 256,
150                        16392, 0x2000108, 256, 0, 0x2004108, 0x2004008, 0x2004100, 264, 16384, 16640, 0x2004008,
151                        0x2000100, 264, 8, 16648, 0x2004000, 0x2000008 },
152                { 0x20000010, 0x80010, 0, 0x20080800, 0x80010, 2048, 0x20000810, 0x80000, 2064, 0x20080810, 0x80800,
153                        0x20000000, 0x20000800, 0x20000010, 0x20080000, 0x80810, 0x80000, 0x20000810, 0x20080010, 0, 2048,
154                        16, 0x20080800, 0x20080010, 0x20080810, 0x20080000, 0x20000000, 2064, 16, 0x80800, 0x80810,
155                        0x20000800, 2064, 0x20000000, 0x20000800, 0x80810, 0x20080800, 0x80010, 0, 0x20000800, 0x20000000,
156                        2048, 0x20080010, 0x80000, 0x80010, 0x20080810, 0x80800, 16, 0x20080810, 0x80800, 0x80000,
157                        0x20000810, 0x20000010, 0x20080000, 0x80810, 0, 2048, 0x20000010, 0x20000810, 0x20080800,
158                        0x20080000, 2064, 16, 0x20080010 },
159                { 4096, 128, 0x400080, 0x400001, 0x401081, 4097, 4224, 0, 0x400000, 0x400081, 129, 0x401000, 1, 0x401080,
160                        0x401000, 129, 0x400081, 4096, 4097, 0x401081, 0, 0x400080, 0x400001, 4224, 0x401001, 4225,
161                        0x401080, 1, 4225, 0x401001, 128, 0x400000, 4225, 0x401000, 0x401001, 129, 4096, 128, 0x400000,
162                        0x401001, 0x400081, 4225, 4224, 0, 128, 0x400001, 1, 0x400080, 0, 0x400081, 0x400080, 4224, 129,
163                        4096, 0x401081, 0x400000, 0x401080, 1, 4097, 0x401081, 0x400001, 0x401080, 0x401000, 4097 },
164                { 0x8200020, 0x8208000, 32800, 0, 0x8008000, 0x200020, 0x8200000, 0x8208020, 32, 0x8000000, 0x208000,
165                        32800, 0x208020, 0x8008020, 0x8000020, 0x8200000, 32768, 0x208020, 0x200020, 0x8008000, 0x8208020,
166                        0x8000020, 0, 0x208000, 0x8000000, 0x200000, 0x8008020, 0x8200020, 0x200000, 32768, 0x8208000, 32,
167                        0x200000, 32768, 0x8000020, 0x8208020, 32800, 0x8000000, 0, 0x208000, 0x8200020, 0x8008020,
168                        0x8008000, 0x200020, 0x8208000, 32, 0x200020, 0x8008000, 0x8208020, 0x200000, 0x8200000,
169                        0x8000020, 0x208000, 32800, 0x8008020, 0x8200000, 32, 0x8208000, 0x208020, 0, 0x8000000,
170                        0x8200020, 32768, 0x208020 } };
171    
172        /**
173         * Generates a crypt(3) compatible hash using the DES algorithm.
174         * <p>
175         * As no salt is given, a random one will be used.
176         *
177         * @param original
178         *            plaintext password
179         * @return a 13 character string starting with the salt string
180         */
181        public static String crypt(byte[] original) {
182            return crypt(original, null);
183        }
184    
185        /**
186         * Generates a crypt(3) compatible hash using the DES algorithm.
187         * <p>
188         * Using unspecified characters as salt results incompatible hash values.
189         *
190         * @param original
191         *            plaintext password
192         * @param salt
193         *            a two character string drawn from [a-zA-Z0-9./] or null for a random one
194         * @return a 13 character string starting with the salt string
195         * @throws IllegalArgumentException
196         *             if the salt does not match the allowed pattern
197         */
198        public static String crypt(byte[] original, String salt) {
199            if (salt == null) {
200                Random randomGenerator = new Random();
201                int numSaltChars = SALT_CHARS.length;
202                salt = "" + SALT_CHARS[randomGenerator.nextInt(numSaltChars)] +
203                        SALT_CHARS[randomGenerator.nextInt(numSaltChars)];
204            } else if (!salt.matches("^[" + B64.B64T + "]{2,}$")) {
205                throw new IllegalArgumentException("Invalid salt value: " + salt);
206            }
207    
208            StringBuilder buffer = new StringBuilder("             ");
209            char charZero = salt.charAt(0);
210            char charOne = salt.charAt(1);
211            buffer.setCharAt(0, charZero);
212            buffer.setCharAt(1, charOne);
213            int eSwap0 = CON_SALT[charZero];
214            int eSwap1 = CON_SALT[charOne] << 4;
215            byte key[] = new byte[8];
216            for (int i = 0; i < key.length; i++) {
217                key[i] = 0;
218            }
219    
220            for (int i = 0; i < key.length && i < original.length; i++) {
221                int iChar = original[i];
222                key[i] = (byte) (iChar << 1);
223            }
224    
225            int schedule[] = desSetKey(key);
226            int out[] = body(schedule, eSwap0, eSwap1);
227            byte b[] = new byte[9];
228            intToFourBytes(out[0], b, 0);
229            intToFourBytes(out[1], b, 4);
230            b[8] = 0;
231            int i = 2;
232            int y = 0;
233            int u = 128;
234            for (; i < 13; i++) {
235                int j = 0;
236                int c = 0;
237                for (; j < 6; j++) {
238                    c <<= 1;
239                    if ((b[y] & u) != 0) {
240                        c |= 0x1;
241                    }
242                    u >>>= 1;
243                    if (u == 0) {
244                        y++;
245                        u = 128;
246                    }
247                    buffer.setCharAt(i, (char) COV2CHAR[c]);
248                }
249            }
250            return buffer.toString();
251        }
252    
253        /**
254         * Generates a crypt(3) compatible hash using the DES algorithm.
255         * <p>
256         * As no salt is given, a random one is used.
257         *
258         * @param original
259         *            plaintext password
260         * @return a 13 character string starting with the salt string
261         */
262        public static String crypt(String original) {
263            return crypt(original.getBytes(Charsets.UTF_8));
264        }
265    
266        /**
267         * Generates a crypt(3) compatible hash using the DES algorithm.
268         *
269         * @param original
270         *            plaintext password
271         * @param salt
272         *            a two character string drawn from [a-zA-Z0-9./] or null for a random one
273         * @return a 13 character string starting with the salt string
274         * @throws IllegalArgumentException
275         *             if the salt does not match the allowed pattern
276         */
277        public static String crypt(String original, String salt) {
278            return crypt(original.getBytes(Charsets.UTF_8), salt);
279        }
280    
281        private static int[] body(int schedule[], int eSwap0, int eSwap1) {
282            int left = 0;
283            int right = 0;
284            int t = 0;
285            for (int j = 0; j < 25; j++) {
286                for (int i = 0; i < 32; i += 4) {
287                    left = dEncrypt(left, right, i, eSwap0, eSwap1, schedule);
288                    right = dEncrypt(right, left, i + 2, eSwap0, eSwap1, schedule);
289                }
290                t = left;
291                left = right;
292                right = t;
293            }
294    
295            t = right;
296            right = left >>> 1 | left << 31;
297            left = t >>> 1 | t << 31;
298            int results[] = new int[2];
299            permOp(right, left, 1, 0x55555555, results);
300            right = results[0];
301            left = results[1];
302            permOp(left, right, 8, 0xff00ff, results);
303            left = results[0];
304            right = results[1];
305            permOp(right, left, 2, 0x33333333, results);
306            right = results[0];
307            left = results[1];
308            permOp(left, right, 16, 65535, results);
309            left = results[0];
310            right = results[1];
311            permOp(right, left, 4, 0xf0f0f0f, results);
312            right = results[0];
313            left = results[1];
314            int out[] = new int[2];
315            out[0] = left;
316            out[1] = right;
317            return out;
318        }
319    
320        private static int byteToUnsigned(byte b) {
321            int value = b;
322            return value < 0 ? value + 256 : value;
323        }
324    
325        private static int dEncrypt(int el, int r, int s, int e0, int e1, int sArr[]) {
326            int v = r ^ r >>> 16;
327            int u = v & e0;
328            v &= e1;
329            u = u ^ u << 16 ^ r ^ sArr[s];
330            int t = v ^ v << 16 ^ r ^ sArr[s + 1];
331            t = t >>> 4 | t << 28;
332            el ^= SPTRANS[1][t & 0x3f] | SPTRANS[3][t >>> 8 & 0x3f] | SPTRANS[5][t >>> 16 & 0x3f] |
333                    SPTRANS[7][t >>> 24 & 0x3f] | SPTRANS[0][u & 0x3f] | SPTRANS[2][u >>> 8 & 0x3f] |
334                    SPTRANS[4][u >>> 16 & 0x3f] | SPTRANS[6][u >>> 24 & 0x3f];
335            return el;
336        }
337    
338        private static int[] desSetKey(byte key[]) {
339            int schedule[] = new int[32];
340            int c = fourBytesToInt(key, 0);
341            int d = fourBytesToInt(key, 4);
342            int results[] = new int[2];
343            permOp(d, c, 4, 0xf0f0f0f, results);
344            d = results[0];
345            c = results[1];
346            c = hPermOp(c, -2, 0xcccc0000);
347            d = hPermOp(d, -2, 0xcccc0000);
348            permOp(d, c, 1, 0x55555555, results);
349            d = results[0];
350            c = results[1];
351            permOp(c, d, 8, 0xff00ff, results);
352            c = results[0];
353            d = results[1];
354            permOp(d, c, 1, 0x55555555, results);
355            d = results[0];
356            c = results[1];
357            d = (d & 0xff) << 16 | d & 0xff00 | (d & 0xff0000) >>> 16 | (c & 0xf0000000) >>> 4;
358            c &= 0xfffffff;
359            int j = 0;
360            for (int i = 0; i < 16; i++) {
361                if (SHIFT2[i]) {
362                    c = c >>> 2 | c << 26;
363                    d = d >>> 2 | d << 26;
364                } else {
365                    c = c >>> 1 | c << 27;
366                    d = d >>> 1 | d << 27;
367                }
368                c &= 0xfffffff;
369                d &= 0xfffffff;
370                int s = SKB[0][c & 0x3f] | SKB[1][c >>> 6 & 0x3 | c >>> 7 & 0x3c] |
371                        SKB[2][c >>> 13 & 0xf | c >>> 14 & 0x30] |
372                        SKB[3][c >>> 20 & 0x1 | c >>> 21 & 0x6 | c >>> 22 & 0x38];
373                int t = SKB[4][d & 0x3f] | SKB[5][d >>> 7 & 0x3 | d >>> 8 & 0x3c] | SKB[6][d >>> 15 & 0x3f] |
374                        SKB[7][d >>> 21 & 0xf | d >>> 22 & 0x30];
375                schedule[j++] = (t << 16 | s & 0xffff);
376                s = s >>> 16 | t & 0xffff0000;
377                s = s << 4 | s >>> 28;
378                schedule[j++] = s;
379            }
380    
381            return schedule;
382        }
383    
384        private static int fourBytesToInt(byte b[], int offset) {
385            int value = byteToUnsigned(b[offset++]);
386            value |= byteToUnsigned(b[offset++]) << 8;
387            value |= byteToUnsigned(b[offset++]) << 16;
388            value |= byteToUnsigned(b[offset++]) << 24;
389            return value;
390        }
391    
392        private static int hPermOp(int a, int n, int m) {
393            int t = (a << 16 - n ^ a) & m;
394            a = a ^ t ^ t >>> 16 - n;
395            return a;
396        }
397    
398        private static void intToFourBytes(int iValue, byte b[], int offset) {
399            b[offset++] = (byte) (iValue & 0xff);
400            b[offset++] = (byte) (iValue >>> 8 & 0xff);
401            b[offset++] = (byte) (iValue >>> 16 & 0xff);
402            b[offset++] = (byte) (iValue >>> 24 & 0xff);
403        }
404    
405        private static void permOp(int a, int b, int n, int m, int results[]) {
406            int t = (a >>> n ^ b) & m;
407            a ^= t << n;
408            b ^= t;
409            results[0] = a;
410            results[1] = b;
411        }
412    
413    }