[Активист]

Скачал с инета не сильно старую ревизию тех же разработчиков.
Порылся в файлах нашел интересненькое incolution.jar а в нем уже
Blowfish.class
Crypt.class
Twofish.class
Теперь посмотрю темки по декомпиляции, надеюсь если и получится, то хотя бы читабельный код.

Добавлено через 2 часа 50 минут
Декодировал эту красоту теперь надо посидеть над кодом и подумать, но время поджимает и некогда сидеть за разбором кода.


Добавлено через 8 минут
Blowfish
Оффтоп

package org.inc.nionetcore.util.crypt;

import org.inc.incolution.util.ArrayUtil;

public final class Blowfish
  extends Crypt
{
  private static final int BLOCK_SIZE = 8;
  private static final int[] KP = { 111111111, -1111111111 };//// в этих массивах я убрал кучу переменных
  private static final int[] KS1 = { 111111111,  -111111111 };//// в этих массивах я убрал кучу переменных
  private static final int[] KS2 = { -111111111, 1111111111 };//// в этих массивах я убрал кучу переменных
  private static final int[] KS3 = { 111111111, 111111111 };//// в этих массивах я убрал кучу переменных
  private static final int P_SZ = 18;
  private static final int ROUNDS = 16;
  private static final int SBOX_SK = 256;
  private final int[] _P;
  private final int[] _S0;
  private final int[] _S1;
  private final int[] _S2;
  private final int[] _S3;
  
  public Blowfish(byte[] key)
  {
    super(key);
    
    this._S0 = new int[256];
    this._S1 = new int[256];
    this._S2 = new int[256];
    this._S3 = new int[256];
    this._P = new int[18];
    
    System.arraycopy(KS0, 0, this._S0, 0, 256);
    System.arraycopy(KS1, 0, this._S1, 0, 256);
    System.arraycopy(KS2, 0, this._S2, 0, 256);
    System.arraycopy(KS3, 0, this._S3, 0, 256);
    System.arraycopy(KP, 0, this._P, 0, 18);
    
    int keyLength = key.length;
    int keyIndex = 0;
    for (int i = 0; i < 18; i++)
    {
      int data = 0;
      for (int j = 0; j < 4; j++)
      {
        data = data << 8 | key[(keyIndex++)] & 0xFF;
        if (keyIndex >= keyLength) {
          keyIndex = 0;
        }
      }
      this._P[i] ^= data;
    }
    processTable(0, 0, this._P);
    processTable(this._P[16], this._P[17], this._S0);
    processTable(this._S0['þ'], this._S0['ÿ'], this._S1);
    processTable(this._S1['þ'], this._S1['ÿ'], this._S2);
    processTable(this._S2['þ'], this._S2['ÿ'], this._S3);
  }
  
  public final void appendChecksum(byte[] raw, int offset, int size)
  {
    int count = offset + size - 4;
    int checksum = 0;
    for (; offset < count; offset += 4) {
      checksum ^= ArrayUtil.getD(raw, offset);
    }
    ArrayUtil.putD(raw, offset, checksum);
  }
  
  protected final void decryptBlock(byte[] data, int offset)
  {
    int xl = ArrayUtil.getD(data, offset);
    int xr = ArrayUtil.getD(data, offset + 4);
    xl ^= this._P[17];
    for (int k = 16; k > 0;)
    {
      xr ^= func(xl) ^ this._P[(k--)];
      xl ^= func(xr) ^ this._P[(k--)];
    }
    xr ^= this._P[0];
    ArrayUtil.putD(data, offset, xr);
    ArrayUtil.putD(data, offset + 4, xl);
  }
  
  protected final void encryptBlock(byte[] data, int offset)
  {
    int xl = ArrayUtil.getD(data, offset);
    int xr = ArrayUtil.getD(data, offset + 4);
    xl ^= this._P[0];
    for (int k = 1; k < 16;)
    {
      xr ^= func(xl) ^ this._P[(k++)];
      xl ^= func(xr) ^ this._P[(k++)];
    }
    xr ^= this._P[17];
    ArrayUtil.putD(data, offset, xr);
    ArrayUtil.putD(data, offset + 4, xl);
  }
  
  private final int func(int x)
  {
    return (this._S0[(x >>> 24)] + this._S1[(x >>> 16 & 0xFF)] ^ this._S2[(x >>> 8 & 0xFF)]) + this._S3[(x & 0xFF)];
  }
  
  protected final int getBlockSize()
  {
    return 8;
  }
  
  private final void processTable(int xl, int xr, int[] table)
  {
    int size = table.length;
    for (int s = 0; s < size; s += 2)
    {
      xl ^= this._P[0];
      for (int i = 1; i < 16; i += 2)
      {
        xr ^= func(xl) ^ this._P[i];
        xl ^= func(xr) ^ this._P[(i + 1)];
      }
      xr ^= this._P[17];
      table[s] = xr;
      table[(s + 1)] = xl;
      xr = xl;
      xl = table[s];
    }
  }
  
  public final boolean verifyChecksum(byte[] raw, int offset, int size)
  {
    if ((size <= 4) || ((size & 0x3) != 0)) {
      return false;
    }
    int count = offset + size - 4;
    int checksum = 0;
    for (; offset < count; offset += 4) {
      checksum ^= ArrayUtil.getD(raw, offset);
    }
    return checksum == ArrayUtil.getD(raw, offset);
  }
  
  public final int calcDataSize(int size)
  {
    size += 4;
    return size + (8 - size % 8);
  }
}

