Tuesday, January 3, 2017

Kriptosistem Simetris Menggunakan C#.NET (Bagian 2)


Kriptosistem Simetris Menggunakan C#.NET (Bagian 2)



1.10 Kriptosistem BlowFish/TwoFish dan Lainnya





using System;
using System.Diagnostics;
using System.Security.Cryptography;

namespace Twofish_NET
{
        public sealed class Twofish : SymmetricAlgorithm
        {
                public Twofish()
                {
                        this.LegalKeySizesValue = new KeySizes[]{new KeySizes(128,256,64)};

                        this.LegalBlockSizesValue = new KeySizes[]{new KeySizes(128,128,0)};

                        this.BlockSize = 128;
                        this.KeySize = 128;

                        this.Padding = PaddingMode.Zeros;

                        this.Mode = CipherMode.ECB;

                }

                public override ICryptoTransform CreateEncryptor(byte[] key, byte[] iv)
                {
                        Key = key; // this appears to make a new copy

                        if (Mode == CipherMode.CBC)
                                IV = iv;
                       
                        return new TwofishEncryption(KeySize, ref KeyValue, ref IVValue,
                                ModeValue, TwofishBasis.ArahEnkripsi.Mengenkripsi);
                }

                public override ICryptoTransform CreateDecryptor(byte[] kunci, byte[] iv)
                {
                        Key = kunci;

                        if (Mode == CipherMode.CBC)
                                IV = iv;

                        return new TwofishEncryption(KeySize, ref KeyValue, ref IVValue,
                                ModeValue, TwofishBasis.ArahEnkripsi.Mendekripsi);
                }

