AES加密算法软件实现-Java

已于 2022-03-21 17:45:40 修改
阅读量868 收藏
点赞数
分类专栏： 密码学 文章标签： java
于 2022-03-21 17:33:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/npu_nazi/article/details/123641106
版权

AES加密算法软件实现-Java

参考资料

  1. https://blog.csdn.net/qq_28205153/article/details/55798628
  2. https://www.bilibili.com/video/BV1HK4y1s7Np?spm_id_from=333.337.search-card.all.click

执行结果

在这里插入图片描述
在这里插入图片描述

程序源码

仅实现了128


/*************************************************************************  
    > File Name: AES.java
    > Author: Yu/Jinyang

    > Created Time: 2021/10/10
 ************************************************************************/ 
import java.util.*;
// import java.lang.*;

public class AES {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        System.out.println("请输入十六进制128位明文:");
        String ming = s.next();
        System.out.println("请输入十六进制128位密钥:");
        String k = s.next();
        s.close();
        int[][] mingwen = Algorithm.DataFormat(ming);// 4,8
        int[][] key = Algorithm.DataFormat(k);// 4,8
        int[][] key1 = Algorithm.DataFormat(k);// 存一份为解密用
        // mingwen = Algorithm.transporsition(mingwen);
        // key = Algorithm.transporsition(key);
        // key1=Algorithm.transporsition(key1);
        // 加密过程正式开始
        int[][] miwen = Algorithm.encoder(mingwen, key);
        System.out.println("\n加密后的密文为:");
        for (int i = 0; i < miwen.length; i++) {
            for (int j = 0; j < miwen[0].length; j++) {
                System.out.printf("%x", miwen[i][j]);
            }
        }
        int[][] mingwen2 = Algorithm.decoder(miwen, key1);
        System.out.println("\n重新解密后的明文为:");
        for (int i = 0; i < mingwen2.length; i++) {
            for (int j = 0; j < mingwen2[0].length; j++) {
                System.out.printf("%x", mingwen2[i][j]);
            }
        }
        // middle = Algorithm.S_Box(mingwen);
        // middle = Algorithm.ShiftRow(middle);
        // //ceshi
        // int[][] temp = { { 0xc9,0xe5,0xfd,0x2b },
        // { 0x7a,0xf2,0x78,0x6e },
        // { 0x63,0x9c,0x26,0x67 },
        // { 0xb0,0xa7,0x82,0xe5 } };
        // int[][] tem2 = Algorithm.change4To8(temp);
        // temp=Algorithm.change8To4(tem2);
        // middle =Algorithm.ColumnMix(tem2);

        // int [][] key1= Algorithm.keyExtention(key, 1);
        // for (int i = 0; i < 4; i++) {
        // for (int j = 0; j < 8; j++) {
        // System.out.printf("%x ", key1[i][j]);
        // }
        // System.out.println("\n");
        // }
        // System.out.println("/n");
        // for (int i = 0; i < 4; i++) {
        // for (int j = 0; j < 8; j++) {
        // System.out.print(key[i][j] + " ");
        // }
        // }
    }
}

