desfunc.cs

des算法

#region Using directives
using System;
using System.Collections.Generic;
using System.Text;
#endregion

namespace DesFunc          //DES加密函数库
{
    public class DesFunc
    {

        //IP置换
        public int[] IP(char[] mchar)
        {
            int[] mint = new int[64];
            int[] mreturn = new int[64];
            for (int i = 0; i < mint.Length; i++)
            {
                mint[i] = 0;
            }

            //将char明文转化为2进制明文
            for (int i = 0; i < mchar.Length; i++)
            {
                if ((mchar[i] & 0x80) != 0) mint[i * 8 + 0] = 1;
                if ((mchar[i] & 0x40) != 0) mint[i * 8 + 1] = 1;
                if ((mchar[i] & 0x20) != 0) mint[i * 8 + 2] = 1;
                if ((mchar[i] & 0x10) != 0) mint[i * 8 + 3] = 1;
                if ((mchar[i] & 0x8) != 0) mint[i * 8 + 4] = 1;
                if ((mchar[i] & 0x4) != 0) mint[i * 8 + 5] = 1;
                if ((mchar[i] & 0x2) != 0) mint[i * 8 + 6] = 1;
                if ((mchar[i] & 0x1) != 0) mint[i * 8 + 7] = 1;
            }

            //置换表
            mreturn[0] = mint[57]; mreturn[1] = mint[49]; mreturn[2] = mint[41];
            mreturn[3] = mint[33]; mreturn[4] = mint[25]; mreturn[5] = mint[17];
            mreturn[6] = mint[9]; mreturn[7] = mint[1]; mreturn[8] = mint[59];
            mreturn[9] = mint[51]; mreturn[10] = mint[43]; mreturn[11] = mint[35];
            mreturn[12] = mint[27]; mreturn[13] = mint[19]; mreturn[14] = mint[11];
            mreturn[15] = mint[3]; mreturn[16] = mint[61]; mreturn[17] = mint[53];
            mreturn[18] = mint[45]; mreturn[19] = mint[37]; mreturn[20] = mint[29];
            mreturn[21] = mint[21]; mreturn[22] = mint[13]; mreturn[23] = mint[5];
            mreturn[24] = mint[63]; mreturn[25] = mint[55]; mreturn[26] = mint[47];
            mreturn[27] = mint[39]; mreturn[28] = mint[31]; mreturn[29] = mint[23];
            mreturn[30] = mint[15]; mreturn[31] = mint[7]; mreturn[32] = mint[56];
            mreturn[33] = mint[48]; mreturn[34] = mint[40]; mreturn[35] = mint[32];
            mreturn[36] = mint[24]; mreturn[37] = mint[16]; mreturn[38] = mint[8];
            mreturn[39] = mint[0]; mreturn[40] = mint[58]; mreturn[41] = mint[50];
            mreturn[42] = mint[42]; mreturn[43] = mint[34]; mreturn[44] = mint[26];
            mreturn[45] = mint[18]; mreturn[46] = mint[10]; mreturn[47] = mint[2];
            mreturn[48] = mint[60]; mreturn[49] = mint[52]; mreturn[50] = mint[44];
            mreturn[51] = mint[36]; mreturn[52] = mint[28]; mreturn[53] = mint[20];
            mreturn[54] = mint[12]; mreturn[55] = mint[4]; mreturn[56] = mint[62];
            mreturn[57] = mint[54]; mreturn[58] = mint[46]; mreturn[59] = mint[38];
            mreturn[60] = mint[30]; mreturn[61] = mint[22]; mreturn[62] = mint[14];
            mreturn[63] = mint[6];
            return mreturn;
        }
        //IP-1置换
        public int[] IP_1(int[] mchar)
        {
            //置换表
            int[] IPreturn = new int[64];
            IPreturn[0] = mchar[39];
            IPreturn[1] = mchar[7];
            IPreturn[2] = mchar[47];
            IPreturn[3] = mchar[15];
            IPreturn[4] = mchar[55];
            IPreturn[5] = mchar[23];
            IPreturn[6] = mchar[63];
            IPreturn[7] = mchar[31];
            IPreturn[8] = mchar[38];
            IPreturn[9] = mchar[6];
            IPreturn[10] = mchar[46];
            IPreturn[11] = mchar[14];
            IPreturn[12] = mchar[54];
            IPreturn[13] = mchar[22];
            IPreturn[14] = mchar[62];
            IPreturn[15] = mchar[30];
            IPreturn[16] = mchar[37];
            IPreturn[17] = mchar[5];
            IPreturn[18] = mchar[45];
            IPreturn[19] = mchar[13];
            IPreturn[20] = mchar[53];
            IPreturn[21] = mchar[21];
            IPreturn[22] = mchar[61];
            IPreturn[23] = mchar[29];
            IPreturn[24] = mchar[36];
            IPreturn[25] = mchar[4];
            IPreturn[26] = mchar[44];
            IPreturn[27] = mchar[12];
            IPreturn[28] = mchar[52];
            IPreturn[29] = mchar[20];
            IPreturn[30] = mchar[60];
            IPreturn[31] = mchar[28];
            IPreturn[32] = mchar[35];
            IPreturn[33] = mchar[3];
            IPreturn[34] = mchar[43];
            IPreturn[35] = mchar[11];
            IPreturn[36] = mchar[51];
            IPreturn[37] = mchar[19];
            IPreturn[38] = mchar[59];
            IPreturn[39] = mchar[27];
            IPreturn[40] = mchar[34];
            IPreturn[41] = mchar[2];
            IPreturn[42] = mchar[42];
            IPreturn[43] = mchar[10];
            IPreturn[44] = mchar[50];
            IPreturn[45] = mchar[18];
            IPreturn[46] = mchar[58];
            IPreturn[47] = mchar[26];
            IPreturn[48] = mchar[33];
            IPreturn[49] = mchar[1];
            IPreturn[50] = mchar[41];
            IPreturn[51] = mchar[9];
            IPreturn[52] = mchar[49];
            IPreturn[53] = mchar[17];
            IPreturn[54] = mchar[57];
            IPreturn[55] = mchar[25];
            IPreturn[56] = mchar[32];
            IPreturn[57] = mchar[0];
            IPreturn[58] = mchar[40];
            IPreturn[59] = mchar[8];
            IPreturn[60] = mchar[48];
            IPreturn[61] = mchar[16];
            IPreturn[62] = mchar[56];
            IPreturn[63] = mchar[24];
            return IPreturn;
        }
        //64位原始密钥计算16个48位密钥
        public int[][] makekey(char[] kchar)
        {
            //16位数组存放16个输出密钥
            int[][] keyreturn = new int[16][];
            int[] temp = new int[64];
            int[] kint = new int[56];
            int[] c0 = new int[28]; int[] d0 = new int[28];
            int[] c16 = new int[28]; int[] d1 = new int[28];
            int[] c1 = new int[28]; int[] d2 = new int[28];
            int[] c2 = new int[28]; int[] d3 = new int[28];
            int[] c3 = new int[28]; int[] d4 = new int[28];
            int[] c4 = new int[28]; int[] d5 = new int[28];
            int[] c5 = new int[28]; int[] d6 = new int[28];
            int[] c6 = new int[28]; int[] d7 = new int[28];
            int[] c7 = new int[28]; int[] d8 = new int[28];
            int[] c8 = new int[28]; int[] d9 = new int[28];
            int[] c9 = new int[28]; int[] d10 = new int[28];
            int[] c10 = new int[28]; int[] d11 = new int[28];
            int[] c11 = new int[28]; int[] d12 = new int[28];
            int[] c12 = new int[28]; int[] d13 = new int[28];
            int[] c13 = new int[28]; int[] d14 = new int[28];
            int[] c14 = new int[28]; int[] d15 = new int[28];
            int[] c15 = new int[28]; int[] d16 = new int[28];
            int[] k1 = new int[48]; int[] k2 = new int[48]; int[] k3 = new int[48];
            int[] k4 = new int[48]; int[] k5 = new int[48]; int[] k6 = new int[48];
            int[] k7 = new int[48]; int[] k8 = new int[48]; int[] k9 = new int[48];
            int[] k10 = new int[48]; int[] k11 = new int[48]; int[] k12 = new int[48];
            int[] k13 = new int[48]; int[] k14 = new int[48]; int[] k15 = new int[48];
            int[] k16 = new int[48];

            //获得原始密钥2进制形式
            for (int i = 0; i < kchar.Length; i++)
            {
                if ((kchar[i] & 0x80) != 0) temp[i * 8 + 0] = 1;
                if ((kchar[i] & 0x40) != 0) temp[i * 8 + 1] = 1;
                if ((kchar[i] & 0x20) != 0) temp[i * 8 + 2] = 1;
                if ((kchar[i] & 0x10) != 0) temp[i * 8 + 3] = 1;
                if ((kchar[i] & 0x8) != 0) temp[i * 8 + 4] = 1;
                if ((kchar[i] & 0x4) != 0) temp[i * 8 + 5] = 1;
                if ((kchar[i] & 0x2) != 0) temp[i * 8 + 6] = 1;
                if ((kchar[i] & 0x1) != 0) temp[i * 8 + 7] = 1;
            }

            //去掉奇校检位并打乱
            kint[0] = temp[56];
            kint[1] = temp[48];
            kint[2] = temp[40];
            kint[3] = temp[32];
            kint[4] = temp[24];
            kint[5] = temp[16];
            kint[6] = temp[8];
            kint[7] = temp[0];
            kint[8] = temp[57];
            kint[9] = temp[49];
            kint[10] = temp[41];
            kint[11] = temp[33];
            kint[12] = temp[25];
            kint[13] = temp[17];
            kint[14] = temp[9];
            kint[15] = temp[1];
            kint[16] = temp[58];
            kint[17] = temp[50];
            kint[18] = temp[42];
            kint[19] = temp[34];
            kint[20] = temp[26];
            kint[21] = temp[18];
            kint[22] = temp[10];
            kint[23] = temp[2];
            kint[24] = temp[59];
            kint[25] = temp[51];
            kint[26] = temp[43];
            kint[27] = temp[35];
            kint[28] = temp[62];
            kint[29] = temp[54];
            kint[30] = temp[46];
            kint[31] = temp[38];
            kint[32] = temp[30];
            kint[33] = temp[22];
            kint[34] = temp[14];
            kint[35] = temp[6];
            kint[36] = temp[61];
            kint[37] = temp[53];
            kint[38] = temp[45];
            kint[39] = temp[37];
            kint[40] = temp[29];
            kint[41] = temp[21];
            kint[42] = temp[13];
            kint[43] = temp[5];
            kint[44] = temp[60];
            kint[45] = temp[52];
            kint[46] = temp[44];
            kint[47] = temp[36];
            kint[48] = temp[28];
            kint[49] = temp[20];
            kint[50] = temp[12];
            kint[51] = temp[4];
            kint[52] = temp[27];
            kint[53] = temp[19];
            kint[54] = temp[11];
            kint[55] = temp[3];

            //分组56位密钥为2部分
            for (int i = 0; i < 28; i++)
            {
                c0[i] = kint[i];
                d0[i] = kint[i + 28];
            }


            //循环左移1位
            for (int i = 1; i < 28; i++)
            {
                c1[i - 1] = c0[i];
                d1[i - 1] = d0[i];
            }
            c1[27] = c0[0];
            d1[27] = d0[0];

            //循环左移1位
            for (int i = 1; i < 28; i++)
            {
                c2[i - 1] = c1[i];
                d2[i - 1] = d1[i];
            }
            c2[27] = c1[0];
            d2[27] = d1[0];

            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c3[i - 2] = c2[i];
                d3[i - 2] = d2[i];
            }
            c3[26] = c2[0];
            c3[27] = c2[1];