                public override void GenerateIV()
                {
                        IV = new byte[16]{0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
                }

                public override void GenerateKey()
                {
                        Key = new byte[KeySize/8];

                        for (int i=Key.GetLowerBound(0);i<Key.GetUpperBound(0);i++)
                        {
                                Key[i]=0;
                        }
                }

                public override CipherMode Mode
                {
                        set
                        {
                                switch (value)
                                {
                                        case CipherMode.CBC:
                                                break;
                                        case CipherMode.ECB:
                                                break;
                                        default:
                                                throw (new CryptographicException("CipherMode  
                                                        tidak didukung."));
                                }
                                this.ModeValue = value;
                        }
                }

        }
}



using System;
using System.Diagnostics;
using System.Security.Cryptography;

namespace Twofish_NET
{

        internal class TwofishBasis
        {
                public enum ArahEnkripsi
                {
                        Mengenkripsi,
                        Mendekripsi
                }

                public TwofishBasis()
                {
                }

                protected int masukanUkuranBlok = UKURAN_BLOK/8;
                protected int keluaranUkuranBlok = UKURAN_BLOK/8;

                private static uint f32(uint x,ref uint[] k32,int kunciPjg)
                {
                        byte[]  b = {b0(x),b1(x),b2(x),b3(x)};

                        switch (((kunciPjg + 63)/64) & 3)
                        {
                                case 0:        
                                b[0] = (byte)(P8x8[P_04,b[0]] ^ b0(k32[3]));
                                b[1] = (byte)(P8x8[P_14,b[1]] ^ b1(k32[3]));
                                b[2] = (byte)(P8x8[P_24,b[2]] ^ b2(k32[3]));
                                b[3] = (byte)(P8x8[P_34,b[3]] ^ b3(k32[3]));

                                goto case 3;
                                case 3:        
                                b[0] = (byte)(P8x8[P_03,b[0]] ^ b0(k32[2]));
                                b[1] = (byte)(P8x8[P_13,b[1]] ^ b1(k32[2]));
                                b[2] = (byte)(P8x8[P_23,b[2]] ^ b2(k32[2]));
                                b[3] = (byte)(P8x8[P_33,b[3]] ^ b3(k32[2]));

                                goto case 2;
                                case 2:
                                b[0] = P8x8[P_00, P8x8[P_01, P8x8[P_02, b[0]] ^ b0(k32[1])] ^ b0(k32[0])];
                                b[1] = P8x8[P_10, P8x8[P_11, P8x8[P_12, b[1]] ^ b1(k32[1])] ^ b1(k32[0])];
                                b[2] = P8x8[P_20, P8x8[P_21, P8x8[P_22, b[2]] ^ b2(k32[1])] ^ b2(k32[0])];
                                b[3] = P8x8[P_30, P8x8[P_31, P8x8[P_32, b[3]] ^ b3(k32[1])] ^ b3(k32[0])];
                                break;
                        }

                        return  (uint)((M00(b[0]) ^ M01(b[1]) ^ M02(b[2]) ^ M03(b[3]))) ^
                        (uint)((M10(b[0]) ^ M11(b[1]) ^ M12(b[2]) ^ M13(b[3])) <<  8) ^
                        (uint)((M20(b[0]) ^ M21(b[1]) ^ M22(b[2]) ^ M23(b[3])) << 16) ^
                        (uint)((M30(b[0]) ^ M31(b[1]) ^ M32(b[2]) ^ M33(b[3])) << 24) ;
                }

                protected bool reKey(int kunciPjg, ref uint[] kunci32)
                {
                        int i, k64Hit;
                        kunciPanjang      = kunciPjg;
                        putaran = jumPutaran[(kunciPjg-1)/64];
                        int             subkeyCnt = PUTARAN_SUBKUNCI + 2*putaran;
                        uint    A,B;
                        uint[] k32e = new uint[BIT_KUNCI_MAKS/64];
                        uint[] k32o = new uint[BIT_KUNCI_MAKS/64];
                       
                        k64Hit=(kunciPjg+63)/64;               
                        for (i=0;i<k64Hit;i++)
                        {              
                                k32e[i]=kunci32[2*i  ];
                                k32o[i]=kunci32[2*i+1];

                                sboxKunci[k64Hit-1-i]=RS_MDS_Enkode(k32e[i],k32o[i]);
                        }

                        for (i=0;i<subkeyCnt/2;i++)                                    
                        {
                                A = f32((uint)(i*SK_LANGKAH)        ,ref k32e, kunciPjg);      
                                B = f32((uint)(i*SK_LANGKAH+SK_BUMP),ref k32o, kunciPjg);      
                                B = ROT_Kiri(B,8);
                                subKunci[2*i  ] = A+  B;                       
                                subKunci[2*i+1] = ROT_Kiri(A+2*B,SK_ROTL);
                        }

                        return true;
                }

                protected void blokDekripsi(ref uint[] x)
                {
                        uint t0,t1;
                        uint[] xtemp = new uint[4];

                        if (cipherMode == CipherMode.CBC)
                        {
                                x.CopyTo(xtemp,0);
                        }

                        for (int i=0;i<UKURAN_BLOK/32;i++)     
                                x[i] ^= subKunci[KELUARAN_WHITEN+i];

                        for (int r=putaran-1;r>=0;r--)                 
                        {
                                t0      = f32(    x[0]   ,ref sboxKunci,kunciPanjang);
                                t1      = f32(ROT_Kiri(x[1],8),ref sboxKunci,kunciPanjang);

                                x[2] = ROT_Kiri(x[2],1);
                                x[2]^= t0 +   t1 + subKunci[PUTARAN_SUBKUNCI+2*r  ];
                                x[3]^= t0 + 2*t1 + subKunci[PUTARAN_SUBKUNCI+2*r+1];
                                x[3] = ROT_Kanan(x[3],1);

                                if (r>0)                                                                       
                                {
                                        t0   = x[0]; x[0]= x[2]; x[2] = t0;    
                                        t1   = x[1]; x[1]= x[3]; x[3] = t1;
                                }
                        }

                        for (int i=0;i<UKURAN_BLOK/32;i++)     
                        {
                                x[i] ^= subKunci[MASUKAN_WHITEN+i];
                                if (cipherMode == CipherMode.CBC)
                                {
                                        x[i] ^= IV[i];
                                        IV[i] = xtemp[i];
                                }
                        }
                }

                protected void blokEnkripsi(ref uint[] x)
                {
                        uint t0,t1,tmp;
                       
                        for (int i=0;i<UKURAN_BLOK/32;i++)     
                        {
                                x[i] ^= subKunci[MASUKAN_WHITEN+i];
                                if (cipherMode == CipherMode.CBC)
                                        x[i] ^= IV[i];
                        }

                        for (int r=0;r<putaran;r++)                    
                        {      
#if FEISTEL

#else
                                t0      = f32(    x[0]   ,ref sboxKunci,kunciPanjang);
                                t1      = f32(ROT_Kiri(x[1],8),ref sboxKunci,kunciPanjang);

                                x[3] = ROT_Kiri(x[3],1);
                                x[2]^= t0 +   t1 + subKunci[PUTARAN_SUBKUNCI+2*r  ];
                                x[3]^= t0 + 2*t1 + subKunci[PUTARAN_SUBKUNCI+2*r+1];
                                x[2] = ROT_Kanan(x[2],1);

#endif
                                if (r < putaran-1)                                             
                                {
                                        tmp = x[0]; x[0]= x[2]; x[2] = tmp;
                                        tmp = x[1]; x[1]= x[3]; x[3] = tmp;
                                }
                        }
#if FEISTEL
                        x[0] = ROR(x[0],8);                   
                        x[1] = ROL(x[1],8);
                        x[2] = ROR(x[2],8);
                        x[3] = ROL(x[3],8);
#endif
                        for (int i=0;i<UKURAN_BLOK/32;i++)     
                        {
                                x[i] ^= subKunci[KELUARAN_WHITEN+i];
                                if (cipherMode == CipherMode.CBC)
                                {
                                        IV[i] = x[i];
                                }
                        }

                }

                private int[] jumPutaran = {0,PUTARAN_128,PUTARAN_192,PUTARAN_256};

                static private uint RS_MDS_Enkode(uint k0,uint k1)
                {
                        uint i,j;
                        uint r;

                        for (i=r=0;i<2;i++)
                        {
                                r ^= (i>0) ? k0 : k1;                  
                                for (j=0;j<4;j++)                      
                                        RS_rem(ref r);                         
                        }
                        return r;
                }

                protected uint[] sboxKunci = new uint[BIT_KUNCI_MAKS/64];      
                protected uint[] subKunci = new uint[TOTAL_SUBKUNCI];          
                protected uint[] Kunci = {0,0,0,0,0,0,0,0};                            
                protected uint[] IV = {0,0,0,0};                                               
                private int kunciPanjang;
                private int putaran;
                protected CipherMode cipherMode = CipherMode.ECB;


                #region Definisi-Definisi
                static private readonly int     UKURAN_BLOK = 128;     
                static private readonly int     PUTARAN_MAKS = 16;     
                static private readonly int     PUTARAN_128 = 16;      
                static private readonly int     PUTARAN_192 = 16;      
                static private readonly int     PUTARAN_256 = 16;      
                static private readonly int     BIT_KUNCI_MAKS = 256;  
                static private readonly int     BIT_KUNCI_MIN = 128;   

                static private readonly int     MASUKAN_WHITEN = 0;    
                static private readonly int     KELUARAN_WHITEN = (MASUKAN_WHITEN + UKURAN_BLOK/32);
                static private readonly int     PUTARAN_SUBKUNCI = (KELUARAN_WHITEN + UKURAN_BLOK/32);     
                static private readonly int     TOTAL_SUBKUNCI = (PUTARAN_SUBKUNCI + 2*PUTARAN_MAKS);

                #endregion

                #region Definisi lain

                static private readonly uint SK_LANGKAH = 0x02020202u;
                static private readonly uint SK_BUMP = 0x01010101u;
                static private readonly int SK_ROTL = 9;
               
                static private readonly uint    RS_GF_FDBK = 0x14D;            
                static private void RS_rem(ref uint x)         
                {
                        byte  b  = (byte) (x >> 24);                                                                           
                        uint g2 = (uint)(((b << 1) ^ (((b & 0x80)==0x80) ? RS_GF_FDBK : 0 )) & 0xFF);                
                        uint g3 = (uint)(((b >> 1) & 0x7F) ^ (((b & 1)==1) ? RS_GF_FDBK >> 1 : 0 ) ^ g2) ;
                        x = (x << 8) ^ (g3 << 24) ^ (g2 << 16) ^ (g3 << 8) ^ b;                        
                }

                static private readonly int     MDS_GF_FDBK     = 0x169;       
                static private int LFSR1(int x)
                {
                        return ( ((x) >> 1)  ^ ((((x) & 0x01)==0x01) ?   MDS_GF_FDBK/2 : 0));
                }

                static private int LFSR2(int x)
                {
                        return ( ((x) >> 2)  ^ ((((x) & 0x02)==0x02) ?   MDS_GF_FDBK/2 : 0) ^
                                ((((x) & 0x01)==0x01) ?   MDS_GF_FDBK/4 : 0));
                }

                static private int Mx_1(int x)
                {
                        return x;
                }

                static private int Mx_X(int x)
                {
                        return x ^ LFSR2(x);    /* 5B */
                }

                static private int Mx_Y(int x)
                {
                        return x ^ LFSR1(x) ^ LFSR2(x); /* EF */
                }

                static private int M00(int x)
                {
                        return Mul_1(x);
                }
                static private int M01(int x)
                {
                        return Mul_Y(x);
                }
                static private int M02(int x)
                {
                        return Mul_X(x);
                }
                static private int M03(int x)
                {
                        return Mul_X(x);
                }

                static private int M10(int x)
                {
                        return Mul_X(x);
                }
                static private int M11(int x)
                {
                        return Mul_Y(x);
                }
                static private int M12(int x)
                {
                        return Mul_Y(x);
                }
                static private int M13(int x)
                {
                        return Mul_1(x);
                }

                static private int M20(int x)
                {
                        return Mul_Y(x);
                }
                static private int M21(int x)
                {
                        return Mul_X(x);
                }
                static private int M22(int x)
                {
                        return Mul_1(x);
                }
                static private int M23(int x)
                {
                        return Mul_Y(x);
                }

                static private int M30(int x)
                {
                        return Mul_Y(x);
                }
                static private int M31(int x)
                {
                        return Mul_1(x);
                }
                static private int M32(int x)
                {
                        return Mul_Y(x);
                }
                static private int M33(int x)
                {
                        return Mul_X(x);
                }

                static private int Mul_1(int x)
                {
                        return Mx_1(x);
                }
                static private int Mul_X(int x)
                {
                        return Mx_X(x);
                }
                static private int Mul_Y(int x)
                {
                        return Mx_Y(x);
                }              

                static private readonly int     P_00 = 1;                                      
                static private readonly int     P_01 = 0;
                static private readonly int     P_02 = 0;
                static private readonly int     P_03 = (P_01^1);                       
                static private readonly int     P_04 = 1;

                static private readonly int     P_10 = 0;
                static private readonly int     P_11 = 0;
                static private readonly int     P_12 = 1;
                static private readonly int     P_13 = (P_11^1);
                static private readonly int     P_14 = 0;

                static private readonly int     P_20 = 1;
                static private readonly int     P_21 = 1;
                static private readonly int     P_22 = 0;
                static private readonly int     P_23 = (P_21^1);
                static private readonly int     P_24 = 0;

                static private readonly int     P_30 = 0;
                static private readonly int     P_31 = 1;
                static private readonly int     P_32 = 1;
                static private readonly int     P_33 = (P_31^1);
                static private readonly int     P_34 = 1;

                static private byte[,] P8x8 =
                {
                                {
                                0xA9, 0x67, 0xB3, 0xE8, 0x04, 0xFD, 0xA3, 0x76,
                                0x9A, 0x92, 0x80, 0x78, 0xE4, 0xDD, 0xD1, 0x38,
                                0x0D, 0xC6, 0x35, 0x98, 0x18, 0xF7, 0xEC, 0x6C,
                                0x43, 0x75, 0x37, 0x26, 0xFA, 0x13, 0x94, 0x48,
                                0xF2, 0xD0, 0x8B, 0x30, 0x84, 0x54, 0xDF, 0x23,
                                0x19, 0x5B, 0x3D, 0x59, 0xF3, 0xAE, 0xA2, 0x82,
                                0x63, 0x01, 0x83, 0x2E, 0xD9, 0x51, 0x9B, 0x7C,
                                0xA6, 0xEB, 0xA5, 0xBE, 0x16, 0x0C, 0xE3, 0x61,
                                0xC0, 0x8C, 0x3A, 0xF5, 0x73, 0x2C, 0x25, 0x0B,
                                0xBB, 0x4E, 0x89, 0x6B, 0x53, 0x6A, 0xB4, 0xF1,
                                0xE1, 0xE6, 0xBD, 0x45, 0xE2, 0xF4, 0xB6, 0x66,
                                0xCC, 0x95, 0x03, 0x56, 0xD4, 0x1C, 0x1E, 0xD7,
                                0xFB, 0xC3, 0x8E, 0xB5, 0xE9, 0xCF, 0xBF, 0xBA,
                                0xEA, 0x77, 0x39, 0xAF, 0x33, 0xC9, 0x62, 0x71,
                                0x81, 0x79, 0x09, 0xAD, 0x24, 0xCD, 0xF9, 0xD8,
                                0xE5, 0xC5, 0xB9, 0x4D, 0x44, 0x08, 0x86, 0xE7,
                                0xA1, 0x1D, 0xAA, 0xED, 0x06, 0x70, 0xB2, 0xD2,
                                0x41, 0x7B, 0xA0, 0x11, 0x31, 0xC2, 0x27, 0x90,
                                0x20, 0xF6, 0x60, 0xFF, 0x96, 0x5C, 0xB1, 0xAB,
                                0x9E, 0x9C, 0x52, 0x1B, 0x5F, 0x93, 0x0A, 0xEF,
                                0x91, 0x85, 0x49, 0xEE, 0x2D, 0x4F, 0x8F, 0x3B,
                                0x47, 0x87, 0x6D, 0x46, 0xD6, 0x3E, 0x69, 0x64,
                                0x2A, 0xCE, 0xCB, 0x2F, 0xFC, 0x97, 0x05, 0x7A,
                                0xAC, 0x7F, 0xD5, 0x1A, 0x4B, 0x0E, 0xA7, 0x5A,
                                0x28, 0x14, 0x3F, 0x29, 0x88, 0x3C, 0x4C, 0x02,
                                0xB8, 0xDA, 0xB0, 0x17, 0x55, 0x1F, 0x8A, 0x7D,
                                0x57, 0xC7, 0x8D, 0x74, 0xB7, 0xC4, 0x9F, 0x72,
                                0x7E, 0x15, 0x22, 0x12, 0x58, 0x07, 0x99, 0x34,
                                0x6E, 0x50, 0xDE, 0x68, 0x65, 0xBC, 0xDB, 0xF8,
                                0xC8, 0xA8, 0x2B, 0x40, 0xDC, 0xFE, 0x32, 0xA4,
                                0xCA, 0x10, 0x21, 0xF0, 0xD3, 0x5D, 0x0F, 0x00,
                                0x6F, 0x9D, 0x36, 0x42, 0x4A, 0x5E, 0xC1, 0xE0
                        },

                        {
                                0x75, 0xF3, 0xC6, 0xF4, 0xDB, 0x7B, 0xFB, 0xC8,
                                0x4A, 0xD3, 0xE6, 0x6B, 0x45, 0x7D, 0xE8, 0x4B,
                                0xD6, 0x32, 0xD8, 0xFD, 0x37, 0x71, 0xF1, 0xE1,
                                0x30, 0x0F, 0xF8, 0x1B, 0x87, 0xFA, 0x06, 0x3F,
                                0x5E, 0xBA, 0xAE, 0x5B, 0x8A, 0x00, 0xBC, 0x9D,
                                0x6D, 0xC1, 0xB1, 0x0E, 0x80, 0x5D, 0xD2, 0xD5,
                                0xA0, 0x84, 0x07, 0x14, 0xB5, 0x90, 0x2C, 0xA3,
                                0xB2, 0x73, 0x4C, 0x54, 0x92, 0x74, 0x36, 0x51,
                                0x38, 0xB0, 0xBD, 0x5A, 0xFC, 0x60, 0x62, 0x96,
                                0x6C, 0x42, 0xF7, 0x10, 0x7C, 0x28, 0x27, 0x8C,
                                0x13, 0x95, 0x9C, 0xC7, 0x24, 0x46, 0x3B, 0x70,
                                0xCA, 0xE3, 0x85, 0xCB, 0x11, 0xD0, 0x93, 0xB8,
                                0xA6, 0x83, 0x20, 0xFF, 0x9F, 0x77, 0xC3, 0xCC,
                                0x03, 0x6F, 0x08, 0xBF, 0x40, 0xE7, 0x2B, 0xE2,
                                0x79, 0x0C, 0xAA, 0x82, 0x41, 0x3A, 0xEA, 0xB9,
                                0xE4, 0x9A, 0xA4, 0x97, 0x7E, 0xDA, 0x7A, 0x17,
                                0x66, 0x94, 0xA1, 0x1D, 0x3D, 0xF0, 0xDE, 0xB3,
                                0x0B, 0x72, 0xA7, 0x1C, 0xEF, 0xD1, 0x53, 0x3E,
                                0x8F, 0x33, 0x26, 0x5F, 0xEC, 0x76, 0x2A, 0x49,
                                0x81, 0x88, 0xEE, 0x21, 0xC4, 0x1A, 0xEB, 0xD9,
                                0xC5, 0x39, 0x99, 0xCD, 0xAD, 0x31, 0x8B, 0x01,
                                0x18, 0x23, 0xDD, 0x1F, 0x4E, 0x2D, 0xF9, 0x48,
                                0x4F, 0xF2, 0x65, 0x8E, 0x78, 0x5C, 0x58, 0x19,
                                0x8D, 0xE5, 0x98, 0x57, 0x67, 0x7F, 0x05, 0x64,
                                0xAF, 0x63, 0xB6, 0xFE, 0xF5, 0xB7, 0x3C, 0xA5,
                                0xCE, 0xE9, 0x68, 0x44, 0xE0, 0x4D, 0x43, 0x69,
                                0x29, 0x2E, 0xAC, 0x15, 0x59, 0xA8, 0x0A, 0x9E,
                                0x6E, 0x47, 0xDF, 0x34, 0x35, 0x6A, 0xCF, 0xDC,
                                0x22, 0xC9, 0xC0, 0x9B, 0x89, 0xD4, 0xED, 0xAB,
                                0x12, 0xA2, 0x0D, 0x52, 0xBB, 0x02, 0x2F, 0xA9,
                                0xD7, 0x61, 0x1E, 0xB4, 0x50, 0x04, 0xF6, 0xC2,
                                0x16, 0x25, 0x86, 0x56, 0x55, 0x09, 0xBE, 0x91
                        }
                };
                #endregion

                #region Definisi
                // rotasi kiri
                private static uint ROT_Kiri(uint x, int n)
                {
                        return ( ((x) << ((n) & 0x1F)) | (x) >> (32-((n) & 0x1F)) );
                }

                // rotasi kanan
                private static uint ROT_Kanan(uint x,int n)
                {
                        return (((x) >> ((n) & 0x1F)) | ((x) << (32-((n) & 0x1F))));
                }

                // byte pertama
                protected static byte b0(uint x)
                {
                        return (byte)(x );//& 0xFF);
                }
                // byte kedua
                protected static byte b1(uint x)
                {
                        return (byte)((x >> 8));// & (0xFF));
                }
                // byte ketiga
                protected static byte b2(uint x)
                {
                        return (byte)((x >> 16));// & (0xFF));
                }
                // byte keempat
                protected static byte b3(uint x)
                {
                        return (byte)((x >> 24));// & (0xFF));
                }
                #endregion
        }
}

using System;

namespace Blowfish_NET
{
        public class Blowfish
        {
                public const int PJGKUNCI_MAKS = 56;

                public const int UKURANBLOK = 8;

                const int PBOX_ENTRI = 18;
                const int SBOX_ENTRI = 256;

                uint[] m_pbox;
                uint[] m_sbox1;
                uint[] m_sbox2;
                uint[] m_sbox3;
                uint[] m_sbox4;

                int m_nApaKunciLemah;

                public bool ApaKunciLemah
                {
                        get
                        {
                                if (-1 == m_nApaKunciLemah)
                                {
                                        m_nApaKunciLemah = 0;

                                        int nI, nJ;
                                        for (nI = 0; nI < SBOX_ENTRI - 1; nI++)
                                        {
                                                nJ = nI + 1;
                                                while (nJ < SBOX_ENTRI)
                                                {
                                                        if ((m_sbox1[nI] == m_sbox1[nJ]) |
                                                            (m_sbox2[nI] == m_sbox2[nJ]) |
                                                            (m_sbox3[nI] == m_sbox3[nJ]) |
                                                            (m_sbox4[nI] == m_sbox4[nJ]))
                                                                break;
                                                        else nJ++;
                                                }
                                                if (nJ < SBOX_ENTRI)
                                                {
                                                        m_nApaKunciLemah = 1;
                                                        break;
                                                }
                                        }
                                }

                                return (1 == m_nApaKunciLemah);
                        }
                }

                public Blowfish
                        (byte[] kunci)
                {
                        int nI;

                        m_pbox = new uint[PBOX_ENTRI];

                        for (nI = 0; nI < PBOX_ENTRI; nI++)
                        {
                                m_pbox[nI] = TabelBlowfish.pbox_init[nI];
                        }

                        m_sbox1 = new uint[SBOX_ENTRI];
                        m_sbox2 = new uint[SBOX_ENTRI];
                        m_sbox3 = new uint[SBOX_ENTRI];
                        m_sbox4 = new uint[SBOX_ENTRI];

                        for (nI = 0; nI < SBOX_ENTRI; nI++)
                        {
                                m_sbox1[nI] = TabelBlowfish.sbox_init_1[nI];
                                m_sbox2[nI] = TabelBlowfish.sbox_init_2[nI];
                                m_sbox3[nI] = TabelBlowfish.sbox_init_3[nI];
                                m_sbox4[nI] = TabelBlowfish.sbox_init_4[nI];
                        }

                        int nPjg = kunci.Length;
                        if (nPjg == 0) return;
                        int nKunciPos = 0;
                        uint unBangun = 0;

                        for (nI = 0; nI < PBOX_ENTRI; nI++)
                        {
                                for (int nJ = 0; nJ < 4; nJ++)
                                {
                                        unBangun = (unBangun << 8) | kunci[nKunciPos];
     
                                        if (++nKunciPos == nPjg)
                                        {
                                                nKunciPos = 0;
                                        }
                                }
                                m_pbox[nI] ^= unBangun;
                        }

                        uint unZeroHi = 0;
                        uint unZeroLo = 0;

                        for (nI = 0; nI < PBOX_ENTRI; nI += 2)
                        {
                                BasisEnkripsi(ref unZeroHi, ref unZeroLo);
                                m_pbox[nI] = unZeroHi;
                                m_pbox[nI + 1] = unZeroLo;
                        }
                        for (nI = 0; nI < SBOX_ENTRI; nI += 2)
                        {
                                BasisEnkripsi(ref unZeroHi, ref unZeroLo);
                                m_sbox1[nI] = unZeroHi;
                                m_sbox1[nI + 1] = unZeroLo;
                        }
                        for (nI = 0; nI < SBOX_ENTRI; nI += 2)
                        {
                                BasisEnkripsi(ref unZeroHi, ref unZeroLo);
                                m_sbox2[nI] = unZeroHi;
                                m_sbox2[nI + 1] = unZeroLo;
                        }
                        for (nI = 0; nI < SBOX_ENTRI; nI += 2)
                        {
                                BasisEnkripsi(ref unZeroHi, ref unZeroLo);
                                m_sbox3[nI] = unZeroHi;
                                m_sbox3[nI + 1] = unZeroLo;
                        }
                        for (nI = 0; nI < SBOX_ENTRI; nI += 2)
                        {
                                BasisEnkripsi(ref unZeroHi, ref unZeroLo);
                                m_sbox4[nI] = unZeroHi;
                                m_sbox4[nI + 1] = unZeroLo;
                        }

                        m_nApaKunciLemah = -1;
                }

                public virtual void Bakar()
                {
                        int nI;

                        for (nI = 0; nI < PBOX_ENTRI; nI++)
                        {
                                m_pbox[nI] = 0;
                        }

                        for (nI = 0; nI < SBOX_ENTRI; nI++)
                        {
                                m_sbox1[nI] = m_sbox2[nI] = m_sbox3[nI] = m_sbox4[nI] = 0;
                        }
                }

                static readonly byte[] TEST_KUNCI = { 0x1c, 0x58, 0x7f, 0x1c, 0x13, 0x92, 0x4f, 0xef };
                static readonly uint[] TEST_VEKTOR_PLAIN  = { 0x30553228, 0x6d6f295a };
                static readonly uint[] TEST_VEKTOR_CIPHER = { 0x55cb3774, 0xd13ef201 };

                public static bool TestDiri()
                {
                        uint unHi = TEST_VEKTOR_PLAIN[0];
                        uint unLo = TEST_VEKTOR_PLAIN[1];

                        Blowfish bf = new Blowfish(TEST_KUNCI);

                        bf.Enkripsi(ref unHi, ref unLo);

                        if ((unHi != TEST_VEKTOR_CIPHER[0]) ||
                                (unLo != TEST_VEKTOR_CIPHER[1]))
                        {
                                return false;
                        }

                        bf.Dekripsi(ref unHi, ref unLo);

                        if ((unHi != TEST_VEKTOR_PLAIN[0]) ||
                                (unLo != TEST_VEKTOR_PLAIN[1]))
                        {
                                return false;
                        }

                        return true;
                }

                protected void BasisEnkripsi
                        (ref uint unHiRef,
                        ref uint unLoRef)
                {
  
                        uint unHi = unHiRef;
                        uint unLo = unLoRef;

                        uint[] sbox1 = m_sbox1;
                        uint[] sbox2 = m_sbox2;
                        uint[] sbox3 = m_sbox3;
                        uint[] sbox4 = m_sbox4;

                        uint[] pbox = m_pbox;

                        unHi ^= pbox[0];
                        unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[1];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[2];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[3];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[4];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[5];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[6];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[7];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[8];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[9];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[10];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[11];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[12];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[13];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[14];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[15];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[16];

                        unLoRef = unHi;
                        unHiRef = unLo ^ pbox[17];
                }

                public virtual void Enkripsi
                        (ref uint unHiRef,
                        ref uint unLoRef)
                {
                        BasisEnkripsi(ref unHiRef, ref unLoRef);
                }

                public int Enkripsi
                        (byte[] dataMasuk,
                        byte[] dataKeluar,
                        int nPosMasuk,
                        int nPosKeluar,
                        int nJumlah)
                {
                        nJumlah >>= 3;

                        for (int nI = 0; nI < nJumlah; nI++)
                        {
                                uint unHi = (((uint) dataMasuk[nPosMasuk]) << 24) |
                                        (((uint) dataMasuk[nPosMasuk + 1]) << 16) |
                                        (((uint) dataMasuk[nPosMasuk + 2]) << 8) |
                                        dataMasuk[nPosMasuk + 3];

                                uint unLo = (((uint) dataMasuk[nPosMasuk + 4]) << 24) |
                                        (((uint) dataMasuk[nPosMasuk + 5]) << 16) |
                                        (((uint) dataMasuk[nPosMasuk + 6]) << 8) |
                                        dataMasuk[nPosMasuk + 7];

                                Enkripsi(ref unHi, ref unLo);

                                dataKeluar[nPosKeluar]     = (byte)(unHi >> 24);
                                dataKeluar[nPosKeluar + 1] = (byte)(unHi >> 16);
                                dataKeluar[nPosKeluar + 2] = (byte)(unHi >> 8);
                                dataKeluar[nPosKeluar + 3] = (byte)unHi;
                                dataKeluar[nPosKeluar + 4] = (byte)(unLo >> 24);
                                dataKeluar[nPosKeluar + 5] = (byte)(unLo >> 16);
                                dataKeluar[nPosKeluar + 6] = (byte)(unLo >> 8);
                                dataKeluar[nPosKeluar + 7] = (byte)unLo;

                                nPosMasuk += 8;
                                nPosKeluar += 8;
                        }

                        return nJumlah;
                }

                public virtual void Dekripsi
                        (ref uint unHiRef,
                        ref uint unLoRef)
                {
                        uint unHi = unHiRef;
                        uint unLo = unLoRef;

                        uint[] sbox1 = m_sbox1;
                        uint[] sbox2 = m_sbox2;
                        uint[] sbox3 = m_sbox3;
                        uint[] sbox4 = m_sbox4;

                        uint[] pbox = m_pbox;

                        unHi ^= pbox[(int)(17)];
                        unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[16];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[15];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[14];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[13];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[12];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[11];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[10];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[9];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[8];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[7];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[6];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[5];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[4];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[3];
                             unLo ^= (((sbox1[(int)(unHi >> 24)] + sbox2[(int)((unHi >> 16) & 0x0ff)]) ^ sbox3[(int)((unHi >> 8) & 0x0ff)]) + sbox4[(int)(unHi & 0x0ff)]) ^ pbox[2];
                             unHi ^= (((sbox1[(int)(unLo >> 24)] + sbox2[(int)((unLo >> 16) & 0x0ff)]) ^ sbox3[(int)((unLo >> 8) & 0x0ff)]) + sbox4[(int)(unLo & 0x0ff)]) ^ pbox[1];

                        unLoRef = unHi;
                        unHiRef = unLo ^ pbox[0];
                }

                public int Dekripsi
                        (byte[] dataMasuk,
                        byte[] dataKeluar,
                        int nPosMasuk,
                        int nPosKeluar,
                        int nJumlah)
                {
                        nJumlah >>= 3;

                        for (int nI = 0; nI < nJumlah; nI++)
                        {
                                uint unHi = (((uint) dataMasuk[nPosMasuk]) << 24) |
                                        (((uint) dataMasuk[nPosMasuk + 1]) << 16) |
                                        (((uint) dataMasuk[nPosMasuk + 2]) << 8) |
                                        dataMasuk[nPosMasuk + 3];

                                uint unLo = (((uint) dataMasuk[nPosMasuk + 4]) << 24) |
                                        (((uint) dataMasuk[nPosMasuk + 5]) << 16) |
                                        (((uint) dataMasuk[nPosMasuk + 6]) << 8) |
                                        dataMasuk[nPosMasuk + 7];

                                Dekripsi(ref unHi, ref unLo);

                                dataKeluar[nPosKeluar]     = (byte)(unHi >> 24);
                                dataKeluar[nPosKeluar + 1] = (byte)(unHi >> 16);
                                dataKeluar[nPosKeluar + 2] = (byte)(unHi >> 8);
                                dataKeluar[nPosKeluar + 3] = (byte)unHi;
                                dataKeluar[nPosKeluar + 4] = (byte)(unLo >> 24);
                                dataKeluar[nPosKeluar + 5] = (byte)(unLo >> 16);
                                dataKeluar[nPosKeluar + 6] = (byte)(unLo >> 8);
                                dataKeluar[nPosKeluar + 7] = (byte)unLo;

                                nPosMasuk += 8;
                                nPosKeluar += 8;
                        }
                        return nJumlah;
                }
        }
}

namespace Blowfish_NET
{
        public class TabelBlowfish
        {

                public static readonly uint[] pbox_init =
                {
                        0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344, 0xa4093822, 0x299f31d0,
                        0x082efa98, 0xec4e6c89, 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
                        0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917, 0x9216d5d9, 0x8979fb1b 
                };

                public static readonly uint[] sbox_init_1 =
                {

                             0xd1310ba6,   0x98dfb5ac,   0x2ffd72db,   0xd01adfb7,   0xb8e1afed,   0x6a267e96,
                             0xba7c9045,   0xf12c7f99,   0x24a19947,   0xb3916cf7,   0x0801f2e2,   0x858efc16,
                             0x636920d8,   0x71574e69,   0xa458fea3,   0xf4933d7e,   0x0d95748f,   0x728eb658,
                             0x718bcd58,   0x82154aee,   0x7b54a41d,   0xc25a59b5,   0x9c30d539,   0x2af26013,
                             0xc5d1b023,   0x286085f0,   0xca417918,   0xb8db38ef,   0x8e79dcb0,   0x603a180e,
                             0x6c9e0e8b,   0xb01e8a3e,   0xd71577c1,   0xbd314b27,   0x78af2fda,   0x55605c60,
                             0xe65525f3,   0xaa55ab94,   0x57489862,   0x63e81440,   0x55ca396a,   0x2aab10b6,
                             0xb4cc5c34,   0x1141e8ce,   0xa15486af,   0x7c72e993,   0xb3ee1411,   0x636fbc2a,
                             0x2ba9c55d,   0x741831f6,   0xce5c3e16,   0x9b87931e,   0xafd6ba33,   0x6c24cf5c,
                             0x7a325381,   0x28958677,   0x3b8f4898,   0x6b4bb9af,   0xc4bfe81b,   0x66282193,
                             0x61d809cc,   0xfb21a991,   0x487cac60,   0x5dec8032,   0xef845d5d,   0xe98575b1,
                             0xdc262302,   0xeb651b88,   0x23893e81,   0xd396acc5,   0x0f6d6ff3,   0x83f44239,
                             0x2e0b4482,   0xa4842004,   0x69c8f04a,   0x9e1f9b5e,   0x21c66842,   0xf6e96c9a,
                             0x670c9c61,   0xabd388f0,   0x6a51a0d2,   0xd8542f68,   0x960fa728,   0xab5133a3,
                             0x6eef0b6c,   0x137a3be4,   0xba3bf050,   0x7efb2a98,   0xa1f1651d,   0x39af0176,
                             0x66ca593e,   0x82430e88,   0x8cee8619,   0x456f9fb4,   0x7d84a5c3,   0x3b8b5ebe,
                             0xe06f75d8,   0x85c12073,   0x401a449f,   0x56c16aa6,   0x4ed3aa62,   0x363f7706,
                             0x1bfedf72,   0x429b023d,   0x37d0d724,   0xd00a1248,   0xdb0fead3,   0x49f1c09b,
                             0x075372c9,   0x80991b7b,   0x25d479d8,   0xf6e8def7,   0xe3fe501a,   0xb6794c3b,
                             0x976ce0bd,   0x04c006ba,   0xc1a94fb6,   0x409f60c4,   0x5e5c9ec2,   0x196a2463,
                             0x68fb6faf,   0x3e6c53b5,   0x1339b2eb,   0x3b52ec6f,   0x6dfc511f,   0x9b30952c,
                             0xcc814544,   0xaf5ebd09,   0xbee3d004,   0xde334afd,   0x660f2807,   0x192e4bb3,
                             0xc0cba857,   0x45c8740f,   0xd20b5f39,   0xb9d3fbdb,   0x5579c0bd,   0x1a60320a,
                             0xd6a100c6,   0x402c7279,   0x679f25fe,   0xfb1fa3cc,   0x8ea5e9f8,   0xdb3222f8,
                             0x3c7516df,   0xfd616b15,   0x2f501ec8,   0xad0552ab,   0x323db5fa,   0xfd238760,
                             0x53317b48,   0x3e00df82,   0x9e5c57bb,   0xca6f8ca0,   0x1a87562e,   0xdf1769db,
                             0xd542a8f6,   0x287effc3,   0xac6732c6,   0x8c4f5573,   0x695b27b0,   0xbbca58c8,
                             0xe1ffa35d,   0xb8f011a0,   0x10fa3d98,   0xfd2183b8,   0x4afcb56c,   0x2dd1d35b,
                             0x9a53e479,   0xb6f84565,   0xd28e49bc,   0x4bfb9790,   0xe1ddf2da,   0xa4cb7e33,
                             0x62fb1341,   0xcee4c6e8,   0xef20cada,   0x36774c01,   0xd07e9efe,   0x2bf11fb4,
                             0x95dbda4d,   0xae909198,   0xeaad8e71,   0x6b93d5a0,   0xd08ed1d0,   0xafc725e0,
                             0x8e3c5b2f,   0x8e7594b7,   0x8ff6e2fb,   0xf2122b64,   0x8888b812,   0x900df01c,
                             0x4fad5ea0,   0x688fc31c,   0xd1cff191,   0xb3a8c1ad,   0x2f2f2218,   0xbe0e1777,
                             0xea752dfe,   0x8b021fa1,   0xe5a0cc0f,   0xb56f74e8,   0x18acf3d6,   0xce89e299,
                             0xb4a84fe0,   0xfd13e0b7,   0x7cc43b81,   0xd2ada8d9,   0x165fa266,   0x80957705,
                             0x93cc7314,   0x211a1477,   0xe6ad2065,   0x77b5fa86,   0xc75442f5,   0xfb9d35cf,
                             0xebcdaf0c,   0x7b3e89a0,   0xd6411bd3,   0xae1e7e49,   0x00250e2d,   0x2071b35e,
                             0x226800bb,   0x57b8e0af,   0x2464369b,   0xf009b91e,   0x5563911d,   0x59dfa6aa,
                             0x78c14389,   0xd95a537f,   0x207d5ba2,   0x02e5b9c5,   0x83260376,   0x6295cfa9,
                             0x11c81968,   0x4e734a41,   0xb3472dca,   0x7b14a94a,   0x1b510052,   0x9a532915,
                             0xd60f573f,   0xbc9bc6e4,   0x2b60a476,   0x81e67400,   0x08ba6fb5,   0x571be91f,
                             0xf296ec6b,   0x2a0dd915,   0xb6636521,   0xe7b9f9b6,   0xff34052e,   0xc5855664,
                             0x53b02d5d,   0xa99f8fa1,   0x08ba4799,   0x6e85076a
                };

                public static readonly uint[] sbox_init_2 =
                {

                             0x4b7a70e9,   0xb5b32944,
                             0xdb75092e,   0xc4192623,   0xad6ea6b0,   0x49a7df7d,   0x9cee60b8,   0x8fedb266,
                             0xecaa8c71,   0x699a17ff,   0x5664526c,   0xc2b19ee1,   0x193602a5,   0x75094c29,
                             0xa0591340,   0xe4183a3e,   0x3f54989a,   0x5b429d65,   0x6b8fe4d6,   0x99f73fd6,
                             0xa1d29c07,   0xefe830f5,   0x4d2d38e6,   0xf0255dc1,   0x4cdd2086,   0x8470eb26,
                             0x6382e9c6,   0x021ecc5e,   0x09686b3f,   0x3ebaefc9,   0x3c971814,   0x6b6a70a1,
                             0x687f3584,   0x52a0e286,   0xb79c5305,   0xaa500737,   0x3e07841c,   0x7fdeae5c,
                             0x8e7d44ec,   0x5716f2b8,   0xb03ada37,   0xf0500c0d,   0xf01c1f04,   0x0200b3ff,
                             0xae0cf51a,   0x3cb574b2,   0x25837a58,   0xdc0921bd,   0xd19113f9,   0x7ca92ff6,
                             0x94324773,   0x22f54701,   0x3ae5e581,   0x37c2dadc,   0xc8b57634,   0x9af3dda7,
                             0xa9446146,   0x0fd0030e,   0xecc8c73e,   0xa4751e41,   0xe238cd99,   0x3bea0e2f,
                             0x3280bba1,   0x183eb331,   0x4e548b38,   0x4f6db908,   0x6f420d03,   0xf60a04bf,
                             0x2cb81290,   0x24977c79,   0x5679b072,   0xbcaf89af,   0xde9a771f,   0xd9930810,
                             0xb38bae12,   0xdccf3f2e,   0x5512721f,   0x2e6b7124,   0x501adde6,   0x9f84cd87,
                             0x7a584718,   0x7408da17,   0xbc9f9abc,   0xe94b7d8c,   0xec7aec3a,   0xdb851dfa,
                             0x63094366,   0xc464c3d2,   0xef1c1847,   0x3215d908,   0xdd433b37,   0x24c2ba16,
                             0x12a14d43,   0x2a65c451,   0x50940002,   0x133ae4dd,   0x71dff89e,   0x10314e55,
                             0x81ac77d6,   0x5f11199b,   0x043556f1,   0xd7a3c76b,   0x3c11183b,   0x5924a509,
                             0xf28fe6ed,   0x97f1fbfa,   0x9ebabf2c,   0x1e153c6e,   0x86e34570,   0xeae96fb1,
                             0x860e5e0a,   0x5a3e2ab3,   0x771fe71c,   0x4e3d06fa,   0x2965dcb9,   0x99e71d0f,
                             0x803e89d6,   0x5266c825,   0x2e4cc978,   0x9c10b36a,   0xc6150eba,   0x94e2ea78,
                             0xa5fc3c53,   0x1e0a2df4,   0xf2f74ea7,   0x361d2b3d,   0x1939260f,   0x19c27960,
                             0x5223a708,   0xf71312b6,   0xebadfe6e,   0xeac31f66,   0xe3bc4595,   0xa67bc883,
                             0xb17f37d1,   0x018cff28,   0xc332ddef,   0xbe6c5aa5,   0x65582185,   0x68ab9802,
                             0xeecea50f,   0xdb2f953b,   0x2aef7dad,   0x5b6e2f84,   0x1521b628,   0x29076170,
                             0xecdd4775,   0x619f1510,   0x13cca830,   0xeb61bd96,   0x0334fe1e,   0xaa0363cf,
                             0xb5735c90,   0x4c70a239,   0xd59e9e0b,   0xcbaade14,   0xeecc86bc,   0x60622ca7,
                             0x9cab5cab,   0xb2f3846e,   0x648b1eaf,   0x19bdf0ca,   0xa02369b9,   0x655abb50,
                             0x40685a32,   0x3c2ab4b3,   0x319ee9d5,   0xc021b8f7,   0x9b540b19,   0x875fa099,
                             0x95f7997e,   0x623d7da8,   0xf837889a,   0x97e32d77,   0x11ed935f,   0x16681281,
                             0x0e358829,   0xc7e61fd6,   0x96dedfa1,   0x7858ba99,   0x57f584a5,   0x1b227263,
                             0x9b83c3ff,   0x1ac24696,   0xcdb30aeb,   0x532e3054,   0x8fd948e4,   0x6dbc3128,
                             0x58ebf2ef,   0x34c6ffea,   0xfe28ed61,   0xee7c3c73,   0x5d4a14d9,   0xe864b7e3,
                             0x42105d14,   0x203e13e0,   0x45eee2b6,   0xa3aaabea,   0xdb6c4f15,   0xfacb4fd0,
                             0xc742f442,   0xef6abbb5,   0x654f3b1d,   0x41cd2105,   0xd81e799e,   0x86854dc7,
                             0xe44b476a,   0x3d816250,   0xcf62a1f2,   0x5b8d2646,   0xfc8883a0,   0xc1c7b6a3,
                             0x7f1524c3,   0x69cb7492,   0x47848a0b,   0x5692b285,   0x095bbf00,   0xad19489d,
                             0x1462b174,   0x23820e00,   0x58428d2a,   0x0c55f5ea,   0x1dadf43e,   0x233f7061,
                             0x3372f092,   0x8d937e41,   0xd65fecf1,   0x6c223bdb,   0x7cde3759,   0xcbee7460,
                             0x4085f2a7,   0xce77326e,   0xa6078084,   0x19f8509e,   0xe8efd855,   0x61d99735,
                             0xa969a7aa,   0xc50c06c2,   0x5a04abfc,   0x800bcadc,   0x9e447a2e,   0xc3453484,
                             0xfdd56705,   0x0e1e9ec9,   0xdb73dbd3,   0x105588cd,   0x675fda79,   0xe3674340,
                             0xc5c43465,   0x713e38d8,   0x3d28f89e,   0xf16dff20,   0x153e21e7,   0x8fb03d4a,
                             0xe6e39f2b,   0xdb83adf7
                };

                public static readonly uint[] sbox_init_3 =
                {
                             0xe93d5a68,   0x948140f7,   0xf64c261c,   0x94692934,
                             0x411520f7,   0x7602d4f7,   0xbcf46b2e,   0xd4a20068,   0xd4082471,   0x3320f46a,
                             0x43b7d4b7,   0x500061af,   0x1e39f62e,   0x97244546,   0x14214f74,   0xbf8b8840,
                             0x4d95fc1d,   0x96b591af,   0x70f4ddd3,   0x66a02f45,   0xbfbc09ec,   0x03bd9785,
                             0x7fac6dd0,   0x31cb8504,   0x96eb27b3,   0x55fd3941,   0xda2547e6,   0xabca0a9a,
                             0x28507825,   0x530429f4,   0x0a2c86da,   0xe9b66dfb,   0x68dc1462,   0xd7486900,
                             0x680ec0a4,   0x27a18dee,   0x4f3ffea2,   0xe887ad8c,   0xb58ce006,   0x7af4d6b6,
                             0xaace1e7c,   0xd3375fec,   0xce78a399,   0x406b2a42,   0x20fe9e35,   0xd9f385b9,
                             0xee39d7ab,   0x3b124e8b,   0x1dc9faf7,   0x4b6d1856,   0x26a36631,   0xeae397b2,
                             0x3a6efa74,   0xdd5b4332,   0x6841e7f7,   0xca7820fb,   0xfb0af54e,   0xd8feb397,
                             0x454056ac,   0xba489527,   0x55533a3a,   0x20838d87,   0xfe6ba9b7,   0xd096954b,
                             0x55a867bc,   0xa1159a58,   0xcca92963,   0x99e1db33,   0xa62a4a56,   0x3f3125f9,
                             0x5ef47e1c,   0x9029317c,   0xfdf8e802,   0x04272f70,   0x80bb155c,   0x05282ce3,
                             0x95c11548,   0xe4c66d22,   0x48c1133f,   0xc70f86dc,   0x07f9c9ee,   0x41041f0f,
                             0x404779a4,   0x5d886e17,   0x325f51eb,   0xd59bc0d1,   0xf2bcc18f,   0x41113564,
                             0x257b7834,   0x602a9c60,   0xdff8e8a3,   0x1f636c1b,   0x0e12b4c2,   0x02e1329e,
                             0xaf664fd1,   0xcad18115,   0x6b2395e0,   0x333e92e1,   0x3b240b62,   0xeebeb922,
                             0x85b2a20e,   0xe6ba0d99,   0xde720c8c,   0x2da2f728,   0xd0127845,   0x95b794fd,
                             0x647d0862,   0xe7ccf5f0,   0x5449a36f,   0x877d48fa,   0xc39dfd27,   0xf33e8d1e,
                             0x0a476341,   0x992eff74,   0x3a6f6eab,   0xf4f8fd37,   0xa812dc60,   0xa1ebddf8,
                             0x991be14c,   0xdb6e6b0d,   0xc67b5510,   0x6d672c37,   0x2765d43b,   0xdcd0e804,
                             0xf1290dc7,   0xcc00ffa3,   0xb5390f92,   0x690fed0b,   0x667b9ffb,   0xcedb7d9c,
                             0xa091cf0b,   0xd9155ea3,   0xbb132f88,   0x515bad24,   0x7b9479bf,   0x763bd6eb,
                             0x37392eb3,   0xcc115979,   0x8026e297,   0xf42e312d,   0x6842ada7,   0xc66a2b3b,
                             0x12754ccc,   0x782ef11c,   0x6a124237,   0xb79251e7,   0x06a1bbe6,   0x4bfb6350,
                             0x1a6b1018,   0x11caedfa,   0x3d25bdd8,   0xe2e1c3c9,   0x44421659,   0x0a121386,
                             0xd90cec6e,   0xd5abea2a,   0x64af674e,   0xda86a85f,   0xbebfe988,   0x64e4c3fe,
                             0x9dbc8057,   0xf0f7c086,   0x60787bf8,   0x6003604d,   0xd1fd8346,   0xf6381fb0,
                             0x7745ae04,   0xd736fccc,   0x83426b33,   0xf01eab71,   0xb0804187,   0x3c005e5f,
                             0x77a057be,   0xbde8ae24,   0x55464299,   0xbf582e61,   0x4e58f48f,   0xf2ddfda2,
                             0xf474ef38,   0x8789bdc2,   0x5366f9c3,   0xc8b38e74,   0xb475f255,   0x46fcd9b9,
                             0x7aeb2661,   0x8b1ddf84,   0x846a0e79,   0x915f95e2,   0x466e598e,   0x20b45770,
                             0x8cd55591,   0xc902de4c,   0xb90bace1,   0xbb8205d0,   0x11a86248,   0x7574a99e,
                             0xb77f19b6,   0xe0a9dc09,   0x662d09a1,   0xc4324633,   0xe85a1f02,   0x09f0be8c,
                             0x4a99a025,   0x1d6efe10,   0x1ab93d1d,   0x0ba5a4df,   0xa186f20f,   0x2868f169,
                             0xdcb7da83,   0x573906fe,   0xa1e2ce9b,   0x4fcd7f52,   0x50115e01,   0xa70683fa,
                             0xa002b5c4,   0x0de6d027,   0x9af88c27,   0x773f8641,   0xc3604c06,   0x61a806b5,
                             0xf0177a28,   0xc0f586e0,   0x006058aa,   0x30dc7d62,   0x11e69ed7,   0x2338ea63,
                             0x53c2dd94,   0xc2c21634,   0xbbcbee56,   0x90bcb6de,   0xebfc7da1,   0xce591d76,
                             0x6f05e409,   0x4b7c0188,   0x39720a3d,   0x7c927c24,   0x86e3725f,   0x724d9db9,
                             0x1ac15bb4,   0xd39eb8fc,   0xed545578,   0x08fca5b5,   0xd83d7cd3,   0x4dad0fc4,
                             0x1e50ef5e,   0xb161e6f8,   0xa28514d9,   0x6c51133c,   0x6fd5c7e7,   0x56e14ec4,
                             0x362abfce,   0xddc6c837,   0xd79a3234,   0x92638212,   0x670efa8e,   0x406000e0
                };

                public static readonly uint[] sbox_init_4 =
                {

                             0x3a39ce37,   0xd3faf5cf,   0xabc27737,   0x5ac52d1b,   0x5cb0679e,   0x4fa33742,
                             0xd3822740,   0x99bc9bbe,   0xd5118e9d,   0xbf0f7315,   0xd62d1c7e,   0xc700c47b,
                             0xb78c1b6b,   0x21a19045,   0xb26eb1be,   0x6a366eb4,   0x5748ab2f,   0xbc946e79,
                             0xc6a376d2,   0x6549c2c8,   0x530ff8ee,   0x468dde7d,   0xd5730a1d,   0x4cd04dc6,
                             0x2939bbdb,   0xa9ba4650,   0xac9526e8,   0xbe5ee304,   0xa1fad5f0,   0x6a2d519a,
                             0x63ef8ce2,   0x9a86ee22,   0xc089c2b8,   0x43242ef6,   0xa51e03aa,   0x9cf2d0a4,
                             0x83c061ba,   0x9be96a4d,   0x8fe51550,   0xba645bd6,   0x2826a2f9,   0xa73a3ae1,
                             0x4ba99586,   0xef5562e9,   0xc72fefd3,   0xf752f7da,   0x3f046f69,   0x77fa0a59,
                             0x80e4a915,   0x87b08601,   0x9b09e6ad,   0x3b3ee593,   0xe990fd5a,   0x9e34d797,
                             0x2cf0b7d9,   0x022b8b51,   0x96d5ac3a,   0x017da67d,   0xd1cf3ed6,   0x7c7d2d28,
                             0x1f9f25cf,   0xadf2b89b,   0x5ad6b472,   0x5a88f54c,   0xe029ac71,   0xe019a5e6,
                             0x47b0acfd,   0xed93fa9b,   0xe8d3c48d,   0x283b57cc,   0xf8d56629,   0x79132e28,
                             0x785f0191,   0xed756055,   0xf7960e44,   0xe3d35e8c,   0x15056dd4,   0x88f46dba,
                             0x03a16125,   0x0564f0bd,   0xc3eb9e15,   0x3c9057a2,   0x97271aec,   0xa93a072a,
                             0x1b3f6d9b,   0x1e6321f5,   0xf59c66fb,   0x26dcf319,   0x7533d928,   0xb155fdf5,
                             0x03563482,   0x8aba3cbb,   0x28517711,   0xc20ad9f8,   0xabcc5167,   0xccad925f,
                             0x4de81751,   0x3830dc8e,   0x379d5862,   0x9320f991,   0xea7a90c2,   0xfb3e7bce,
                             0x5121ce64,   0x774fbe32,   0xa8b6e37e,   0xc3293d46,   0x48de5369,   0x6413e680,
                             0xa2ae0810,   0xdd6db224,   0x69852dfd,   0x09072166,   0xb39a460a,   0x6445c0dd,
                             0x586cdecf,   0x1c20c8ae,   0x5bbef7dd,   0x1b588d40,   0xccd2017f,   0x6bb4e3bb,
                             0xdda26a7e,   0x3a59ff45,   0x3e350a44,   0xbcb4cdd5,   0x72eacea8,   0xfa6484bb,
                             0x8d6612ae,   0xbf3c6f47,   0xd29be463,   0x542f5d9e,   0xaec2771b,   0xf64e6370,
                             0x740e0d8d,   0xe75b1357,   0xf8721671,   0xaf537d5d,   0x4040cb08,   0x4eb4e2cc,
                             0x34d2466a,   0x0115af84,   0xe1b00428,   0x95983a1d,   0x06b89fb4,   0xce6ea048,
                             0x6f3f3b82,   0x3520ab82,   0x011a1d4b,   0x277227f8,   0x611560b1,   0xe7933fdc,
                             0xbb3a792b,   0x344525bd,   0xa08839e1,   0x51ce794b,   0x2f32c9b7,   0xa01fbac9,
                             0xe01cc87e,   0xbcc7d1f6,   0xcf0111c3,   0xa1e8aac7,   0x1a908749,   0xd44fbd9a,
                             0xd0dadecb,   0xd50ada38,   0x0339c32a,   0xc6913667,   0x8df9317c,   0xe0b12b4f,
                             0xf79e59b7,   0x43f5bb3a,   0xf2d519ff,   0x27d9459c,   0xbf97222c,   0x15e6fc2a,
                             0x0f91fc71,   0x9b941525,   0xfae59361,   0xceb69ceb,   0xc2a86459,   0x12baa8d1,
                             0xb6c1075e,   0xe3056a0c,   0x10d25065,   0xcb03a442,   0xe0ec6e0e,   0x1698db3b,
                             0x4c98a0be,   0x3278e964,   0x9f1f9532,   0xe0d392df,   0xd3a0342b,   0x8971f21e,
                             0x1b0a7441,   0x4ba3348c,   0xc5be7120,   0xc37632d8,   0xdf359f8d,   0x9b992f2e,
                             0xe60b6f47,   0x0fe3f11d,   0xe54cda54,   0x1edad891,   0xce6279cf,   0xcd3e7e6f,
                             0x1618b166,   0xfd2c1d05,   0x848fd2c5,   0xf6fb2299,   0xf523f357,   0xa6327623,
                             0x93a83531,   0x56cccd02,   0xacf08162,   0x5a75ebb5,   0x6e163697,   0x88d273cc,
                             0xde966292,   0x81b949d0,   0x4c50901b,   0x71c65614,   0xe6c6c7bd,   0x327a140a,
                             0x45e1d006,   0xc3f27b9a,   0xc9aa53fd,   0x62a80f00,   0xbb25bfe2,   0x35bdd2f6,
                             0x71126905,   0xb2040222,   0xb6cbcf7c,   0xcd769c2b,   0x53113ec0,   0x1640e3d3,
                             0x38abbd60,   0x2547adf0,   0xba38209c,   0xf746ce76,   0x77afa1c5,   0x20756060,
                             0x85cbfe4e,   0x8ae88dd8,   0x7aaaf9b0,   0x4cf9aa7e,   0x1948c25c,   0x02fb8a8c,
                             0x01c36ae4,   0xd6ebe1f9,   0x90d4f869,   0xa65cdea0,   0x3f09252d,   0xc208e69f,
                             0xb74e6132,   0xce77e25b,   0x578fdfe3,   0x3ac372e6
                };
        }
}



1.11 Pengacak Teks




using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace PengacakTeks
{
    public class Pengacak{
        private string SemuaKarSumber =
                "><!@#$%&*abcdefghiklmnopqrstuvwxyzABCDEFGHIKLMNOPQRSTUVWXYZ1234567890";

        public string StringBiner(string StringUtama){
            return BinerKerja(StringUtama);}

        public string StringAcak(string StringUtama){
            return AcakBiner(BinerKerja(StringUtama));}

        public string StringUtama(string StrDilewatkan, byte BinerAcak){
            string TeksUtama = "";
            switch (BinerAcak){
                case 0:
                    TeksUtama = DekodeBiner(StrDilewatkan);
                    break;
                case 1:
                    TeksUtama = DekodeBiner((TakAcakStringBiner(StrDilewatkan)));
                    break;}

            return TeksUtama;}

        private string BinerKerja(string ApaYangDikerjakan){
            string BinaryResults = "";

            foreach (char GetKarakter in ApaYangDikerjakan){
                BinaryResults += GetBiner(GetKarakter);}

            return BinaryResults;}

        private string DekodeBiner(string StringDilewatkan){
            int ii;
            string KarakterHasil = "";

            for (ii = 0; ii < StringDilewatkan.Length; ii += 8){
                try{
                    KarakterHasil += GetKarakter(StringDilewatkan.Substring(ii, 8));}
                catch (OverflowException) { }}
            return KarakterHasil;}

        private string TakAcakStringBiner(string Uacak){
            string[] strSatuKeNol = new string[3];
            string aKar = SemuaKarSumber;
            int ii;

            string AkhirSembilan = balikString(Uacak.Substring(Uacak.Length - 9));

            foreach (char ChrNine in AkhirSembilan){
                if (strSatuKeNol[0] == null){
                    strSatuKeNol[0] = ChrNine.ToString(); continue;}
                if (strSatuKeNol[0] == ChrNine.ToString()) continue;
                if (strSatuKeNol[1] == null){
                    strSatuKeNol[1] = ChrNine.ToString(); continue;}
                if (strSatuKeNol[1] == ChrNine.ToString()) continue;
                strSatuKeNol[2] = ChrNine.ToString();
                break;}

            aKar = aKar.Replace(strSatuKeNol[1], "");
            aKar = aKar.Replace(strSatuKeNol[2], "");

            for (ii = 0; ii < aKar.Length; ii++){
                Uacak = Uacak.Replace(aKar.Substring(ii, 1), "");}

            Uacak = StringTunggal(strSatuKeNol[1], Uacak);
            Uacak = StringTunggal(strSatuKeNol[2], Uacak);

            Uacak = Uacak.Replace(";", "");
            Uacak = Uacak.Replace(":", "");
            Uacak = Uacak.Replace(strSatuKeNol[1], "0");
            Uacak = Uacak.Replace(strSatuKeNol[2], "1");

            return Uacak.Substring(0, (Uacak.Length - 2));}

        private string StringTunggal(string StringJamak, string StrUtuh){
            while (StrUtuh.IndexOf(StringJamak + StringJamak) != -1){
                StrUtuh = StrUtuh.Replace(StringJamak + StringJamak, StringJamak);}

            return StrUtuh;}

        private string balikString(string BalikIni){
            string balikStr = "";
            int ii;
            for (ii = (BalikIni.Length - 1); ii > 0; ii--){
                balikStr += BalikIni.Substring(ii, 1);}
            return balikStr;}

        private string AcakBiner(string aString){
            int acakRep;

            Random intAcak = new Random();
            string baruString = "";
            string aKar = SemuaKarSumber;
            string karSatu = aKar.Substring(intAcak.Next(aKar.Length), 1);
            aKar = aKar.Replace(karSatu, "");
            string aNol = aKar.Substring(intAcak.Next(aKar.Length), 1);
            aKar = aKar.Replace(aNol, "");

            int IntStrPjg = aString.Length;

            foreach (char OZkar in aString){
                acakRep = intAcak.Next(3);

                switch (OZkar){
                    case '1':
                        baruString += SatuDanNol(acakRep, karSatu) + SatuDanNol(acakRep, ";");
                        break;
                    case '0':
                        baruString += SatuDanNol(acakRep, aNol) + SatuDanNol(acakRep, ":");
                        break;}

                baruString += SatuDanNol(intAcak.Next(1, 3),
                        aKar.Substring(intAcak.Next(aKar.Length), 1));}

            return SatuDanNol(intAcak.Next(1, 3), aKar.Substring(intAcak.Next(aKar.Length), 1))
                + baruString + SatuDanNol(intAcak.Next(3), karSatu) +
                SatuDanNol(intAcak.Next(3), aNol)
                + SatuDanNol(intAcak.Next(1, 3), aKar.Substring(intAcak.Next(aKar.Length), 1));}

        private string SatuDanNol(int Rept, string sOZ){
            int ii;
            for (ii = 0; ii < Rept; ii++){
                sOZ += sOZ.Substring(0, 1);}
            return sOZ;}

        private char GetKarakter(string strBiner){
            return (char)Convert.ToInt32(strBiner, 2);}

        private string GetBiner(char strKar){
            return Convert.ToString(strKar, 2).PadLeft(8, '0');}}
}

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;

namespace PengacakTeks2
{
    public partial class FormPengacakTeks : Form{
        PengacakTeks.Pengacak BaruSumber = new PengacakTeks.Pengacak();

        public FormPengacakTeks(){
            InitializeComponent();}

        private void btnBinerKeTeks_Click(object sender, EventArgs e){
            MessageBox.Show(BaruSumber.StringUtama(teksKodeBiner.Text ,0));}

        private void btnAcakKeTeks_Click(object sender, EventArgs e){
            MessageBox.Show(BaruSumber.StringUtama(teksAcak.Text, 1));}

        private void btnAcak_Click(object sender, EventArgs e){
            teksKodeBiner.Text = BaruSumber.StringBiner(teksTeks.Text);
            teksAcak.Text = BaruSumber.StringAcak(teksTeks.Text);}

        private void btnKeluar_Click(object sender, EventArgs e){
            if (Application.MessageLoop){
                Application.Exit();}
            else{
                Environment.Exit(1);}}}
}



1.12 Mesin Enigma


using System;
using System.Text;
using System.Windows.Forms;

namespace Enigma
{
       
        public class Rotor
        {
                private string tataLetak;
                private byte offset;
                private Rotor sbmlmNya, slnjtNya;
                private Label lbl;
                private char cIn = '\0', notchPos;
       
                public Rotor(string aTataLetak,Label lbl,char notchPos)
                {
                        this.tataLetak = aTataLetak;
                        this.sbmlmNya = sbmlmNya;
                        this.slnjtNya = slnjtNya;
                        this.lbl = lbl;
                        this.notchPos = notchPos;
                        offset = 0;
                       
                }
               
                public string GetTataLetak(){
                        return tataLetak;
                }
               
                public void SetRotorSelanjutnya(Rotor slnjtnya){
                        this.slnjtNya = slnjtnya;
                }
                public void SetRotorSblmNya(Rotor sblmnya){
                        this.sbmlmNya = sblmnya;
                }
               
                public char GetKarTerbalikPada(string kar){
                        int pos = tataLetak.IndexOf(kar);
                       
                        if(offset>pos){
                                pos = 26 - (offset-pos);
                        }else{
                                pos = pos - offset;
                        }
                       
                        if(sbmlmNya!=null){
                                pos = (pos+sbmlmNya.GetOffset())%26;
                        }
                       
                        return (char)(65+pos);
                }
               
                public int GetOffset(){
                        return offset;
                }
               
                public char GetNotchPos(){
                        return notchPos;
                }
               
                public void ResetOffset(){
                        offset = 0;
                }
               
                public bool AdaSelanjutnya(){
                        return slnjtNya!=null;
                }
               
                public bool AdaSebelumnya(){
                        return sbmlmNya!=null;
                }
               
                public void Geser(){
                        if(slnjtNya==null){
                                return;
                        }
                        offset++;
                        if(offset==26){
                                offset = 0;
                        }
                       
                        if(slnjtNya!=null && (offset+66) == ((notchPos-64)%26)+66){
                                slnjtNya.Geser();
                        }
                        lbl.Text = ""+((char)(65+offset));
                }
               
                public void GeserBalik(){
                        if(offset==0){
                                offset = 26;
                        }
                        offset--;
                       
                        lbl.Text = ""+((char)(65+offset));
                }
               
                public void TempatkanDataPada(char s){
                        cIn = s;
                        char c = s;
                        c = (char)(((c - 65) + offset) % 26 + 65);
                       
                        if(slnjtNya!=null){
                                c = tataLetak.Substring((c-65),1).ToCharArray()[0];
                                if((((c-65)+(-offset))%26 + 65)>=65){
                                        c = (char)(((c-65)+(-offset))%26 + 65);
                                }else{
                                        c = (char)(((c-65)+(26+(-offset)))%26 + 65);
                                }
                                slnjtNya.TempatkanDataPada(c);
                               
                        }
                }
               
                public char GetDataKel(){
                        char c = '\0';
                       
                        if(slnjtNya!=null){
                                c = slnjtNya.GetDataKel();
                                c = GetKarTerbalikPada(""+c);
                        }else{
                                c = tataLetak.Substring((cIn-65),1).ToCharArray()[0];
                                c = (char)(((c - 65) + sbmlmNya.offset)%26+65);
                               
                        }
                       
                        return c;
                }
        }
}

using System;
using System.Drawing;
using System.Windows.Forms;
using System.Collections;

namespace Enigma
{
        public class Pengaturan : System.Windows.Forms.Form
        {
                private System.ComponentModel.IContainer components;
                private System.Windows.Forms.ListBox listRotorDipilih;
                private System.Windows.Forms.Label lblStrukturRotor;
                private System.Windows.Forms.ListBox listRotor;
                private System.Windows.Forms.Button btnCancel;
                private System.Windows.Forms.GroupBox groupBox1;
                private System.Windows.Forms.ComboBox cmbReflektor;
                private System.Windows.Forms.ToolTip ttDown;
                private System.Windows.Forms.ToolTip ttSelect;
                private System.Windows.Forms.ToolTip ttDeselect;
                private System.Windows.Forms.Button btnAtas;
                private System.Windows.Forms.Label label3;
                private System.Windows.Forms.Label label2;
                private System.Windows.Forms.Label label1;
                private System.Windows.Forms.Button btnTakPilih;
                private System.Windows.Forms.Button btnOk;
                private System.Windows.Forms.Label label4;
                private System.Windows.Forms.Button btnBawah;
                private System.Windows.Forms.Button btnPilih;
                private System.Windows.Forms.ToolTip ttUp;
                private string rotor1,rotor2,rotor3,rotor4,rotor5;
                private FormUtama mf;
                private ArrayList al1, al2, al3;
               
                public Pengaturan(FormUtama mf)
                {
                        InitializeComponent();
                        this.mf = mf;

                }
               
                void BtnCancelClick(object sender, System.EventArgs e)
                {
                        Close();
                }
               
                void MuatPengaturan(object sender, System.EventArgs e)
                {
                        al1 = new ArrayList();
                        al2 = new ArrayList();
                        al3 = new ArrayList();
                        al1.Add("Rotor I");
                        al1.Add("Rotor II");
                        al1.Add("Rotor III");
                        al1.Add("Rotor IV");
                        al1.Add("Rotor V");
                        rotor1 = "EKMFLGDQVZNTOWYHXUSPAIBRCJ";
                        rotor2 = "AJDKSIRUXBLHWTMCQGZNPYFVOE";
                        rotor3 = "BDFHJLCPRTXVZNYEIWGAKMUSQO";
                        rotor4 = "ESOVPZJAYQUIRHXLNFTGKDCMWB";
                        rotor5 = "VZBRGITYUPSDNHLXAWMJQOFECK";
                        al2.Add(rotor1);
                        al2.Add(rotor2);
                        al2.Add(rotor3);
                        al2.Add(rotor4);
                        al2.Add(rotor5);
                        al3.Add("Q");
                        al3.Add("E");
                        al3.Add("V");
                        al3.Add("J");
                        al3.Add("Z");
                        listRotor.Items.Clear();
                        for(int i=0;i<al1.Count;i++){
                                listRotor.Items.Add(al1[i]);
                        }
                        ttSelect.SetToolTip(btnPilih,"Pilih rotor yang tersedia");
                        ttDeselect.SetToolTip(btnTakPilih,"Hapus rotor");
                        ttUp.SetToolTip(btnAtas,"Menggeser atas pemilihan");
                        ttDown.SetToolTip(btnBawah,"Menggeser bawah pemilihan");
                       
                        for(int i=0;i<cmbReflektor.Items.Count;i++){
                                if(cmbReflektor.Items[i].ToString().
                                        EndsWith(mf.GetReflektor())){
                                        cmbReflektor.SelectedIndex = i;
                                }
                        }
                       
                        for(int i=0;i<al2.Count;i++){
                                if(al2[i].ToString()==mf.GetRotorKiri()){
                                        listRotor.Items.Remove(al1[i].ToString());
                                        listRotorDipilih.Items.Add(al1[i].ToString());
                                        break;
                                }
                        }
                       
                        for(int i=0;i<al2.Count;i++){
                                if(al2[i].ToString()==mf.GetRotorTengah()){
                                        listRotor.Items.Remove(al1[i].ToString());
                                        listRotorDipilih.Items.Add(al1[i].ToString());
                                        break;
                                }
                        }
                        for(int i=0;i<al2.Count;i++){
                                if(al2[i].ToString()==mf.GetRotorKanan()){
                                        listRotor.Items.Remove(al1[i].ToString());
                                        listRotorDipilih.Items.Add(al1[i].ToString());
                                        break;
                                }
                        }
                }
               
                void ListRotorTersediaSelectedIndexChanged(object sender, System.EventArgs e)
                {
                        if(listRotor.SelectedIndex<0){
                                return;
                        }
                        for(int i=0;i<al1.Count;i++){
                                if(listRotor.SelectedItem.ToString() == "" + al1[i]){
                                        lblStrukturRotor.Text = "" + al2[i];
                                        return;
                                }
                        }
                        lblStrukturRotor.Text = "";
                }
               
                void btnPilihClick(object sender, System.EventArgs e)
                {
                        if(listRotor.SelectedIndex<0){
                                MessageBox.Show(this,"Pilih rotor yang
                                        tersedia!","Perhatian!",MessageBoxButtons.OK,
                                        MessageBoxIcon.Exclamation);
                                return;
                        }
                        listRotorDipilih.Items.Add(listRotor.SelectedItem);
                        listRotor.Items.Remove(listRotor.SelectedItem);
                        lblStrukturRotor.Text = "";
                }
               
                void btnTakPilihClick(object sender, System.EventArgs e)
                {
                        if(listRotorDipilih.SelectedIndex<0){
                MessageBox.Show(this, "Hapus rotor!", "Perhatian!", MessageBoxButtons.OK,
                        MessageBoxIcon.Exclamation);
                                return;
                        }
                        listRotor.Items.Add(listRotorDipilih.SelectedItem);
                        listRotorDipilih.Items.Remove(listRotorDipilih.SelectedItem);
                }
               
                void btnAtasClick(object sender, System.EventArgs e)
                {
                        if(listRotorDipilih.SelectedIndex<=0){
                                return;
                        }
                       
                        string strTemp =
                                ""+listRotorDipilih.Items[listRotorDipilih.SelectedIndex-1];
                        listRotorDipilih.Items[listRotorDipilih.SelectedIndex -1 ] =
                                listRotorDipilih.SelectedItem;
                        listRotorDipilih.Items[listRotorDipilih.SelectedIndex] = strTemp;
                        listRotorDipilih.SelectedIndex = listRotorDipilih.SelectedIndex - 1;
                       
                }
               
                void btnBawahClick(object sender, System.EventArgs e)
                {
                        if(listRotorDipilih.SelectedIndex<0 || listRotorDipilih.SelectedIndex ==
                                listRotorDipilih.Items.Count-1){
                                return;
                        }
                       
                        string strTemp =
                                ""+listRotorDipilih.Items[listRotorDipilih.SelectedIndex+1];
                        listRotorDipilih.Items[listRotorDipilih.SelectedIndex +1 ] =
                                listRotorDipilih.SelectedItem;
                        listRotorDipilih.Items[listRotorDipilih.SelectedIndex] = strTemp;
                        listRotorDipilih.SelectedIndex = listRotorDipilih.SelectedIndex + 1;
                }
               
                void BtnOkClick(object sender, System.EventArgs e)
                {
                        if(listRotorDipilih.Items.Count!=3){
                                MessageBox.Show(this,"Semua pengaturan akan
                                        dimuat!","Perhatian!",MessageBoxButtons.OK,
                                MessageBoxIcon.Exclamation);
                                return;
                        }
                       
                        ArrayList alRot = new ArrayList();
                        ArrayList alRotNama = new ArrayList();
                        ArrayList alRotNotch = new ArrayList();
                       
                        for(int j=0;j<listRotorDipilih.Items.Count;j++){
                                for(int i=0;i<al1.Count;i++){
                                        if(listRotorDipilih.Items[j].ToString() == "" + al1[i]){
                                                alRot.Add(al2[i]);
                                                alRotNama.Add(al1[i].ToString().Substring(al1[i].ToString().LastIndexOf(" ")).Trim());
                                                alRotNotch.Add(al3[i]);
                                                break;
                                        }
                                }
                        }
                       
                        mf.UbahRotor(alRot[0].ToString(),
                                        alRotNama[0].ToString(),
                                        alRotNotch[0].ToString().ToCharArray()[0],
                                        alRot[1].ToString(),
                                        alRotNama[1].ToString(),
                                        alRotNotch[1].ToString().ToCharArray()[0],
                                        alRot[2].ToString(),
                                        alRotNama[2].ToString(),
                                        alRotNotch[2].ToString().ToCharArray()[0]);
                       
                        if(cmbReflektor.SelectedIndex>-0){
                                mf.SetReflektor(cmbReflektor.SelectedItem.ToString().Substring(cmbReflektor.SelectedItem
                .ToString().LastIndexOf("=")+2).Trim());
                        }
                        Close();
                }
               
        }
}

  

1.13 Hash MD5 dan SHA1





using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Security.Cryptography;
using System.IO;
using System.Threading;

namespace PerangkatHASH {
    public partial class FormHASH : Form {

        string teks = "", filePath = "";
        byte[] inArr;
        int ukuranBuffer = 1024, bufferPembagi = 100;
        long ukuranFile = 0;

        MD5CryptoServiceProvider serviceMD5;
        SHA1CryptoServiceProvider serviceSHA1;
        OpenFileDialog diag;
        FileStream stream;

        public FormHASH() {
            InitializeComponent();

            serviceMD5  = new MD5CryptoServiceProvider();
            serviceSHA1 = new SHA1CryptoServiceProvider();
            diag = new OpenFileDialog();
        }

        private void btnEnkripsi_Click(object sender, EventArgs e) {
            teks = teksPesan.Text;
            if(teks.Length > 0) {

                inArr = System.Text.Encoding.ASCII.GetBytes(teks);
                teksMD5.Text =  System.BitConverter.ToString(serviceMD5.ComputeHash(inArr)).Replace("-", "").ToLowerInvariant();
                teksSHA1.Text = System.BitConverter.ToString(serviceSHA1.ComputeHash(inArr)).Replace("-", "").ToLowerInvariant();
            }
            else {
                teksMD5.Text = "";
                teksSHA1.Text = "";
                teks = "";
            }
        }

        private void btnBrowse_Click(object sender, EventArgs e) {

            if(diag.ShowDialog() == DialogResult.OK) {

                textBox5.Text = "";
                textBox6.Text = "";

                filePath = diag.FileName;
                if(filePath.Length > 40) { teksFile.Text = filePath.Substring(0, 20) + "[...]" + filePath.Substring(diag.FileName.Length - 20, 20); }
                else { teksFile.Text = filePath; }
                stream = new FileStream(diag.FileName, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
                ukuranFile = stream.Length;

                if(ukuranFile <= 0) {
                    teksFile.Text = "";
                    filePath = "";
                    MessageBox.Show("File Kosong!");                   
                }
                else if(ukuranFile < 1024) {
                    ukuranBuffer = (int)(ukuranFile / 1);
                    progressBar1.Maximum = (int)(ukuranFile / ukuranBuffer);
                    progressBar2.Maximum = progressBar1.Maximum;
                    stream.Close();
                }
                else {
                    ukuranBuffer = (int)(ukuranFile / bufferPembagi);
                    progressBar1.Maximum = (int)(ukuranFile / ukuranBuffer);
                    progressBar2.Maximum = progressBar1.Maximum;
                    stream.Close();
                }
            }
        }


        private void btnSalinMD5_Click(object sender, EventArgs e) {
            if(teks.Length > 0) {
                System.Windows.Forms.Clipboard.SetText(teksMD5.Text);
            }
        }

        private void btnSalinSHA1_Click(object sender, EventArgs e) {
            if(teks.Length > 0) {
                System.Windows.Forms.Clipboard.SetText(teksSHA1.Text);
            }
        }

        public void gerakProgressBar(ProgressBar p) {
            if(p.Value < 100) { p.Value += 1; }
            else { p.Value = 0; }
        }

        private void btnGetMD5_Click(object sender, EventArgs e) {
            if(filePath.Length > 0) {
                progressBar1.Show();
                btnBrowse.Enabled = false;
                btnGetMD5.Enabled = false;
                btnGetSHA1.Enabled = false;
                BackgroundWorker getFileMD5 = new BackgroundWorker();
                getFileMD5.DoWork += new DoWorkEventHandler(MD5_Kerjakan);
                getFileMD5.RunWorkerCompleted += new RunWorkerCompletedEventHandler(MD5_Selesai);
                getFileMD5.RunWorkerAsync();
            }
        }

        public void MD5_Kerjakan(object sender, DoWorkEventArgs e) {
            stream = new FileStream(diag.FileName, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
            byte[] buffer = new byte[ukuranBuffer];
            int bacaJumlah;
            HashAlgorithm algoritma = MD5.Create();

            while((bacaJumlah = stream.Read(buffer, 0, ukuranBuffer)) > 0) {
                algoritma.TransformBlock(buffer, 0, bacaJumlah, buffer, 0);
                progressBar1.Invoke((MethodInvoker)delegate() {
                    if(progressBar1.Value < progressBar1.Maximum)
                        progressBar1.Value += 1;
                    else
                        progressBar1.Value = 0;
                });
            }
            algoritma.TransformFinalBlock(buffer, 0, bacaJumlah);
            string result = System.BitConverter.ToString(algoritma.Hash).Replace("-", "");           
            e.Result = result;
        }

        public void MD5_Selesai(object sender, RunWorkerCompletedEventArgs e) {
            stream.Close();
            progressBar1.Value = 0;
            progressBar1.Hide();
            textBox5.Text = ((string)e.Result).ToLowerInvariant();
            btnBrowse.Enabled = true;
            btnGetMD5.Enabled = true;
            btnGetSHA1.Enabled = true;

            System.Windows.Forms.Clipboard.SetText(textBox5.Text);
            MessageBox.Show("Hash MD5 atas file disalin ke clipboard");
        }

        private void btnGetSHA1_Click(object sender, EventArgs e) {
            if(filePath.Length > 0) {
                if(filePath.Length > 0) {
                    progressBar2.Show();                       
                    btnBrowse.Enabled = false;
                    btnGetMD5.Enabled = false;
                    btnGetSHA1.Enabled = false;
                    BackgroundWorker getFileSHA1 = new BackgroundWorker();
                    getFileSHA1.DoWork += new DoWorkEventHandler(SHA1_Kerjakan);
                    getFileSHA1.RunWorkerCompleted += new RunWorkerCompletedEventHandler(SHA1_Selesai);
                    getFileSHA1.RunWorkerAsync();
                }
            }
        }

        public void SHA1_Kerjakan(object sender, DoWorkEventArgs e) {
            stream = new FileStream(diag.FileName, System.IO.FileMode.Open, System.IO.FileAccess.Read, System.IO.FileShare.ReadWrite);
            byte[] buffer = new byte[ukuranBuffer];
            int bacaJumlah;
            HashAlgorithm algoritma = SHA1.Create();

            while((bacaJumlah = stream.Read(buffer, 0, ukuranBuffer)) > 0) {
                algoritma.TransformBlock(buffer, 0, bacaJumlah, buffer, 0);
                progressBar2.Invoke((MethodInvoker)delegate() {
                    if(progressBar2.Value < progressBar1.Maximum)
                        progressBar2.Value += 1;
                    else
                        progressBar2.Value = 0;
                });
            }
            algoritma.TransformFinalBlock(buffer, 0, bacaJumlah);
            string result = System.BitConverter.ToString(algoritma.Hash).Replace("-", "");
            e.Result = result;
        }

        public void SHA1_Selesai(object sender, RunWorkerCompletedEventArgs e) {
            stream.Close();
            progressBar2.Value = 0;
            progressBar2.Hide();
            textBox6.Text = ((string)e.Result).ToLowerInvariant();
            btnBrowse.Enabled = true;
            btnGetMD5.Enabled = true;
            btnGetSHA1.Enabled = true;

            System.Windows.Forms.Clipboard.SetText(textBox6.Text);
            MessageBox.Show("Hash SHA1 atas file disalin ke clipboard");
        }

        private void Form1_Load(object sender, EventArgs e) {

        }

    }
}




No comments: