| /* |
| * 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; |
| ek[ 95] |= 1; ek[102] |= 1; ek[111] |= 2; |
| ek[117] |= 2; ek[126] |= 4; |
| } |
| if ((octet & 0x2) != 0) { |
| ek[ 5] |= 1; ek[ 15] |= 16; ek[ 20] |= 32; |
| ek[ 30] |= 32; ek[ 37] |= 4; ek[ 46] |= 2; |
| ek[ 52] |= 16; ek[ 61] |= 8; ek[ 70] |= 1; |
| ek[ 79] |= 2; ek[ 85] |= 2; ek[103] |= 8; |
| ek[110] |= 16; ek[119] |= 32; ek[124] |= 4; |
| } |
| octet = key[6]; |
| if ((octet & 0x80) != 0) { |
| ek[ 0] |= 16; ek[ 9] |= 2; ek[ 18] |= 16; |
| ek[ 24] |= 8; ek[ 43] |= 8; ek[ 59] |= 1; |
| ek[ 65] |= 4; ek[ 75] |= 16; ek[ 80] |= 4; |
| ek[ 99] |= 2; ek[104] |= 32; ek[113] |= 1; |
| ek[123] |= 32; |
| } |
| if ((octet & 0x40) != 0) { |
| ek[ 10] |= 32; ek[ 17] |= 8; ek[ 26] |= 8; |
| ek[ 35] |= 32; ek[ 41] |= 2; ek[ 50] |= 16; |
| ek[ 56] |= 8; ek[ 66] |= 1; ek[ 73] |= 16; |
| ek[ 82] |= 2; ek[ 88] |= 2; ek[ 97] |= 4; |
| ek[107] |= 16; ek[112] |= 4; ek[121] |= 32; |
| } |
| if ((octet & 0x20) != 0) { |
| ek[ 0] |= 2; ek[ 11] |= 1; ek[ 16] |= 1; |
| ek[ 26] |= 4; ek[ 33] |= 32; ek[ 42] |= 32; |
| ek[ 49] |= 8; ek[ 58] |= 8; ek[ 65] |= 1; |
| ek[ 72] |= 16; ek[ 83] |= 4; ek[ 98] |= 1; |
| ek[105] |= 16; ek[114] |= 2; |
| } |
| if ((octet & 0x10) != 0) { |
| ek[ 8] |= 8; ek[ 27] |= 8; ek[ 43] |= 1; |
| ek[ 48] |= 1; ek[ 58] |= 4; ek[ 64] |= 4; |
| ek[ 83] |= 2; ek[ 88] |= 32; ek[ 97] |= 1; |
| ek[104] |= 16; ek[115] |= 4; ek[122] |= 16; |
| } |
| if ((octet & 0x8) != 0) { |
| ek[ 5] |= 8; ek[ 14] |= 1; ek[ 23] |= 2; |
| ek[ 29] |= 2; ek[ 47] |= 8; ek[ 54] |= 16; |
| ek[ 63] |= 32; ek[ 68] |= 4; ek[ 79] |= 16; |
| ek[ 84] |= 32; ek[ 94] |= 32; ek[101] |= 4; |
| ek[110] |= 2; ek[116] |= 16; ek[127] |= 1; |
| } |
| if ((octet & 0x4) != 0) { |
| ek[ 4] |= 8; ek[ 15] |= 8; ek[ 22] |= 16; |
| ek[ 31] |= 32; ek[ 37] |= 1; ek[ 46] |= 8; |
| ek[ 60] |= 2; ek[ 69] |= 4; ek[ 78] |= 2; |
| ek[ 84] |= 16; ek[ 93] |= 8; ek[108] |= 1; |
| ek[118] |= 4; |
| } |
| if ((octet & 0x2) != 0) { |
| ek[ 7] |= 16; ek[ 14] |= 8; ek[ 28] |= 2; |
| ek[ 39] |= 4; ek[ 45] |= 32; ek[ 55] |= 1; |
| ek[ 62] |= 1; ek[ 76] |= 1; ek[ 86] |= 4; |
| ek[ 92] |= 8; ek[109] |= 16; ek[116] |= 4; |
| ek[125] |= 1; |
| } |
| octet = key[7]; |
| if ((octet & 0x80) != 0) { |
| ek[ 1] |= 2; ek[ 11] |= 4; ek[ 26] |= 1; |
| ek[ 33] |= 16; ek[ 42] |= 2; ek[ 48] |= 2; |
| ek[ 57] |= 4; ek[ 64] |= 1; ek[ 74] |= 4; |
| ek[ 81] |= 32; ek[ 90] |= 32; ek[ 97] |= 8; |
| ek[106] |= 8; ek[115] |= 32; ek[120] |= 16; |
| } |
| if ((octet & 0x40) != 0) { |
| ek[ 2] |= 32; ek[ 11] |= 2; ek[ 16] |= 32; |
| ek[ 25] |= 1; ek[ 32] |= 16; ek[ 43] |= 4; |
| ek[ 58] |= 1; ek[ 75] |= 8; ek[ 91] |= 1; |
| ek[ 96] |= 1; ek[106] |= 4; ek[113] |= 32; |
| } |
| if ((octet & 0x20) != 0) { |
| ek[ 3] |= 1; ek[ 9] |= 4; ek[ 19] |= 16; |
| ek[ 24] |= 4; ek[ 43] |= 2; ek[ 48] |= 32; |
| ek[ 57] |= 1; ek[ 67] |= 32; ek[ 73] |= 2; |
| ek[ 82] |= 16; ek[ 88] |= 8; ek[107] |= 8; |
| ek[120] |= 2; |
| } |
| if ((octet & 0x10) != 0) { |
| ek[ 0] |= 8; ek[ 10] |= 1; ek[ 17] |= 16; |
| ek[ 26] |= 2; ek[ 32] |= 2; ek[ 41] |= 4; |
| ek[ 51] |= 16; ek[ 56] |= 4; ek[ 65] |= 32; |
| ek[ 74] |= 32; ek[ 81] |= 8; ek[ 90] |= 8; |
| ek[ 99] |= 32; ek[105] |= 2; ek[114] |= 16; |
| } |
| if ((octet & 0x8) != 0) { |
| ek[ 6] |= 1; ek[ 20] |= 1; ek[ 30] |= 4; |
| ek[ 36] |= 8; ek[ 53] |= 16; ek[ 60] |= 4; |
| ek[ 69] |= 1; ek[ 78] |= 8; ek[ 92] |= 2; |
| ek[103] |= 4; ek[109] |= 32; ek[119] |= 1; |
| ek[125] |= 8; |
| } |
| if ((octet & 0x4) != 0) { |
| ek[ 7] |= 8; ek[ 21] |= 16; ek[ 28] |= 4; |
| ek[ 39] |= 16; ek[ 44] |= 32; ek[ 54] |= 32; |
| ek[ 61] |= 4; ek[ 71] |= 4; ek[ 77] |= 32; |
| ek[ 87] |= 1; ek[ 94] |= 1; ek[103] |= 2; |
| ek[109] |= 2; ek[124] |= 8; |
| } |
| if ((octet & 0x2) != 0) { |
| ek[ 6] |= 8; ek[ 12] |= 32; ek[ 22] |= 32; |
| ek[ 29] |= 4; ek[ 38] |= 2; ek[ 44] |= 16; |
| ek[ 53] |= 8; ek[ 71] |= 2; ek[ 77] |= 2; |
| ek[ 95] |= 8; ek[102] |= 16; ek[111] |= 32; |
| ek[117] |= 1; ek[127] |= 16; |
| } |
| |
| expandedKey = ek; |
| } |
| } |