Click here to Skip to main content
15,887,485 members
Please Sign up or sign in to vote.
0.00/5 (No votes)
See more:
I have tried this code to measure time of the encryption process i want it to measure time based on key length, i do not know where i should change
because i get result but it gets lower every time were it should increase more based on the entered key .
i work with three keys 128-bit , 192-bit and 256-bit

Java
byte[] plain = plaintext.getText().getBytes();
        byte[] K = key.getText().getBytes();
        long startTime = System.currentTimeMillis();
        byte[] encrypted = encrypt(plain, K);
        String a = bytesToHex(encrypted);
        encryptedtext.setText(a);
        long stopTime = System.currentTimeMillis();
        long elapsedTime = stopTime - startTime;
        time.append(Integer.toString((int) elapsedTime) + " ms \n");



the source code is:
Java
package test;
       public class MARS {
       private static int[] K;

       private static int [] s_box ={
                0x09d0c479, 0x28c8ffe0, 0x84aa6c39,     0x9dad7287, 0x7dff9be3, 0xd4268361, 0xc96da1d4,        0x7974cc93, 0x85d0582e, 0x2a4b5705,
                0x1ca16a62, 0xc3bd279d, 0x0f1f25e5, 0x5160372f, 0xc695c1fb, 0x4d7ff1e4, 0xae5f6bf4, 0x0d72ee46, 0xff23de8a, 0xb1cf8e83,
                0xf14902e2, 0x3e981e42, 0x8bf53eb6, 0x7f4bf8ac, 0x83631f83, 0x25970205, 0x76afe784, 0x3a7931d4, 0x4f846450, 0x5c64c3f6,
                0x210a5f18, 0xc6986a26, 0x28f4e826, 0x3a60a81c, 0xd340a664, 0x7ea820c4, 0x526687c5, 0x7eddd12b, 0x32a11d1d, 0x9c9ef086,
                0x80f6e831, 0xab6f04ad, 0x56fb9b53, 0x8b2e095c, 0xb68556ae, 0xd2250b0d, 0x294a7721, 0xe21fb253, 0xae136749, 0xe82aae86,
                0x93365104, 0x99404a66, 0x78a784dc, 0xb69ba84b, 0x04046793, 0x23db5c1e, 0x46cae1d6, 0x2fe28134, 0x5a223942, 0x1863cd5b,
                0xc190c6e3, 0x07dfb846, 0x6eb88816, 0x2d0dcc4a, 0xa4ccae59, 0x3798670d, 0xcbfa9493, 0x4f481d45, 0xeafc8ca8, 0xdb1129d6,
                0xb0449e20, 0x0f5407fb, 0x6167d9a8, 0xd1f45763, 0x4daa96c3, 0x3bec5958, 0xababa014, 0xb6ccd201, 0x38d6279f, 0x02682215,
                0x8f376cd5, 0x092c237e, 0xbfc56593, 0x32889d2c, 0x854b3e95, 0x05bb9b43, 0x7dcd5dcd, 0xa02e926c, 0xfae527e5, 0x36a1c330,
                0x3412e1ae, 0xf257f462, 0x3c4f1d71, 0x30a2e809, 0x68e5f551, 0x9c61ba44, 0x5ded0ab8, 0x75ce09c8, 0x9654f93e, 0x698c0cca,
                0x243cb3e4, 0x2b062b97, 0x0f3b8d9e, 0x00e050df, 0xfc5d6166, 0xe35f9288, 0xc079550d, 0x0591aee8, 0x8e531e74, 0x75fe3578,
                0x2f6d829a, 0xf60b21ae, 0x95e8eb8d, 0x6699486b, 0x901d7d9b, 0xfd6d6e31, 0x1090acef, 0xe0670dd8, 0xdab2e692, 0xcd6d4365,
                0xe5393514, 0x3af345f0, 0x6241fc4d, 0x460da3a3, 0x7bcf3729, 0x8bf1d1e0, 0x14aac070, 0x1587ed55, 0x3afd7d3e, 0xd2f29e01,
                0x29a9d1f6, 0xefb10c53, 0xcf3b870f, 0xb414935c, 0x664465ed, 0x024acac7, 0x59a744c1, 0x1d2936a7, 0xdc580aa6, 0xcf574ca8,
                0x040a7a10, 0x6cd81807, 0x8a98be4c, 0xaccea063, 0xc33e92b5, 0xd1e0e03d, 0xb322517e, 0x2092bd13, 0x386b2c4a, 0x52e8dd58,
                0x58656dfb, 0x50820371, 0x41811896, 0xe337ef7e, 0xd39fb119, 0xc97f0df6, 0x68fea01b, 0xa150a6e5, 0x55258962, 0xeb6ff41b,
                0xd7c9cd7a, 0xa619cd9e, 0xbcf09576, 0x2672c073, 0xf003fb3c, 0x4ab7a50b, 0x1484126a, 0x487ba9b1, 0xa64fc9c6, 0xf6957d49,
                0x38b06a75, 0xdd805fcd, 0x63d094cf, 0xf51c999e, 0x1aa4d343, 0xb8495294, 0xce9f8e99, 0xbffcd770, 0xc7c275cc, 0x378453a7,
                0x7b21be33, 0x397f41bd, 0x4e94d131, 0x92cc1f98, 0x5915ea51, 0x99f861b7, 0xc9980a88, 0x1d74fd5f, 0xb0a495f8, 0x614deed0,
                0xb5778eea, 0x5941792d, 0xfa90c1f8, 0x33f824b4, 0xc4965372, 0x3ff6d550, 0x4ca5fec0, 0x8630e964, 0x5b3fbbd6, 0x7da26a48,
                0xb203231a, 0x04297514, 0x2d639306, 0x2eb13149, 0x16a45272, 0x532459a0, 0x8e5f4872, 0xf966c7d9, 0x07128dc0, 0x0d44db62,
                0xafc8d52d, 0x06316131, 0xd838e7ce, 0x1bc41d00, 0x3a2e8c0f, 0xea83837e, 0xb984737d, 0x13ba4891, 0xc4f8b949, 0xa6d6acb3,
                0xa215cdce, 0x8359838b, 0x6bd1aa31, 0xf579dd52, 0x21b93f93, 0xf5176781, 0x187dfdde, 0xe94aeb76, 0x2b38fd54, 0x431de1da,
                0xab394825, 0x9ad3048f, 0xdfea32aa, 0x659473e3, 0x623f7863, 0xf3346c59, 0xab3ab685, 0x3346a90b, 0x6b56443e, 0xc6de01f8,
                0x8d421fc0, 0x9b0ed10c, 0x88f1a1e9, 0x54c1f029, 0x7dead57b, 0x8d7ba426, 0x4cf5178a, 0x551a7cca, 0x1a9a5f08, 0xfcd651b9,
                0x25605182, 0xe11fc6c3, 0xb6fd9676, 0x337b3027, 0xb7c8eb14, 0x9e5fd030, 0x6b57e354, 0xad913cf7, 0x7e16688d, 0x58872a69,
                0x2c2fc7df, 0xe389ccc6, 0x30738df1, 0x0824a734, 0xe1797a8b, 0xa4a8d57b, 0x5b5d193b, 0xc8a8309b, 0x73f9a978, 0x73398d32,
                0x0f59573e, 0xe9df2b03, 0xe8a5b6c8, 0x848d0704, 0x98df93c2, 0x720a1dc3, 0x684f259a, 0x943ba848, 0xa6370152, 0x863b5ea3,
                0xd17b978b, 0x6d9b58ef, 0x0a700dd4, 0xa73d36bf, 0x8e6a0829, 0x8695bc14, 0xe35b3447, 0x933ac568, 0x8894b022, 0x2f511c27,
                0xddfbcc3c, 0x006662b6, 0x117c83fe, 0x4e12b414, 0xc2bca766, 0x3a2fec10, 0xf4562420, 0x55792e2a, 0x46f5d857, 0xceda25ce,
                0xc3601d3b, 0x6c00ab46, 0xefac9c28, 0xb3c35047, 0x611dfee3, 0x257c3207, 0xfdd58482, 0x3b14d84f, 0x23becb64, 0xa075f3a3,
                0x088f8ead, 0x07adf158, 0x7796943c, 0xfacabf3d, 0xc09730cd, 0xf7679969, 0xda44e9ed, 0x2c854c12, 0x35935fa3, 0x2f057d9f,
                0x690624f8, 0x1cb0bafd, 0x7b0dbdc6, 0x810f23bb, 0xfa929a1a, 0x6d969a17, 0x6742979b, 0x74ac7d05, 0x010e65c4, 0x86a3d963,
                0xf907b5a0, 0xd0042bd3, 0x158d7d03, 0x287a8255, 0xbba8366f, 0x096edc33, 0x21916a7b, 0x77b56b86, 0x951622f9, 0xa6c5e650,
                0x8cea17d1, 0xcd8c62bc, 0xa3d63433, 0x358a68fd, 0x0f9b9d3c, 0xd6aa295b, 0xfe33384a, 0xc000738e, 0xcd67eb2f, 0xe2eb6dc2,
                0x97338b02, 0x06c9f246, 0x419cf1ad, 0x2b83c045, 0x3723f18a, 0xcb5b3089, 0x160bead7, 0x5d494656, 0x35f8a74b, 0x1e4e6c9e,
                0x000399bd, 0x67466880, 0xb4174831, 0xacf423b2, 0xca815ab3, 0x5a6395e7, 0x302a67c5, 0x8bdb446b, 0x108f8fa4, 0x10223eda,
                0x92b8b48b, 0x7f38d0ee, 0xab2701d4, 0x0262d415, 0xaf224a30, 0xb3d88aba, 0xf8b2c3af, 0xdaf7ef70, 0xcc97d3b7, 0xe9614b6c,
                0x2baebff4, 0x70f687cf, 0x386c9156, 0xce092ee5, 0x01e87da6, 0x6ce91e6a, 0xbb7bcc84, 0xc7922c20, 0x9d3b71fd, 0x060e41c6,
                0xd7590f15, 0x4e03bb47, 0x183c198e, 0x63eeb240, 0x2ddbf49a, 0x6d5cba54, 0x923750af, 0xf9e14236, 0x7838162b, 0x59726c72,
                0x81b66760, 0xbb2926c1, 0x48a0ce0d, 0xa6c0496d, 0xad43507b, 0x718d496a, 0x9df057af, 0x44b1bde6, 0x054356dc, 0xde7ced35,
                0xd51a138b, 0x62088cc9, 0x35830311, 0xc96efca2, 0x686f86ec, 0x8e77cb68, 0x63e1d6b8, 0xc80f9778, 0x79c491fd, 0x1b4c67f2,
                0x58656dfb, 0x50820371, 0x41811896, 0xe337ef7e, 0xd39fb119, 0xc97f0df6, 0x68fea01b, 0xa150a6e5, 0x55258962, 0xeb6ff41b,
                0xd7c9cd7a, 0xa619cd9e, 0xbcf09576, 0x2672c073, 0xf003fb3c, 0x4ab7a50b, 0x1484126a, 0x487ba9b1, 0xa64fc9c6, 0xf6957d49,
                0x38b06a75, 0xdd805fcd, 0x63d094cf, 0xf51c999e, 0x1aa4d343, 0xb8495294, 0xce9f8e99, 0xbffcd770, 0xc7c275cc, 0x378453a7,
                0x7b21be33, 0x397f41bd, 0x4e94d131, 0x92cc1f98, 0x5915ea51, 0x99f861b7, 0xc9980a88, 0x1d74fd5f, 0xb0a495f8, 0x614deed0,
                0xb5778eea, 0x5941792d, 0xfa90c1f8, 0x33f824b4, 0xc4965372, 0x3ff6d550, 0x4ca5fec0, 0x8630e964, 0x5b3fbbd6, 0x7da26a48,
                0xb203231a, 0x04297514, 0x2d639306, 0x2eb13149, 0x16a45272, 0x532459a0, 0x8e5f4872, 0xf966c7d9, 0x07128dc0, 0x0d44db62,
                0xafc8d52d, 0x06316131, 0xd838e7ce, 0x1bc41d00, 0x3a2e8c0f, 0xea83837e, 0xb984737d, 0x13ba4891, 0xc4f8b949, 0xa6d6acb3,
                0xa215cdce, 0x8359838b, 0x6bd1aa31, 0xf579dd52, 0x21b93f93, 0xf5176781, 0x187dfdde, 0xe94aeb76, 0x2b38fd54, 0x431de1da,
                0xab394825, 0x9ad3048f, 0xdfea32aa, 0x659473e3, 0x623f7863, 0xf3346c59, 0xab3ab685, 0x3346a90b, 0x6b56443e, 0xc6de01f8,
                0x8d421fc0, 0x9b0ed10c, 0x88f1a1e9, 0x54c1f029, 0x7dead57b, 0x8d7ba426, 0x4cf5178a, 0x551a7cca, 0x1a9a5f08, 0xfcd651b9,
                0x25605182, 0xe11fc6c3, 0xb6fd9676, 0x337b3027, 0xb7c8eb14, 0x9e5fd030, 0x6b57e354, 0xad913cf7, 0x7e16688d, 0x58872a69,
                0x2c2fc7df, 0xe389ccc6, 0x30738df1, 0x0824a734, 0xe1797a8b, 0xa4a8d57b, 0x5b5d193b, 0xc8a8309b, 0x73f9a978, 0x73398d32,
                0x0f59573e, 0xe9df2b03, 0xe8a5b6c8, 0x848d0704, 0x98df93c2, 0x720a1dc3, 0x684f259a, 0x943ba848, 0xa6370152, 0x863b5ea3,
                0xd17b978b, 0x6d9b58ef, 0x0a700dd4, 0xa73d36bf, 0x8e6a0829, 0x8695bc14, 0xe35b3447, 0x933ac568, 0x8894b022, 0x2f511c27,
                0xddfbcc3c, 0x006662b6, 0x117c83fe, 0x4e12b414, 0xc2bca766, 0x3a2fec10, 0xf4562420, 0x55792e2a, 0x46f5d857, 0xceda25ce,
                0xc3601d3b, 0x6c00ab46, 0xefac9c28, 0xb3c35047, 0x611dfee3, 0x257c3207, 0xfdd58482, 0x3b14d84f, 0x23becb64, 0xa075f3a3,
                0x088f8ead, 0x07adf158, 0x7796943c, 0xfacabf3d, 0xc09730cd, 0xf7679969, 0xda44e9ed, 0x2c854c12, 0x35935fa3, 0x2f057d9f,
                0x690624f8, 0x1cb0bafd, 0x7b0dbdc6, 0x810f23bb, 0xfa929a1a, 0x6d969a17, 0x6742979b, 0x74ac7d05, 0x010e65c4, 0x86a3d963,
                0xf907b5a0, 0xd0042bd3, 0x158d7d03, 0x287a8255, 0xbba8366f, 0x096edc33, 0x21916a7b, 0x77b56b86, 0x951622f9, 0xa6c5e650,
                0x8cea17d1, 0xcd8c62bc, 0xa3d63433, 0x358a68fd, 0x0f9b9d3c, 0xd6aa295b, 0xfe33384a, 0xc000738e, 0xcd67eb2f, 0xe2eb6dc2,
                0x97338b02, 0x06c9f246, 0x419cf1ad, 0x2b83c045, 0x3723f18a, 0xcb5b3089, 0x160bead7, 0x5d494656, 0x35f8a74b, 0x1e4e6c9e,
                0x000399bd, 0x67466880, 0xb4174831, 0xacf423b2, 0xca815ab3, 0x5a6395e7, 0x302a67c5, 0x8bdb446b, 0x108f8fa4, 0x10223eda,
                0x92b8b48b, 0x7f38d0ee, 0xab2701d4, 0x0262d415, 0xaf224a30, 0xb3d88aba, 0xf8b2c3af, 0xdaf7ef70, 0xcc97d3b7, 0xe9614b6c,
                0x2baebff4, 0x70f687cf, 0x386c9156, 0xce092ee5, 0x01e87da6, 0x6ce91e6a, 0xbb7bcc84, 0xc7922c20, 0x9d3b71fd, 0x060e41c6,
                0xd7590f15, 0x4e03bb47, 0x183c198e, 0x63eeb240, 0x2ddbf49a, 0x6d5cba54, 0x923750af, 0xf9e14236, 0x7838162b, 0x59726c72,
                0x81b66760, 0xbb2926c1, 0x48a0ce0d, 0xa6c0496d, 0xad43507b, 0x718d496a, 0x9df057af, 0x44b1bde6, 0x054356dc, 0xde7ced35,
                0xd51a138b, 0x62088cc9, 0x35830311, 0xc96efca2, 0x686f86ec, 0x8e77cb68, 0x63e1d6b8, 0xc80f9778, 0x79c491fd, 0x1b4c67f2,
        };

        private static int rotl(int val, int pas) {
                return (val << pas) | (val >>> (32 - pas));
        }
        private static int rotr(int val, int pas) {
                return (val >>> pas) | (val << (32-pas));
        }


        private static int[] expandKey(byte[] key){
                int n = key.length/4;
                int[] tmp = new int[40];
                int[] data = new int[n];

                for(int i =0;i<data.length;i++)
                        data[i] = 0;

                int off = 0;
                for(int i=0;i<data.length;i++){
                        data[i] =       ((key[off++]&0xff))|
                                                ((key[off++]&0xff) << 8) |
                                                ((key[off++]&0xff) << 16) |
                                                ((key[off++]&0xff) << 24);
                }

                int[] T = new int[15];
                for(int i=0;i<T.length;i++){
                        if(i<data.length) T[i] = data[i];
                        else if(i == data.length) T[i] = n;
                        else T[i] = 0;
                }

                for(int j=0;j<4;j++){
                        for(int i=0;i<T.length;i++)
                                T[i] = T[i] ^ (rotl(T[Math.abs(i-7 %15)] ^     T[Math.abs(i-2 %15)],3) ^ (4*i+j));
                        for(int c=0;c<4;c++)
                                for(int i=0;i<T.length;i++)
                                        T[i] = T[i] + rotl(s_box[(int).   (T[Math.abs(i-1%15)] & 0x000001ff)],9);
                        for(int i = 0;i<=9;i++) tmp[10*j+i] = T[4*i%15];
                }

                int[] B = {0xa4a8d57b, 0x5b5d193b, 0xc8a8309b,     0x73f9a978};
                int j,w,m,r,p;
                for(int i = 5;i<=35;i++){
                        j = tmp[i] & 0x00000003;
                w = tmp[i] | 0x00000003;
                        m = generateMask(w);
                        r = tmp[i-1] & 0x0000001f;
                        p = rotl(B[j],r);
                        tmp[i] = w ^ (p & m);
                }

                return tmp;
        }

        private static int generateMask(int x){
                int m;

                m = (~x ^ (x>>>1)) & 0x7fffffff;
                m &= (m >> 1) & (m >> 2);
                m &= (m >> 3) & (m >> 6);

                if(m == 0)
                        return 0;

                m <<= 1; m |= (m << 1); m |= (m << 2); m |= (m << 4);

                m |= (m << 1) & ~x & 0x80000000;

                return m & 0xfffffffc;

        }


        public static byte[] encryptBloc(byte[] in){
                byte[] tmp =  new byte[in.length];
                int aux;


                int[] data = new int[in.length/4];
                for(int i =0;i<data.length;i++)
                        data[i] = 0;
                int off = 0;
                for(int i=0;i<data.length;i++){
                        data[i] =       ((in[off++]&0xff))|
                                                ((in[off++]&0xff) << 8) |
                                                ((in[off++]&0xff) << 16) |
                                                ((in[off++]&0xff) << 24);
                }

                int A = data[0],B = data[1],C = data[2],D = data[3];
                A = A + K[0];
                B = B + K[1];
                C = C + K[2];
                D = D + K[3];

                //forward mixing
                for(int i = 0;i<=7;i++){
                        B = B ^ s_box[A & 0xff];
                        B = B + s_box[(rotr(A,8) & 0xff) + 256];
            C = C + s_box[rotr(A,16) & 0xff];
            D = D ^ s_box[(rotr(A,24) & 0xff) + 256];

            A = rotr(A,24);

            if(i == 1 || i == 5) A = A + B;
            if(i == 0 || i == 4) A = A + D;

            aux = A;
                        A = B;
                        B = C;
                        C = D;
                        D = aux;
                }
                int R,L,M;
                int[] eout;
                //cryptographic core
                for(int i = 0;i<=15;i++){

                        eout = E_func(A, K[2*i+4], K[2*i+5]);

                        A = rotl(A,13);
                        C = C + eout[1];

                        if(i<8) {
                                B = B + eout[0];
                                D = D ^ eout[2];
                        }
                        else{
                                D = D + eout[0];
                                B = B ^ eout[2];
                        }

                        aux = A;
                        A = B;
                        B = C;
                        C = D;
                        D = aux;
                }
                //backward mixing
                for(int i = 0;i<=7;i++){

                        if(i == 3 || i == 7) A = A - B;
                        if(i == 2 || i == 6) A = A - D;

                        B = B ^ s_box[(A & 0xff) + 256];
                        C = C - s_box[rotr(A,24) & 0xff];
                        D = D - s_box[(rotr(A,16) & 0xff) + 256];
                        D = D ^ s_box[rotr(A,8) & 0xff];

                        A = rotl(A,24);

                        aux = A;
                        A = B;
                        B = C;
                        C = D;
                        D = aux;

                }
                A = A - K[36];
                B = B - K[37];
                C = C - K[38];
                D = D - K[39];

                data[0] = A;data[1] = B;data[2] = C;data[3] = D;

                for(int i = 0;i<tmp.length;i++){
                        tmp[i] = (byte)((data[i/4] >>> (i%4)*8) & 0xff);
                }

                return tmp;
        }

        private static int[] E_func(int in,int k1,int k2){
                int[] tmp = new int[3];
                int M,L,R;
                M = in + k1;
                R = rotl(in,13) * k2;
                L = s_box[M & 0x000001ff];
                R = rotl(R,5);
                M = rotl(M,R & 0x0000001f);
                L = L ^ R;
                R = rotl(R,5);
                L = L ^ R;
                L = rotl(L,R & 0x0000001f);

                tmp[0] = L;
                tmp[1] = M;
                tmp[2] = R;

                return tmp;
        }


        public static byte[] encrypt(byte[] in,byte[] key){
                K = expandKey(key);
                int lenght=0;
                byte[] padding = new byte[1];
                int i;
                lenght = 16 - in.length % 16;
                padding = new byte[lenght];
                padding[0] = (byte) 0x80;

                for (i = 1; i < lenght; i++)
                        padding[i] = 0;

                byte[] tmp = new byte[in.length + lenght];
                byte[] bloc = new byte[16];

                int count = 0;

                for (i = 0; i < in.length + lenght; i++) {
                        if (i > 0 && i % 16 == 0) {
                                bloc = encryptBloc(bloc);
                                System.arraycopy(bloc, 0, tmp, i - 16, bloc.length);
                        }
                        if (i < in.length)
                                bloc[i % 16] = in[i];
                        else{
                                bloc[i % 16] = padding[count % 16];
                                count++;
                        }
                }
                if(bloc.length == 16){
                        bloc = encryptBloc(bloc);
                        System.arraycopy(bloc, 0, tmp, i - 16, bloc.length);
                }

                return tmp;
        }

}


