Feistel密码结构、原理及java代码实现

密码学研究中，Feistel密码结构是用于分组密码中的一种对称结构。理解了Feistel密码结构，对于理解DES算法的原理有很大的帮助。 Feistel建议使用乘积密码的概念来逼近理想分组密码。乘积密码是指依次使用两个或两个以上基本密码，所得结果的密码强度将强于所有单个密码的强度。Feistel密码交替使用代替和置换来进行加密解密。 代替和置换的定义如下： 代替：每个明文元素或元素组被唯一地替换为相应的密文元素或元素组。 置换：明文元素的序列被替换为该序列的一个置换。也就是说，序列中没有元素被添加、删除或替换，但序列中元素出现的顺序改变了。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

原理

关于Feistel的加密与解密过程如下图所示：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

上图是Feistel的密码结构。加密算法的输入是长为2w位的明文分组和密钥K。明文分组被分为等长的两部分：L₀和R₀。这两半数据经过n轮迭代后组合成密文分组。第i轮迭代的输入L_i-1和R_i-1来自于上轮迭代的输出；而输入的子密钥K_i是由整个密钥K推导出的。一般地，K_i不同于K，也互不相同。尽管可以使用任意轮数，但上图使用了16轮。每轮迭代都有相同的结构。代替作用在数据的左半部分。它通过用轮函数F作用于数据的右半部分后，与左半部分数据进行异或来完成。每轮迭代的轮函数是相同的，但是输入的子密钥K_i不同。换一种说法，F是w位长的右半分组以及y位长的子密钥的函数，输出w位的值：F(RE_i,K_i+1)。代替之后，交换数据的左右两半完成置换。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

影响因素

Feistel结构的具体实现依赖于以下参数和特征：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

分组长度：分组长度越长意味着安全性越高，但是会降低加、解密的速度。这种安全性的增加来自更好的扩散性。传统上，64位的分组长度比较合理，在分组密码设计里很常用。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

密钥长度：密钥较长同样意味着安全性较高，但会降低加、解密的速度。这种安全性的增加来自更好的抗穷尽攻击能力和更好的混淆性。现在一般认为64位的密钥还不够。通常使用的密钥长度是128位。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

迭代轮数：Feistel密码的本质在于单轮不能提供足够的安全性而多轮加密可取得很高的安全性。迭代轮数的典型值是16。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

子密钥产生算法：子密钥产生越复杂，密码分析就越困难。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

轮函数F：同样，轮函数越复杂，抗攻击的能力就越强。文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

代码实现

只要把理论搞清楚，代码实现并不算难，具体代码如下：文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html

package com.general.encryanddecode;

import java.util.Arrays;

/**
 *
 *@author generalandroid
 *
 *Feistel密码算法
 * **/
public class FeistelTest {

    /**加密轮数**/
    private static final int LOOP_NUM=16;
    private String [] keys=new String[LOOP_NUM];
    private String [] pContent;
    private String [] cContent;
    private int origin_length;

    public static void main(String[] args){

        FeistelTest feistelTest=new FeistelTest("Android将军->GeneralAndroid","ABCDE");
        feistelTest.encrypt();
        feistelTest.decrypt();


    }
    public FeistelTest(String content,String key){
        generateKey(key);
        divideGroups(content);

        System.out.println("原始明文："+content+"\n原始密钥："+key);
    }


    public void encrypt(){
        StringBuilder c=new StringBuilder();
        for(int i=0;i<pContent.length;i++){
                cContent[i]=loop(pContent[i],0);
            c.append(cContent[i]);
        }

       System.out.println("密文:\n"+c.toString());
    }
    public void decrypt(){
        StringBuilder p=new StringBuilder();
        for(int i=0;i<cContent.length;i++){
            pContent[i]=loop(cContent[i],1);
            p.append(pContent[i]);
        }
        System.out.println("明文：\n"+p.toString().substring(0,origin_length));
    }
    /**生成子密钥，采用简单移位操作来实现**/
    public void  generateKey(String key){
        while (key.length()<16){
            key=key+key;
        }
        key=key.substring(0,16);
//        System.out.println("after sub key:"+key);
        for(int i=0;i<16;i++){
            key=swapStr(key,i);
            keys[i]=key;
        }
//        System.out.println(Arrays.toString(keys));
    }
    private String swapStr(String key,int i){
        char last=key.charAt(key.length()-1);
        key=last+key.substring(0,key.length()-1);
//        System.out.println("i:"+i+"\t key:"+key);
        return key;
    }

    /**对明文进行分组**/
    public void divideGroups(String content){
        int g_num;
        int m_num;
        int b_num;
        origin_length=content.length();
        g_num=origin_length/8;
        m_num=origin_length%8;
        b_num=8-m_num;
//        System.out.println("g_num:"+g_num+"\t m_num:"+m_num+"\t b_num:"+b_num);
        if(m_num!=0){
            for (int i=0;i<=b_num;i++){
                content=content+b_num;
            }
        }
        g_num=content.length()/8;
        pContent=new String[g_num];
        cContent=new String[g_num];
        for(int i=0;i<g_num;i++){
            pContent[i]=content.substring(8*i,8*(i+1));
        }
//        System.out.println(Arrays.toString(pContent));
    }



    /**轮加密与解密**/
    public String loop(String content,int flag){
        if(flag==0){
            for(int i=0;i<16;i++){
                content=f(i,content,flag);
            }
        }else if(flag==1){
            for(int i=15;i>-1;i--){
                content=f(i,content,flag);
            }
        }
        return content;

    }
    /**f函数**/
    public String f(int time,String content,int flag){
        if(content.length()>8){
            System.out.println("ERROR!!!!!");
        }
        String LE=content.substring(0,4);
        String RE=content.substring(4,8);
        String LE1=null;
        String RE1=null;
        String key=keys[time];
//        System.out.println("LE:"+LE+"\t RE:"+RE+"\t key:"+key);
        char[] tmp=new char[4];
        for(int j=0;j<4;j++){
            tmp[j]=(char)(RE.charAt(j)^key.charAt(4*j)^LE.charAt(j));
        }
//        System.out.println("tmp re:"+Arrays.toString(tmp));
        LE1=RE;
        RE1=new String(tmp);
//        System.out.println("time:"+time+"\t L:"+LE1+RE1+"\t key:"+key);


        if (((flag == 0) && (time == 15)) || ((flag == 1) && (time == 0))) {
           return RE1+LE1;
        }

        return LE1+RE1;
    }


}
/****
 * 运行结果：
 * 
 * 
 原始明文：Android将军->GeneralAndroid
 原始密钥：ABCDE
 密文:
 oAB尴ooc尀冿uehbtDXlGdthoFB@7101
 明文：
 Android将军->GeneralAndroid

 * 
 * *****/
复制代码

参考资料

《密码编码学与网络安全》第六版文章源自菜鸟学院-https://www.cainiaoxueyuan.com/suanfa/4964.html