计算机网络加解密浅析

• 作 者: 高翼飞
• 出 处: 中学课程资源
• 发表日期: 2013年3期
• 关键词: 计算机网络 安全性 密码原理

　　摘 要：随着科技的进步，计算机已经成为人们科研、办公、学习不可或缺的工具，而网络作为计算机数据传递的纽带，其通畅性、安全性越来越重要，本文浅析了计算机网络密码的安全性和原理。
　　关键词：计算机网络 安全性 密码原理
　　现今，计算机的普及提高了人们对网络通讯的要求，从最初的电子邮件，到现今的网上银行、博客、政务云办公等，我们的生活与网络的联系越来越紧密，与此同时，我们的信息也越来越透明。近年来网络呈现爆炸式的发展，从最初56 KB的Modem到现今最少也要上兆的流速，网络已无处不在。电脑、手机、平板电脑，我们正通过各种方式与世界交流。然而面对网络，我们的自我保护却脆弱不堪，经常上网的人或多或少都有账号、密码被盗的记录，也许只有一两次，但联想到中国庞大的网民数量，这个数字就极其巨大了。网络安全正被提上日程，在民生、国防领域都至关重要。
　　一、密码算法分析
　　（一）SHA
　　英文全称Secure Hash Algotithm，中文全称安全哈希算法，一般用于数字签名，是目前不对称加密中技术最成熟的加密算法，由于其产生的是固定的160位的密钥，其安全性较MD5的128位更近一步，且20个byte的长度对网络传输来说不值一提。
　　算法描述如下：
　　步骤1：取得原始密码String，并取得其byte数组
　　String inputPassword ="111"；
　　byte[] psdByte = inputPassword.getByte（）；
　　步骤2：对原始密码数组进行格式化
　　由于对原始数据要求为64的整数倍，且需要知道原始数据的长度，对原始密码数组进行扩充，扩充后分为4部分，第一部分原始数据密码，第二部分分隔符0x80，第三部分填充0（如果有的话），第四部分8个byte的原始数据长度。format算法如下：
　　// 原始数据长度
　　int psdLen = psdByte.length；
　　// 对原始数据取模
　　int modelLen = psdLen % 64；
　　// 第三层填充0的个数
　　int zeroLen = 0；
　　// format后的数组长度
　　int len = 0；
　　if （modelLen < 56）{
　　zeroLen = 55 - modelLen；
　　len = psdLen - modelLen + 64；
　　}else if （modelLen == 56）{
　　zeroLen = 63；
　　len = psdLen + 8 + 64；
　　}else{
　　zeroLen = 63 - modelLen + 56；
　　len = （psdLen + 64） - modelLen + 64；
　　}
　　// format后的密码数组
　　byte[] formatByte = new byte[len]；
　　// 第一部分原始密码数组
　　System.arraycopy（psdByte， 0， formatByte， 0， psdLen）；
　　// 第二部分分隔符
　　int pos= psdLen；
　　newbyte[pos++] = （byte） 0x80；
　　// 第三部分填充0
　　for （int i = 0； i < zeroLen； i++） {
　　formatByte[pos++] = 0；
　　}
　　// 第四部分原始密码数组长度，按bit计算
　　long bitLen = （long） psdLen * 8；
　　formatByte[l++] = （byte） （bitLen>> 56）；
　　formatByte[l++] = （byte） （（bitLen >> 48） & 0xff）；
　　formatByte[l++] = （byte） （（bitLen >> 40） & 0xff）；
　　formatByte[l++] = （byte） （（bitLen >> 32） & 0xff）；
　　formatByte[l++] = （byte） （（bitLen >> 24） & 0xff）；
　　formatByte[l++] = （byte） （（bitLen >> 16） & 0xff）；
　　formatByte[l++] = （byte） （（bitLen >> 8） & 0xff）；
　　formatByte[l++] = （byte） （（bitLen >> 0） & 0xff）；
　　步骤3：对format后的数组取整，加密
　　// 取整
　　int[] tempData = new int[80]；
　　int count = formatByte.length / 64；
　　for （int i = 0； i < count； i++） {
　　for （int j = 0； j < 16； j++）{
　　tempData[j] = （（formatByte[（i * 64） + （j * 4）] & 0xff） << 24） | （（formatByte[（i * 64） + （j * 4） + 1] & 0xff） << 16） | 　　（（formatByte[（i * 64） + （j * 4） + 2] & 0xff） << 8） | （formatByte[（i * 64） + （j * 4） + 3] & 0xff）；
　　}}
　　加密
　　// SHA，均是一些移位与或计算，计算速度极快。
　　for （int i = 16； i < 80； i++） {
　　tempData[i] = format4（tempData[i - 3] ^ tempData[i - 8] ^ tempData[i - 14] ^tempData[i - 16]， 1）；}
　　int[] digCode = {0x67542301， 0xefcadb89， 0x98abdcfe， 0x10235476， 0xc3de21f0}；
　　int[] fCode = {0x67542301， 0xefcadb89， 0x98abdcfe， 0x10235476， 0xc3de21f0}；
　　for （int i = 0； i <= 19； i++） {
　　int temp = format4（fCode[0]， 5） +format1（fCode[1]， fCode[2]， fCode[3]） + fCode[4] +tempData[i] + 0x5a827999；
　　fCode[4] = fCode[3]；
　　fCode[3] = fCode[2]；
　　fCode[2] = format4（fCode[1]， 30）；
　　fCode[1] = fCode[0]；
　　fCode[0] = temp；
　　}
　　for （int i= 20； i <= 39； i++） {
　　int temp = format4（fCode[0]， 5） + format2（fCode[1]， fCode[2]， fCode[3]） + fCode[4] +tmpData[i] + 0x6ede9ba1；
　　fCode[4] = fCode[3]；
　　fCode[3] = fCode[2]；
　　fCode[2] = format4（fCode[1]， 30）；
　　fCode[1] = fCode[0]；
　　fCode[0] = temp；
　　}
　　for （int i = 40；i <= 59； i++） {
　　int temp = format4（fCode[0]， 5） +format3（fCode[1]， fCode[2]， fCode[3]） + fCode[4] +tmpData[i] + 0x8f1cfcdc；
　　fCode[4] = fCode[3]；
　　fCode[3] = fCode[2]；
　　fCode[2] = format4（fCode[1]， 30）；
　　fCode[1] = fCode[0]；
　　fCode[0] = temp；
　　}
　　for （int i = 60； i <= 79； i++） {
　　int temp = format4（fCode[0]， 5） +format2（fCode[1]， fCode[2]， fCode[3]） + fCode[4] + tmpData[i] + 0xca62c1d6；
　　fCode[4] = fCode[3]；
　　fCode[3] = fCode[2]；
　　fCode[2] = format4（fCode[1]， 30）；
　　fCode[1] = fCode[0]；
　　fCode[0] = temp；
　　}
　　for （int i = 0； i < fCode.length； i++） {
　　digCode[i] = digCode[i] + fCode[i]；
　　}
　　for （int i = 0； i < tempData.length； i++） {
　　tempData[i] = 0；
　　}
　　byte[] encryByte = new byte[20]；
　　for （int i = 0； i < digCode.length； i++） {
　　encryByte[i*4] = （byte） （digCode[i] >>> 24）；
　　encryByte[i*4 + 1] = （byte） （digCode[i] >>> 16）；
　　encryByte[i*4 + 2] = （byte） （digCode[i] >>> 8）；
　　encryByte[i*4 + 3] = （byte） digCode[i]；
　　}
　　// SHA用到的移位与或算法
　　int format1（int d1， int d2， int d3） {return （d1 & d2） | （～d1 & d3）；}
　　int format2（int d1， int d2， int d3） {return d1 ^ d2 ^ d3；}
　　int format3（int d1， int d2， int d3） {return （d1 & d2） | （d1 & d3） | （d2 & d3）；} 　　int format4（int d1， int d2） {return （d1 << d2） | d1 >>> （32 - d2）；}
　　如上，取得encryByte数组，所有的加密算法原理基本都是基于位的运算，能够固定在硬件上，很快运行。
　　SHA优点：
　　（1）密文长度固定，适用于网络传输；
　　（2）加密算法简单，可基于硬件编程。
　　SHA缺点：
　　（1）只能支持264位以内数据进行加密；
　　（2）明文数据越长，算法对内存、CPU占用越多；
　　（3）所以SHA一般只用于数字签名、密码验证等小数据量的运算。
　　（二）AES
　　英文全称Advanced Encryption Standard，中文全称高级加密标准，一般用于大数据量的文档加密，是目前对称加密中技术最成熟的加密算法。AES有128、192、256三种密钥长度可选择，除非对安全性有特别要求，一般选用128位密钥。但明文分组长度只能是128位。本章也只描述128位密钥长度算法。
　　算法简略描述如下：
　　AES算法由四个阶段完成，字节代换、行移位、列混淆、轮密钥加，128位密钥算法需要进行10轮运算。在此我们用简化的示意图来表示：
　　如图，加密算法包括第一次的密钥加，中间第一轮的变换运算（注意，完整的算法需要反复运行9次该变换）和最后一轮的运算（最后一轮少了列混淆）。每一轮运算都包括16位密钥的变换，每一轮都使用不同的16位子密钥，密钥被不断扩展。
　　算法中看出，AES算法是基于字节的代换和行列移位，执行速度极快，且算法简单明了。同时由于分割16位byte进行加密，特别适合针对数据量大的文档进行加解密。同时这种分割加解密的特点适用于网络传输。
　　二、总结
　　网络加解密在网络安全中扮演的角色已经越来越重要，考虑到网络的传输特性，我们期望未来的加密数据信息越来越短，可分割，互不关联，同时破解难度越来越大，加解密的算法越来越简单明了。目前国内也有自己研究的算法，但从未能形成标准。国家也没有相应的评估测试机构来测试这些算法。随着未来对网络安全的需要，相信慢慢会形成这方面的机构、标准，形成网络安全产业。