class Algorithm {
    static int[][] DataFormat(String s) {// 数据格式转换,将十六进制字符串转换为数据表输出
        int[][] a = new int[4][8];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 8; j++) {
                a[i][j] = Character.digit(s.charAt(i * 8 + j), 16);
            }
        }
        return a;
    }

    static int[][] S_Box(int[][] a) {// s盒变换
        int[][] S = {
                { 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76 },
                { 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0 },
                { 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15 },
                { 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75 },
                { 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84 },
                { 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf },
                { 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8 },
                { 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2 },
                { 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73 },
                { 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb },
                { 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79 },
                { 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08 },
                { 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a },
                { 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e },
                { 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf },
                { 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 } };

        int[][] mi = new int[a.length][a[0].length];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j += 2) {
                int c = S[a[i][j]][a[i][j + 1]];
                mi[i][j] = (c & 0xf0) >> 4;
                mi[i][j + 1] = c & 0x0f;
            }
        }
        return mi;
    }

    static int[][] ShiftRow(int[][] a) {// 行移位
        
        int[][] s = new int[4][8];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 8; j++) {
                s[i][j] = a[i][(j + i * 2) % 8];
            }
        }
        return s;
    }

    static int[][] ColumnMix(int[][] a) {// 列混合
        int[][] s = new int[4][8];
        int[][] matrix = { { 2, 3, 1, 1 }, { 1, 2, 3, 1 }, { 1, 1, 2, 3 }, { 3, 1, 1, 2 } };
        int[][] amiddle = Algorithm.change8To4(a);// 4,4
        int[][] middle = new int[4][4];
        for (int i = 0; i < 4; i++) {
            int[][] t = new int[4][1];
            for (int j = 0; j < 4; j++) {// 取出列
                t[j][0] = amiddle[j][i];
            }
            t = matrixMul(matrix, t);// 矩阵乘
            for (int j = 0; j < 4; j++) {// 写入列
                middle[j][i] = t[j][0];
            }
        }
        s = Algorithm.change4To8(middle);
        return s;
    }

    static int[][] change8To4(int[][] a) {// 将原来的八位转换为四位便于矩阵相乘
        int[][] ret = new int[4][4];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                ret[i][j] = ((a[i][j * 2]) << 4) + a[i][j * 2 + 1];
            }
        }
        return ret;
    }

    static int[][] change4To8(int[][] a) {
        int[][] ret = new int[4][8];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                ret[i][2 * j] = (a[i][j] & 0xf0) >> 4;
                ret[i][2 * j + 1] = a[i][j] & 0x0f;
            }
        }
        return ret;
    }

    static int[][] matrixMul(int[][] a, int[][] b) {// 有限域上的矩阵乘 4,1
        int[][] result = new int[a.length][b[0].length];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < b[0].length; j++) {
                int t = 0;
                for (int k = 0; k < a[0].length; k++) {
                    t ^= Algorithm.mulInDomain(a[i][k], b[k][j]);// 异或等, 乘法重新定义
                }
                result[i][j] = t;
            }
        }
        return result;
    }

    static int mulInDomain(int a, int b) {// 有限域乘法
        int t1, t2, t3, t4;
        if ((a & 0x01) == 1) {// 第一位
            t1 = b;
        } else {
            t1 = 0;
        }
        if ((a & 0x02) == 2) {// 第二位
            t2 = mul2InDomain(b);
        } else {
            t2 = 0;
        }
        if ((a & 0x04) == 4) {// 第三位
            t3 = mul2InDomain(mul2InDomain(b));
        } else {
            t3 = 0;
        }
        if ((a & 0x08) == 8) {// 第四位
            t4 = mul2InDomain(mul2InDomain(mul2InDomain(b)));
        } else {
            t4 = 0;
        }
        return t1 ^ t2 ^ t3 ^ t4;
        // if (a == 1) {
        // return b;
        // } else if (a == 2) {// 可以将乘2的部分单独写成函数,这里最多是3,故先不管了
        // return mul2InDomain(b);
        // } else if (a == 3) {
        // if ((b & 0x80) >> 7 == 0) {
        // return ((b << 1) & 0xfe) ^ b;
        // } else {
        // return (((b << 1) & 0xfe) ^ 0x1b) ^ b;
        // }
        // } else {
        // System.out.println("有限域乘出错!");
        // return 0;
        // }
    }

    static int mul2InDomain(int b) {
        if ((b & 0x80) >> 7 == 0) {
            return (b << 1) & 0xfe;
        } else {
            return ((b << 1) & 0xfe) ^ 0x1b;
        }
    }

    static int[][] keyExtention(int[][] prekey, int t) {// 密钥扩展
        int[][] nextkey = new int[4][8];
        
        for (int i = 0; i < 4; i++) {
            if (i == 0) {
                int[] t1 = Algorithm.T(prekey[3], t);
                for (int j = 0; j < 8; j++) {
                    nextkey[i][j] = t1[j] ^ prekey[0][j];
                }
                // System.out.println("\n将prekey[4]进行T变换后的结果:");
                // for(int j=0;j<8;j++){
                // System.out.print(t1[j]);
                // }
            } else {
                for (int j = 0; j < 8; j++) {
                    nextkey[i][j] = nextkey[i - 1][j] ^ prekey[i][j];
                }
            }
        }
        return nextkey;
    }

    static int[][] transporsition(int[][] prekey){//转置
        int[][] pk = new int[4][8];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 8; j++) {
                pk[i][j] = prekey[i][j];
            }
        }
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                prekey[i][j * 2] = pk[j][i * 2];
                prekey[i][j * 2 + 1] = pk[j][i * 2 + 1];
            }
        }
        return prekey;
    }
 
    static int[] T(int[] k4, int lun) {// T变换(密钥扩展用)
        int[] nextk4 = new int[8];
        if (lun < 9) {// 将轮数转换为相应的数字.
            lun = 0x1 << (lun - 1);
        } else if (lun == 9) {
            lun = 0x1b;
        } else if (lun == 10) {
            lun = 0x36;
        } else {
            System.out.println("轮转换出错!");
        }
        int[] lunc = { (lun & 0xf0) >> 4, lun & 0x0f, 0, 0, 0, 0, 0, 0 };

        for (int j = 0; j < 8; j++)// 移位操作
            nextk4[j] = k4[(j + 2) % 8];
        int[][] k42w = new int[1][8];
        k42w[0] = nextk4;// 为了调用sbox需要传入二维数组
        k42w = Algorithm.S_Box(k42w);
        nextk4 = k42w[0];
        for (int i = 0; i < nextk4.length; i++) {
            nextk4[i] = nextk4[i] ^ lunc[i];
        }
        return nextk4;
    }

    static int[][] addRoundKey(int[][] a, int[][] b) {// 轮密钥加
        int[][] re = new int[4][8];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j++) {
                re[i][j] = a[i][j] ^ b[i][j];
            }
        }
        return re;
    }

    static int[][] encoder(int[][] mingwen, int[][] key) {// 加密方法
        
        int[][] middle = Algorithm.addRoundKey(mingwen, key);
        
        // System.out.println("首先进行轮密钥加后的结果:");
        // for (int i = 0; i < middle.length; i++) {
        // for (int j = 0; j < middle[0].length; j++) {
        // System.out.printf("%x", middle[i][j]);
        // }
        // }
        for (int i = 1; i < 10; i++) {
            middle = Algorithm.S_Box(middle);
            // System.out.printf("\n第%d次S盒后的结果:", i);
            // for (int i1 = 0; i1 < middle.length; i1++) {
            // for (int j = 0; j < middle[0].length; j++) {
            // System.out.printf("%x", middle[i1][j]);
            // }
            // }
            middle = Algorithm.transporsition(middle);
            middle = Algorithm.ShiftRow(middle);
            // System.out.printf("\n第%d次行移位后的结果:", i);
            // for (int i1 = 0; i1 < middle.length; i1++) {
            // for (int j = 0; j < middle[0].length; j++) {
            // System.out.printf("%x", middle[i1][j]);
            // }
            // }

            middle = Algorithm.ColumnMix(middle);
            // System.out.printf("\n第%d次列混合后的结果:", i);
            // for (int i1 = 0; i1 < middle.length; i1++) {
            // for (int j = 0; j < middle[0].length; j++) {
            // System.out.printf("%x", middle[i1][j]);
            // }
            // }
            middle = Algorithm.transporsition(middle);
            key = Algorithm.keyExtention(key, i);
            
            // System.out.printf("\n第%d次密钥转换后的密钥:", i);
            // for (int i1 = 0; i1 < key.length; i1++) {
            // for (int j = 0; j < key[0].length; j++) {
            // System.out.printf("%x", key[i1][j]);
            // }
            // }
            middle = Algorithm.addRoundKey(middle, key);
            
            // System.out.printf("\n第%d次加密后的结果:", i);
            // for (int i1 = 0; i1 < middle.length; i1++) {
            // for (int j = 0; j < middle[0].length; j++) {
            // System.out.printf("%x", middle[i1][j]);
            // }
            // }
        }
        // 第十轮不用列混合
        middle = Algorithm.S_Box(middle);
        middle = Algorithm.transporsition(middle);
        middle = Algorithm.ShiftRow(middle);
        key = Algorithm.keyExtention(key, 10);
        middle = Algorithm.transporsition(middle);
        middle = Algorithm.addRoundKey(middle, key);
        return middle;
    }

    static int[][] S_Box_(int[][] a) {// s盒变换逆
        int[][] S = {
                { 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb },
                { 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb },
                { 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e },
                { 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25 },
                { 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92 },
                { 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84 },
                { 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06 },
                { 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b },
                { 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73 },
                { 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e },
                { 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b },
                { 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4 },
                { 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f },
                { 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef },
                { 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61 },
                { 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d } };

        int[][] mi = new int[a.length][a[0].length];
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a[0].length; j += 2) {
                int c = S[a[i][j]][a[i][j + 1]];
                mi[i][j] = (c & 0xf0) >> 4;
                mi[i][j + 1] = c & 0x0f;
            }
        }
        return mi;
    }

    static int[][] ShiftRow_(int[][] a) {// 行移位逆
        int[][] s = new int[4][8];
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 8; j++) {
                s[i][j] = a[i][(j + 8 - i * 2) % 8];
            }
        }
        return s;
    }

    static int[][] ColumnMix_(int[][] a) {// 列混合逆
        int[][] s = new int[4][8];
        int[][] matrix = { { 0x0e, 0x0b, 0x0d, 0x09 }, { 0x09, 0x0e, 0x0b, 0x0d }, { 0x0d, 0x09, 0x0e, 0x0b },
                { 0x0b, 0x0d, 0x09, 0x0e } };
        int[][] amiddle = Algorithm.change8To4(a);// 4,4
        int[][] middle = new int[4][4];
        for (int i = 0; i < 4; i++) {
            int[][] t = new int[4][1];
            for (int j = 0; j < 4; j++) {// 取出列
                t[j][0] = amiddle[j][i];
            }
            t = matrixMul(matrix, t);// 矩阵乘
            for (int j = 0; j < 4; j++) {// 写入列
                middle[j][i] = t[j][0];
            }
        }
        s = Algorithm.change4To8(middle);
        return s;
    }

    static int[][] decoder(int[][] miwen, int[][] key) {
        int[][][] keyExtentioned = new int[11][][];
        keyExtentioned[0] = key;
        for (int i = 1; i < 11; i++) {
            keyExtentioned[i] = keyExtention(keyExtentioned[i - 1], i);
        }
        // for (int i = 0; i < 10; i++) {
        //     int[][] pk2 = new int[4][8];
        //     for (int k = 0; k < 4; k++) {
        //         for (int j = 0; j < 8; j++) {
        //             pk2[k][j] = keyExtentioned[i][k][j];
        //         }
        //     }
        //     for (int k = 0; k < 4; k++) {
        //         for (int j = 0; j < 4; j++) {
        //             keyExtentioned[i][k][j * 2] = pk2[j][k * 2];
        //             keyExtentioned[i][k][j * 2 + 1] = pk2[j][k * 2 + 1];
        //         }
        //     }
        // }
        int[][] middle = addRoundKey(miwen, keyExtentioned[10]);
        middle = Algorithm.transporsition(middle);
        // System.out.println("解密过程,第十轮密钥为:");
        // for (int i = 0; i < keyExtentioned[10].length; i++) {
        //     for (int j = 0; j < keyExtentioned[10][0].length; j++) {
        //         System.out.printf("%x", keyExtentioned[10][i][j]);
        //     }
        // }
        // System.out.println("\n解密过程,首先进行轮密钥加后的结果:");
        // for (int i = 0; i < middle.length; i++) {
        //     for (int j = 0; j < middle[0].length; j++) {
        //         System.out.printf("%x", middle[i][j]);
        //     }
        // }
        for (int i = 9; i > 0; i--) {

            middle = ShiftRow_(middle);
            // System.out.println("\n解密过程,进行行移位逆后的结果:");
            // for (int k = 0; k < middle.length; k++) {
            //     for (int j = 0; j < middle[0].length; j++) {
            //         System.out.printf("%x", middle[k][j]);
            //     }
            // }
            middle = S_Box_(middle);
            // System.out.println("\n解密过程,进行s盒逆后的结果:");
            // for (int k = 0; k < middle.length; k++) {
            //     for (int j = 0; j < middle[0].length; j++) {
            //         System.out.printf("%x", middle[k][j]);
            //     }
            // }
            middle = Algorithm.transporsition(middle);
            middle = addRoundKey(middle, keyExtentioned[i]);
            // System.out.println("\n解密过程,第i轮密钥为:");
            // for (int k = 0; k < keyExtentioned[i].length; k++) {
            //     for (int j = 0; j < keyExtentioned[i][0].length; j++) {
            //         System.out.printf("%x", keyExtentioned[i][k][j]);
            //     }
            // }
            // System.out.println("\n解密过程,进行轮密钥加后的结果:");
            // for (int k = 0; k < middle.length; k++) {
            //     for (int j = 0; j < middle[0].length; j++) {
            //         System.out.printf("%x", middle[k][j]);
            //     }
            // }
            middle = Algorithm.transporsition(middle);
            middle = ColumnMix_(middle);
            // System.out.println("\n解密过程,进行列混合逆后的结果:");
            // for (int k = 0; k < middle.length; k++) {
            //     for (int j = 0; j < middle[0].length; j++) {
            //         System.out.printf("%x", middle[k][j]);
            //     }
            // }
        }
        // 第十轮
        middle = ShiftRow_(middle);
        middle = S_Box_(middle);
        middle = Algorithm.transporsition(middle);
        middle = addRoundKey(middle, keyExtentioned[0]);
        return middle;
    }
}
// 3CA10B2157F01916902E1380ACC107BD
西瓜刀盹了
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java写的AES文件加密软件
12-24
命令行版本的文件加密软件，采用AES算法，密钥长度为128位，使用方法：在软件所在目录运行以下命令:java -jar aes.jar，然后回车，根据提示操作即可，请牢记自己的加密密钥，丢失无法找回。
AES加密算法程序
04-24
该程序是使用了AES中ECB、无填充模式的加解密程序，它是基于code:block该软件进行建立工程的。可以在window系统上用该软件打开工程运行
aes-tool（aes加密工具）
05-03
Rijndael加密法可以支持更大范围的区块和密钥长度：AES的区块长度固定为128 比特，密钥长度则可以是128，192或256比特；而Rijndael使用的密钥和区块长度可以是32位的整数倍，以128位为下限，256比特为上限。包括AES-ECB,AES-CBC,AES-CTR,AES-OFB,AES-CFB
AES加密算法（java）实现
01-15
AES高级加密标准，在密码学中又称Rijndael加密法，是美国联邦政府采用的一种区块加密标准。这个标准用来替代原先的DES，已经被多方分析且广为全世界所使用。经过五年的甄选流程，高级加密标准由美国国家标准与技术研究院（NIST）于2001年11月26日发布于FIPS PUB 197，并在2002年5月26日成为有效的标准。2006年，高级加密标准已然成为对称密钥加密中最流行的算法之一。本软件是用java语言开发，实现了AES算法对文件的加密和解密，并在界面上加了进度条，来提示用户加密解密的进度。如果不足之处，欢迎留言。
AES加密软件
06-23
AES。7Z压缩包里，直接用aes.exe代码。但是整个压缩包都需要下载下来。因为exe文件需特定的运行环境
JAVA实现AES-256-CBC加密算法
就牙白
08-12 4660
看到网上很多说要换jar，注意该问题。 好像jdk1.8.0_162及以后是不需要替换的。 //加密 public String encryyptstr(byte[] iv,String key,String text){ String algorithm = "AES"; String transform = "AES/CBC/PKCS5Padding";// Cipher cipher = null; String result =
Java实现AES加密算法
m0_60252632的博客
02-21 9310
一、AES简介 高级加密标准（AES，Advanced Encryption Standard）为最常见的对称加密算法。 对称加密算法：加密和解密用相同的密钥。 图解： 介绍： 明文 P 没有经过加密的原始数据 密钥 K 用来加密明文的密码，在对称加密算法中，加密与解密的密钥是相同的，密钥为发送方与接收方协商产生，但不可以直接在网络上传输，否则会导致密钥泄露，通常是通过非对称加密算法加密密钥，然后再通过网络传输给对方，或者直接面对面商量密钥 AES 加密函数 设AES加密函数为
Java实现加密——AES加密算法
最新发布
weixin_41755554的博客
08-09 1051
高级加密标准（AES，Advanced Encryption Standard）为最常见的。对称加密算法：加密和解密用相同的密钥。
Java实现AES对称加解密算法-块加密
生命的意义在于创造和毁灭
09-18 5309
生成AES固定、随机密钥或指定密钥实现AES加解密算法
Java实现AES加密算法的简单示例分享
09-02
主要介绍了Java实现AES加密算法的简单示例分享,AES算法是基于对密码值的置换和替代,需要的朋友可以参考下
Java实现AES加密和解密算法
11-05
本文就简单介绍如何通过JAVA实现AES加密： /** * 测试AES加密和解密 * @param args */ public static void main(String[] args) { /**数据初始化**/ String content = "http://www.mbaike.net"; String password = "1234567890"; /**加密(1)**/ System.out.println("加密前：" + content); byte[] encryptResult = encrypt(content, password); String encryptResultStr = parseByte2HexStr(encryptResult); System.out.println("加密后：" + encryptResultStr); /**解密(2)**/ byte[] decryptFrom = parseHexStr2Byte(encryptResultStr); byte[] decryptResult = decrypt(decryptFrom,password); System.out.println("解密后：" + new String(decryptResult)); } } 说明如下： 在demo中使用了两个转换方法，及二进制转化成十六进制，和十六进制转化成二进制； 我们在AES加密的时候需要使用一个加密算的公共密钥来实现加密和解密； 加密后的字节数组不能直接转化为字符串，需要我们通过给出的两个方法转化；
AES 5.1.0 版 加密与解密软件
05-16
AES 5.1.0 版 加密与解密软件 此版本软件较早前版本的作了较大修改，特别是调整了软件的界面布局，以使软件更加动感和美观。除此之外此版本软件还在早前的版本上作了以下改进： 1、软件的运行效率较早前版本的略有提升。 2、修正了直接将文件或文件夹拖动到编辑框或列表框中以设置相应路径的功能，以方便用户使用。 3、解决了在加密/解密字符串模块下，修改源字符串或滚动加密后字符串时，对应编辑框内的数据显示混乱这一问题。 4、新增了以十六进制编码显示加密后字符串的功能，以符合某些用户的特殊需求（此功能是依一网友的要求而增加的）。 5、新增了加密/解密单个文件时，给出将要处理（选择待处理文件后）或正处理的文件所需剩余时间，以方便用户进一步了解文件的处理进程。 6、新增了在加密单个文件时保存原文件扩展名的功能，以使用户不会因时间推移而忘记自己所加密的原文件的文件类型（此功能是依一网友的要求而增加的）。 7、放宽了用户在加密/解密批量文件下，用增加文件（而非目录）功能来新增待处理文件时一次只能选择一个文件的限制，允许用户一次选择多个待处理文件，方便了用户的操作。 8、新增了“加密包”这一概念与功能，即用户可以将多个待加密的文件加密成一个加密包，当然也可以将一个加密包中的已加密后的文件数据解密到指定的目录之下。此功能类似于压缩包，但并非先将文件压缩之后再作加密；且其与“加密/解密批量文件”功能也是完全不同的。 9、新增了自动关联文件类型（共三种文件类型：“.cryp”、“.cryb”、“.key”）的功能（在Windows XP及以上的操作系统下需要以管理员权限来运行软件才能真正地关联文件类型）。使得文件的相应的文件在您的电脑里不再是以未知类型文件的图标来显示；当然，您可以更换skins目录下的“CrypedFileIcon.ico”、“CrypedPackageIcon.ico”或“KeyFileIcon.ico”文件来更改图标。这一功能使得用户可以在Windows系统的资源管理器下双击“.cryp”的文件时会自动打开软件并切换到加密/解密单个文件的界面同时设置好“待解密文件路径”与“解密后文件路径”这两个参数。双击“.cryb”的文件时会自动打开软件并切换到加密/解密加密包的界面同时设置“执行模式”为“解密文件”，并以列表的形式给出该加密包中所保存的加密后的文件信息列表。双击“.key”的文件时会自动打开记事本，并将该文件的信息显示在记事本中，以供用户编辑。 当然，本版本软件保存了本系列软件的早前版的所有功能。 注： 1、本软件中在所给定的密钥长度小于所需的密钥长度时采取了自动补全的策略，同时将其中的不可显示字符（如：回车符）用空格取代策略。在初始向量的导入也采用了将其中的不可显示的字符（如：回车符）用空格取代的策略。 2、软件的速度测试是在电脑的配置为：系统类型：32位操作系统；操作系统版本：Windows 7 旗舰版；处理器：Intel(R) Core(TM)2 Duo CPU T5870 @2.00GHZ 2.00GHZ 前端总线/二级缓存：800MHz/2M；内存(RAM)：2.00G 速度：667MHz 类型：PC2-5300 DDR2；硬盘类型：SATA 硬盘转速：5400rpm时所得到的。其平均速度不低于16MB/s。 3、建议在Windows 2000及以上版本的操作系统上运行本软件。
AES加解密算法软件程序（包含全部模式128/256）
09-14
AES加解密算法软件程序（包含全部模式128/256）AES加解密算法软件程序（包含全部模式128/256）AES加解密算法软件程序（包含全部模式128/256）
AES加密软件 AES加密软件
03-13
AES加密软件AES加密软件AES加密软件AES加密软件AES加密软件
AES 加密工具（ECB,CBC,CMAC）
06-25
AES工具，支持ECB，CBC加解密运算，以及CMAC运算。支持多种PADDING
java实现的AES加密算法完整实例
09-02
主要介绍了java实现的AES加密算法,结合完整实例形式分析了AES加密类的实现技巧,具有一定参考借鉴价值,需要的朋友可以参考下
128位AES加密算法C语言实现
11-26
用C语言实现的128位AES加密算法，可以运行在JAVA的JNI 中AIS加密算法c语言实现代码 nt cnt for(ent =0: cnt< 8: cnt++) BvtcToBit(*(ch+cnt), bit+(ent<<3)) return /将二进制位串转为长度为8的字符串水 ...
AES加密算法的JAVA实现
12-27
运行环境：Windows + eclipse + JAVA AES为分组密码，分组密码也就是把明文分成一组一组的，每组长度相等，每次加密一组数据，直到加密完整个明文。在AES标准规范中，分组长度只能是128位，也就是说，每个分组为16...
aes-encryption:加密算法AES的软件实现
05-11
AES加密 自动从code.google.com/p/aes-encryption导出 加密算法AES的软件实现 文档（简介）： ://docme.ru/iP（ukr） 文档（高级）： ://docme.ru/jP（ukr） 演示： ：//docme.ru/Iw（ukr） 来源： : 执行： : raw 二手技术：JDK 1.6，Swing，AWT
aes加密算法java实现
07-21
在Java中，可以使用javax.crypto包中的类来实现AES加密算法。 下面是一个简单的示例代码，演示如何使用AES加密算法进行加密和解密： ```java import javax.crypto.Cipher; import javax.crypto.spec.SecretKeySpec...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值