            d3[26] = d2[0];
            d3[27] = d2[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c4[i - 2] = c3[i];
            }
            c4[26] = c3[0];
            c4[27] = c3[1];
            for (int i = 2; i < 28; i++)
            {
                d4[i - 2] = d3[i];
            }
            d4[26] = d3[0];
            d4[27] = d3[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c5[i - 2] = c4[i];
            }
            c5[26] = c4[0];
            c5[27] = c4[1];
            for (int i = 2; i < 28; i++)
            {
                d5[i - 2] = d4[i];
            }
            d5[26] = d4[0];
            d5[27] = d4[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c6[i - 2] = c5[i];
            }
            c6[26] = c5[0];
            c6[27] = c5[1];
            for (int i = 2; i < 28; i++)
            {
                d6[i - 2] = d5[i];
            }
            d6[26] = d5[0];
            d6[27] = d5[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c7[i - 2] = c6[i];
            }
            c7[26] = c6[0];
            c7[27] = c6[1];
            for (int i = 2; i < 28; i++)
            {
                d7[i - 2] = d6[i];
            }
            d7[26] = d6[0];
            d7[27] = d6[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c8[i - 2] = c7[i];
            }
            c8[26] = c7[0];
            c8[27] = c7[1];
            for (int i = 2; i < 28; i++)
            {
                d8[i - 2] = d7[i];
            }
            d8[26] = d7[0];
            d8[27] = d7[1];
            //循环左移1位
            for (int i = 1; i < 28; i++)
            {
                c9[i - 1] = c8[i];
            }
            c9[27] = c8[0];
            for (int i = 1; i < 28; i++)
            {
                d9[i - 1] = d8[i];
            }
            d9[27] = d8[0];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c10[i - 2] = c9[i];
            }
            c10[26] = c9[0];
            c10[27] = c9[1];
            for (int i = 2; i < 28; i++)
            {
                d10[i - 2] = d9[i];
            }
            d10[26] = d9[0];
            d10[27] = d9[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c11[i - 2] = c10[i];
            }
            c11[26] = c10[0];
            c11[27] = c10[1];
            for (int i = 2; i < 28; i++)
            {
                d11[i - 2] = d10[i];
            }
            d11[26] = d10[0];
            d11[27] = d10[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c12[i - 2] = c11[i];
            }
            c12[26] = c11[0];
            c12[27] = c11[1];
            for (int i = 2; i < 28; i++)
            {
                d12[i - 2] = d11[i];
            }
            d12[26] = d11[0];
            d12[27] = d11[1];
            //循环左移2位
            for (int i = 2; i < 28; i++)
            {
                c13[i - 2] = c12[i];
            }
            c13[26] = c12[0];
            c13[27] = c12[1];
            for (int i = 2; i < 28; i++)
            {
                d13[i - 2] = d12[i];
            }