Crypt
Оффтоп

package org.inc.nionetcore.util.crypt;

import java.util.Random;
import org.inc.incolution.util.ArrayUtil;

public abstract class Crypt
{
  private static final Random rnd = new Random();
  public static final int KEY_256_BIT = 32;
  public static final int KEY_192_BIT = 24;
  public static final int KEY_128_BIT = 16;
  public static final int KEY_64_BIT = 8;
  private final byte[] _key;
  
  public static void encXORPass(byte[] raw, int key)
  {
    Blowfish.encXORPass(raw, 0, raw.length, key);
  }
  
  public static void encXORPass(byte[] raw, int offset, int size, int key)
  {
    int stop = size - 8;
    int pos = 4 + offset;
    
    int ecx = key;
    while (pos < stop)
    {
      int edx = raw[pos] & 0xFF;
      edx |= (raw[(pos + 1)] & 0xFF) << 8;
      edx |= (raw[(pos + 2)] & 0xFF) << 16;
      edx |= (raw[(pos + 3)] & 0xFF) << 24;
      
      ecx += edx;
      edx ^= ecx;
      
      raw[(pos++)] = ((byte)(edx & 0xFF));
      raw[(pos++)] = ((byte)(edx >> 8 & 0xFF));
      raw[(pos++)] = ((byte)(edx >> 16 & 0xFF));
      raw[(pos++)] = ((byte)(edx >> 24 & 0xFF));
    }
    raw[(pos++)] = ((byte)(ecx & 0xFF));
    raw[(pos++)] = ((byte)(ecx >> 8 & 0xFF));
    raw[(pos++)] = ((byte)(ecx >> 16 & 0xFF));
    raw[pos] = ((byte)(ecx >> 24 & 0xFF));
  }
  
  public static void decXORPass(byte[] raw, int offset, int size)
  {
    size = size + offset - 8;
    offset += 4;
    int ecx = ArrayUtil.getD(raw, size);
    ArrayUtil.putD(raw, size, 0);
    while (size > offset)
    {
      size -= 4;
      int edx = ArrayUtil.getD(raw, size);
      edx ^= ecx;
      ecx -= edx;
      ArrayUtil.putD(raw, size, edx);
    }
  }
  
  protected Crypt(byte[] key)
  {
    this._key = key;
  }
  
  public final byte[] getKey()
  {
    return this._key;
  }
  
  public static final byte[] generateTwofishKey(int keyLenght)
  {
    checkTwofishKeyLenght(keyLenght);
    byte[] key = new byte[keyLenght];
    rnd.nextBytes(key);
    return key;
  }
  
  public static final byte[] generateBlowfishKey(int keyLenght)
  {
    byte[] key = new byte[keyLenght];
    rnd.nextBytes(key);
    return key;
  }
  
  protected static void checkTwofishKeyLenght(int keyLenght)
  {
    switch (keyLenght)
    {
    case 8: 
    case 16: 
    case 24: 
    case 32: 
      break;
    default: 
      throw new IllegalArgumentException("Incorrect key length");
    }
  }
  
  public final void decrypt(byte[] data, int offset, int size)
  {
    int blockSize = getBlockSize();
    for (int i = size / blockSize; i-- > 0;) {
      decryptBlock(data, offset + i * blockSize);
    }
  }
  
  public final void encrypt(byte[] data, int offset, int size)
  {
    int blockSize = getBlockSize();
    for (int i = size / blockSize; i-- > 0;) {
      encryptBlock(data, offset + i * blockSize);
    }
  }
  
  protected abstract int getBlockSize();
  
  protected abstract void decryptBlock(byte[] paramArrayOfByte, int paramInt);
  
  protected abstract void encryptBlock(byte[] paramArrayOfByte, int paramInt);
  
  public abstract boolean verifyChecksum(byte[] paramArrayOfByte, int paramInt1, int paramInt2);
  
  public abstract void appendChecksum(byte[] paramArrayOfByte, int paramInt1, int paramInt2);
  
  public abstract int calcDataSize(int paramInt);
}

Добавлено через 7 минут
Последний class ну никак не влазит, он в 2а раза больше размера сообщения.