精华内容
下载资源
问答
  • 对称加密协议DES、3DES aes DES、3DES、TDEA、Blowfish、RC2、RC4、RC5、IDEA、SKIPJACK、AES等。 和非对称加密协议(不用分发私钥 RSA) 原创地址:...

    对称加密协议DES、3DES aes   DES3DES、TDEA、Blowfish、RC2、RC4、RC5IDEA、SKIPJACK、AES等。

    和非对称加密协议(不用分发私钥 RSA)





    原创地址:http://www.cnblogs.com/jfzhu/p/4020928.html

    转载请注明出处

     

    (一)对称加密(Symmetric Cryptography)

    对称加密是最快速、最简单的一种加密方式,加密(encryption)与解密(decryption)用的是同样的密钥(secret key)。对称加密有很多种算法,由于它效率很高,所以被广泛使用在很多加密协议的核心当中。

    对称加密通常使用的是相对较小的密钥,一般小于256 bit。因为密钥越大,加密越强,但加密与解密的过程越慢。如果你只用1 bit来做这个密钥,那黑客们可以先试着用0来解密,不行的话就再用1解;但如果你的密钥有1 MB大,黑客们可能永远也无法破解,但加密和解密的过程要花费很长的时间。密钥的大小既要照顾到安全性,也要照顾到效率,是一个trade-off。

    2000年10月2日,美国国家标准与技术研究所(NIST--American National Institute of Standards and Technology)选择了Rijndael算法作为新的高级加密标准(AES--AdvancedEncryption Standard)。.NET中包含了Rijndael算法,类名叫RijndaelManaged,下面举个例子。

    加密过程:

     

    复制代码
            private string myData = "hello";
            private string myPassword = "OpenSesame";
            private byte[] cipherText;
            private byte[] salt = { 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x5, 0x4, 0x3, 0x2, 0x1, 0x0 };
                
    
            private void mnuSymmetricEncryption_Click(object sender, RoutedEventArgs e)
            {
                var key = new Rfc2898DeriveBytes(myPassword, salt);
                // Encrypt the data.
                var algorithm = new RijndaelManaged();
                algorithm.Key = key.GetBytes(16);
                algorithm.IV = key.GetBytes(16);
                var sourceBytes = new System.Text.UnicodeEncoding().GetBytes(myData);
                using (var sourceStream = new MemoryStream(sourceBytes))
                using (var destinationStream = new MemoryStream())
                using (var crypto = new CryptoStream(sourceStream, algorithm.CreateEncryptor(), CryptoStreamMode.Read))
                {
                    moveBytes(crypto, destinationStream);
                    cipherText = destinationStream.ToArray();
                }
                MessageBox.Show(String.Format("Data:{0}{1}Encrypted and Encoded:{2}", myData, Environment.NewLine, Convert.ToBase64String(cipherText)));
            }
            private void moveBytes(Stream source, Stream dest)
            {
                byte[] bytes = new byte[2048];
                var count = source.Read(bytes, 0, bytes.Length);
                while (0 != count)
                {
                    dest.Write(bytes, 0, count);
                    count = source.Read(bytes, 0, bytes.Length);
                }
            }
    复制代码

     

    解密过程:

     

    复制代码
            private void mnuSymmetricDecryption_Click(object sender, RoutedEventArgs e)
            {
                if (cipherText == null)
                {
                    MessageBox.Show("Encrypt Data First!");
                    return;
                }
                var key = new Rfc2898DeriveBytes(myPassword, salt);
                // Try to decrypt, thus showing it can be round-tripped.
                var algorithm = new RijndaelManaged();
                algorithm.Key = key.GetBytes(16);
                algorithm.IV = key.GetBytes(16);
                using (var sourceStream = new MemoryStream(cipherText))
                using (var destinationStream = new MemoryStream())
                using (var crypto = new CryptoStream(sourceStream, algorithm.CreateDecryptor(), CryptoStreamMode.Read))
                {
                    moveBytes(crypto, destinationStream);
                    var decryptedBytes = destinationStream.ToArray();
                    var decryptedMessage = new UnicodeEncoding().GetString(
                    decryptedBytes);
                    MessageBox.Show(decryptedMessage);
                }
            }
    复制代码

     

    对称加密的一大缺点是密钥的管理与分配,换句话说,如何把密钥发送到需要解密你的消息的人的手里是一个问题。在发送密钥的过程中,密钥有很大的风险会被黑客们拦截。现实中通常的做法是将对称加密的密钥进行非对称加密,然后传送给需要它的人。

     

     

    (二)非对称加密(Asymmetric Cryptography)

    非对称加密为数据的加密与解密提供了一个非常安全的方法,它使用了一对密钥,公钥(public key)和私钥(private key)。私钥只能由一方安全保管,不能外泄,而公钥则可以发给任何请求它的人。非对称加密使用这对密钥中的一个进行加密,而解密则需要另一个密钥。比如,你向银行请求公钥,银行将公钥发给你,你使用公钥对消息加密,那么只有私钥的持有人--银行才能对你的消息解密。与对称加密不同的是,银行不需要将私钥通过网络发送出去,因此安全性大大提高。

    目前最常用的非对称加密算法是RSA算法,是Rivest, Shamir, 和Adleman于1978年发明,他们那时都是在MIT。.NET中也有RSA算法,请看下面的例子:

    加密过程:

     

    复制代码
            private byte[] rsaCipherText;
            private void mnuAsymmetricEncryption_Click(object sender, RoutedEventArgs e)
            {
                var rsa = 1;
                // Encrypt the data.
                var cspParms = new CspParameters(rsa);
                cspParms.Flags = CspProviderFlags.UseMachineKeyStore;
                cspParms.KeyContainerName = "My Keys";
                var algorithm = new RSACryptoServiceProvider(cspParms);
                var sourceBytes = new UnicodeEncoding().GetBytes(myData);
                rsaCipherText = algorithm.Encrypt(sourceBytes, true);
                MessageBox.Show(String.Format("Data: {0}{1}Encrypted and Encoded: {2}",
                    myData, Environment.NewLine,
                    Convert.ToBase64String(rsaCipherText)));
            }
    复制代码

     

    解密过程:

     

    复制代码
            private void mnuAsymmetricDecryption_Click(object sender, RoutedEventArgs e)
            {
                if(rsaCipherText==null)
                {
                    MessageBox.Show("Encrypt First!");
                    return;
                }
                var rsa = 1;
                // decrypt the data.
                var cspParms = new CspParameters(rsa);
                cspParms.Flags = CspProviderFlags.UseMachineKeyStore;
                cspParms.KeyContainerName = "My Keys";
                var algorithm = new RSACryptoServiceProvider(cspParms);
                var unencrypted = algorithm.Decrypt(rsaCipherText, true);
                MessageBox.Show(new UnicodeEncoding().GetString(unencrypted));
            }
    复制代码

     

    虽然非对称加密很安全,但是和对称加密比起来,它非常的慢,所以我们还是要用对称加密来传送消息,但对称加密所使用的密钥我们可以通过非对称加密的方式发送出去。为了解释这个过程,请看下面的例子:

    (1) Alice需要在银行的网站做一笔交易,她的浏览器首先生成了一个随机数作为对称密钥。

    (2) Alice的浏览器向银行的网站请求公钥。

    (3) 银行将公钥发送给Alice。

    (4) Alice的浏览器使用银行的公钥将自己的对称密钥加密。

    (5) Alice的浏览器将加密后的对称密钥发送给银行。

    (6) 银行使用私钥解密得到Alice浏览器的对称密钥。

    (7) Alice与银行可以使用对称密钥来对沟通的内容进行加密与解密了。

     

    image_thumb3

     

    (三)总结

    (1) 对称加密加密与解密使用的是同样的密钥,所以速度快,但由于需要将密钥在网络传输,所以安全性不高。

    (2) 非对称加密使用了一对密钥,公钥与私钥,所以安全性高,但加密与解密速度慢。

    (3) 解决的办法是将对称加密的密钥使用非对称加密的公钥进行加密,然后发送出去,接收方使用私钥进行解密得到对称加密的密钥,然后双方可以使用对称加密来进行沟通。

    分类: 算法

    展开全文
  • 研究分为三部分:首先进行IPSec协议以及安全缺陷分析,然后根据分析结果利用改进后的DES算法弥补IPSec协议安全缺陷,提高其安全性,最后进行安全性测试。结果表明:与改进前相比,利用改进后的IPSec协议对明文进行...
  • 提出了一种适用于小型集散控制系统(DCS)的简洁可靠的总线通信协议,核心思想是:首先针对小型集散控制系统处理数据量小、计算能力有限、实时性要求高、可靠性要求高的特点,对协议进行分析的出该协议应满足简洁性、...
  • C语言写的DOS系统银行Pos程序,支持SDLC同步modern通讯和ISO8583协议以及DES加密,串口通讯中断,时钟中断,采用BorlandC 3.1编写。可以作为C语言入门的学习资料,也是我的第一个原创作品。
  • 1. 不对称可逆加密的 的2种用法 (1)保证信息不被篡改 (2) 保证信息只能被我看到 ...流程如下: 百度公司 向CA机构报备 持有者姓名, 有效期, 要发布的公钥 , 扩展信息, 也就是如下图12345信息 ...

    1. 不对称可逆加密的 的2种用法

    (1)保证信息不被篡改

    image

    (2) 保证信息只能被我看到

    image

     

    2. CA证书的基本原理

    流程如下:  百度公司 向CA机构报备 持有者姓名, 有效期, 要发布的公钥 , 扩展信息, 也就是如下图12345信息

                  CA机构会把 12345 提取MD5摘要, 然后用自己的私钥 加密,生成数字签名

                 CA机构的解密钥 是内置在了 浏览器中

                  证书安装在IIS

    请求开始: 浏览器访问 iis, iis先把 123456信息给浏览器, 浏览器用内置的 解密钥解密数字签名, 看是否是MD5, 再把12345进行MD5加密看 是否与解密的MD5 是否一致 才确认是否百度服务器

    image

     

    CA认证通过 ,只是证明了 访问的是百度的服务器

    那么 浏览器 与 服务器之间的 信息安全怎么保证呢?

     

    3. 单边认证 HTTPS

    根据上面2步骤描述, 能解密=CA证书是CA机构发的,  MD5匹配,说明上图 12345信息无误,

    这样 就拿到了 服务器的 公钥(加密钥)  ,浏览器用该 公钥加密 "1234" 给服务器 , 服务器返还解密结果 ,证明 我是证书对应的服务器

    下面 双方约定使用 随即字符串 作为对称加密key 吧数据进行加密传输

    image

     

    4. 对于有些网站 如12306 为什么会显示不安全呢?

    因为它没有使用CA机构颁发的证书, 它的证书是自己颁发的, 浏览器没有内置 12306的根证书

     

    5. 私钥是不是只用来加密? 公钥只用来解密?

    公钥私钥 与加密解密无关系, 如图1,图2 所示

     

    excel资料 下载链接 https://files.cnblogs.com/files/xtxtx/%E5%8A%A0%E5%AF%86%E8%A7%A3%E5%AF%86.rar

    转载于:https://www.cnblogs.com/xtxtx/p/9165169.html

    展开全文
  • 标题http协议 使用httpserver组件完成server(服务端)接受post请求数据并使用3DES+base64加解密希望对大家有帮助这里写代码片 /** *刚刚接触3DES+base64加解密传输数据网上收罗了一些代码加上项目经理的指点终于写...

    http协议 使用httpserver组件完成server(服务端)接受post请求数据并使用3DES+base64加解密希望对大家有帮助

    http协议 使用httpserver组件完成server(服务端)接受post请求数据并使用3DES+base64加解密希望对大重点内容家有帮助

    这里写代码片
    /**
    *刚刚接触3DES+base64加解密传输数据网上收罗了一些代码加上项目经理的指点终于写出了一个server端
    /
    package com.caitong.httpserver;
    
    import java.io.BufferedReader;
    import java.io.IOException;
    import java.io.InputStream;
    import java.io.InputStreamReader;
    import java.io.OutputStream;
    import java.net.HttpURLConnection;
    import java.net.InetSocketAddress;
    import java.util.Iterator;
    import java.util.List;
    import java.util.Set;
    import javax.servlet.http.HttpServletRequest;
    import org.apache.commons.io.IOUtils;
    import org.apache.http.HttpRequest;
    import com.caitong.httpserver.util.Encrypt;
    import com.sun.net.httpserver.Headers;
    import com.sun.net.httpserver.HttpExchange;
    import com.sun.net.httpserver.HttpHandler;
    import com.sun.net.httpserver.HttpServer;
    //http协议 server端
    public class HttpServerTest {
    
            //主线程
            public static void main(String[] args) {
                 try {  
                        //允许最大连接数  
                        int maxLog = 10; 
                        //绑定的端口
                        HttpServer httpServer = HttpServer.create(new InetSocketAddress("192.168.20.205", 8888), maxLog);//"192.168.20.205"这是你要监听的ip地址
                        //直接返回Hello.....  
                        httpServer.createContext("/demo1", new DemoA()); 
                        //显示已经处理的请求数,采用线程池  
                        httpServer.setExecutor(null);  
                        httpServer.start();  
                        System.out.println("HttpServer启动...!");  
                    } catch (Exception e) {  
                        e.printStackTrace();  
                    }  
            }
    
            //获取请求数据并响应回去(实现HttpHandler类来处理请求过来的数据)
            public static class DemoA implements HttpHandler{  
    
                private final byte[] keybyte="1A1FBDD13082FF4722F12783".getBytes();//这是3DES解密需要的密钥
                public void handle(HttpExchange exchange) throws IOException {//HttpExchange是用来处理请求和相应数据的类
                        //System.out.println("ddd");
                      InputStream in = exchange.getRequestBody(); //获得输入流  
                      BufferedReader reader = new BufferedReader(new InputStreamReader(in, "utf-8")); 
                      //将BufferedReader转化为字符串
                      String text = IOUtils.toString(reader);
                      //转码解密
                      String tt = Encrypt.DataDecrypt(keybyte, text);//Encrypt是写好的工具类(里面有定义好的base64转码和3DES解密的方法)
                      exchange.sendResponseHeaders(HttpURLConnection.HTTP_OK, tt.getBytes().length);
                      OutputStream out = exchange.getResponseBody();  //获得输出流  
                      out.write(tt.getBytes());  
                      out.flush();  
                      exchange.close();  //exchange一定要关闭                               
                }  
    
            } 
    }
    
    
    ----------
    
    
    package com.caitong.httpserver.util;
    
    import java.io.IOException;
    import javax.crypto.Cipher;
    import javax.crypto.SecretKey;
    import javax.crypto.spec.SecretKeySpec;
    import sun.misc.BASE64Decoder;
    import sun.misc.BASE64Encoder;
    import java.io.UnsupportedEncodingException;
    import java.net.URLDecoder;
    import java.net.URLEncoder;
    import org.apache.commons.logging.Log;
    import org.apache.commons.logging.LogFactory;
    
    /**
     * 加密解密工具类(是3DES+base64工具的集成类)
     * @author  Juny965174016
     * @version 20160623
     */
    public class Encrypt {
        private static final Log log = LogFactory.getLog(Encrypt.class);
    
        /***
         * 加密密钥
         */
        private final byte[] keybyte="1A1FBDD13082FF4722F12783".getBytes(); //keybyte为加密密钥,长度为24字节
        /**
         * 加密方法提供3des加密,并且base64编码
         * @param key 24字节的密钥
         * @param str 明文
         * @return
         */
        public static String DataEncrypt(byte[] key, String str ) {
            String encrypt = null;
            try {
                byte[] ret = ThreeDes.encryptMode(key,str.getBytes("UTF-8"));
    
                encrypt = new String(Base64Util.encode(ret));
            } catch (Exception e) {
                System.out.print(e);
                encrypt = str;
            }
            return encrypt;
        }
        /***
         * 解密方法,先转码base64,再给3des解密
         * @param key 24字节的密钥
         * @param str 密文
         * @return
         */
        public static String DataDecrypt(byte[] key,String str ) {
            String decrypt = null;
            try {
                byte[] ret = ThreeDes.decryptMode( key,Base64Util.decode(str));
                decrypt = new String(ret, "UTF-8");
            } catch (Exception e) {
                System.out.print(e);
                decrypt = str;
            }
            return decrypt;
        }   
    }
    
    
    ----------
    
    
    package com.caitong.httpserver.util;
    
    import java.security.*;
    import javax.crypto.*;
    import javax.crypto.spec.SecretKeySpec;
    
        /**
        *3DES工具
         * 字符串 DESede(3DES) 加密
         * @author Juny965174016
         * @version 20160623
         */
        public class ThreeDes {
            private static final String Algorithm = "DESede"; // 定义 加密算法,可用
            // keybyte为加密密钥,长度为24字节
            // src为被加密的数据缓冲区(源)
            public static byte[] encryptMode(byte[] keybyte, byte[] src) {
                try {
                    // 生成密钥
                    SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
                    // 加密
                    Cipher c1 = Cipher.getInstance(Algorithm);
                    c1.init(Cipher.ENCRYPT_MODE, deskey);
                    return c1.doFinal(src);
                } catch (java.security.NoSuchAlgorithmException e1) {
                    e1.printStackTrace();
                } catch (javax.crypto.NoSuchPaddingException e2) {
                    e2.printStackTrace();
                } catch (java.lang.Exception e3) {
                    e3.printStackTrace();
                }
                return null;
            }
    
            // keybyte为加密密钥,长度为24字节
            // src为加密后的缓冲区
            public static byte[] decryptMode(byte[] keybyte, byte[] src) {
                try {
                    // 生成密钥
                    SecretKey deskey = new SecretKeySpec(keybyte, Algorithm);
                    // 解密
                    Cipher c1 = Cipher.getInstance(Algorithm);
                    c1.init(Cipher.DECRYPT_MODE, deskey);
                    return c1.doFinal(src);
                } catch (java.security.NoSuchAlgorithmException e1) {
                    e1.printStackTrace();
                } catch (javax.crypto.NoSuchPaddingException e2) {
                    e2.printStackTrace();
                } catch (java.lang.Exception e3) {
                    e3.printStackTrace();
                }
                return null;
            }     
    }
    
    
    ----------
    
    
    package com.caitong.httpserver.util;
    /**
    *base64工具
     * base64编码工具类
     * @author Juny965174016
     * @version 20160623
     */
    public class Base64Util {
    
        /**
         *  将 s 进行 BASE64 编码
         * @param s
         * @return
         */
        public static String encode(byte[] s) {
            if (s == null)
                return null;
            return (new sun.misc.BASE64Encoder()).encode(s);
        }
        /**
         *  将 s 进行 BASE64 编码
         * @param s
         * @return
         */
        public static String encode(String s) {
    
            if (s == null)
                return null;
            return encode(s.getBytes());
        }
    
        /**将 BASE64 编码的字符串 s 进行解码
         *
         * @param s
         * @return
         */
        public static byte[] decode(String s) {
            if (s == null)
                return null;
            sun.misc.BASE64Decoder decoder = new sun.misc.BASE64Decoder();
            try {
                byte[] b = decoder.decodeBuffer(s);
                return b;
            } catch (Exception e) {
                return null;
            }
        }
    }
    
    展开全文
  • DES实现

    2010-10-12 16:18:00
    DES加密,主要参考1:《网络安全:加密原理、算法与协议》,金名等译,清华大学出版社 主要参考2:《口令破解与加密技术》 胡志远 */ #include #include #include #include typedef unsigned char uchar...
    C++语言: Codee#13635
    /*
    DES加密,主要参考1:《网络安全:加密原理、算法与协议》,金名等译,清华大学出版社
    主要参考2:《口令破解与加密技术》 胡志远
    */

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <assert.h>
    typedef unsigned char uchar;

    //初始换位IP
    char IP[64] =
    {
        58,50,42,34,26,18,10,2,
        60,52,44,36,28,20,12,4,
        62,54,46,38,30,22,14,6,
        64,56,48,40,32,24,16,8,
        57,49,41,33,25,17,9,1,
        59,51,43,35,27,19,11,3,
        61,53,45,37,29,21,13,5,
        63,55,47,39,31,23,15,7
    };

    //逆初始换位IP-1
    char IP_1[64] =
    {
        40,8,48,16,56,24,64,32,
        39,7,47,15,55,23,63,31,
        38,6,46,14,54,22,62,30,
        37,5,45,13,53,21,61,29,
        36,4,44,12,52,20,60,28,
        35,3,43,11,51,19,59,27,
        34,2,42,10,50,18,58,26,
        33,1,41,9,49,17,57,25
    };

    //置换选择1
    char PC_1[56] =
    {
        57,49,41,33,25,17,9,
        1,58,50,42,34,26,18,
        10,2,59,51,43,35,27,
        19,11,3,60,52,44,36,
        63,55,47,39,31,23,15,
        7,62,54,46,38,30,22,
        14,6,61,53,45,37,29,
        21,13,5,28,20,12,4
    };

    //置换选择2
    char PC_2[48] =
    {
        14,17,11,24,1,5,
        3,28,15,6,21,10,
        23,19,12,4,26,8,
        16,7,27,20,13,2,
        41,52,31,37,47,55,
        30,40,51,45,33,48,
        44,49,39,56,34,53,
        46,42,50,36,29,32
    };

    //扩展置换Expansion
    char Expansion[48]=
    {
        32,1,2,3,4,5,
        4,5,6,7,8,9,
        8,9,10,11,12,13,
        12,13,14,15,16,17,
        16,17,18,19,20,21,
        20,21,22,23,24,25,
        24,25,26,27,28,29,
        28,29,30,31,32,1
    };

    //P盒置换
    char PBox[32] = {16,7,20,21,29,12,28,17,1,15,23,26,5,18,31,10,2,8,24,14,32,27,3,9,19,13,30,6,22,11,4,25};

    //S盒子
    char SBox[8][4][16] =
    {
        {
            14,4,13,1,2,15,11,8,3,10,6,12,5,9,0,7,
            0,15,7,4,14,2,13,1,10,6,12,11,9,5,3,8,
            4,1,14,8,13,6,2,11,15,12,9,7,3,10,5,0,
            15,12,8,2,4,9,1,7,5,11,3,14,10,0,6,13
        },
        {
            15,1,8,14,6,11,3,4,9,7,2,13,12,0,5,10,
            3,13,4,7,15,2,8,14,12,0,1,10,6,9,11,5,
            0,14,7,11,10,4,13,1,5,8,12,6,9,3,2,15,
            13,8,10,1,3,15,4,2,11,6,7,12,0,5,14,9
        },
        {
            10,0,9,14,6,3,15,5,1,13,12,7,11,4,2,8,
            13,7,0,9,3,4,6,10,2,8,5,14,12,11,15,1,
            13,6,4,9,8,15,3,0,11,1,2,12,5,10,14,7,
            1,10,13,0,6,9,8,7,4,15,14,3,11,5,2,12
        },
        {
            7,13,14,3,0,6,9,10,1,2,8,5,11,12,4,15,
            13,8,11,5,6,15,0,3,4,7,2,12,1,10,14,9,
            10,6,9,0,12,11,7,13,15,1,3,14,5,2,8,4,
            3,15,0,6,10,1,13,8,9,4,5,11,12,7,2,14
        },
        {
            2,12,4,1,7,10,11,6,8,5,3,15,13,0,14,9,
            14,11,2,12,4,7,13,1,5,0,15,10,3,9,8,6,
            4,2,1,11,10,13,7,8,15,9,12,5,6,3,0,14,
            11,8,12,7,1,14,2,13,6,15,0,9,10,4,5,3
        },
        {
            12,1,10,15,9,2,6,8,0,13,3,4,14,7,5,11,
            10,15,4,2,7,12,9,5,6,1,13,14,0,11,3,8,
            9,14,15,5,2,8,12,3,7,0,4,10,1,13,11,6,
            4,3,2,12,9,5,15,10,11,14,1,7,6,0,8,13
        },
        {
            4,11,2,14,15,0,8,13,3,12,9,7,5,10,6,1,
            13,0,11,7,4,9,1,10,14,3,5,12,2,15,8,6,
            1,4,11,13,12,3,7,14,10,15,6,8,0,5,9,2,
            6,11,13,8,1,4,10,7,9,5,0,15,14,2,3,12
        },
        {
            13,2,8,4,6,15,11,1,10,9,3,14,5,0,12,7,
            1,15,13,8,10,3,7,4,12,5,6,11,0,14,9,2,
            7,11,4,1,9,12,14,2,0,6,10,13,15,3,5,8,
            2,1,14,7,4,10,8,13,15,12,9,0,3,5,6,11
        }
    };

    //密钥移位次序(循环左移),左右28位分别循环左移的
    char LM[16]={1,1,2,2,2,2,2,2,1,2,2,2,2,2,2,1};

    //按位输出n个字节
    void printBit(uchar a[], int n)
    {
        int i,j,bit;
        for(i=0; i<n; i++){
            for(j=0; j<8; j++){
                bit = (a[i] >> (7-j)) & 0x01;
                printf("%d",bit);
            }

            if(i == n-1) printf("/n");
            else printf(",");
        }
    }


    //输出n个字节大小的数的16进制
    void printHex(uchar a[], int n)
    {
        int i,t;
        printf("0x");

        for(i=0; i<n; i++){
            t = a[i]; //考虑到int在内存中的存储(低低高高),就一个字节一个字节的存储。
            if(t>16 )
                printf("%x",t);
            else
                printf("0%x",t);
        }
        printf("/n");
    }


    //取bits位数的某位,为0返回0,为1就返回1
    int GetBit(const uchar *number, int pos, int bits)
    {
        assert(pos>0 && pos<=bits);
        int i,j;
        pos--;
        i = pos / 8;
        j = pos % 8;

        return (number[i] >> (7-j)) & 0x01;
    }


    //使用bit数组来设置number的各位的值(共更改bits位)
    void SetBit(uchar *number, int *bit, int bits)
    {
        uchar t;
        int i,j,bytes;

        if(bits%8 ==0) bytes = bits/8;
        else bytes = bits/8  + 1;

        for(i=0; i<bytes; i++){
            t = 0;
            for(j=0; (j<8) && (i*8+j<bits); j++)
                t |= (char)(bit[i*8+j] << (7-j));
            number[i] = t;
        }
    }


    //初始换位
    void ip(uchar LR[8])
    {
        int i,bit[64];
        for(i=0; i<64; i++)
            bit[i] = GetBit(LR, IP[i], 64);

        SetBit(LR, bit, 64);
    }


    //逆初始换位
    void ip_1(uchar LR[8])
    {
        int i, bit[64];
        for(i=0; i<64; i++)
            bit[i] = GetBit(LR, IP_1[i], 64);

        SetBit(LR, bit, 64);
    }


    //置换选择1,从初始的64位密钥中选取56位
    void pc_1(const uchar password[8], uchar key[])
    {
        int i, bit[56];
        for(i=0; i<56; i++)
            bit[i] = GetBit(password, PC_1[i], 64);
        SetBit(key, bit, 56);
    }


    //置换选择2,从56位的CD(28b+28b)导出48为密钥
    void pc_2(const uchar CD[7], uchar K[6])
    {
        int i, bit[48];
        for(i=0; i<48; i++)
            bit[i] = GetBit(CD, PC_2[i], 56);
        SetBit(K, bit, 48);
    }


    //对28位数循环左移n位,num[28]是01字符数组
    void LeftMoveOf28Bit(int num[28], int n)
    {
        int i,t;
        while(n--){
            t = num[0];
            for(i=0; i<27; i++)
                num[i] = num[i+1];
            num[27] = t;
        }
    }


    //把56为的cd分成两个28位,分别循环左移n位
    void lm(uchar CD[7], int n)
    {
        int i,bit[56],*C,*D;

        for(i=0; i<56; i++)
            bit[i] = GetBit(CD, i+1, 56);

        C = bit;
        D = bit + 28;

        LeftMoveOf28Bit(C, n);
        LeftMoveOf28Bit(D, n);

        SetBit(CD, bit, 56);
    }


    //扩展置换,把Ri从32为扩展到48位
    void expansion(const uchar Ri[4], uchar Re[6])
    {
        int i, bit[48];
        for(i=0; i<48; i++)
            bit[i] = GetBit(Ri, Expansion[i], 32);
        SetBit(Re, bit, 48);
    }


    //对前bits位进行异或操作,X=A^B
    void XOR(const uchar *A, const uchar *B, uchar *X, int bits)
    {
        int i,bytes;
        if(bits%8 == 0) bytes = bits/8;
        else bytes = bits/8 + 1;

        //memset(X, 0, bytes);
        for(i=0; i<bytes; i++)
            X[i] = A[i] ^ B[i];
    }

    //设置a[1]~a[4],表示为二进制的x, x>=0 && x<=15
    void sboxSetBit(int a[], int x)
    {
        assert(x>=0 && x<=15);
        a[0] = (x & 8) >> 3;
        a[1] = (x & 4) >> 2;
        a[2] = (x & 2) >> 1;
        a[3] = (x & 1);
    }

    //S盒子操作
    void sbox(uchar A[6], uchar B[4])
    {
        int i,t,row,column,bitA[48],bitB[32];
        for(i=0; i<48; i++)
            bitA[i] = GetBit(A, i+1, 48);

        //s盒子代换,由bitA[48]得到bitB[32]
        for(i=0; i<8; i++){
            row = bitA[i*6]*2 + bitA[i*6+5];
            column = bitA[i*6+1]*8 + bitA[i*6+2]*4 + bitA[i*6+3]*2 + bitA[i*6+4];
            t = SBox[i][row][column];

            sboxSetBit(bitB+i*4, t);//t>=0 && t=<15,占4bit
        }

        SetBit(B, bitB, 32);
    }


    //P盒子操作
    void pbox(uchar A[4])
    {
        int i,bit[32];
        for(i=0; i<32; i++)
            bit[i] = GetBit(A, PBox[i], 32);
        SetBit(A, bit, 32);
    }


    //输入的明文是8个字节长的带加密字符,和密钥
    uchar* DES(const char str[8], const char password[8])
    {
        int i;
        uchar LR[8], key[8], CD[7], K[16][6], LRi[16][8], Rie[6], xorResult[6], sResult[4];
        memcpy(LR, str, 8);
        memcpy(key, password, 8);

        //1、初始置换
        ip(LR);

        //2、置换选择1
        //密钥产生,置换选择1,64位->56位
        pc_1(key, CD);

        //3、依次产生16组密钥
        for(i=0; i<16; i++){
            //3.1、把CD分成两个28位,并分别循环移位
            lm(CD, LM[i]);

            //3.2、经过置换选择2,从56位选出48为的K
            pc_2(CD, K[i]);

            //输入子密钥
            //printf("K%d=",i); printHex(K[i], 6);
        }


        //4、进行16轮的扩展置换和S盒子代换
        for(i=0; i<16; i++){
            //4.1 设置Li = Ri-1
            if(i == 0) {
                memcpy(LRi[0], LR+4, 4);
            }else{
                memcpy(LRi[i], LRi[i-1]+4, 4);//Li=Ri-1
            }

            //4.2、扩展Ri
            if(i == 0){
                expansion(LR+4, Rie);
            }else{
                expansion(LRi[i-1]+4, Rie);//扩展Ri-1
            }

            //4.3、密钥Ki与扩展后的分组异或
            XOR(K[i], Rie, xorResult, 48);

            //4.4、进行S盒子运算,将上步得到的48位的xorResult转换成32位
            sbox(xorResult, sResult);

            //4.5、将上步得到的sResult做p盒子置换
            pbox(sResult);

            //4.6、继续和Li-1做异或运算,结果保存到Ri
            if(i == 0){
                XOR(sResult, LR, LRi[0]+4, 32);
            }else{
                XOR(sResult, LRi[i-1], LRi[i]+4, 32);
            }

            //输出每轮的加密结果
            //printf("i=%-2d:",i); printHex(LRi[i],8);
        }

        //5、需要把最后一轮的左右两部分互换一下
        uchar t_uchar[4];
        memcpy(t_uchar,   LRi[15],   4);
        memcpy(LRi[15],   LRi[15]+4, 4);
        memcpy(LRi[15]+4, t_uchar,   4);


        //6、逆初始置换
        ip_1(LRi[15]);

        uchar *EncryptStr = (uchar*)malloc(8);
        memcpy(EncryptStr, LRi[15], 8);
        return EncryptStr;
    }


    //DES解密
    uchar* DES_1(const uchar str[8], const char password[8])
    {
        int i;
        uchar LR[8], key[8], CD[7], K[16][6], LRi[16][8], Rie[6], xorResult[6], sResult[4];
        memcpy(LR, str, 8);
        memcpy(key, password, 8);

        //1、初始置换
        ip(LR);

        //2、置换选择1
        //密钥产生,置换选择1,64位->56位
        pc_1(key, CD);

        //3、依次产生16组密钥
        for(i=0; i<16; i++){
            //3.1、把CD分成两个28位,并分别循环移位
            lm(CD, LM[i]);

            //3.2、经过置换选择2,从56位选出48为的K
            pc_2(CD, K[i]);

            //输入子密钥
            //printf("K%d=",i); printHex(K[i], 6);
        }


        //4、进行16轮的扩展置换和S盒子代换
        for(i=0; i<16; i++){
            //4.1 设置Li = Ri-1
            if(i == 0) {
                memcpy(LRi[0], LR+4, 4);
            }else{
                memcpy(LRi[i], LRi[i-1]+4, 4);//Li=Ri-1
            }

            //4.2、扩展Ri
            if(i == 0){
                expansion(LR+4, Rie);
            }else{
                expansion(LRi[i-1]+4, Rie);//扩展Ri-1
            }

            //4.3、密钥Ki与扩展后的分组异或
            XOR(K[15-i], Rie, xorResult, 48);

            //4.4、进行S盒子运算,将上步得到的48位的xorResult转换成32位
            sbox(xorResult, sResult);

            //4.5、将上步得到的sResult做p盒子置换
            pbox(sResult);

            //4.6、继续和Li-1做异或运算,结果保存到Ri
            if(i == 0){
                XOR(sResult, LR, LRi[0]+4, 32);
            }else{
                XOR(sResult, LRi[i-1], LRi[i]+4, 32);
            }

            //输出每轮的加密结果
            //printf("i=%-2d:",i); printHex(LRi[i],8);
        }

        //5、需要把最后一轮的左右两部分互换一下
        uchar t_uchar[4];
        memcpy(t_uchar,   LRi[15],   4);
        memcpy(LRi[15],   LRi[15]+4, 4);
        memcpy(LRi[15]+4, t_uchar,   4);


        //6、逆初始置换
        ip_1(LRi[15]);

        uchar *EncryptStr = (uchar*)malloc(8);
        memcpy(EncryptStr, LRi[15], 8);
        return EncryptStr;
    }

    int main()
    {
        char str[9],pass[9], str2[9];
        uchar *result,*result2;

        while(1){
            memset(str,0,9);
            memset(str2,0,9);
            memset(pass,0,9);
            scanf("%s%s",str,pass);

            //加密
            result = DES(str, pass);

            //解密
            result2 = DES_1(result, pass);


            uchar t;
            memcpy(&t, str ,8);
            printf("明文的16进制  :");
            printHex(&t, 8); //输出原文的16进制

            printf("密文的16进制  :");
            printHex(result, 8); //输出密文


            printf("解密后的16进制:");
            printHex(result2,8); //输出解密后的16进制
            printf("解密后的字符  :");
            memcpy(str2, result2, 8); //输出解密的结果(字符)
            printf("%s/n/n",str2);
            free(result2); result2 = NULL;

            free(result); result = NULL;
        }
        return 0;
    }


    展开全文
  • cbc_des.rar

    2020-05-22 15:52:24
    版权声明:本文为CSDN博主「工农村贴膜小哥」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。 原文链接:https://blog.csdn.net/qq_35651984/article/details/89195112
  • DES加密算法

    2015-04-17 10:13:19
    同时为了适应计算机通信和电子商务迅速发展的需要,密码学的研究领域逐渐从消息加密扩大到数字签名、消息认证、身份识别、抗欺骗协议等新课题[1]。 美国国家标准局(NBS)1973年开始研究除国防部外的其它部门的...
  • 第3部分电子商务安全 主讲人:胡冰 苏興托普信戛职业技术学院 第3部分电子商务安全 目录 3.1电子商务安全的要求 3.2数据加密技术 33认证技术 3.4安全交易协议 3.2数据加密技术 3.2.1传统的代换密码 3.2.2对称加密算法...
  • (加密基础)DES

    2020-05-04 20:37:42
    DES加密是一种对称加密算法,被广泛应用与协议传输、本地数据加密、加密用户登录结果信息并序列化到本地磁盘 一.C语言实现和原理解析 说明:理论部分借鉴看雪密码学大佬:https://bbs.pediy.com/thread-25355...
  • 在通讯过程中为了防止普通的玩家截取协议修改内容并且发送,我们是有必要对协议进行加密的。当前这样的加密手段都已经是变成世界里面的基础设施了。我们只需要将其引入到工程中就好。本文将会基于OpenSSL来编写一个...
  • ipad协议

    2021-05-25 14:26:11
    首先我们要先了解下ipad协议是什么 ,ipad协议又叫微信协议 是基于微信IPad协议的智能控制系统,利用人工智能AI技术、云计算技术、虚拟技术、边缘计算技术、大数据技术, 打造出智能桌面系统RDS 、 智能聊天系统ACS ...
  • 在分析通信协议的时候 经常遇到的加密算法就是那几个 AES DES 3DES RSA 在hook AES DES RSA这些常见的加密算法之前 这里先看一下3个算法的java实现 1 AES加解密 java代码实现 1.1 AES加密 //bytesContent 要加密的...
  • 对称加密算法 ~ Des

    2019-04-26 09:29:00
    一、对称加密(Symmetric Key Encryption) ...对称加密有很多种算法,由于它效率很高,所以被广泛使用在很多加密协议的核心当中。自1977年美国颁布DES(Data Encryption Standard)密码算法作为美国数据加...
  • 本文分析了现有的RFID安全机制,在EPCglobal UHF协议规定的基础上,提出了针对标签和阅读器之间安全通讯的模型,并且对原有的DES加密算法进行改进,降低了标签电路的尺寸,同时也提高了RFID读写系统的安全性.
  • DES-3226S配置Spanning tree

    2012-11-04 16:06:05
    DES-3226S配置Spanning tree DES-3226S配置生成树协议的方法,实现在两个不同的交换机网络的互联,而且两台交换机的有多根数据线互联,不容易导致其中一根数据线出现故障而导致网络的断开,更具有网络的使用性。
  • 网络协议之https协议

    2021-01-12 22:35:44
    什么是https协议? HTTPS(全称:Hypertext Transfer Protocol over Secure Socket Layer),是以安全为目标的HTTP通道,简单讲是HTTP的安全版。即HTTP下加入SSL层,HTTPS的安全基础是SSL。https的默认端口号是443。...
  •  从技术角度讲,网络安全除了依赖安全的网络通信协议及应用协议外,更多地取决于网络设备如交换机、路由器等所提供的加/解密功能。目前,基于DES算法的加/解密硬件仍在广泛应用于国内卫星通信、网关服务器、机顶盒...
  • C语言利用openSSL库DES模块加密

    千次阅读 2016-05-23 07:53:52
    在通讯过程中为了防止普通的玩家截取协议修改内容并且发送,我们是有必要对协议进行加密的。当前这样的加密手段都已经是变成世界里面的基础设施了。我们只需要将其引入到工程中就好。本文将会基于OpenSSL来编写一个...
  • 各位小伙伴们 我一开始不能...比如我们现在向服务端发送一条消息,内容是个人介绍:Name="xxl",Age=22,Des="贼帅贼帅的" 1.二进制协议的做法是:客户端 告诉 服务端 定制的协议的结构:比如客户端说 我给你发上去
  • RAS、AES、DES加密

    2018-12-27 17:48:44
    加密协议  加密算法说白了就是数学算法,简单点来说就理解为一个函数吧,将一个数据经过某种复杂处理,映射为另一个数据;这就是加密。加密的关键不是在于加密算法与解密算法本身的编写有多大难度,而是在某些未知...
  • 采用McBSP1 接口与CD4066 开关电源设计了IC 卡读卡器,并通过CCS 开发环境编写、和调试应用程序,完成了DSP 与SLE5542 卡之间的ISO7816-3 通信协议。另外通过McBSP0 连接MAX232 电平转换器,以软件形式实现了目标板...
  • 公司协议安全需求、需要对传输内容做des、md5加密。 因为是新人、刚交给我这个任务的时候有点眩晕。就开始在网上找各种des加密的内容。因为不懂以为需要把原理也搞明白,最后误了时间、把自己也搞糊涂了。当然,逻辑...
  • 局域聊天+DES加密ci

    2010-03-07 18:26:46
    自己制作的局域聊天+DES加密ci,使用Java语言,UDP协议。具体的都在里面啦。还不成熟,请大家多指教。
  • Kerberos协议

    千次阅读 2016-08-08 19:21:14
    协议的核心在于,在用户验证的过程中,引入一个可信的第三方,也就是Kerberos服务器,也通常称之为密钥分发服务器,负责执行用户和服务的安全认证,Kerberos服务器在网络上传输的数据使用DES算法进行加密,除了可以...
  • android 用户协议和隐私政策封装

    千次阅读 2020-05-20 10:49:21
    String user_agreement_des = "用户协议\n用户协议用户协议用户协议用户协议用户协议用户协议用户协议用户协议用户协议\n用户协议用户协议用户协议用户协议用户协议用户协议用户协议用户协议用户协议\n用户协议用户...
  • DES和RSA加密数据传输信息Java实现

    千次阅读 2015-10-26 19:05:55
    DES加密的方式现在已经不安全了,而我们的RAS加密的速度很慢,并且有长度限制,每一个块只能达到117字节,在给移动终端编写接口时传输的信息大都明文传输,而使用Https协议又不是很方便,所有我就写了一个DES和RSA...
  • STP协议

    2012-06-05 17:48:16
    STP协议 STP为生成树协议,就是把一个环形的结构改变成一个树型的结构。STP协议就是用来将物理上存在环路的网络,通过一种算法,在逻辑上断开一些端口,来生成一个逻辑上的树型结构。...选择指定端口(des...
  • HTTPS协议

    2020-06-30 22:22:53
    加密分为两种方式一种是对称加密(比如DES,AES),一种是非对称加密(RSA)。 在对称加密算法中,加密和解密使用的密钥是相同的。在非对称加密算法中,加密使用的密钥和解密使用的密钥是不相同的。一把是作为公开的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,091
精华内容 436
关键字:

des协议