*
 * Project xxxx
 * Package com.xxxx.utils
 *
 */
package com.xxxxx.utils;

import java.io.FileInputStream;
import java.io.ObjectInputStream;
import java.security.NoSuchAlgorithmException;
import java.security.Security;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

public class DES {
 private String Algorithm = "DESede"; //"DESede" for Triple DES
 private KeyGenerator keygen;
 private SecretKey deskey;
 private Cipher c;
 private byte[] cipherByte;

 public DES() {
  init();
 }
 public DES(String filename) {
  init(filename);
 }
 public SecretKey genKey() {
  try {
    keygen = KeyGenerator.getInstance(Algorithm);
   deskey = keygen.generateKey();   //利用JavaBean的持久化将key保存为文件XXX.key
  } catch (NoSuchAlgorithmException ex) {
   ex.printStackTrace();
  } catch (Exception ex) {
   ex.printStackTrace();
  }

  return deskey;
 }
 /**
  * 
  * @param filename
  */
 public void init(String filename) {
  //  restore key
  Security.addProvider(new com.sun.crypto.provider.SunJCE());
  try {
   FileInputStream fis = new FileInputStream(filename);
   fis = new FileInputStream(filename);
   ObjectInputStream ois = new ObjectInputStream(fis);
   deskey = (SecretKey) ois.readObject();
   ois.close();
   fis.close();
   c = Cipher.getInstance(Algorithm);
  } catch (NoSuchAlgorithmException ex) {
   ex.printStackTrace();
  } catch (NoSuchPaddingException ex) {
   ex.printStackTrace();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
 }
 public void init() {
  Security.addProvider(new com.sun.crypto.provider.SunJCE());
  try {
   keygen = KeyGenerator.getInstance(Algorithm);
   deskey = keygen.generateKey();

   c = Cipher.getInstance(Algorithm);
  } catch (NoSuchAlgorithmException ex) {
   ex.printStackTrace();
  } catch (NoSuchPaddingException ex) {
   ex.printStackTrace();
  }
 }

 public byte[] encryptor(String str) {
  try {
   c.init(Cipher.ENCRYPT_MODE, deskey);
   cipherByte = c.doFinal(str.getBytes());
  } catch (java.security.InvalidKeyException ex) {
   ex.printStackTrace();
  } catch (javax.crypto.BadPaddingException ex) {
   ex.printStackTrace();
  } catch (javax.crypto.IllegalBlockSizeException ex) {
   ex.printStackTrace();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return cipherByte;
 }

 public String decryptor(byte[] buff) {
  try {
   c.init(Cipher.DECRYPT_MODE, deskey);
   cipherByte = c.doFinal(buff);
  } catch (java.security.InvalidKeyException ex) {
   ex.printStackTrace();
  } catch (javax.crypto.BadPaddingException ex) {
   ex.printStackTrace();
  } catch (javax.crypto.IllegalBlockSizeException ex) {
   ex.printStackTrace();
  } catch (Exception ex) {
   ex.printStackTrace();
  }
  return (new String(cipherByte));
 }
}

/*
 * Project xxxx
 * Package com.xxxx.utils
 * Created on 2003-11-24
 * Author Derys
 *
 */
package com.xxxx.utils;

/**
 * 
 *
 */
public class XXXDES {
 private static XXXDES instance = new XXXDES();
 public XXXDES() {

 }
 /**
  * 
  * @param str
  * @return
  */
 public String encrypt(String str) {
  StringBuffer buffer = new StringBuffer();
  DES des = new DES("XXX.key");

  byte[] en = des.encryptor(str);

  for (int i = 0; i < en.length; i++) {
   buffer.append((char) en[i]);
  }
  return buffer.toString();
 }
 /**
  * 
  * @param str
  * @return
  */
 public String decrypt(String str) {
  DES des = new DES("XXX.key");
  byte[] en = new byte[str.length()];
  for (int i = 0; i < str.length(); i++) {
   en[i] = (byte) str.charAt(i);
  }

  String de = des.decryptor(en);
  return de;
 }
 /**
  * 
  * @param str
  * @return
  */
 public String replaceChar(String str) {
   StringBuffer buffer = new StringBuffer();

   int index = str.indexOf("'");
   if (index == -1) {
    return str;
   }
   while (index > -1) {
    buffer.append(str.substring(0, index));
    buffer.append("''");
    str = str.substring(index + 1);
    index = str.indexOf("'");
   }
   buffer.append(str);
   return buffer.toString();
  }
 /**
  * 
  * @return
  */
 public static XXXDES getInstance(){
  if(instance == null){
   instance = new XXXDES();
  }
  return instance;
 }
}
使用:
encryptedTextXXXDES.getInstance().encrypt("your plain text");
plainText=XXXDES.getInstance().decrypt("your encrypted text"); 欢迎访问米鼠网:<a href='http://fac.misuland.com'>http://fac.misuland.com</a>



 using System;
    using System.Collections.Generic;
    using System.Text;
    using System.IO;
    using System.Security.Cryptography; 中国网管联盟www、bitsCN、com 

    namespace ConsoleApplication1
    {
        class Program
        {
            public static string Encrypt3DES(string a_strString, string a_strKey)
            {
                TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider(); 

中国网管联盟www_bitscn_com

                DES.Key = ASCIIEncoding.ASCII.GetBytes(a_strKey);
                DES.Mode = CipherMode.ECB; 

网管网bitsCN.com

                ICryptoTransform DESEncrypt = DES.CreateEncryptor(); 中国网管联盟www_bitscn_com 

                byte[] Buffer = ASCIIEncoding.ASCII.GetBytes(a_strString);
                return Convert.ToBase64String(DESEncrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
            } 网管网bitsCN_com 

            public static string Decrypt3DES(string a_strString, string a_strKey)
            {
                TripleDESCryptoServiceProvider DES = new TripleDESCryptoServiceProvider(); 

网管网bitsCN_com

                DES.Key = ASCIIEncoding.ASCII.GetBytes(a_strKey);
                DES.Mode = CipherMode.ECB;
                DES.Padding = System.Security.Cryptography.PaddingMode.PKCS7; 

中国网管联盟www、bitsCN、com

                ICryptoTransform DESDecrypt = DES.CreateDecryptor(); 54com.cn 

                string result = "";
                try
                {
                    byte[] Buffer = Convert.FromBase64String(a_strString);
                    result = ASCIIEncoding.ASCII.GetString(DESDecrypt.TransformFinalBlock(Buffer, 0, Buffer.Length));
                }
                catch (Exception e)
                { 

网管网bitsCN.com


                }
                return result;
            } 

网管网bitsCN.com

            static void Main(string[] args)
            {
                Console.WriteLine(Encrypt3DES("999999999", "#s^un2ye31<cn%|aoXpR,+vh");
                Console.ReadLine();
            }
        }
    }


中国网管论坛bbs.bitsCN.com


public class TRIP3DES

    {

        //密钥

        private string sKey = "qJzGEh6hESZDVJeCnFPGuxzaiB7NLQM3"; 

        //矢量，矢量可以为空

        private string sIV = "qcDY6X+aPLw=";

        //构造一个对称算法

        private SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();

 

        public TRIP3DES(string _sKey,string _sIV)
        {
            sKey=_sKey;
            sIV=_sIV;
        }

 

        #region public string EncryptString(string Value)

        /// 

        /// 加密字符串

        /// 

        /// 输入的字符串

        /// 加密后的字符串

        public string EncryptString(string Value)

        {

            ICryptoTransform ct;

            MemoryStream ms;

            CryptoStream cs;

            byte[] byt;

            mCSP.Key = Convert.FromBase64String(sKey);

            mCSP.IV = Convert.FromBase64String(sIV);

            //指定加密的运算模式

            mCSP.Mode = System.Security.Cryptography.CipherMode.ECB;

            //获取或设置加密算法的填充模式

            mCSP.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

            ct = mCSP.CreateEncryptor(mCSP.Key, mCSP.IV);

            byt = Encoding.UTF8.GetBytes(Value);

            ms = new MemoryStream();

            cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);

            cs.Write(byt, 0, byt.Length);

            cs.FlushFinalBlock();

            cs.Close();

            //return Convert.ToBase64String(ms.ToArray());
            //return Convert.ToChar(ms.ToArray()).ToString();

            string strResult="";
            byte[] b=ms.ToArray();
            for(int i=0;i<b.Length;i++)
            {
                strResult += b[i].ToString("x").PadLeft(2,'0');
            }
            return strResult;
        }

        #endregion

 

        #region public string DecryptString(string Value)

        /// 

        /// 解密字符串

        /// 

        /// 加过密的字符串

        /// 解密后的字符串

        public string DecryptString(string Value)

        {

            ICryptoTransform ct;

            MemoryStream ms;

            CryptoStream cs;

            byte[] byt;

            mCSP.Key = Convert.FromBase64String(sKey);

            mCSP.IV = Convert.FromBase64String(sIV);

            mCSP.Mode = System.Security.Cryptography.CipherMode.ECB;

            mCSP.Padding = System.Security.Cryptography.PaddingMode.PKCS7;

            ct = mCSP.CreateDecryptor(mCSP.Key, mCSP.IV);

            //byt = Convert.FromBase64String(Value);

            byt=new byte[Value.Length/2];
            int bi=0;
            for (int i=0;i<Value.Length;i+=2)
            {
                byt[bi]= (byte)Int32.Parse(Value.Substring(i,2),System.Globalization.NumberStyles.HexNumber);
                bi++;
            }

            ms = new MemoryStream();

            cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);

            cs.Write(byt, 0, byt.Length);

            cs.FlushFinalBlock();

            cs.Close();

 

            return Encoding.UTF8.GetString(ms.ToArray());

        }

        #endregion

    }

******************************************************************************************************************************8
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;

using System.Security.Cryptography;
using System.IO;
using System.Text;


public partial class Default3 : System.Web.UI.Page
{
    //密钥
    private const string sKey = "5tpMC2dovLDHzt/pRr/TOGSJPXANLG51";

    protected void Page_Load(object sender, EventArgs e)
    {
        //Response.Write(EncryptString("aabbcc"));
        //Response.Write("<BR>");
        //Response.Write(DecryptString(EncryptString("aabbcc")));


        //string transDesKey = "L/Lcp55e4H8OMelF1nw9yMhhpFvymI9b";
        //Encrypt3DES test = new Encrypt3DES(transDesKey);
        //Response.Write(EncryptString("aabbcc"));
        //test.EncryptString("aabbcc");
    }
    
    /// <summary>
    /// 加密
    /// </summary>
    /// <param name="encryptValue"></param>
    /// <returns></returns>
    private string EncryptString(string encryptValue)
    {
        TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
        des.Key = Convert.FromBase64String(sKey);
        des.Mode = CipherMode.ECB;

        byte[] valBytes = Encoding.Unicode.GetBytes(encryptValue);
        ICryptoTransform transform = des.CreateEncryptor();

        MemoryStream ms = new MemoryStream();
        CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write);
        cs.Write(valBytes, 0, valBytes.Length);
        cs.FlushFinalBlock();
        byte[] returnBytes = ms.ToArray();
        cs.Close();

        return Convert.ToBase64String(returnBytes);
    }

    /// <summary>
    /// 解密
    /// </summary>
    /// <param name="encryptedValue"></param>
    /// <returns></returns>
    private string DecryptString(string encryptedValue)
    {
        TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
        des.Key = Convert.FromBase64String(sKey);
        des.Mode = CipherMode.ECB;

        byte[] valBytes = Convert.FromBase64String(encryptedValue);
        ICryptoTransform transform = des.CreateDecryptor();

        MemoryStream ms = new MemoryStream();
        CryptoStream cs = new CryptoStream(ms, transform, CryptoStreamMode.Write);
        cs.Write(valBytes, 0, valBytes.Length);
        cs.FlushFinalBlock();
        byte[] returnBytes = ms.ToArray();
        cs.Close();

        return Encoding.Unicode.GetString(returnBytes);
    }

    //private string ByteToHex(byte[] byteArray)
    //{
    //    string outString = "";
    //    foreach (Byte b in byteArray)
    //        outString += b.ToString("X2");
    //    return outString;
    //}

    //private byte[] HexToByte(string hexString)
    //{
    //    byte[] returnBytes = new byte[hexString.Length / 2];
    //    for (int i = 0; i < returnBytes.Length; i++)
    //        returnBytes[i] = Convert.ToByte(hexString.Substring(i * 2, 2), 16);
    //    return returnBytes;
    //}

}
************************************************************************************************************************
using System;
using System.IO;
using System.Data;
using System.Text;
using System.Security;
using System.Security.Cryptography;namespace My3des
{
 /// <summary>
 /// des3 的摘要说明。
 /// </summary>
 public class des3
 {
  
  public des3()
  {
   //
   // TODO: 在此处添加构造函数逻辑
   //
  }  /// <summary>
  /// 十六进制字符串转换为数据流
  /// </summary>
  /// <param name="strHexString"></param>
  /// <returns></returns>
  private static byte[] HexStringToByteArray1(string strHexString)
  {
   
   int len = strHexString.Length ;
   if ( (len % 2) !=0)
    throw new Exception("HexString 字符出错!!");   int byteLen = len /2 ;   byte[] bytes = new byte [byteLen];   for (int i=0;i<byteLen ;i++ )
   {
    bytes[i] = Convert.ToByte( strHexString.Substring( i*2,2),16);
   }   return bytes;
  }  private static byte[] HexStringToByteArray(string str)
  {
    
   int l = str.Length;
   int  bytelen =  l /2;
   //bytelen = 24;
   byte[] bytes = new byte[bytelen];
   int ii = bytes.Length;
   string buf = str.ToLower();
   
  
   for (int i = 0; i < buf.Length; i += 2)
   {
    
    char    left  = buf.ToCharArray()[i];
    char    right = buf.ToCharArray()[i+1];
    int     index = i / 2;
   
    if (left < 'a')
    {
     bytes[index] = (byte)((left - '0') << 4);
    }
    else
    {
     bytes[index] = (byte)((left - 'a' + 10) << 4);
    }
    if (right < 'a')
    {
     bytes[index] += (byte)(right - '0');
    }
    else
    {
     bytes[index] += (byte)(right - 'a' + 10);
    }
   }   return bytes; 
  }  /// <summary>
  /// 使用DES加密（Added by niehl 2005-4-6）
  /// </summary>
  /// <param name="originalValue">待加密的字符串</param>
  /// <param name="key">密钥</param>
  /// <param name="IV">初始化向量</param>
  /// <returns>加密后的字符串</returns>
  public string DESEncrypt(string originalValue,string key,string IV)
  {
   
   SymmetricAlgorithm sa;   
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;//   sa = new DESCryptoServiceProvider();
   sa = new TripleDESCryptoServiceProvider();//   sa.Key = Encoding.UTF8.GetBytes(key);
//   sa.IV = Encoding.UTF8.GetBytes(IV);   //sa.IV = Encoding.ASCII.GetBytes(IV);
   sa.Key = HexStringToByteArray(key);
   sa.IV = HexStringToByteArray(IV);
   
   ct = sa.CreateEncryptor();   byt = Encoding.UTF8.GetBytes(originalValue);   ms = new MemoryStream();
   cs = new CryptoStream(ms, ct,CryptoStreamMode.Write);
   cs.Write(byt, 0, byt.Length);
   cs.FlushFinalBlock();   cs.Close();   return Convert.ToBase64String(ms.ToArray());  }
  /// <summary>
  /// 使用DES解密（Added by niehl 2005-4-6）
  /// </summary>
  /// <param name="encryptedValue">待解密的字符串</param>
  /// <param name="key">密钥</param>
  /// <param name="IV">m初始化向量(最大长度8)</param>
  /// <returns>解密后的字符串</returns>
  public string DESDecrypt(string encryptedValue,string key,string IV)
  {   SymmetricAlgorithm sa;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;   //sa = new DESCryptoServiceProvider();
   sa = new TripleDESCryptoServiceProvider();//   sa.Key = Encoding.UTF8.GetBytes(key);
//   sa.IV = Encoding.UTF8.GetBytes(IV);
   sa.IV =HexStringToByteArray(IV);
   sa.Key = HexStringToByteArray(key);   ct = sa.CreateDecryptor();   byt = Convert.FromBase64String(encryptedValue);   ms = new MemoryStream();
   cs = new CryptoStream(ms, ct,
    CryptoStreamMode.Write);
   cs.Write(byt, 0, byt.Length);
   cs.FlushFinalBlock();   cs.Close();   return Encoding.UTF8.GetString(ms.ToArray());  }
  /// <summary>
  /// 使用DES加密（Added by niehl 2005-4-6）
  /// </summary>
  /// <param name="originalValue">待加密的字符串</param>
  /// <param name="key">密钥(最大长度8)</param>
  /// <param name="IV">初始化向量(最大长度8)</param>
  /// <returns>加密后的字符串</returns>
  public string DESEncrypt1(string originalValue,string key,string IV)
  {
   //将key和IV处理成8个字符
   key += "12345678";
   IV += "12345678";
   key = key.Substring(0,8);
   IV = IV.Substring(0,8);   SymmetricAlgorithm sa;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;   sa = new DESCryptoServiceProvider();   sa.Key = Encoding.UTF8.GetBytes(key);
   sa.IV = Encoding.UTF8.GetBytes(IV);
   ct = sa.CreateEncryptor();   byt = Encoding.UTF8.GetBytes(originalValue);   ms = new MemoryStream();
   cs = new CryptoStream(ms, ct,
    CryptoStreamMode.Write);
   cs.Write(byt, 0, byt.Length);
   cs.FlushFinalBlock();   cs.Close();   return Convert.ToBase64String(ms.ToArray());  }  public string DESEncrypt2(string originalValue,string key)
  {
   return DESEncrypt(originalValue,key,key);
  }  /// <summary>
  /// 使用DES解密（Added by niehl 2005-4-6）
  /// </summary>
  /// <param name="encryptedValue">待解密的字符串</param>
  /// <param name="key">密钥(最大长度8)</param>
  /// <param name="IV">m初始化向量(最大长度8)</param>
  /// <returns>解密后的字符串</returns>
  public string DESDecrypt1(string encryptedValue,string key,string IV)
  {
   //将key和IV处理成8个字符
   key += "12345678";
   IV += "12345678";
   key = key.Substring(0,8);
   IV = IV.Substring(0,8);   SymmetricAlgorithm sa;
   ICryptoTransform ct;
   MemoryStream ms;
   CryptoStream cs;
   byte[] byt;   sa = new DESCryptoServiceProvider();
   sa.Key = Encoding.UTF8.GetBytes(key);
   sa.IV = Encoding.UTF8.GetBytes(IV);
   
   ct = sa.CreateDecryptor();   byt = Convert.FromBase64String(encryptedValue);   ms = new MemoryStream();
   cs = new CryptoStream(ms, ct,
    CryptoStreamMode.Write);
   cs.Write(byt, 0, byt.Length);
   cs.FlushFinalBlock();   cs.Close();   return Encoding.UTF8.GetString(ms.ToArray());  }  public string DESDecrypt2(string encryptedValue,string key)
  {
   return DESDecrypt(encryptedValue,key,key);
  }//  private string GetStringValue(byte[] Byte)
//  {
//   string tmpString = "";
//
//   if (this.isReturnNum == false)
//   {
//    ASCIIEncoding Asc = new ASCIIEncoding();
//    tmpString = Asc.GetString(Byte);
//   }
//   else
//   {
//    int iCounter;
//
//    for
//     (iCounter=0;iCounter<Byte.Length;iCounter++)
//    {
//     tmpString = tmpString +
//      Byte[iCounter].ToString();
//    }
//    
//   }
//   
//   return tmpString;
//  }  private byte[] GetKeyByteArray(string strKey)
  {   ASCIIEncoding Asc = new ASCIIEncoding();
   
   int tmpStrLen = strKey.Length;
   byte[] tmpByte = new byte[tmpStrLen-1];   tmpByte = Asc.GetBytes(strKey);   return tmpByte;  } } 
}