des加密偏移量
A. 前端jsp登录密码加密为des3加密方法
*_*?我是谁
原创
关注
0点赞·757人阅读
<%@ page contentType="text/html;charset=GBK"%>
<%@ page language="java" import="java.util.regex.*,
com.excellence.common.OAConstant,
com.excellence.common.UserInfo,
java.util.*,
java.text.SimpleDateFormat," %>
<html>
<head>
<title>XX系统</title>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312">
<link rel="stylesheet" href="/common/styles/default/default.css" type="text/css">
</head>
<script language="javascript">
</script>
<script language="JavaScript" src="/oa/javascripts/crypto-js.js"></script>
<body bgcolor="#FFFFFF" text="#000000" leftmargin="0" topmargin="0">
<center>
</center>
</body>
<script type="text/vbscript">
Function str2asc(strstr)
str2asc = hex(asc(strstr))
End Function
Function asc2str(ascasc)
asc2str = chr(ascasc)
End Function
</script>
<script>
<%
UserInfo userInfo = (UserInfo) request.getSession().getAttribute("userInfo ");
String account="";
//获取用户账号
if(userInfo.getAccount()!=null&&!"".equals(userInfo.getAccount()))
account=userInfo.getAccount();
//有效期：格式：yyyy-MM-dd HH:mm:ss 有效期不能设置超过10分钟
SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date now = new Date();
Date date = new Date(now .getTime() + 600000);
String time = df.format(date);
%>
//sessionid = base64(DES(用户账号&有效期))
//DES key：67HT4WrP
var sessionId = "<%=account%>" + "&" + "<%=time%>";
var mykey = "67HT4WrP";
// DES加密模式：CBC模式/ECB模式
// CBC模式加密
function encryptCBC(text, textKey) {
// 密钥转成16进制的字符串
var key = CryptoJS.enc.Utf8.parse(textKey);
// 加密过程
var encrypted = CryptoJS.DES.encrypt(text, key, {
// iv偏移量为key值
iv: key,
// 模式为CBC
mode: CryptoJS.mode.CBC,
// DES加密padding为Pkcs7
padding: CryptoJS.pad.Pkcs7
});
// 加密返回为字符串密文(加密经过一次base64加密，结果可看结果)
return encrypted.toString();
}
//对字符串中的特殊字符进行UrlEncode转码
function UrlEncode(str){
var ret="";
var strSpecial="!\"#$%&'()*+,/:;<=>?[]^`{|}~%";
var tt= "";
for(var i=0;i<str.length;i++){
var chr = str.charAt(i);
var c=str2asc(chr);
tt += chr+":"+c+"n";
if(parseInt("0x"+c) > 0x7f){
ret+="%"+c.slice(0,2)+"%"+c.slice(-2);
}else{
if(chr==" ")
ret+="+";
else if(strSpecial.indexOf(chr)!=-1)
ret+="%"+c.toString(16);
else
ret+=chr;
}
}
return ret;
}
//对sessionid进行加密
var desPass=encryptCBC(sessionId,mykey);
//对加密的sessionid中的特殊字符转码
var desPassEncode=UrlEncode(desPass);
//URL格式:http://xxxxxxxxxxxx?sessionid=&appid=&redirectUrl=~/Portals/Views/Test/index.html
var url="http://xxxxxxxxxxxx?sessionid="+desPassEncode+"&appid=&redirectUrl=~/Portals/Views/Test/index.html";
window.close();
window.open(url);
</script>
</html>
登录后复制
注意事项：
1、crypto-js.js使用到了这个js，要记得引入，很多地方可以下载的，除了这里面能用到des加密，也可以从网上找其他的des加密脚本，但是因为des加密模式的问题，要注意调用函数时参数的使用，确定自己要使用的是哪种des加密方法。
2、因为这里实现的是自动登录，涉及到了url的处理，由于使用了加密，密文中会含有特殊字符，直接通过url转跳，要把url中含有的特殊字符进行UrlEncode转码。
3、注意这里des的加密方式，这样进行转跳，跳进去的网站是.net实现的，因为des的加密模式有几种，java,.net等默认的des加密模式有可能不一致，就会导致加密后的密文不一样，所以要确定自己使用哪种模式，或者直接输出加密密文来进行比较。
4、使用js比较方便的地方是因为我这里用的jsp页面，所以对处理的数据可以任意写，而且不会影响后台的使用，我觉得这是js的好处，特别是进行像这种进行类似单点登录，自己系统用的java实现，而别人用的.net,直接用脚本，可以节省时间，不会对自己系统造成什么影响。
5、有一个地方要注意，这里对url进行转码时，使用到了VB脚本的一些函数，这种脚本已经很少有人会用了，而且有些浏览器已经不支持了，网络显示ie11不支持，但是我自己的电脑就是ie11，可以使用，所以这个也不是绝对的，有可能和使用到的函数有关。
6、除了des加密，还有md5，单独的base64加密，这些常用的加密方式，都可以直接用js脚本实现。
7、这里只有des的一种加密模式，还有其他的，crypto-js.js中都有，可以网络下其他加密方法的使用！
B. C# DES加密后存储，解密后显示问题。
在我这里测试你的代码是可以的，不过我把object o = sr.ReadLine();改成了object o = sr.ReadToEnd();
C. VS中用C#编写一个DES（或3DES)加解密的Windows应用程序
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
namespace ZU14
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
//ZU14.DES des = new ZU14.DES();
ZU14.DES des = null;
private void btn_jiami_Click(object sender, EventArgs e)
{
textBox2.Text = des.Encrypt(textBox1.Text);
// MessageBox.Show("加密成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
private void btn_jiemi_Click(object sender, EventArgs e)
{
textBox3.Text = des.Decrypt(textBox2.Text);
//MessageBox.Show("解密成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
private void btn_wjjiami_Click(object sender, EventArgs e)
{
OpenFileDialog open = new OpenFileDialog();
open.InitialDirectory = @"d:\";
open.Filter = "文本文件(*.txt,*.doc,*.xls)|*.txt;*.doc;*.xls";
if (open.ShowDialog()== DialogResult.OK)
{
des.EncryptFile(open.FileName, open.FileName);
MessageBox.Show("加密成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
}
private void btn_wjjiemi_Click(object sender, EventArgs e)
{
OpenFileDialog open = new OpenFileDialog();
open.InitialDirectory = @"d:\";
open.Filter = "文本文件(*.txt,*.doc,*.xls)|*.txt;*.doc;*.xls";
if (open.ShowDialog() == DialogResult.OK)
{
des.DecryptFile(open.FileName);
MessageBox.Show("解密成功！", "提示", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
}
}
private void button1_Click(object sender, EventArgs e)
{
zifu.setmisi1 = textBox4.Text.Trim();
zifu.setmisi2 = textBox5.Text.Trim();
des = new ZU14.DES();
}
}
}
上面的代码是窗体的
下面是调用的两个类的
using System;
using System.Collections.Generic;
using System.Text;
namespace ZU14
{
class zifu
{
private static string misi1;
private static string misi2;
public static string getmisi1
{
get
{
return misi1;
}
}
public static string setmisi1
{
set
{
misi1 = value;
}
}
public static string getmisi2
{
get
{
return misi2;
}
}
public static string setmisi2
{
set
{
misi2 = value;
}
}
}
}
using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Security;
using System.Security.Cryptography;
using System.Collections;
using System.Data;
using System.Windows.Forms;
namespace ZU14
{
class DES
{
string iv =zifu.getmisi1; //"1234的yza";
string key = zifu.getmisi2;//"123在yzb";
/// <summary>
/// DES加密偏移量，必须是>=8位长的字符串
/// </summary>
public string IV
{
get { return iv; }
set { iv = value; }
}
/// <summary>
/// DES加密的私钥，必须是8位长的字符串
/// </summary>
public string Key
{
get { return key; }
set { key = value; }
}
/// <summary>
/// 对字符串进行DES加密
/// </summary>
/// <param name="sourceString">待加密的字符串</param>
/// <returns>加密后的BASE64编码的字符串</returns>
public string Encrypt(string sourceString)
{
byte[] btKey = Encoding.Default.GetBytes(key);
byte[] btIV = Encoding.Default.GetBytes(iv);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
using (MemoryStream ms = new MemoryStream())
{
byte[] inData = Encoding.Default.GetBytes(sourceString);
try
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(btKey, btIV), CryptoStreamMode.Write))
{
cs.Write(inData, 0, inData.Length);
cs.FlushFinalBlock();
}
return Convert.ToBase64String(ms.ToArray());
}
catch
{
throw;
}
}
}
/// <summary>
/// 对DES加密后的字符串进行解密
/// </summary>
/// <param name="encryptedString">待解密的字符串</param>
/// <returns>解密后的字符串</returns>
public string Decrypt(string encryptedString)
{
byte[] btKey = Encoding.Default.GetBytes(key);
byte[] btIV = Encoding.Default.GetBytes(iv);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
using (MemoryStream ms = new MemoryStream())
{
byte[] inData = Convert.FromBase64String(encryptedString);
try
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(btKey, btIV), CryptoStreamMode.Write))
{
cs.Write(inData, 0, inData.Length);
cs.FlushFinalBlock();
}
return Encoding.Default.GetString(ms.ToArray());
}
catch
{
throw;
}
}
}
/// <summary>
/// 对文件内容进行DES加密
/// </summary>
/// <param name="sourceFile">待加密的文件绝对路径</param>
/// <param name="destFile">加密后的文件保存的绝对路径</param>
public void EncryptFile(string sourceFile, string destFile)
{
if (!File.Exists(sourceFile)) throw new FileNotFoundException("指定的文件路径不存在！", sourceFile);
byte[] btKey = Encoding.Default.GetBytes(key);
byte[] btIV = Encoding.Default.GetBytes(iv);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] btFile = File.ReadAllBytes(sourceFile);
using (FileStream fs = new FileStream(destFile, FileMode.Create, FileAccess.Write))
{
try
{
using (CryptoStream cs = new CryptoStream(fs, des.CreateEncryptor(btKey, btIV), CryptoStreamMode.Write))
{
cs.Write(btFile, 0, btFile.Length);
cs.FlushFinalBlock();
}
}
catch
{
// throw;
}
finally
{
fs.Close();
}
}
}
/// <summary>
/// 对文件内容进行DES加密，加密后覆盖掉原来的文件
/// </summary>
/// <param name="sourceFile">待加密的文件的绝对路径</param>
public void EncryptFile(string sourceFile)
{
EncryptFile(sourceFile, sourceFile);
}
/// <summary>
/// 对文件内容进行DES解密
/// </summary>
/// <param name="sourceFile">待解密的文件绝对路径</param>
/// <param name="destFile">解密后的文件保存的绝对路径</param>
public void DecryptFile(string sourceFile, string destFile)
{
if (!File.Exists(sourceFile)) throw new FileNotFoundException("指定的文件路径不存在！", sourceFile);
byte[] btKey = Encoding.Default.GetBytes(key);
byte[] btIV = Encoding.Default.GetBytes(iv);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] btFile = File.ReadAllBytes(sourceFile);
using (FileStream fs = new FileStream(destFile, FileMode.Create, FileAccess.Write))
{
try
{
using (CryptoStream cs = new CryptoStream(fs, des.CreateDecryptor(btKey, btIV), CryptoStreamMode.Write))
{
cs.Write(btFile, 0, btFile.Length);
cs.FlushFinalBlock();
}
}
catch
{
// MessageBox.Show(ex.Message);
//throw;
}
finally
{
fs.Close();
}
}
}
/// <summary>
/// 对文件内容进行DES解密，加密后覆盖掉原来的文件
/// </summary>
/// <param name="sourceFile">待解密的文件的绝对路径</param>
public void DecryptFile(string sourceFile)
{
DecryptFile(sourceFile, sourceFile);
}
}
}
有什么看不明白的，再联系我，我的账号就是我的QQ
D. C# DES加密解密问题
这个其实就是一个加密解密问题而已，算法网上都有。
button1提交的时候加密内容后存入数据库，button搜索的时候先加密用于搜索的字符然后查询数据库查出来再解密绑定到datagridview上就行了。
当然这里因为加密了所以你搜索的时候只能全词搜索而不能做模糊匹配搜索。
/// <summary>
/// DEC 加密过程
/// </summary>
/// <param name="pToEncrypt">被加密的字符串</param>
/// <param name="sKey">密钥（只支持8个字节的密钥）</param>
/// <returns>加密后的字符串</returns>
public string Encrypt(string pToEncrypt, string sKey)
{
//访问数据加密标准(DES)算法的加密服务提供程序 (CSP) 版本的包装对象
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);//建立加密对象的密钥和偏移量
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey); //原文使用ASCIIEncoding.ASCII方法的GetBytes方法
byte[] inputByteArray = Encoding.Default.GetBytes(pToEncrypt);//把字符串放到byte数组中
MemoryStream ms = new MemoryStream();//创建其支持存储区为内存的流
//定义将数据流链接到加密转换的流
CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
//上面已经完成了把加密后的结果放到内存中去
StringBuilder ret = new StringBuilder();
foreach (byte b in ms.ToArray())
{
ret.AppendFormat("{0:X2}", b);
}
ret.ToString();
return ret.ToString();
}
/// <summary>
/// DEC 解密过程
/// </summary>
/// <param name="pToDecrypt">被解密的字符串</param>
/// <param name="sKey">密钥（只支持8个字节的密钥，同前面的加密密钥相同）</param>
/// <returns>返回被解密的字符串</returns>
public string Decrypt(string pToDecrypt, string sKey)
{
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
byte[] inputByteArray = new byte[pToDecrypt.Length / 2];
for (int x = 0; x < pToDecrypt.Length / 2; x++)
{
int i = (Convert.ToInt32(pToDecrypt.Substring(x * 2, 2), 16));
inputByteArray[x] = (byte)i;
}
des.Key = ASCIIEncoding.ASCII.GetBytes(sKey);//建立加密对象的密钥和偏移量，此值重要，不能修改
des.IV = ASCIIEncoding.ASCII.GetBytes(sKey);
MemoryStream ms = new MemoryStream();
CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(), CryptoStreamMode.Write);
cs.Write(inputByteArray, 0, inputByteArray.Length);
cs.FlushFinalBlock();
//建立StringBuild对象，createDecrypt使用的是流对象，必须把解密后的文本变成流对象
StringBuilder ret = new StringBuilder();
return System.Text.Encoding.Default.GetString(ms.ToArray());
}
E. 求一简单的 DES加密实例。要c#.net实现！
public sealed class DES
{
private static string iv = "123456789";
private static string key = "12345678"; /// <summary>
/// DES加密偏移量，必须是>=8位长的字符串
/// </summary>
public string IV
{
get { return iv; }
set { iv = value; }
} /// <summary>
/// DES加密的私钥，必须是8位长的字符串
/// </summary>
///
public string Key
{
get { return key; }
set { key = value; }
} /// <summary>
/// 对字符串进行DES加密
/// </summary>
/// <param name="sourceString">待加密的字符串</param>
/// <returns>加密后的BASE64编码的字符串</returns> public static string Encrypt(string sourceString)
{
if (sourceString != "")
{
byte[] btKey = Encoding.Default.GetBytes(key);
byte[] btIV = Encoding.Default.GetBytes(iv);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
using (MemoryStream ms = new MemoryStream())
{
byte[] inData = Encoding.Default.GetBytes(sourceString);
try
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(btKey, btIV), CryptoStreamMode.Write))
{
cs.Write(inData, 0, inData.Length);
cs.FlushFinalBlock();
}
return Convert.ToBase64String(ms.ToArray());
}
catch
{
throw;
}
}
}
else
return "";
} /// <summary>
/// 对DES加密后的字符串进行解密
/// </summary>
/// <param name="encryptedString">待解密的字符串</param>
/// <returns>解密后的字符串</returns> public static string Decrypt(string encryptedString)
{
if (encryptedString != "")
{
byte[] btKey = Encoding.Default.GetBytes(key);
byte[] btIV = Encoding.Default.GetBytes(iv);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
using (MemoryStream ms = new MemoryStream())
{
byte[] inData = Convert.FromBase64String(encryptedString);
try
{
using (CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(btKey, btIV), CryptoStreamMode.Write))
{
cs.Write(inData, 0, inData.Length);
cs.FlushFinalBlock();
}
return Encoding.Default.GetString(ms.ToArray());
}
catch
{
throw;
}
}
}
else
return "";
}}
F. DES 加密算法解析
第一步是用密钥初始化des
初始化的过程主要是用传入的密钥生成16对长度为48的Kn 子密钥
生成48位子密钥Kn的函数主要是 __create_sub_keys , 主要设计两个换位表pc1和pc2
key = self.__permutate(des.__pc1, self.__String_to_BitList(self.getKey())) 开始先用换位表生成56位的初始key值（同pc1表的位数)
之后划分成两部分self.L和self.R各28位，然后是一个循环16此的左移操作，最后用pc2换位表生成第一个子密钥Kn[0]
我们传入数据调用encrypt函数即可， DES.encrypt('flag{isisisikey}') 我们先来看encrypt函数
encrypt函数主要调用了crypt函数，继续跟进crypt函数，开始一部分是cbc模式获取iv的过程，这里先暂时不考虑cbc,直接看关键部分
这里就设计到分组加密的核心了，为什么DES又叫分组加密，有一操作是 block = self.__String_to_BitList(data[i:i+8]) 把加密数据每八个字节分成一个block,然后调用 __String_to_BitList 会将八字节字符转换为64bit的二进制，每个block再调用 __des_crypt 函数加密
开始几步和子密钥生成函数类似，用一个ip换位表初始化block,然后划分成self,L和self.R 各32位。
之后又是一个16轮的计算，我们分析一下每轮操作
self.R = self.__permutate(des.__expansion_table, self.R) 利用一个扩展表将32bit扩展成48位，扩展表:
B = [self.R[:6], self.R[6:12], self.R[12:18], self.R[18:24], self.R[24:30], self.R[30:36], self.R[36:42], self.R[42:]] 将48位的self.R 分成6*8为，之后一个循环就是经典的是s-box的置换操作
s-box盒一个八个，m是前后2bit,n是中间6bit, v是s-box的(n,m)处的值
self.R = self.__permutate(des.__p, Bn) 是P-box置换盒。 最后返回64bit的processed_block, 经过BitList_to_String函数处理就变成8字节的字符流了，最后把每个block分组join一块就是最后的密文。
我们再来总结一下这个过程
子密钥生成算法
des 加密算法
附上完整版des加解密算法脚本
G. DES加密解密问题，java 和 C#
usingSystem;
usingSystem.Collections.Generic;
usingSystem.Text;
usingSystem.IO;
usingSystem.Security;
usingSystem.Security.Cryptography;
/*----------------------------------------------
*DES加密、解密类库，字符串加密结果使用BASE64编码返回，支持文件的加密和解密
*作者：三角猫/DeltaCat
*网址：
*转载务必保留此信息
*---------------------------------------------
*/
namespaceZU14
{
publicsealedclassDES
{
stringiv="1234的yzo";
stringkey="123在yzo";
///<summary>
///DES加密偏移量，必须是>=8位长的字符串
///</summary>
publicstringIV
{
get{returniv;}
set{iv=value;}
}
///<summary>
///DES加密的私钥，必须是8位长的字符串
///</summary>
publicstringKey
{
get{returnkey;}
set{key=value;}
}
///<summary>
///对字符串进行DES加密
///</summary>
///<paramname="sourceString">待加密的字符串</param>
///<returns>加密后的BASE64编码的字符串</returns>
publicstringEncrypt(stringsourceString)
{
byte[]btKey=Encoding.Default.GetBytes(key);
byte[]btIV=Encoding.Default.GetBytes(iv);
DESCryptoServiceProviderdes=newDESCryptoServiceProvider();
using(MemoryStreamms=newMemoryStream())
{
byte[]inData=Encoding.Default.GetBytes(sourceString);
try
{
using(CryptoStreamcs=newCryptoStream(ms,des.CreateEncryptor(btKey,btIV),CryptoStreamMode.Write))
{
cs.Write(inData,0,inData.Length);
cs.FlushFinalBlock();
}
returnConvert.ToBase64String(ms.ToArray());
}
catch
{
throw;
}
}
}
///<summary>
///对DES加密后的字符串进行解密
///</summary>
///<paramname="encryptedString">待解密的字符串</param>
///<returns>解密后的字符串</returns>
publicstringDecrypt(stringencryptedString)
{
byte[]btKey=Encoding.Default.GetBytes(key);
byte[]btIV=Encoding.Default.GetBytes(iv);
DESCryptoServiceProviderdes=newDESCryptoServiceProvider();
using(MemoryStreamms=newMemoryStream())
{
byte[]inData=Convert.FromBase64String(encryptedString);
try
{
using(CryptoStreamcs=newCryptoStream(ms,des.CreateDecryptor(btKey,btIV),CryptoStreamMode.Write))
{
cs.Write(inData,0,inData.Length);
cs.FlushFinalBlock();
}
returnEncoding.Default.GetString(ms.ToArray());
}
catch
{
throw;
}
}
}
///<summary>
///对文件内容进行DES加密
///</summary>
///<paramname="sourceFile">待加密的文件绝对路径</param>
///<paramname="destFile">加密后的文件保存的绝对路径</param>
publicvoidEncryptFile(stringsourceFile,stringdestFile)
{
if(!File.Exists(sourceFile))thrownewFileNotFoundException("指定的文件路径不存在！",sourceFile);
byte[]btKey=Encoding.Default.GetBytes(key);
byte[]btIV=Encoding.Default.GetBytes(iv);
DESCryptoServiceProviderdes=newDESCryptoServiceProvider();
byte[]btFile=File.ReadAllBytes(sourceFile);
using(FileStreamfs=newFileStream(destFile,FileMode.Create,FileAccess.Write))
{
try
{
using(CryptoStreamcs=newCryptoStream(fs,des.CreateEncryptor(btKey,btIV),CryptoStreamMode.Write))
{
cs.Write(btFile,0,btFile.Length);
cs.FlushFinalBlock();
}
}
catch
{
throw;
}
finally
{
fs.Close();
}
}
}
///<summary>
///对文件内容进行DES加密，加密后覆盖掉原来的文件
///</summary>
///<paramname="sourceFile">待加密的文件的绝对路径</param>
publicvoidEncryptFile(stringsourceFile)
{
EncryptFile(sourceFile,sourceFile);
}
///<summary>
///对文件内容进行DES解密
///</summary>
///<paramname="sourceFile">待解密的文件绝对路径</param>
///<paramname="destFile">解密后的文件保存的绝对路径</param>
publicvoidDecryptFile(stringsourceFile,stringdestFile)
{
if(!File.Exists(sourceFile))thrownewFileNotFoundException("指定的文件路径不存在！",sourceFile);
byte[]btKey=Encoding.Default.GetBytes(key);
byte[]btIV=Encoding.Default.GetBytes(iv);
DESCryptoServiceProviderdes=newDESCryptoServiceProvider();
byte[]btFile=File.ReadAllBytes(sourceFile);
using(FileStreamfs=newFileStream(destFile,FileMode.Create,FileAccess.Write))
{
try
{
using(CryptoStreamcs=newCryptoStream(fs,des.CreateDecryptor(btKey,btIV),CryptoStreamMode.Write))
{
cs.Write(btFile,0,btFile.Length);
cs.FlushFinalBlock();
}
}
catch
{
throw;
}
finally
{
fs.Close();
}
}
}
///<summary>
///对文件内容进行DES解密，加密后覆盖掉原来的文件
///</summary>
///<paramname="sourceFile">待解密的文件的绝对路径</param>
publicvoidDecryptFile(stringsourceFile)
{
DecryptFile(sourceFile,sourceFile);
}
}
}
H. 使用.net内置的DES进行加密
好了，明白了它的License种类，我们得看看它是如何验证合法的License的，换句话说就是它的License是如何构成的。它通过定位/bin目录下的License文件，License文件由类名(FreeTextBox)+ “.lic”构成。FreeTextBox.Lic文件内容分三个部分，第一部分为明文FreeTextBox License，也就是类名+ License”字符串，第二部分为[License种类的加密文本]，加密算法采用的.NET内置的DES，用于DES加密的密钥和偏移量均为{ 0x39, 0x48, 0x42, 50, 0x38, 0x31, 70, 0x36 }，当然它不是直接对文本加密的，做了一个小小的处理，这个处理就是加上原文本的长度，并预留5位，不够则补零,例如字符串DistributionLicense，那用于加密的就是00019DistributionLicense，因为字符串DistributionLicense的长度是19位，前面还有3个空位就补3个零。这样加密后的结果就是=，注意需要用[]分隔，FreeTextBox设计者出于方便使用正则匹配所以使用[]来分隔，第三部分就是你注册标识的加密文本，当然也有[]，处理方式跟第二部分的一样，例如我的域名为Ycweb.Net，我想以此作为标识来生成License，于是对字符串00009Ycweb.Net进行DES加密，结果为tyn3Gf1Y5GH2VphAJ2U++g==，所以综合这个三个部分的内容，就构成了一个完整的License文件内容，整理一下就是： FreeTextBox License [=] [tyn3Gf1Y5GH2VphAJ2U++g==] 这是Distribution的License，如果是Professional的License，内容就是： FreeTextBox License [tyn3Gf1Y5GH2VphAJ2U++g==] 补充： 我现在是要加密的方法，求一个函数，将原文：00019DistributionLicense，加密为密文：=]，不知所谓，连内容都不看就回答了 补充： 又多一个不看内容的，文章里面不是说了吗：
I. 对称加密算法之DES介绍
DES (Data Encryption Standard)是分组对称密码算法。
DES算法利用 多次组合替代算法 和 换位算法 ，分散和错乱的相互作用，把明文编制成密码强度很高的密文，它的加密和解密用的是同一算法。
DES算法，是一种 乘积密码 ，其在算法结构上主要采用了 置换 、 代替 、 模二相加 等函数，通过 轮函数 迭代的方式来进行计算和工作。
DES算法也会使用到数据置换技术，主要有初始置换 IP 和逆初始置换 IP^-1 两种类型。DES算法使用置换运算的目的是将原始明文的所有格式及所有数据全部打乱重排。而在轮加密函数中，即将数据全部打乱重排，同时在数据格式方面，将原有的32位数据格式，扩展成为48位数据格式，目的是为了满足S盒组对数据长度和数据格式规范的要求。
一组数据信息经过一系列的非线性变换以后，很难从中推导出其计算的过程和使用的非线性组合；但是如果这组数据信息使用的是线性变换，计算就容易的多。在DES算法中，属于非线性变换的计算过程只有S盒，其余的数据计算和变换都是属于线性变换，所以DES算法安全的关键在于S盒的安全强度。此外，S盒和置换IP相互配合，形成了很强的抗差分攻击和抗线性攻击能力，其中抗差分攻击能力更强一些。
DES算法是一种分组加密机制，将明文分成N个组，然后对各个组进行加密，形成各自的密文，最后把所有的分组密文进行合并，形成最终的密文。
DES加密是对每个分组进行加密，所以输入的参数为分组明文和密钥，明文分组需要置换和迭代，密钥也需要置换和循环移位。在初始置换IP中，根据一张8*8的置换表，将64位的明文打乱、打杂，从而提高加密的强度；再经过16次的迭代运算，在这些迭代运算中，要运用到子密钥；每组形成的初始密文，再次经过初始逆置换 IP^-1 ，它是初始置换的逆运算，最后得到分组的最终密文。
图2右半部分，给出了作用56比特密钥的过程。DES算法的加密密钥是64比特，但是由于密钥的第n*8(n=1,2…8)是校验(保证含有奇数个1)，因此实际参与加密的的密钥只有 56比特 。开始时，密钥经过一个置换，然后经过循环左移和另一个置换分别得到子密钥ki，供每一轮的迭代加密使用。每轮的置换函数都一样，但是由于密钥位的重复迭代使得子密钥互不相同。
DES算法 利用多次组合替代算法和换位算法，分散和错乱的相互作用，把明文编制成密码强度很高的密文，它的加密和解密用的是同一算法。
DES算法详述：DES对64位明文分组(密钥56bit)进行操作。
1、 初始置换函数IP：64位明文分组x经过一个初始置换函数IP，产生64位的输出x0，再将分组x0分成左半部分L0和右半部分R0：即将输入的第58位换到第一位，第50位换到第2位，…，依次类推，最后一位是原来的第7位。L0、R0则是换位输出后的两部分，L0是输出的左32位，R0是右32位。例，设置换前的输入值为D1D2D3…D64，则经过初始置换后的结果为：L0=D58D50…D8；R0=D57D49…D7.其置换规则如表1所示。
DES加密过程最后的逆置换 IP^-1 ，是表1的 逆过程 。就是把原来的每一位都恢复过去，即把第1位的数据，放回到第58位，把第2位的数据，放回到第50位。
2、 获取子密钥 Ki ：DES加密算法的密钥长度为56位，一般表示为64位(每个第8位用于奇偶校验)，将用户提供的64位初始密钥经过一系列的处理得到K1,K2,…,K16，分别作为 1~16 轮运算的 16个子密钥 。
(1). 将64位密钥去掉8个校验位，用密钥置换 PC-1 (表2)置换剩下的56位密钥；
(2). 将56位分成前28位C0和后28位D0，即 PC-1(K56)=C0D0 ;
(3). 根据轮数，这两部分分别循环左移1位或2位，表3：
(4). 移动后，将两部分合并成56位后通过压缩置换PC-2(表4)后得到48位子密钥，即Ki=PC-2(CiDi).
子密钥产生如图2所示：
3、 密码函数F(非线性的)
(1). 函数F的操作步骤：密码函数F 的输入是32比特数据和48比特的子密钥：
A．扩展置换(E):将数据的右半部分Ri从32位扩展为48位。位选择函数(也称E盒)，如表5所示：
B．异或：扩展后的48位输出E(Ri)与压缩后的48位密钥Ki作异或运算；
C．S盒替代：将异或得到的48位结果分成八个6位的块，每一块通过对应的一个S盒产生一个4位的输出。
(2)、D、P盒置换：将八个S盒的输出连在一起生成一个32位的输出，输出结果再通过置换P产生一个32位的输出即：F(Ri,Ki)，F(Ri,Ki)算法描述如图3，最后，将P盒置换的结果与最初的64位分组的左半部分异或，然后，左、右半部分交换，开始下一轮计算。
4、密文输出：经过16次迭代运算后，得到L16、R16，将此作为输入，进行逆置换，即得到密文输出。逆置换正好是初始置的逆运算。例如，第1位经过初始置换后，处于第40位，而通过逆置换，又将第40位换回到第1位，其逆置换规则如表8所示：
图4为DES算法加密原理图：
DES算法加密和解密过程采用相同的算法，并采用相同的加密密钥和解密密钥，两者的区别是：(1)、DES加密是从L0、R0到L15、R15进行变换，而解密时是从L15、R15到L0、R0进行变换的；(2)、加密时各轮的加密密钥为K0K1…K15，而解密时各轮的解密密钥为K15K14…K0；(3)、加密时密钥循环左移，解密时密钥循环右移。
DES加密过程分析：
(1)、首先要生成64位密钥，这64位的密钥经过“子密钥算法”换转后，将得到总共16个子密钥。将这些子密钥标识为Kn(n=1,2,…,16)。这些子密钥主要用于总共十六次的加密迭代过程中的加密工具。
(2)、其次要将明文信息按64位数据格式为一组，对所有明文信息进行分组处理。每一段的64位明文都要经过初试置换IP，置换的目的是将数据信息全部打乱重排。然后将打乱的数据分为左右两块，左边一块共32位为一组，标识为L0；右边一块也是32位为一组，标识为R0.
(3)、置换后的数据块总共要进行总共十六次的加密迭代过程。加密迭代主要由加密函数f来实现。首先使用子密钥K1对右边32位的R0进行加密处理，得到的结果也是32位的；然后再将这个32位的结果数据与左边32位的L0进行模2处理，从而再次得到一个32位的数据组。我们将最终得到的这个32位组数据，作为第二次加密迭代的L1，往后的每一次迭代过程都与上述过程相同。
(4)、在结束了最后一轮加密迭代之后，会产生一个64位的数据信息组，然后我们将这个64位数据信息组按原有的数据排列顺序平均分为左右两等分，然后将左右两等分的部分进行位置调换，即原来左等分的数据整体位移至右侧，而原来右等分的数据则整体位移至左侧，这样经过合并后的数据将再次经过逆初始置换IP^-1的计算，我们最终将得到一组64位的密文。
DES解密过程分析：DES的解密过程与它的加密过程是一样的，这是由于DES算法本身属于对称密码体制算法，其加密和解密的过程可以共用同一个过程和运算。
DES加密函数f：在DES算法中，要将64位的明文顺利加密输出成64位的密文，而完成这项任务的核心部分就是加密函数f。加密函数f的主要作用是在第m次的加密迭代中使用子密钥Km对Km-1进行加密操作。加密函数f在加密过程中总共需要运行16轮。
十六轮迭代算法：它先将经过置换后的明文分成两组，每组32位；同时密钥也被分成了两组，每组28位，两组密钥经过运算，再联合成一个48位的密钥，参与到明文加密的运算当中。S盒子，它由8个4*16的矩阵构成，每一行放着0到15的数据，顺序各个不同，是由IBM公司设计好的。经过异或运算的明文，是一个48位的数据，在送入到S盒子的时候，被分成了8份，每份6位，每一份经过一个S盒子，经过运算后输出为4位，即是一个0到15的数字的二进制表示形式。具体运算过程为，将输入的6位中的第1位为第6位合并成一个二进制数，表示行号，其余4位也合并成一个二进制数，表示列号。在当前S盒子中，以这个行号和列号为准，取出相应的数，并以二进制的形式表示，输出，即得到4位的输出，8个S盒子共计32位。
DES算法优缺点：
(1)、产生密钥简单，但密钥必须高度保密，因而难以做到一次一密；
(2)、DES的安全性依赖于密钥的保密。攻击破解DES算法的一个主要方法是通过密钥搜索，使用运算速度非常高的计算机通过排列组合枚举的方式不断尝试各种可能的密钥，直到破解为止。一般，DES算法使用56位长的密钥，通过简单计算可知所有可能的密钥数量最多是2^56个。随着巨型计算机运算速度的不断提高，DES算法的安全性也将随之下降，然而在一般的民用商业场合，DES的安全性仍是足够可信赖的。
(3)、DES算法加密解密速度比较快，密钥比较短，加密效率很高但通信双方都要保持密钥的秘密性，为了安全还需要经常更换DES密钥。
参考链接 ： https://blog.csdn.net/fengbingchun/article/details/42273257
J. 如何用php实现和c#一致的DES加密解密
PHP实现和c#一致的DES加密解密，可以从网上搜到一大堆，但是测试后发现都没法用。以下正确代码是我经过苦苦才找到的。希望大家在系统整合时能用的上。
注意：key的长度为8位以内。
[csharp]viewplainprint?
//C#版DES加解密算法
usingSystem;
usingSystem.Data;
usingSystem.Configuration;
usingSystem.Web;
usingSystem.Web.Security;
usingSystem.Web.UI;
usingSystem.Web.UI.WebControls;
usingSystem.Web.UI.WebControls.WebParts;
usingSystem.Web.UI.HtmlControls;
usingSystem.Data.SqlClient;
usingSystem.Security.Cryptography;
usingSystem.IO;
usingSystem.Text;
publicclassDes{
//加解密密钥
privatestaticstringskey="12345678";
//初始化向量
privatestaticbyte[]DESIV={0x12,0x34,0x56,0x78,0x90,0xAB,0xCD,0xEF};
#regionDESEnCodeDES加密
publicstaticstringDESEnCode(stringpToEncrypt,stringsKey)
{
pToEncrypt=HttpContext.Current.Server.UrlEncode(pToEncrypt);
DESCryptoServiceProviderdes=newDESCryptoServiceProvider();
byte[]inputByteArray=Encoding.GetEncoding("UTF-8").GetBytes(pToEncrypt);
//建立加密对象的密钥和偏移量
//原文使用ASCIIEncoding.ASCII方法的GetBytes方法
//使得输入密码必须输入英文文本
des.Key=ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV=ASCIIEncoding.ASCII.GetBytes(sKey);
MemoryStreamms=newMemoryStream();
CryptoStreamcs=newCryptoStream(ms,des.CreateEncryptor(),CryptoStreamMode.Write);
cs.Write(inputByteArray,0,inputByteArray.Length);
cs.FlushFinalBlock();
StringBuilderret=newStringBuilder();
foreach(bytebinms.ToArray())
{
ret.AppendFormat("{0:X2}",b);
}
ret.ToString();
returnret.ToString();
}
#endregion
///<summary>
///
///</summary>
///<paramname="pToDecrypt">待解密的字符串</param>
///<paramname="sKey">解密密钥,要求为8字节,和加密密钥相同</param>
///<returns>解密成功返回解密后的字符串，失败返源串</returns>
#regionDESDeCodeDES解密
publicstaticstringDESDeCode(stringpToDecrypt,stringsKey)
{
//HttpContext.Current.Response.Write(pToDecrypt+"<br>"+sKey);
//HttpContext.Current.Response.End();
DESCryptoServiceProviderdes=newDESCryptoServiceProvider();
byte[]inputByteArray=newbyte[pToDecrypt.Length/2];
for(intx=0;x<pToDecrypt.Length/2;x++)
{
inti=(Convert.ToInt32(pToDecrypt.Substring(x*2,2),16));
inputByteArray[x]=(byte)i;
}
des.Key=ASCIIEncoding.ASCII.GetBytes(sKey);
des.IV=ASCIIEncoding.ASCII.GetBytes(sKey);
MemoryStreamms=newMemoryStream();
CryptoStreamcs=newCryptoStream(ms,des.CreateDecryptor(),CryptoStreamMode.Write);
cs.Write(inputByteArray,0,inputByteArray.Length);
cs.FlushFinalBlock();
StringBuilderret=newStringBuilder();
returnHttpContext.Current.Server.UrlDecode(System.Text.Encoding.Default.GetString(ms.ToArray()));
}
#endregion
}
[php]viewplainprint?
<?php
classDES
{
var$key;
var$iv;//偏移量
functionDES($key,$iv=0){
//key长度8例如:1234abcd
$this->key=$key;
if($iv==0){
$this->iv=$key;//默认以$key作为iv
}else{
$this->iv=$iv;//mcrypt_create_iv(mcrypt_get_block_size(MCRYPT_DES,MCRYPT_MODE_CBC),MCRYPT_DEV_RANDOM);
}
}
functionencrypt($str){
//加密，返回大写十六进制字符串
$size=mcrypt_get_block_size(MCRYPT_DES,MCRYPT_MODE_CBC);
$str=$this->pkcs5Pad($str,$size);
returnstrtoupper(bin2hex(mcrypt_cbc(MCRYPT_DES,$this->key,$str,MCRYPT_ENCRYPT,$this->iv)));
}
functiondecrypt($str){
//解密
$strBin=$this->hex2bin(strtolower($str));
$str=mcrypt_cbc(MCRYPT_DES,$this->key,$strBin,MCRYPT_DECRYPT,$this->iv);
$str=$this->pkcs5Unpad($str);
return$str;
}
functionhex2bin($hexData){
$binData="";
for($i=0;$i<strlen($hexData);$i+=2){
$binData.=chr(hexdec(substr($hexData,$i,2)));
}
return$binData;
}
functionpkcs5Pad($text,$blocksize){
$pad=$blocksize-(strlen($text)%$blocksize);
return$text.str_repeat(chr($pad),$pad);
}
functionpkcs5Unpad($text){
$pad=ord($text{strlen($text)-1});
if($pad>strlen($text))
returnfalse;
if(strspn($text,chr($pad),strlen($text)-$pad)!=$pad)
returnfalse;
returnsubstr($text,0,-1*$pad);
}
}
?>