What I have tried:

This is the output
52 ms with 128
8 ms with 192
7 ms with 256
Posted
Updated 4-Apr-18 1:07am
v2
Comments
Christiaan van Bergen 3-Apr-18 14:50pm    
Can you explain what kind of encryption you are using? What is behind the method encrypt(plain, K)? Can you show us some code?
lily96 4-Apr-18 6:37am    
i have updated my question by posting the method I'm trying to call

1 solution

What times do you get when you perform the measurements in the reverse order (256, 192, 128)?

The bytesToHex() and setText() calls should not be part of the measurement from my point of view. setText() is a GUI operation which might require significant time; especially when called the first time.

To avoid unwanted side effects I suggest to write a function that accepts the key length and call that for your three key lengths or even use a command line application.

Note also that such time measurements are inaccurate when there are other active threads. It is common to perform the operations multiple times and show statistics (min, max, average, and optionally deviation).
 
Share this answer
 
Comments
lily96 5-Apr-18 4:03am    
I have tried in revers it gives me a good result it decrease,but i can not accept it because i think the source code does not accept the key in length 256-bit as if i rerun the system for each key the result will be in order for(128,192,256) is (51 ms ,39 ms ,50 ms )! .. could you please check the coeds whether encrypts text with key 256-bit or not? .. I hope you understand what i meant
Jochen Arndt 5-Apr-18 4:31am    
If you got different results for different orders your current design is useless for time measurements. What are the times when using the same key length multiple times? I expect they will differ as well.

To avoid side effects write for example a command line application that accepts the key length as parameter and perform multiple measurements in a row as already suggested. The first may be still higher but the following should be similar (there will be still differences due to system load).

I suggest also to read about execution time measurements in general and for Java. You will learn that a single measurement is useless.

I have read your other question regarding the problems with the 256-bit key. I thought it was solved after seeing this question. Checking your code for being correct and for possible errors requires understanding (re-reading about) the algorithms and investing a lot of time. Please realise that I don't have that time.

There may be others which might can help. But you should help them by explaining which algorithm is used and if you have used existing code. Edit your other question to add this information and describe also what exactly is not working for 256-bit keys providing example data (input, expected output and output from your code).
lily96 6-Apr-18 11:33am    
I didn't analysis the results after i asked before for the same issue . I see that the wrong in the source code not time after i read your comment , and because i didn't write the codes by my self i found it difficult for me as a student to read and understand the codes of the algorithm as it is new for me that why i asked for reading the codes.

Thank you for your time and attention, you gave me ideas to search for,and i will update my question.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)



CodeProject, 20 Bay Street, 11th Floor Toronto, Ontario, Canada M5J 2N8 +1 (416) 849-8900