| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| */ |
| |
| /* |
| * @(#)UnixCrypt.java 0.9 96/11/25 |
| * |
| * Copyright (c) 1996 Aki Yoshida. All rights reserved. |
| * |
| * Permission to use, copy, modify and distribute this software |
| * for non-commercial or commercial purposes and without fee is |
| * hereby granted provided that this copyright notice appears in |
| * all copies. |
| */ |
| |
| /** |
| * Unix crypt(3C) utility |
| * |
| * @author <a href="mailto:dev@directory.apache.org">Apache Directory Project</a> |
| * |
| * modified April 2001 |
| * by Iris Van den Broeke, Daniel Deville |
| */ |
| |
| package org.apache.directory.api.util; |
| |
| |
| import org.apache.directory.api.i18n.I18n; |
| |
| |
| /* |
| * @(#)UnixCrypt.java 0.9 96/11/25 |
| * |
| * Copyright (c) 1996 Aki Yoshida. All rights reserved. |
| * |
| * Permission to use, copy, modify and distribute this software |
| * for non-commercial or commercial purposes and without fee is |
| * hereby granted provided that this copyright notice appears in |
| * all copies. |
| */ |
| |
| /** |
| * Unix crypt(3C) utility |
| * |
| * @author Aki Yoshida |
| * 2001 |
| * by Iris Van den Broeke, Daniel Deville |
| */ |
| |
| /* ------------------------------------------------------------ */ |
| /** Unix Crypt. |
| * Implements the one way cryptography used by Unix systems for |
| * simple password protection. |
| * @author Greg Wilkins (gregw) |
| */ |
| public class UnixCrypt extends Object |
| { |
| |
| /* (mostly) Standard DES Tables from Tom Truscott */ |
| private static final byte[] IP = |
| { |
| /* initial permutation */ |
| 58, 50, 42, 34, 26, 18, 10, 2, |
| 60, 52, 44, 36, 28, 20, 12, 4, |
| 62, 54, 46, 38, 30, 22, 14, 6, |
| 64, 56, 48, 40, 32, 24, 16, 8, |
| 57, 49, 41, 33, 25, 17, 9, 1, |
| 59, 51, 43, 35, 27, 19, 11, 3, |
| 61, 53, 45, 37, 29, 21, 13, 5, |
| 63, 55, 47, 39, 31, 23, 15, 7 }; |
| |
| /* The final permutation is the inverse of IP - no table is necessary */ |
| private static final byte[] ExpandTr = |
| { |
| /* expansion operation */ |
| 32, 1, 2, 3, 4, 5, |
| 4, 5, 6, 7, 8, 9, |
| 8, 9, 10, 11, 12, 13, |
| 12, 13, 14, 15, 16, 17, |
| 16, 17, 18, 19, 20, 21, |
| 20, 21, 22, 23, 24, 25, |
| 24, 25, 26, 27, 28, 29, |
| 28, 29, 30, 31, 32, 1 }; |
| |
| private static final byte[] PC1 = |
| { |
| /* permuted choice table 1 */ |
| 57, 49, 41, 33, 25, 17, 9, |
| 1, 58, 50, 42, 34, 26, 18, |
| 10, 2, 59, 51, 43, 35, 27, |
| 19, 11, 3, 60, 52, 44, 36, |
| |
| 63, 55, 47, 39, 31, 23, 15, |
| 7, 62, 54, 46, 38, 30, 22, |
| 14, 6, 61, 53, 45, 37, 29, |
| 21, 13, 5, 28, 20, 12, 4 }; |
| |
| private static final byte[] Rotates = |
| { |
| /* PC1 rotation schedule */ |
| 1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1 }; |
| |
| private static final byte[] PC2 = |
| { |
| /* permuted choice table 2 */ |
| 9, 18, 14, 17, 11, 24, 1, 5, |
| 22, 25, 3, 28, 15, 6, 21, 10, |
| 35, 38, 23, 19, 12, 4, 26, 8, |
| 43, 54, 16, 7, 27, 20, 13, 2, |
| |
| 0, 0, 41, 52, 31, 37, 47, 55, |
| 0, 0, 30, 40, 51, 45, 33, 48, |
| 0, 0, 44, 49, 39, 56, 34, 53, |
| 0, 0, 46, 42, 50, 36, 29, 32 }; |
| |
| private static final byte[][] S = |
| { |
| /* 48->32 bit substitution tables */ |
| /* S[1] */ |
| { 14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7, |
| 0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8, |
| 4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0, |
| 15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13 }, |
| /* S[2] */ |
| { 15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10, |
| 3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5, |
| 0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15, |
| 13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9 }, |
| /* S[3] */ |
| { 10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8, |
| 13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1, |
| 13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7, |
| 1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12 }, |
| /* S[4] */ |
| { 7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15, |
| 13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9, |
| 10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4, |
| 3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14 }, |
| /* S[5] */ |
| { 2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9, |
| 14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6, |
| 4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14, |
| 11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3 }, |
| /* S[6] */ |
| { 12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11, |
| 10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8, |
| 9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6, |
| 4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13 }, |
| /* S[7] */ |
| { 4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1, |
| 13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6, |
| 1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2, |
| 6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12 }, |
| /* S[8] */ |
| { 13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7, |
| 1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2, |
| 7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8, |
| 2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11 } }; |
| |
| private static final byte[] P32Tr = |
| { |
| /* 32-bit permutation function */ |
| 16, 7, 20, 21, |
| 29, 12, 28, 17, |
| 1, 15, 23, 26, |
| 5, 18, 31, 10, |
| 2, 8, 24, 14, |
| 32, 27, 3, 9, |
| 19, 13, 30, 6, |
| 22, 11, 4, 25 }; |
| |
| private static final byte[] CIFP = |
| { |
| /* compressed/interleaved permutation */ |
| 1, 2, 3, 4, 17, 18, 19, 20, |
| 5, 6, 7, 8, 21, 22, 23, 24, |
| 9, 10, 11, 12, 25, 26, 27, 28, |
| 13, 14, 15, 16, 29, 30, 31, 32, |
| |
| 33, 34, 35, 36, 49, 50, 51, 52, |
| 37, 38, 39, 40, 53, 54, 55, 56, |
| 41, 42, 43, 44, 57, 58, 59, 60, |
| 45, 46, 47, 48, 61, 62, 63, 64 }; |
| |
| private static final byte[] ITOA64 = |
| { |
| /* 0..63 => ascii-64 */ |
| ( byte ) '.', |
| ( byte ) '/', |
| ( byte ) '0', |
| ( byte ) '1', |
| ( byte ) '2', |
| ( byte ) '3', |
| ( byte ) '4', |
| ( byte ) '5', |
| ( byte ) '6', |
| ( byte ) '7', |
| ( byte ) '8', |
| ( byte ) '9', |
| ( byte ) 'A', |
| ( byte ) 'B', |
| ( byte ) 'C', |
| ( byte ) 'D', |
| ( byte ) 'E', |
| ( byte ) 'F', |
| ( byte ) 'G', |
| ( byte ) 'H', |
| ( byte ) 'I', |
| ( byte ) 'J', |
| ( byte ) 'K', |
| ( byte ) 'L', |
| ( byte ) 'M', |
| ( byte ) 'N', |
| ( byte ) 'O', |
| ( byte ) 'P', |
| ( byte ) 'Q', |
| ( byte ) 'R', |
| ( byte ) 'S', |
| ( byte ) 'T', |
| ( byte ) 'U', |
| ( byte ) 'V', |
| ( byte ) 'W', |
| ( byte ) 'X', |
| ( byte ) 'Y', |
| ( byte ) 'Z', |
| ( byte ) 'a', |
| ( byte ) 'b', |
| ( byte ) 'c', |
| ( byte ) 'd', |
| ( byte ) 'e', |
| ( byte ) 'f', |
| ( byte ) 'g', |
| ( byte ) 'h', |
| ( byte ) 'i', |
| ( byte ) 'j', |
| ( byte ) 'k', |
| ( byte ) 'l', |
| ( byte ) 'm', |
| ( byte ) 'n', |
| ( byte ) 'o', |
| ( byte ) 'p', |
| ( byte ) 'q', |
| ( byte ) 'r', |
| ( byte ) 's', |
| ( byte ) 't', |
| ( byte ) 'u', |
| ( byte ) 'v', |
| ( byte ) 'w', |
| ( byte ) 'x', |
| ( byte ) 'y', |
| ( byte ) 'z' }; |
| |
| /* ===== Tables that are initialized at run time ==================== */ |
| |
| private static byte[] A64TOI = new byte[128]; /* ascii-64 => 0..63 */ |
| |
| /* Initial key schedule permutation */ |
| private static long[][] PC1ROT = new long[16][16]; |
| |
| /* Subsequent key schedule rotation permutations */ |
| private static long[][][] PC2ROT = new long[2][16][16]; |
| |
| /* Initial permutation/expansion table */ |
| private static long[][] IE3264 = new long[8][16]; |
| |
| /* Table that combines the S, P, and E operations. */ |
| private static long[][] SPE = new long[8][64]; |
| |
| /* compressed/interleaved => final permutation table */ |
| private static long[][] CF6464 = new long[16][16]; |
| |
| /* ==================================== */ |
| |
| static |
| { |
| byte[] perm = new byte[64]; |
| byte[] temp = new byte[64]; |
| |
| // inverse table. |
| for ( int i = 0; i < 64; i++ ) |
| { |
| A64TOI[ITOA64[i]] = ( byte ) i; |
| } |
| |
| // PC1ROT - bit reverse, then PC1, then Rotate, then PC2 |
| for ( int i = 0; i < 64; i++ ) |
| { |
| perm[i] = ( byte ) 0; |
| } |
| |
| for ( int i = 0; i < 64; i++ ) |
| { |
| int k; |
| |
| if ( ( k = PC2[i] ) == 0 ) |
| { |
| continue; |
| } |
| |
| k += Rotates[0] - 1; |
| |
| if ( ( k % 28 ) < Rotates[0] ) |
| { |
| k -= 28; |
| } |
| |
| k = PC1[k]; |
| |
| if ( k > 0 ) |
| { |
| k--; |
| k = ( k | 0x07 ) - ( k & 0x07 ); |
| k++; |
| } |
| |
| perm[i] = ( byte ) k; |
| } |
| |
| init_perm( PC1ROT, perm, 8 ); |
| |
| // PC2ROT - PC2 inverse, then Rotate, then PC2 |
| for ( int j = 0; j < 2; j++ ) |
| { |
| int k; |
| |
| for ( int i = 0; i < 64; i++ ) |
| { |
| perm[i] = temp[i] = 0; |
| } |
| |
| for ( int i = 0; i < 64; i++ ) |
| { |
| if ( ( k = PC2[i] ) == 0 ) |
| { |
| continue; |
| } |
| |
| temp[k - 1] = ( byte ) ( i + 1 ); |
| } |
| |
| for ( int i = 0; i < 64; i++ ) |
| { |
| if ( ( k = PC2[i] ) == 0 ) |
| { |
| continue; |
| } |
| |
| k += j; |
| |
| if ( ( k % 28 ) <= j ) |
| { |
| k -= 28; |
| } |
| |
| perm[i] = temp[k]; |
| } |
| |
| init_perm( PC2ROT[j], perm, 8 ); |
| } |
| |
| // Bit reverse, intial permupation, expantion |
| for ( int i = 0; i < 8; i++ ) |
| { |
| for ( int j = 0; j < 8; j++ ) |
| { |
| int k = ( j < 2 ) ? 0 : IP[ExpandTr[i * 6 + j - 2] - 1]; |
| |
| if ( k > 32 ) |
| { |
| k -= 32; |
| } |
| else if ( k > 0 ) |
| { |
| k--; |
| } |
| |
| if ( k > 0 ) |
| { |
| k--; |
| k = ( k | 0x07 ) - ( k & 0x07 ); |
| k++; |
| } |
| |
| perm[i * 8 + j] = ( byte ) k; |
| } |
| } |
| |
| init_perm( IE3264, perm, 8 ); |
| |
| // Compression, final permutation, bit reverse |
| for ( int i = 0; i < 64; i++ ) |
| { |
| int k = IP[CIFP[i] - 1]; |
| |
| if ( k > 0 ) |
| { |
| k--; |
| k = ( k | 0x07 ) - ( k & 0x07 ); |
| k++; |
| } |
| |
| perm[k - 1] = ( byte ) ( i + 1 ); |
| } |
| |
| init_perm( CF6464, perm, 8 ); |
| |
| // SPE table |
| for ( int i = 0; i < 48; i++ ) |
| { |
| perm[i] = P32Tr[ExpandTr[i] - 1]; |
| } |
| |
| for ( int t = 0; t < 8; t++ ) |
| { |
| for ( int j = 0; j < 64; j++ ) |
| { |
| int k = ( ( ( j >> 0 ) & 0x01 ) << 5 ) | ( ( ( j >> 1 ) & 0x01 ) << 3 ) | |
| ( ( ( j >> 2 ) & 0x01 ) << 2 ) | ( ( ( j >> 3 ) & 0x01 ) << 1 ) | |
| ( ( ( j >> 4 ) & 0x01 ) << 0 ) | ( ( ( j >> 5 ) & 0x01 ) << 4 ); |
| k = S[t][k]; |
| k = ( ( ( k >> 3 ) & 0x01 ) << 0 ) | ( ( ( k >> 2 ) & 0x01 ) << 1 ) | |
| ( ( ( k >> 1 ) & 0x01 ) << 2 ) | ( ( ( k >> 0 ) & 0x01 ) << 3 ); |
| |
| for ( int i = 0; i < 32; i++ ) |
| { |
| temp[i] = 0; |
| } |
| |
| for ( int i = 0; i < 4; i++ ) |
| { |
| temp[4 * t + i] = ( byte ) ( ( k >> i ) & 0x01 ); |
| } |
| |
| long kk = 0; |
| |
| for ( int i = 24; --i >= 0; ) |
| { |
| kk = ( ( kk << 1 ) | |
| ( ( long ) temp[perm[i] - 1] ) << 32 | |
| ( temp[perm[i + 24] - 1] ) ); |
| } |
| |
| SPE[t][j] = to_six_bit( kk ); |
| } |
| } |
| } |
| |
| |
| /** |
| * You can't call the constructer. |
| */ |
| private UnixCrypt() |
| { |
| } |
| |
| |
| /** |
| * Returns the transposed and split code of a 24-bit code |
| * into a 4-byte code, each having 6 bits. |
| */ |
| private static int to_six_bit( int num ) |
| { |
| return ( ( ( num << 26 ) & 0xfc000000 ) | ( ( num << 12 ) & 0xfc0000 ) | |
| ( ( num >> 2 ) & 0xfc00 ) | ( ( num >> 16 ) & 0xfc ) ); |
| } |
| |
| |
| /** |
| * Returns the transposed and split code of two 24-bit code |
| * into two 4-byte code, each having 6 bits. |
| */ |
| private static long to_six_bit( long num ) |
| { |
| return ( ( ( num << 26 ) & 0xfc000000fc000000L ) | ( ( num << 12 ) & 0xfc000000fc0000L ) | |
| ( ( num >> 2 ) & 0xfc000000fc00L ) | ( ( num >> 16 ) & 0xfc000000fcL ) ); |
| } |
| |
| |
| /** |
| * Returns the permutation of the given 64-bit code with |
| * the specified permutataion table. |
| */ |
| private static long perm6464( long c, long[][] p ) |
| { |
| long out = 0L; |
| |
| for ( int i = 8; --i >= 0; ) |
| { |
| int t = ( int ) ( 0x00ff & c ); |
| c >>= 8; |
| long tp = p[i << 1][t & 0x0f]; |
| out |= tp; |
| tp = p[( i << 1 ) + 1][t >> 4]; |
| out |= tp; |
| } |
| |
| return out; |
| } |
| |
| |
| /** |
| * Returns the permutation of the given 32-bit code with |
| * the specified permutataion table. |
| */ |
| private static long perm3264( int c, long[][] p ) |
| { |
| long out = 0L; |
| |
| for ( int i = 4; --i >= 0; ) |
| { |
| int t = ( 0x00ff & c ); |
| c >>= 8; |
| long tp = p[i << 1][t & 0x0f]; |
| out |= tp; |
| tp = p[( i << 1 ) + 1][t >> 4]; |
| out |= tp; |
| } |
| |
| return out; |
| } |
| |
| |
| /** |
| * Returns the key schedule for the given key. |
| */ |
| private static long[] des_setkey( long keyword ) |
| { |
| long K = perm6464( keyword, PC1ROT ); |
| long[] KS = new long[16]; |
| KS[0] = K & ~0x0303030300000000L; |
| |
| for ( int i = 1; i < 16; i++ ) |
| { |
| KS[i] = K; |
| K = perm6464( K, PC2ROT[Rotates[i] - 1] ); |
| |
| KS[i] = K & ~0x0303030300000000L; |
| } |
| return KS; |
| } |
| |
| |
| /** |
| * Returns the DES encrypted code of the given word with the specified |
| * environment. |
| */ |
| private static long des_cipher( long in, int salt, int num_iter, long[] KS ) |
| { |
| salt = to_six_bit( salt ); |
| long L = in; |
| long R = L; |
| L &= 0x5555555555555555L; |
| R = ( R & 0xaaaaaaaa00000000L ) | ( ( R >> 1 ) & 0x0000000055555555L ); |
| L = ( ( ( ( L << 1 ) | ( L << 32 ) ) & 0xffffffff00000000L ) | |
| ( ( R | ( R >> 32 ) ) & 0x00000000ffffffffL ) ); |
| |
| L = perm3264( ( int ) ( L >> 32 ), IE3264 ); |
| R = perm3264( ( int ) ( L & 0xffffffff ), IE3264 ); |
| |
| while ( --num_iter >= 0 ) |
| { |
| for ( int loop_count = 0; loop_count < 8; loop_count++ ) |
| { |
| long kp; |
| long B; |
| long k; |
| |
| kp = KS[( loop_count << 1 )]; |
| k = ( ( R >> 32 ) ^ R ) & salt & 0xffffffffL; |
| k |= ( k << 32 ); |
| B = ( k ^ R ^ kp ); |
| |
| L ^= ( SPE[0][( int ) ( ( B >> 58 ) & 0x3f )] ^ SPE[1][( int ) ( ( B >> 50 ) & 0x3f )] ^ |
| SPE[2][( int ) ( ( B >> 42 ) & 0x3f )] ^ SPE[3][( int ) ( ( B >> 34 ) & 0x3f )] ^ |
| SPE[4][( int ) ( ( B >> 26 ) & 0x3f )] ^ SPE[5][( int ) ( ( B >> 18 ) & 0x3f )] ^ |
| SPE[6][( int ) ( ( B >> 10 ) & 0x3f )] ^ SPE[7][( int ) ( ( B >> 2 ) & 0x3f )] ); |
| |
| kp = KS[( loop_count << 1 ) + 1]; |
| k = ( ( L >> 32 ) ^ L ) & salt & 0xffffffffL; |
| k |= ( k << 32 ); |
| B = ( k ^ L ^ kp ); |
| |
| R ^= ( SPE[0][( int ) ( ( B >> 58 ) & 0x3f )] ^ SPE[1][( int ) ( ( B >> 50 ) & 0x3f )] ^ |
| SPE[2][( int ) ( ( B >> 42 ) & 0x3f )] ^ SPE[3][( int ) ( ( B >> 34 ) & 0x3f )] ^ |
| SPE[4][( int ) ( ( B >> 26 ) & 0x3f )] ^ SPE[5][( int ) ( ( B >> 18 ) & 0x3f )] ^ |
| SPE[6][( int ) ( ( B >> 10 ) & 0x3f )] ^ SPE[7][( int ) ( ( B >> 2 ) & 0x3f )] ); |
| } |
| // swap L and R |
| L ^= R; |
| R ^= L; |
| L ^= R; |
| } |
| L = ( ( ( ( L >> 35 ) & 0x0f0f0f0fL ) | ( ( ( L & 0xffffffff ) << 1 ) & 0xf0f0f0f0L ) ) << 32 | |
| ( ( ( R >> 35 ) & 0x0f0f0f0fL ) | ( ( ( R & 0xffffffff ) << 1 ) & 0xf0f0f0f0L ) ) ); |
| |
| L = perm6464( L, CF6464 ); |
| |
| return L; |
| } |
| |
| |
| /** |
| * Initializes the given permutation table with the mapping table. |
| */ |
| private static void init_perm( long[][] perm, byte[] p, int chars_out ) |
| { |
| for ( int k = 0; k < chars_out * 8; k++ ) |
| { |
| |
| int l = p[k] - 1; |
| |
| if ( l < 0 ) |
| { |
| continue; |
| } |
| |
| int i = l >> 2; |
| l = 1 << ( l & 0x03 ); |
| |
| for ( int j = 0; j < 16; j++ ) |
| { |
| int s = ( ( k & 0x07 ) + ( ( 7 - ( k >> 3 ) ) << 3 ) ); |
| |
| if ( ( j & l ) != 0x00 ) |
| { |
| perm[i][j] |= ( 1L << s ); |
| } |
| } |
| } |
| } |
| |
| |
| /** |
| * Encrypts String into crypt (Unix) code. |
| * @param key the key to be encrypted |
| * @param setting the salt to be used |
| * @return the encrypted String |
| */ |
| @SuppressWarnings("deprecation") |
| public static String crypt( String key, String setting ) |
| { |
| /* encryption constant */ |
| long constdatablock = 0L; |
| /* encrypted result */ |
| byte[] cryptresult = new byte[13]; |
| long keyword = 0L; |
| |
| /* invalid parameters! */ |
| if ( key == null || setting == null ) |
| { |
| // will NOT match under ANY circumstances! |
| return "*"; |
| } |
| |
| int keylen = key.length(); |
| |
| for ( int i = 0; i < 8; i++ ) |
| { |
| keyword = ( keyword << 8 ) | ( ( i < keylen ) ? 2 * key.charAt( i ) : 0 ); |
| } |
| |
| long[] KS = des_setkey( keyword ); |
| |
| int salt = 0; |
| |
| for ( int i = 2; --i >= 0; ) |
| { |
| char c = ( i < setting.length() ) ? setting.charAt( i ) : '.'; |
| cryptresult[i] = ( byte ) c; |
| salt = ( salt << 6 ) | ( 0x00ff & A64TOI[c] ); |
| } |
| |
| long rsltblock = des_cipher( constdatablock, salt, 25, KS ); |
| |
| cryptresult[12] = ITOA64[( ( ( int ) rsltblock ) << 2 ) & 0x3f]; |
| rsltblock >>= 4; |
| |
| for ( int i = 12; --i >= 2; ) |
| { |
| cryptresult[i] = ITOA64[( ( int ) rsltblock ) & 0x3f]; |
| rsltblock >>= 6; |
| } |
| |
| return new String( cryptresult, 0x00, 0, 13 ); |
| } |
| |
| |
| public static void main( String[] arg ) |
| { |
| if ( arg.length != 2 ) |
| { |
| System.err.println( I18n.err( I18n.ERR_04439 ) ); |
| System.exit( 1 ); |
| } |
| |
| System.err.println( I18n.err( I18n.ERR_04440, crypt( arg[0], arg[1] ) ) ); |
| } |
| } |
