Bit permutation inside a byte array

Question

Hi everyone,
I'm trying to implement DES algorithm, i want to permute specified bits inside an 8byte array.
I tought about extract every bits from the byte array inside a 64 byte array and then do the permutation.
But i don't see how to put these bits back into an 8byte array to return the result of encryption/decryption.
This is what i've done so far (inspired by sources i found on the internet) :
// extends 8 byte array into a 64 byte array
public static byte[] extendsByteArray(byte[] bytes) {
byte[] tab = bytes;
short len = (short)(desBlockSize * (short)8);
byte[] bits = new byte[len];
short i,j;
for (i = (short)(desBlockSize - (short)1); i >=0; i--) {
for (j = (short)0; j < desBlockSize; j++)
bits[--len] = (byte) ((tab[i] >> j) & 0x01);
return bits;
// 64 byte array to 8 byte array
public static byte[] transformByteArray(byte[] bits){
byte[] tab = bits;
byte[] bytes = new byte[desBlockSize];
short i,j = (short)0;
for ( i = (short)0; i < (short)8; i++){
bytes[i] = (byte)((bits[j] * (short)2^7) + (bits[j+(short)1] * (short)2^6)+
               (bits[j+(short)2] * (short)2^5) + (bits[j+(short)3] * (short)2^4)
               + (bits[j+(short)4] * (short)2^3) + (bits[j+(short)5] * (short)2^2)
               + (bits[j+(short)6] * (short)2) + (bits[j+(short)7]));
j +=(short)7;
return bits;
This implementation doesn't seems to work, do u have some ideas why it doesn't work or is there an easier solution to permute bits as i'm stuck with this fo the moment.
Thanks in advance for your answers,
Julien

Answer 1

If you are using JavaCard please do not use multiplications as you used in your code. Integer multiplications are very slow in any platform that does not implement them in hardware, and the virtual machine that runs in JavaCards usually does not do any optimizations or Just-In-Time compiling - simply interprets the codes. Memory and CPU power are at a premium in Java Cards. Even if your Java Card has a hardware multiplier, usually it is reserved for RSA operations - it is not available for general use for Java programs.
Instead of using x * 2 raised to the sixth power, use x << 6. It is faster and generates fewer bytecodes.