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