JDK8/Java8源码在线阅读
/*
* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package com.sun.crypto.provider;
import java.security.InvalidKeyException;
/**
* This is the internal DES class responsible for encryption and
* decryption of a byte array of size <code>DES_BLOCK_SIZE</code>.
*
* @author Gigi Ankeny
* @author Jan Luehe
*
*
* @see DESConstants
* @see DESCipher
*/
class DESCrypt extends SymmetricCipher implements DESConstants {
private static final int s0p[] = {
0x00410100, 0x00010000, 0x40400000, 0x40410100, 0x00400000,
0x40010100, 0x40010000, 0x40400000, 0x40010100, 0x00410100,
0x00410000, 0x40000100, 0x40400100, 0x00400000, 0x00000000,
0x40010000, 0x00010000, 0x40000000, 0x00400100, 0x00010100,
0x40410100, 0x00410000, 0x40000100, 0x00400100, 0x40000000,
0x00000100, 0x00010100, 0x40410000, 0x00000100, 0x40400100,
0x40410000, 0x00000000, 0x00000000, 0x40410100, 0x00400100,
0x40010000, 0x00410100, 0x00010000, 0x40000100, 0x00400100,
0x40410000, 0x00000100, 0x00010100, 0x40400000, 0x40010100,
0x40000000, 0x40400000, 0x00410000, 0x40410100, 0x00010100,
0x00410000, 0x40400100, 0x00400000, 0x40000100, 0x40010000,
0x00000000, 0x00010000, 0x00400000, 0x40400100, 0x00410100,
0x40000000, 0x40410000, 0x00000100, 0x40010100,
};
private static final int s1p[] = {
0x08021002, 0x00000000, 0x00021000, 0x08020000, 0x08000002,
0x00001002, 0x08001000, 0x00021000, 0x00001000, 0x08020002,
0x00000002, 0x08001000, 0x00020002, 0x08021000, 0x08020000,
0x00000002, 0x00020000, 0x08001002, 0x08020002, 0x00001000,
0x00021002, 0x08000000, 0x00000000, 0x00020002, 0x08001002,
0x00021002, 0x08021000, 0x08000002, 0x08000000, 0x00020000,
0x00001002, 0x08021002, 0x00020002, 0x08021000, 0x08001000,
0x00021002, 0x08021002, 0x00020002, 0x08000002, 0x00000000,
0x08000000, 0x00001002, 0x00020000, 0x08020002, 0x00001000,
0x08000000, 0x00021002, 0x08001002, 0x08021000, 0x00001000,
0x00000000, 0x08000002, 0x00000002, 0x08021002, 0x00021000,
0x08020000, 0x08020002, 0x00020000, 0x00001002, 0x08001000,
0x08001002, 0x00000002, 0x08020000, 0x00021000,
};
private static final int s2p[] = {
0x20800000, 0x00808020, 0x00000020, 0x20800020, 0x20008000,
0x00800000, 0x20800020, 0x00008020, 0x00800020, 0x00008000,
0x00808000, 0x20000000, 0x20808020, 0x20000020, 0x20000000,
0x20808000, 0x00000000, 0x20008000, 0x00808020, 0x00000020,
0x20000020, 0x20808020, 0x00008000, 0x20800000, 0x20808000,
0x00800020, 0x20008020, 0x00808000, 0x00008020, 0x00000000,
0x00800000, 0x20008020, 0x00808020, 0x00000020, 0x20000000,
0x00008000, 0x20000020, 0x20008000, 0x00808000, 0x20800020,
0x00000000, 0x00808020, 0x00008020, 0x20808000, 0x20008000,
0x00800000, 0x20808020, 0x20000000, 0x20008020, 0x20800000,
0x00800000, 0x20808020, 0x00008000, 0x00800020, 0x20800020,
0x00008020, 0x00800020, 0x00000000, 0x20808000, 0x20000020,
0x20800000, 0x20008020, 0x00000020, 0x00808000,
};
private static final int s3p[] = {
0x00080201, 0x02000200, 0x00000001, 0x02080201, 0x00000000,
0x02080000, 0x02000201, 0x00080001, 0x02080200, 0x02000001,
0x02000000, 0x00000201, 0x02000001, 0x00080201, 0x00080000,
0x02000000, 0x02080001, 0x00080200, 0x00000200, 0x00000001,
0x00080200, 0x02000201, 0x02080000, 0x00000200, 0x00000201,
0x00000000, 0x00080001, 0x02080200, 0x02000200, 0x02080001,
0x02080201, 0x00080000, 0x02080001, 0x00000201, 0x00080000,
0x02000001, 0x00080200, 0x02000200, 0x00000001, 0x02080000,
0x02000201, 0x00000000, 0x00000200, 0x00080001, 0x00000000,
0x02080001, 0x02080200, 0x00000200, 0x02000000, 0x02080201,
0x00080201, 0x00080000, 0x02080201, 0x00000001, 0x02000200,
0x00080201, 0x00080001, 0x00080200, 0x02080000, 0x02000201,
0x00000201, 0x02000000, 0x02000001, 0x02080200,
};
private static final int s4p[] = {
0x01000000, 0x00002000, 0x00000080, 0x01002084, 0x01002004,
0x01000080, 0x00002084, 0x01002000, 0x00002000, 0x00000004,
0x01000004, 0x00002080, 0x01000084, 0x01002004, 0x01002080,
0x00000000, 0x00002080, 0x01000000, 0x00002004, 0x00000084,
0x01000080, 0x00002084, 0x00000000, 0x01000004, 0x00000004,
0x01000084, 0x01002084, 0x00002004, 0x01002000, 0x00000080,
0x00000084, 0x01002080, 0x01002080, 0x01000084, 0x00002004,
0x01002000, 0x00002000, 0x00000004, 0x01000004, 0x01000080,
0x01000000, 0x00002080, 0x01002084, 0x00000000, 0x00002084,
0x01000000, 0x00000080, 0x00002004, 0x01000084, 0x00000080,
0x00000000, 0x01002084, 0x01002004, 0x01002080, 0x00000084,
0x00002000, 0x00002080, 0x01002004, 0x01000080, 0x00000084,
0x00000004, 0x00002084, 0x01002000, 0x01000004,
};
private static final int s5p[] = {
0x10000008, 0x00040008, 0x00000000, 0x10040400, 0x00040008,
0x00000400, 0x10000408, 0x00040000, 0x00000408, 0x10040408,
0x00040400, 0x10000000, 0x10000400, 0x10000008, 0x10040000,
0x00040408, 0x00040000, 0x10000408, 0x10040008, 0x00000000,
0x00000400, 0x00000008, 0x10040400, 0x10040008, 0x10040408,
0x10040000, 0x10000000, 0x00000408, 0x00000008, 0x00040400,
0x00040408, 0x10000400, 0x00000408, 0x10000000, 0x10000400,
0x00040408, 0x10040400, 0x00040008, 0x00000000, 0x10000400,
0x10000000, 0x00000400, 0x10040008, 0x00040000, 0x00040008,
0x10040408, 0x00040400, 0x00000008, 0x10040408, 0x00040400,
0x00040000, 0x10000408, 0x10000008, 0x10040000, 0x00040408,
0x00000000, 0x00000400, 0x10000008, 0x10000408, 0x10040400,
0x10040000, 0x00000408, 0x00000008, 0x10040008,
};
private static final int s6p[] = {
0x00000800, 0x00000040, 0x00200040, 0x80200000, 0x80200840,
0x80000800, 0x00000840, 0x00000000, 0x00200000, 0x80200040,
0x80000040, 0x00200800, 0x80000000, 0x00200840, 0x00200800,
0x80000040, 0x80200040, 0x00000800, 0x80000800, 0x80200840,
0x00000000, 0x00200040, 0x80200000, 0x00000840, 0x80200800,
0x80000840, 0x00200840, 0x80000000, 0x80000840, 0x80200800,
0x00000040, 0x00200000, 0x80000840, 0x00200800, 0x80200800,
0x80000040, 0x00000800, 0x00000040, 0x00200000, 0x80200800,
0x80200040, 0x80000840, 0x00000840, 0x00000000, 0x00000040,
0x80200000, 0x80000000, 0x00200040, 0x00000000, 0x80200040,
0x00200040, 0x00000840, 0x80000040, 0x00000800, 0x80200840,
0x00200000, 0x00200840, 0x80000000, 0x80000800, 0x80200840,
0x80200000, 0x00200840, 0x00200800, 0x80000800,
};
private static final int s7p[] = {
0x04100010, 0x04104000, 0x00004010, 0x00000000, 0x04004000,
0x00100010, 0x04100000, 0x04104010, 0x00000010, 0x04000000,
0x00104000, 0x00004010, 0x00104010, 0x04004010, 0x04000010,
0x04100000, 0x00004000, 0x00104010, 0x00100010, 0x04004000,
0x04104010, 0x04000010, 0x00000000, 0x00104000, 0x04000000,
0x00100000, 0x04004010, 0x04100010, 0x00100000, 0x00004000,
0x04104000, 0x00000010, 0x00100000, 0x00004000, 0x04000010,
0x04104010, 0x00004010, 0x04000000, 0x00000000, 0x00104000,
0x04100010, 0x04004010, 0x04004000, 0x00100010, 0x04104000,
0x00000010, 0x00100010, 0x04004000, 0x04104010, 0x00100000,
0x04100000, 0x04000010, 0x00104000, 0x00004010, 0x04004010,
0x04100000, 0x00000010, 0x04104000, 0x00104010, 0x00000000,
0x04000000, 0x04100010, 0x00004000, 0x00104010,
};
private static final int permRight0[] = {
0x00000000, 0x40000000, 0x00400000, 0x40400000, 0x00004000,
0x40004000, 0x00404000, 0x40404000, 0x00000040, 0x40000040,
0x00400040, 0x40400040, 0x00004040, 0x40004040, 0x00404040,
0x40404040,
};
private static final int permLeft1[] = {
0x00000000, 0x40000000, 0x00400000, 0x40400000, 0x00004000,
0x40004000, 0x00404000, 0x40404000, 0x00000040, 0x40000040,
0x00400040, 0x40400040, 0x00004040, 0x40004040, 0x00404040,
0x40404040,
};
private static final int permRight2[] = {
0x00000000, 0x10000000, 0x00100000, 0x10100000, 0x00001000,
0x10001000, 0x00101000, 0x10101000, 0x00000010, 0x10000010,
0x00100010, 0x10100010, 0x00001010, 0x10001010, 0x00101010,
0x10101010,
};
private static final int permLeft3[] = {
0x00000000, 0x10000000, 0x00100000, 0x10100000, 0x00001000,
0x10001000, 0x00101000, 0x10101000, 0x00000010, 0x10000010,
0x00100010, 0x10100010, 0x00001010, 0x10001010, 0x00101010,
0x10101010,
};
private static final int permRight4[] = {
0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00000400,
0x04000400, 0x00040400, 0x04040400, 0x00000004, 0x04000004,
0x00040004, 0x04040004, 0x00000404, 0x04000404, 0x00040404,
0x04040404,
};
private static final int permLeft5[] = {
0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00000400,
0x04000400, 0x00040400, 0x04040400, 0x00000004, 0x04000004,
0x00040004, 0x04040004, 0x00000404, 0x04000404, 0x00040404,
0x04040404,
};
private static final int permRight6[] = {
0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100,
0x01000100, 0x00010100, 0x01010100, 0x00000001, 0x01000001,
0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101,
0x01010101,
};
private static final int permLeft7[] = {
0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00000100,
0x01000100, 0x00010100, 0x01010100, 0x00000001, 0x01000001,
0x00010001, 0x01010001, 0x00000101, 0x01000101, 0x00010101,
0x01010101,
};
private static final int permRight8[] = {
0x00000000, 0x80000000, 0x00800000, 0x80800000, 0x00008000,
0x80008000, 0x00808000, 0x80808000, 0x00000080, 0x80000080,
0x00800080, 0x80800080, 0x00008080, 0x80008080, 0x00808080,
0x80808080,
};
private static final int permLeft9[] = {
0x00000000, 0x80000000, 0x00800000, 0x80800000, 0x00008000,
0x80008000, 0x00808000, 0x80808000, 0x00000080, 0x80000080,
0x00800080, 0x80800080, 0x00008080, 0x80008080, 0x00808080,
0x80808080,
};
private static final int permRightA[] = {
0x00000000, 0x20000000, 0x00200000, 0x20200000, 0x00002000,
0x20002000, 0x00202000, 0x20202000, 0x00000020, 0x20000020,
0x00200020, 0x20200020, 0x00002020, 0x20002020, 0x00202020,
0x20202020,
};
private static final int permLeftB[] = {
0x00000000, 0x20000000, 0x00200000, 0x20200000, 0x00002000,
0x20002000, 0x00202000, 0x20202000, 0x00000020, 0x20000020,
0x00200020, 0x20200020, 0x00002020, 0x20002020, 0x00202020,
0x20202020,
};
private static final int permRightC[] = {
0x00000000, 0x08000000, 0x00080000, 0x08080000, 0x00000800,
0x08000800, 0x00080800, 0x08080800, 0x00000008, 0x08000008,
0x00080008, 0x08080008, 0x00000808, 0x08000808, 0x00080808,
0x08080808,
};
private static final int permLeftD[] = {
0x00000000, 0x08000000, 0x00080000, 0x08080000, 0x00000800,
0x08000800, 0x00080800, 0x08080800, 0x00000008, 0x08000008,
0x00080008, 0x08080008, 0x00000808, 0x08000808, 0x00080808,
0x08080808,
};
private static final int permRightE[] = {
0x00000000, 0x02000000, 0x00020000, 0x02020000, 0x00000200,
0x02000200, 0x00020200, 0x02020200, 0x00000002, 0x02000002,
0x00020002, 0x02020002, 0x00000202, 0x02000202, 0x00020202,
0x02020202,
};
private static final int permLeftF[] = {
0x00000000, 0x02000000, 0x00020000, 0x02020000, 0x00000200,
0x02000200, 0x00020200, 0x02020200, 0x00000002, 0x02000002,
0x00020002, 0x02020002, 0x00000202, 0x02000202, 0x00020202,
0x02020202,
};
/*
* Initial Permutation
*/
private static final int initPermLeft0[] = {
0x00000000, 0x00008000, 0x00000000, 0x00008000, 0x00000080,
0x00008080, 0x00000080, 0x00008080, 0x00000000, 0x00008000,
0x00000000, 0x00008000, 0x00000080, 0x00008080, 0x00000080,
0x00008080,
};
private static final int initPermRight0[] = {
0x00000000, 0x00000000, 0x00008000, 0x00008000, 0x00000000,
0x00000000, 0x00008000, 0x00008000, 0x00000080, 0x00000080,
0x00008080, 0x00008080, 0x00000080, 0x00000080, 0x00008080,
0x00008080,
};
private static final int initPermLeft1[] = {
0x00000000, 0x80000000, 0x00000000, 0x80000000, 0x00800000,
0x80800000, 0x00800000, 0x80800000, 0x00000000, 0x80000000,
0x00000000, 0x80000000, 0x00800000, 0x80800000, 0x00800000,
0x80800000,
};
private static final int initPermRight1[] = {
0x00000000, 0x00000000, 0x80000000, 0x80000000, 0x00000000,
0x00000000, 0x80000000, 0x80000000, 0x00800000, 0x00800000,
0x80800000, 0x80800000, 0x00800000, 0x00800000, 0x80800000,
0x80800000,
};
private static final int initPermLeft2[] = {
0x00000000, 0x00004000, 0x00000000, 0x00004000, 0x00000040,
0x00004040, 0x00000040, 0x00004040, 0x00000000, 0x00004000,
0x00000000, 0x00004000, 0x00000040, 0x00004040, 0x00000040,
0x00004040,
};
private static final int initPermRight2[] = {
0x00000000, 0x00000000, 0x00004000, 0x00004000, 0x00000000,
0x00000000, 0x00004000, 0x00004000, 0x00000040, 0x00000040,
0x00004040, 0x00004040, 0x00000040, 0x00000040, 0x00004040,
0x00004040,
};
private static final int initPermLeft3[] = {
0x00000000, 0x40000000, 0x00000000, 0x40000000, 0x00400000,
0x40400000, 0x00400000, 0x40400000, 0x00000000, 0x40000000,
0x00000000, 0x40000000, 0x00400000, 0x40400000, 0x00400000,
0x40400000,
};
private static final int initPermRight3[] = {
0x00000000, 0x00000000, 0x40000000, 0x40000000, 0x00000000,
0x00000000, 0x40000000, 0x40000000, 0x00400000, 0x00400000,
0x40400000, 0x40400000, 0x00400000, 0x00400000, 0x40400000,
0x40400000,
};
private static final int initPermLeft4[] = {
0x00000000, 0x00002000, 0x00000000, 0x00002000, 0x00000020,
0x00002020, 0x00000020, 0x00002020, 0x00000000, 0x00002000,
0x00000000, 0x00002000, 0x00000020, 0x00002020, 0x00000020,
0x00002020,
};
private static final int initPermRight4[] = {
0x00000000, 0x00000000, 0x00002000, 0x00002000, 0x00000000,
0x00000000, 0x00002000, 0x00002000, 0x00000020, 0x00000020,
0x00002020, 0x00002020, 0x00000020, 0x00000020, 0x00002020,
0x00002020,
};
private static final int initPermLeft5[] = {
0x00000000, 0x20000000, 0x00000000, 0x20000000, 0x00200000,
0x20200000, 0x00200000, 0x20200000, 0x00000000, 0x20000000,
0x00000000, 0x20000000, 0x00200000, 0x20200000, 0x00200000,
0x20200000,
};
private static final int initPermRight5[] = {
0x00000000, 0x00000000, 0x20000000, 0x20000000, 0x00000000,
0x00000000, 0x20000000, 0x20000000, 0x00200000, 0x00200000,
0x20200000, 0x20200000, 0x00200000, 0x00200000, 0x20200000,
0x20200000,
};
private static final int initPermLeft6[] = {
0x00000000, 0x00001000, 0x00000000, 0x00001000, 0x00000010,
0x00001010, 0x00000010, 0x00001010, 0x00000000, 0x00001000,
0x00000000, 0x00001000, 0x00000010, 0x00001010, 0x00000010,
0x00001010,
};
private static final int initPermRight6[] = {
0x00000000, 0x00000000, 0x00001000, 0x00001000, 0x00000000,
0x00000000, 0x00001000, 0x00001000, 0x00000010, 0x00000010,
0x00001010, 0x00001010, 0x00000010, 0x00000010, 0x00001010,
0x00001010,
};
private static final int initPermLeft7[] = {
0x00000000, 0x10000000, 0x00000000, 0x10000000, 0x00100000,
0x10100000, 0x00100000, 0x10100000, 0x00000000, 0x10000000,
0x00000000, 0x10000000, 0x00100000, 0x10100000, 0x00100000,
0x10100000,
};
private static final int initPermRight7[] = {
0x00000000, 0x00000000, 0x10000000, 0x10000000, 0x00000000,
0x00000000, 0x10000000, 0x10000000, 0x00100000, 0x00100000,
0x10100000, 0x10100000, 0x00100000, 0x00100000, 0x10100000,
0x10100000,
};
private static final int initPermLeft8[] = {
0x00000000, 0x00000800, 0x00000000, 0x00000800, 0x00000008,
0x00000808, 0x00000008, 0x00000808, 0x00000000, 0x00000800,
0x00000000, 0x00000800, 0x00000008, 0x00000808, 0x00000008,
0x00000808,
};
private static final int initPermRight8[] = {
0x00000000, 0x00000000, 0x00000800, 0x00000800, 0x00000000,
0x00000000, 0x00000800, 0x00000800, 0x00000008, 0x00000008,
0x00000808, 0x00000808, 0x00000008, 0x00000008, 0x00000808,
0x00000808,
};
private static final int initPermLeft9[] = {
0x00000000, 0x08000000, 0x00000000, 0x08000000, 0x00080000,
0x08080000, 0x00080000, 0x08080000, 0x00000000, 0x08000000,
0x00000000, 0x08000000, 0x00080000, 0x08080000, 0x00080000,
0x08080000,
};
private static final int initPermRight9[] = {
0x00000000, 0x00000000, 0x08000000, 0x08000000, 0x00000000,
0x00000000, 0x08000000, 0x08000000, 0x00080000, 0x00080000,
0x08080000, 0x08080000, 0x00080000, 0x00080000, 0x08080000,
0x08080000,
};
private static final int initPermLeftA[] = {
0x00000000, 0x00000400, 0x00000000, 0x00000400, 0x00000004,
0x00000404, 0x00000004, 0x00000404, 0x00000000, 0x00000400,
0x00000000, 0x00000400, 0x00000004, 0x00000404, 0x00000004,
0x00000404,
};
private static final int initPermRightA[] = {
0x00000000, 0x00000000, 0x00000400, 0x00000400, 0x00000000,
0x00000000, 0x00000400, 0x00000400, 0x00000004, 0x00000004,
0x00000404, 0x00000404, 0x00000004, 0x00000004, 0x00000404,
0x00000404,
};
private static final int initPermLeftB[] = {
0x00000000, 0x04000000, 0x00000000, 0x04000000, 0x00040000,
0x04040000, 0x00040000, 0x04040000, 0x00000000, 0x04000000,
0x00000000, 0x04000000, 0x00040000, 0x04040000, 0x00040000,
0x04040000,
};
private static final int initPermRightB[] = {
0x00000000, 0x00000000, 0x04000000, 0x04000000, 0x00000000,
0x00000000, 0x04000000, 0x04000000, 0x00040000, 0x00040000,
0x04040000, 0x04040000, 0x00040000, 0x00040000, 0x04040000,
0x04040000,
};
private static final int initPermLeftC[] = {
0x00000000, 0x00000200, 0x00000000, 0x00000200, 0x00000002,
0x00000202, 0x00000002, 0x00000202, 0x00000000, 0x00000200,
0x00000000, 0x00000200, 0x00000002, 0x00000202, 0x00000002,
0x00000202,
};
private static final int initPermRightC[] = {
0x00000000, 0x00000000, 0x00000200, 0x00000200, 0x00000000,
0x00000000, 0x00000200, 0x00000200, 0x00000002, 0x00000002,
0x00000202, 0x00000202, 0x00000002, 0x00000002, 0x00000202,
0x00000202,
};
private static final int initPermLeftD[] = {
0x00000000, 0x02000000, 0x00000000, 0x02000000, 0x00020000,
0x02020000, 0x00020000, 0x02020000, 0x00000000, 0x02000000,
0x00000000, 0x02000000, 0x00020000, 0x02020000, 0x00020000,
0x02020000,
};
private static final int initPermRightD[] = {
0x00000000, 0x00000000, 0x02000000, 0x02000000, 0x00000000,
0x00000000, 0x02000000, 0x02000000, 0x00020000, 0x00020000,
0x02020000, 0x02020000, 0x00020000, 0x00020000, 0x02020000,
0x02020000,
};
private static final int initPermLeftE[] = {
0x00000000, 0x00000100, 0x00000000, 0x00000100, 0x00000001,
0x00000101, 0x00000001, 0x00000101, 0x00000000, 0x00000100,
0x00000000, 0x00000100, 0x00000001, 0x00000101, 0x00000001,
0x00000101,
};
private static final int initPermRightE[] = {
0x00000000, 0x00000000, 0x00000100, 0x00000100, 0x00000000,
0x00000000, 0x00000100, 0x00000100, 0x00000001, 0x00000001,
0x00000101, 0x00000101, 0x00000001, 0x00000001, 0x00000101,
0x00000101,
};
private static final int initPermLeftF[] = {
0x00000000, 0x01000000, 0x00000000, 0x01000000, 0x00010000,
0x01010000, 0x00010000, 0x01010000, 0x00000000, 0x01000000,
0x00000000, 0x01000000, 0x00010000, 0x01010000, 0x00010000,
0x01010000,
};
private static final int initPermRightF[] = {
0x00000000, 0x00000000, 0x01000000, 0x01000000, 0x00000000,
0x00000000, 0x01000000, 0x01000000, 0x00010000, 0x00010000,
0x01010000, 0x01010000, 0x00010000, 0x00010000, 0x01010000,
0x01010000,
};
/*
* the encryption key array after expansion and permutation
*/
byte[] expandedKey = null;
/*
* Are we encrypting or decrypting?
*/
boolean decrypting = false;
/**
* Returns this cipher's block size.
*
* @return this cipher's block size
*/
int getBlockSize() {
return DES_BLOCK_SIZE;
}
void init(boolean decrypting, String algorithm, byte[] rawKey)
throws InvalidKeyException {
this.decrypting = decrypting;
if (!algorithm.equalsIgnoreCase("DES")) {
throw new InvalidKeyException("Wrong algorithm: DES required");
}
if (rawKey.length != DES_BLOCK_SIZE) {
throw new InvalidKeyException("Wrong key size");
}
expandKey(rawKey);
}
/**
* Performs encryption operation.
*
* <p>The input plain text <code>plain</code>, starting at
* <code>plainOffset</code> and ending at
* <code>(plainOffset + len - 1)</code>, is encrypted.
* The result is stored in <code>cipher</code>, starting at
* <code>cipherOffset</code>.
*
* <p>The subclass that implements Cipher should ensure that
* <code>init</code> has been called before this method is called.
*
* @param plain the buffer with the input data to be encrypted
* @param plainOffset the offset in <code>plain</code>
* @param plainLen the length of the input data
* @param cipher the buffer for the result
* @param cipherOffset the offset in <code>cipher</code>
*
* @exception IllegalBlockSizeException if the input length is different
* from the cipher's block size
*/
void encryptBlock(byte[] plain, int plainOffset,
byte[] cipher, int cipherOffset)
{
cipherBlock(plain, plainOffset, cipher, cipherOffset);
}
/**
* Performs decryption operation.
*
* <p>The input cipher text <code>cipher</code>, starting at
* <code>cipherOffset</code> and ending at
* <code>(cipherOffset + len - 1)</code>, is decrypted.
* The result is stored in <code>plain</code>, starting at
* <code>plainOffset</code>.
*
* <p>The subclass that implements Cipher should ensure that
* <code>init</code> has been called before this method is called.
*
* @param cipher the buffer with the input data to be decrypted
* @param cipherOffset the offset in <code>cipherOffset</code>
* @param cipherLen the length of the input data
* @param plain the buffer for the result
* @param plainOffset the offset in <code>plain</code>
*
* @exception IllegalBlockSizeException if the input length is different
* from the cipher's block size
*/
void decryptBlock(byte[] cipher, int cipherOffset,
byte[] plain, int plainOffset)
{
cipherBlock(cipher, cipherOffset, plain, plainOffset);
}
void cipherBlock(byte[] in, int inOffset, byte[] out, int outOffset) {
byte key[];
int temp;
int i, j;
int offset;
int left, right;
left = initialPermutationLeft(in, inOffset);
right = initialPermutationRight(in, inOffset);
key = expandedKey;
if (decrypting) {
offset = 16 - DES_BLOCK_SIZE;
j = 128 - DES_BLOCK_SIZE;
} else {
offset = 0 - DES_BLOCK_SIZE;
j = 0;
}
for (i = 0; i < 16; i++) {
// make the first and last bit adjacent
// move the first bit to the last
temp = (right << 1) | ((right >> 31) & 1);
// mangler function:
// every 6 bit is fed into the sbox, which
// produces 4-bit output
left ^= s0p[(temp & 0x3f) ^ key[j+0]]
^ s1p[((temp >> 4) & 0x3f) ^ key[j+1]]
^ s2p[((temp >> 8) & 0x3f) ^ key[j+2]]
^ s3p[((temp >> 12) & 0x3f) ^ key[j+3]]
^ s4p[((temp >> 16) & 0x3f) ^ key[j+4]]
^ s5p[((temp >> 20) & 0x3f) ^ key[j+5]]
^ s6p[((temp >> 24) & 0x3f) ^ key[j+6]];
// make the last sbox input the last bit from right[0]
temp = ((right & 1) << 5) | ((right >> 27) & 0x1f);
left ^= s7p[temp ^ key[j+7]];
temp = left;
left = right;
right = temp;
j -= offset;
}
temp = left;
left = right;
right = temp;
perm(left, right, out, outOffset);
}
private static void perm(int left, int right,
byte out[], int offset) {
int low, high, temp;
temp = left;
high = permRight0[temp & 0x0000000f];
temp >>= 4;
low = permLeft1[temp & 0x0000000f];
temp >>= 4;
high |= permRight2[temp & 0x0000000f];
temp >>= 4;
low |= permLeft3[temp & 0x0000000f];
temp >>= 4;
high |= permRight4[temp & 0x0000000f];
temp >>= 4;
low |= permLeft5[temp & 0x0000000f];
temp >>= 4;
high |= permRight6[temp & 0x0000000f];
temp >>= 4;
low |= permLeft7[temp & 0x0000000f];
temp = right;
high |= permRight8[temp & 0x0000000f];
temp >>= 4;
low |= permLeft9[temp & 0x0000000f];
temp >>= 4;
high |= permRightA[temp & 0x0000000f];
temp >>= 4;
low |= permLeftB[temp & 0x0000000f];
temp >>= 4;
high |= permRightC[temp & 0x0000000f];
temp >>= 4;
low |= permLeftD[temp & 0x0000000f];
temp >>= 4;
high |= permRightE[temp & 0x0000000f];
temp >>= 4;
low |= permLeftF[temp & 0x0000000f];
out[offset + 0] = (byte)low;
out[offset + 1] = (byte)(low >> 8);
out[offset + 2] = (byte)(low >> 16);
out[offset + 3] = (byte)(low >> 24);
out[offset + 4] = (byte)high;
out[offset + 5] = (byte)(high >> 8);
out[offset + 6] = (byte)(high >> 16);
out[offset + 7] = (byte)(high >> 24);
}
private static int initialPermutationLeft(byte block[], int offset) {
int l;
l = initPermLeft1[block[offset] & 0xf];
l |= initPermLeft0[(block[offset] >> 4) & 0xf];
l |= initPermLeft3[block[offset + 1] & 0xf];
l |= initPermLeft2[(block[offset + 1] >> 4) & 0xf];
l |= initPermLeft5[block[offset + 2] & 0xf];
l |= initPermLeft4[(block[offset + 2] >> 4) & 0xf];
l |= initPermLeft7[block[offset + 3] & 0xf];
l |= initPermLeft6[(block[offset + 3] >> 4) & 0xf];
l |= initPermLeft9[block[offset + 4] & 0xf];
l |= initPermLeft8[(block[offset + 4] >> 4) & 0xf];
l |= initPermLeftB[block[offset + 5] & 0xf];
l |= initPermLeftA[(block[offset + 5] >> 4) & 0xf];
l |= initPermLeftD[block[offset + 6] & 0xf];
l |= initPermLeftC[(block[offset + 6] >> 4) & 0xf];
l |= initPermLeftF[block[offset + 7] & 0xf];
l |= initPermLeftE[(block[offset + 7] >> 4) & 0xf];
return l;
}
private static int initialPermutationRight(byte block[], int offset) {
int l;
l = initPermRight1[block[offset] & 0xf];
l |= initPermRight0[(block[offset] >> 4) & 0xf];
l |= initPermRight3[block[offset + 1] & 0xf];
l |= initPermRight2[(block[offset + 1] >> 4) & 0xf];
l |= initPermRight5[block[offset + 2] & 0xf];
l |= initPermRight4[(block[offset + 2] >> 4) & 0xf];
l |= initPermRight7[block[offset + 3] & 0xf];
l |= initPermRight6[(block[offset + 3] >> 4) & 0xf];
l |= initPermRight9[block[offset + 4] & 0xf];
l |= initPermRight8[(block[offset + 4] >> 4) & 0xf];
l |= initPermRightB[block[offset + 5] & 0xf];
l |= initPermRightA[(block[offset + 5] >> 4) & 0xf];
l |= initPermRightD[block[offset + 6] & 0xf];
l |= initPermRightC[(block[offset + 6] >> 4) & 0xf];
l |= initPermRightF[block[offset + 7] & 0xf];
l |= initPermRightE[(block[offset + 7] >> 4) & 0xf];
return l;
}
void expandKey(byte key[]) {
int octet;
byte ek[] = new byte[128];
octet = key[0];
if ((octet & 0x80) != 0) {
ek[ 3] |= 2; ek[ 9] |= 8; ek[ 18] |= 8;
ek[ 27] |= 32; ek[ 33] |= 2; ek[ 42] |= 16;
ek[ 48] |= 8; ek[ 65] |= 16; ek[ 74] |= 2;
ek[ 80] |= 2; ek[ 89] |= 4; ek[ 99] |= 16;
ek[104] |= 4; ek[122] |= 32;
}
if ((octet & 0x40) != 0) {
ek[ 1] |= 4; ek[ 8] |= 1; ek[ 18] |= 4;
ek[ 25] |= 32; ek[ 34] |= 32; ek[ 41] |= 8;
ek[ 50] |= 8; ek[ 59] |= 32; ek[ 64] |= 16;
ek[ 75] |= 4; ek[ 90] |= 1; ek[ 97] |= 16;
ek[106] |= 2; ek[112] |= 2; ek[123] |= 1;
}
if ((octet & 0x20) != 0) {
ek[ 2] |= 1; ek[ 19] |= 8; ek[ 35] |= 1;
ek[ 40] |= 1; ek[ 50] |= 4; ek[ 57] |= 32;
ek[ 75] |= 2; ek[ 80] |= 32; ek[ 89] |= 1;
ek[ 96] |= 16; ek[107] |= 4; ek[120] |= 8;
}
if ((octet & 0x10) != 0) {
ek[ 4] |= 32; ek[ 20] |= 2; ek[ 31] |= 4;
ek[ 37] |= 32; ek[ 47] |= 1; ek[ 54] |= 1;
ek[ 63] |= 2; ek[ 68] |= 1; ek[ 78] |= 4;
ek[ 84] |= 8; ek[101] |= 16; ek[108] |= 4;
ek[119] |= 16; ek[126] |= 8;
}
if ((octet & 0x8) != 0) {
ek[ 5] |= 4; ek[ 15] |= 4; ek[ 21] |= 32;
ek[ 31] |= 1; ek[ 38] |= 1; ek[ 47] |= 2;
ek[ 53] |= 2; ek[ 68] |= 8; ek[ 85] |= 16;
ek[ 92] |= 4; ek[103] |= 16; ek[108] |= 32;
ek[118] |= 32; ek[124] |= 2;
}
if ((octet & 0x4) != 0) {
ek[ 15] |= 2; ek[ 21] |= 2; ek[ 39] |= 8;
ek[ 46] |= 16; ek[ 55] |= 32; ek[ 61] |= 1;
ek[ 71] |= 16; ek[ 76] |= 32; ek[ 86] |= 32;
ek[ 93] |= 4; ek[102] |= 2; ek[108] |= 16;
ek[117] |= 8; ek[126] |= 1;
}
if ((octet & 0x2) != 0) {
ek[ 14] |= 16; ek[ 23] |= 32; ek[ 29] |= 1;
ek[ 38] |= 8; ek[ 52] |= 2; ek[ 63] |= 4;
ek[ 70] |= 2; ek[ 76] |= 16; ek[ 85] |= 8;
ek[100] |= 1; ek[110] |= 4; ek[116] |= 8;
ek[127] |= 8;
}
octet = key[1];
if ((octet & 0x80) != 0) {
ek[ 1] |= 8; ek[ 8] |= 32; ek[ 17] |= 1;
ek[ 24] |= 16; ek[ 35] |= 4; ek[ 50] |= 1;
ek[ 57] |= 16; ek[ 67] |= 8; ek[ 83] |= 1;
ek[ 88] |= 1; ek[ 98] |= 4; ek[105] |= 32;
ek[114] |= 32; ek[123] |= 2;
}
if ((octet & 0x40) != 0) {
ek[ 0] |= 1; ek[ 11] |= 16; ek[ 16] |= 4;
ek[ 35] |= 2; ek[ 40] |= 32; ek[ 49] |= 1;
ek[ 56] |= 16; ek[ 65] |= 2; ek[ 74] |= 16;
ek[ 80] |= 8; ek[ 99] |= 8; ek[115] |= 1;
ek[121] |= 4;
}
if ((octet & 0x20) != 0) {
ek[ 9] |= 16; ek[ 18] |= 2; ek[ 24] |= 2;
ek[ 33] |= 4; ek[ 43] |= 16; ek[ 48] |= 4;
ek[ 66] |= 32; ek[ 73] |= 8; ek[ 82] |= 8;
ek[ 91] |= 32; ek[ 97] |= 2; ek[106] |= 16;
ek[112] |= 8; ek[122] |= 1;
}
if ((octet & 0x10) != 0) {
ek[ 14] |= 32; ek[ 21] |= 4; ek[ 30] |= 2;
ek[ 36] |= 16; ek[ 45] |= 8; ek[ 60] |= 1;
ek[ 69] |= 2; ek[ 87] |= 8; ek[ 94] |= 16;
ek[103] |= 32; ek[109] |= 1; ek[118] |= 8;
ek[124] |= 32;
}
if ((octet & 0x8) != 0) {
ek[ 7] |= 4; ek[ 14] |= 2; ek[ 20] |= 16;
ek[ 29] |= 8; ek[ 44] |= 1; ek[ 54] |= 4;
ek[ 60] |= 8; ek[ 71] |= 8; ek[ 78] |= 16;
ek[ 87] |= 32; ek[ 93] |= 1; ek[102] |= 8;
ek[116] |= 2; ek[125] |= 4;
}
if ((octet & 0x4) != 0) {
ek[ 7] |= 2; ek[ 12] |= 1; ek[ 22] |= 4;
ek[ 28] |= 8; ek[ 45] |= 16; ek[ 52] |= 4;
ek[ 63] |= 16; ek[ 70] |= 8; ek[ 84] |= 2;
ek[ 95] |= 4; ek[101] |= 32; ek[111] |= 1;
ek[118] |= 1;
}
if ((octet & 0x2) != 0) {
ek[ 6] |= 16; ek[ 13] |= 16; ek[ 20] |= 4;
ek[ 31] |= 16; ek[ 36] |= 32; ek[ 46] |= 32;
ek[ 53] |= 4; ek[ 62] |= 2; ek[ 69] |= 32;
ek[ 79] |= 1; ek[ 86] |= 1; ek[ 95] |= 2;
ek[101] |= 2; ek[119] |= 8;
}
octet = key[2];
if ((octet & 0x80) != 0) {
ek[ 0] |= 32; ek[ 10] |= 8; ek[ 19] |= 32;
ek[ 25] |= 2; ek[ 34] |= 16; ek[ 40] |= 8;
ek[ 59] |= 8; ek[ 66] |= 2; ek[ 72] |= 2;
ek[ 81] |= 4; ek[ 91] |= 16; ek[ 96] |= 4;
ek[115] |= 2; ek[121] |= 8;
}
if ((octet & 0x40) != 0) {
ek[ 3] |= 16; ek[ 10] |= 4; ek[ 17] |= 32;
ek[ 26] |= 32; ek[ 33] |= 8; ek[ 42] |= 8;
ek[ 51] |= 32; ek[ 57] |= 2; ek[ 67] |= 4;
ek[ 82] |= 1; ek[ 89] |= 16; ek[ 98] |= 2;
ek[104] |= 2; ek[113] |= 4; ek[120] |= 1;
}
if ((octet & 0x20) != 0) {
ek[ 1] |= 16; ek[ 11] |= 8; ek[ 27] |= 1;
ek[ 32] |= 1; ek[ 42] |= 4; ek[ 49] |= 32;
ek[ 58] |= 32; ek[ 67] |= 2; ek[ 72] |= 32;
ek[ 81] |= 1; ek[ 88] |= 16; ek[ 99] |= 4;
ek[114] |= 1;
}
if ((octet & 0x10) != 0) {
ek[ 6] |= 32; ek[ 12] |= 2; ek[ 23] |= 4;
ek[ 29] |= 32; ek[ 39] |= 1; ek[ 46] |= 1;
ek[ 55] |= 2; ek[ 61] |= 2; ek[ 70] |= 4;
ek[ 76] |= 8; ek[ 93] |= 16; ek[100] |= 4;
ek[111] |= 16; ek[116] |= 32;
}
if ((octet & 0x8) != 0) {
ek[ 6] |= 2; ek[ 13] |= 32; ek[ 23] |= 1;
ek[ 30] |= 1; ek[ 39] |= 2; ek[ 45] |= 2;
ek[ 63] |= 8; ek[ 77] |= 16; ek[ 84] |= 4;
ek[ 95] |= 16; ek[100] |= 32; ek[110] |= 32;
ek[117] |= 4; ek[127] |= 4;
}
if ((octet & 0x4) != 0) {
ek[ 4] |= 1; ek[ 13] |= 2; ek[ 31] |= 8;
ek[ 38] |= 16; ek[ 47] |= 32; ek[ 53] |= 1;
ek[ 62] |= 8; ek[ 68] |= 32; ek[ 78] |= 32;
ek[ 85] |= 4; ek[ 94] |= 2; ek[100] |= 16;
ek[109] |= 8; ek[127] |= 2;
}
if ((octet & 0x2) != 0) {
ek[ 5] |= 16; ek[ 15] |= 32; ek[ 21] |= 1;
ek[ 30] |= 8; ek[ 44] |= 2; ek[ 55] |= 4;
ek[ 61] |= 32; ek[ 68] |= 16; ek[ 77] |= 8;
ek[ 92] |= 1; ek[102] |= 4; ek[108] |= 8;
ek[126] |= 16;
}
octet = key[3];
if ((octet & 0x80) != 0) {
ek[ 2] |= 8; ek[ 9] |= 1; ek[ 16] |= 16;
ek[ 27] |= 4; ek[ 42] |= 1; ek[ 49] |= 16;
ek[ 58] |= 2; ek[ 75] |= 1; ek[ 80] |= 1;
ek[ 90] |= 4; ek[ 97] |= 32; ek[106] |= 32;
ek[113] |= 8; ek[120] |= 32;
}
if ((octet & 0x40) != 0) {
ek[ 2] |= 4; ek[ 8] |= 4; ek[ 27] |= 2;
ek[ 32] |= 32; ek[ 41] |= 1; ek[ 48] |= 16;
ek[ 59] |= 4; ek[ 66] |= 16; ek[ 72] |= 8;
ek[ 91] |= 8; ek[107] |= 1; ek[112] |= 1;
ek[123] |= 16;
}
if ((octet & 0x20) != 0) {
ek[ 3] |= 8; ek[ 10] |= 2; ek[ 16] |= 2;
ek[ 25] |= 4; ek[ 35] |= 16; ek[ 40] |= 4;
ek[ 59] |= 2; ek[ 65] |= 8; ek[ 74] |= 8;
ek[ 83] |= 32; ek[ 89] |= 2; ek[ 98] |= 16;
ek[104] |= 8; ek[121] |= 16;
}
if ((octet & 0x10) != 0) {
ek[ 4] |= 2; ek[ 13] |= 4; ek[ 22] |= 2;
ek[ 28] |= 16; ek[ 37] |= 8; ek[ 52] |= 1;
ek[ 62] |= 4; ek[ 79] |= 8; ek[ 86] |= 16;
ek[ 95] |= 32; ek[101] |= 1; ek[110] |= 8;
ek[126] |= 32;
}
if ((octet & 0x8) != 0) {
ek[ 5] |= 32; ek[ 12] |= 16; ek[ 21] |= 8;
ek[ 36] |= 1; ek[ 46] |= 4; ek[ 52] |= 8;
ek[ 70] |= 16; ek[ 79] |= 32; ek[ 85] |= 1;
ek[ 94] |= 8; ek[108] |= 2; ek[119] |= 4;
ek[126] |= 2;
}
if ((octet & 0x4) != 0) {
ek[ 5] |= 2; ek[ 14] |= 4; ek[ 20] |= 8;
ek[ 37] |= 16; ek[ 44] |= 4; ek[ 55] |= 16;
ek[ 60] |= 32; ek[ 76] |= 2; ek[ 87] |= 4;
ek[ 93] |= 32; ek[103] |= 1; ek[110] |= 1;
ek[119] |= 2; ek[124] |= 1;
}
if ((octet & 0x2) != 0) {
ek[ 7] |= 32; ek[ 12] |= 4; ek[ 23] |= 16;
ek[ 28] |= 32; ek[ 38] |= 32; ek[ 45] |= 4;
ek[ 54] |= 2; ek[ 60] |= 16; ek[ 71] |= 1;
ek[ 78] |= 1; ek[ 87] |= 2; ek[ 93] |= 2;
ek[111] |= 8; ek[118] |= 16; ek[125] |= 16;
}
octet = key[4];
if ((octet & 0x80) != 0) {
ek[ 1] |= 1; ek[ 11] |= 32; ek[ 17] |= 2;
ek[ 26] |= 16; ek[ 32] |= 8; ek[ 51] |= 8;
ek[ 64] |= 2; ek[ 73] |= 4; ek[ 83] |= 16;
ek[ 88] |= 4; ek[107] |= 2; ek[112] |= 32;
ek[122] |= 8;
}
if ((octet & 0x40) != 0) {
ek[ 0] |= 4; ek[ 9] |= 32; ek[ 18] |= 32;
ek[ 25] |= 8; ek[ 34] |= 8; ek[ 43] |= 32;
ek[ 49] |= 2; ek[ 58] |= 16; ek[ 74] |= 1;
ek[ 81] |= 16; ek[ 90] |= 2; ek[ 96] |= 2;
ek[105] |= 4; ek[115] |= 16; ek[122] |= 4;
}
if ((octet & 0x20) != 0) {
ek[ 2] |= 2; ek[ 19] |= 1; ek[ 24] |= 1;
ek[ 34] |= 4; ek[ 41] |= 32; ek[ 50] |= 32;
ek[ 57] |= 8; ek[ 64] |= 32; ek[ 73] |= 1;
ek[ 80] |= 16; ek[ 91] |= 4; ek[106] |= 1;
ek[113] |= 16; ek[123] |= 8;
}
if ((octet & 0x10) != 0) {
ek[ 3] |= 4; ek[ 10] |= 16; ek[ 16] |= 8;
ek[ 35] |= 8; ek[ 51] |= 1; ek[ 56] |= 1;
ek[ 67] |= 16; ek[ 72] |= 4; ek[ 91] |= 2;
ek[ 96] |= 32; ek[105] |= 1; ek[112] |= 16;
ek[121] |= 2;
}
if ((octet & 0x8) != 0) {
ek[ 4] |= 16; ek[ 15] |= 1; ek[ 22] |= 1;
ek[ 31] |= 2; ek[ 37] |= 2; ek[ 55] |= 8;
ek[ 62] |= 16; ek[ 69] |= 16; ek[ 76] |= 4;
ek[ 87] |= 16; ek[ 92] |= 32; ek[102] |= 32;
ek[109] |= 4; ek[118] |= 2; ek[125] |= 32;
}
if ((octet & 0x4) != 0) {
ek[ 6] |= 4; ek[ 23] |= 8; ek[ 30] |= 16;
ek[ 39] |= 32; ek[ 45] |= 1; ek[ 54] |= 8;
ek[ 70] |= 32; ek[ 77] |= 4; ek[ 86] |= 2;
ek[ 92] |= 16; ek[101] |= 8; ek[116] |= 1;
ek[125] |= 2;
}
if ((octet & 0x2) != 0) {
ek[ 4] |= 4; ek[ 13] |= 1; ek[ 22] |= 8;
ek[ 36] |= 2; ek[ 47] |= 4; ek[ 53] |= 32;
ek[ 63] |= 1; ek[ 69] |= 8; ek[ 84] |= 1;
ek[ 94] |= 4; ek[100] |= 8; ek[117] |= 16;
ek[127] |= 32;
}
octet = key[5];
if ((octet & 0x80) != 0) {
ek[ 3] |= 32; ek[ 8] |= 16; ek[ 19] |= 4;
ek[ 34] |= 1; ek[ 41] |= 16; ek[ 50] |= 2;
ek[ 56] |= 2; ek[ 67] |= 1; ek[ 72] |= 1;
ek[ 82] |= 4; ek[ 89] |= 32; ek[ 98] |= 32;
ek[105] |= 8; ek[114] |= 8; ek[121] |= 1;
}
if ((octet & 0x40) != 0) {
ek[ 1] |= 32; ek[ 19] |= 2; ek[ 24] |= 32;
ek[ 33] |= 1; ek[ 40] |= 16; ek[ 51] |= 4;
ek[ 64] |= 8; ek[ 83] |= 8; ek[ 99] |= 1;
ek[104] |= 1; ek[114] |= 4; ek[120] |= 4;
}
if ((octet & 0x20) != 0) {
ek[ 8] |= 2; ek[ 17] |= 4; ek[ 27] |= 16;
ek[ 32] |= 4; ek[ 51] |= 2; ek[ 56] |= 32;
ek[ 66] |= 8; ek[ 75] |= 32; ek[ 81] |= 2;
ek[ 90] |= 16; ek[ 96] |= 8; ek[115] |= 8;
ek[122] |= 2;
}
if ((octet & 0x10) != 0) {
ek[ 2] |= 16; ek[ 18] |= 1; ek[ 25] |= 16;
ek[ 34] |= 2; ek[ 40] |= 2; ek[ 49] |= 4;
ek[ 59] |= 16; ek[ 66] |= 4; ek[ 73] |= 32;
ek[ 82] |= 32; ek[ 89] |= 8; ek[ 98] |= 8;
ek[107] |= 32; ek[113] |= 2; ek[123] |= 4;
}
if ((octet & 0x8) != 0) {
ek[ 7] |= 1; ek[ 13] |= 8; ek[ 28] |= 1;
ek[ 38] |= 4; ek[ 44] |= 8; ek[ 61] |= 16;
ek[ 71] |= 32; ek[ 77] |= 1; ek[ 86] |= 8;
ek[100] |= 2; ek[111] |= 4; ek[117] |= 32;
ek[124] |= 16;
}
if ((octet & 0x4) != 0) {
ek[ 12] |= 8; ek[ 29] |= 16; ek[ 36] |= 4;
ek[ 47] |= 16; ek[ 52] |= 32; ek[ 62] |= 32;
ek[ 68] |= 2; ek[ 79] |= 4; ek[ 85] |= 32;
/**代码未完, 请加载全部代码(NowJava.com).**/
关注时代Java
关注时代Java