多语言DES加密解密

1. JAVA（其中key为密钥）

import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.security.spec.InvalidKeySpecException;

import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.DESKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;


public class SecretUtilTools {
    
    public static String encryptForDES(String souce, String key) throws InvalidKeyException,
            NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException,
            IllegalBlockSizeException, BadPaddingException, UnsupportedEncodingException {
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 从原始密匙数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key.getBytes("UTF-8"));
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成 一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key1 = keyFactory.generateSecret(dks);
        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.ENCRYPT_MODE, key1, sr);
        // 现在，获取数据并加密
        byte encryptedData[] = cipher.doFinal(souce.getBytes("UTF-8"));
        // 通过BASE64位编码成字符创形式
        String base64Str = new BASE64Encoder().encode(encryptedData);

        return base64Str;
    }

    
    public static String decryptForDES(String souce, String key) throws InvalidKeyException,
            NoSuchAlgorithmException, InvalidKeySpecException, NoSuchPaddingException, IOException,
            IllegalBlockSizeException, BadPaddingException {
        // DES算法要求有一个可信任的随机数源
        SecureRandom sr = new SecureRandom();
        // 从原始密匙数据创建DESKeySpec对象
        DESKeySpec dks = new DESKeySpec(key.getBytes());
        // 创建一个密匙工厂，然后用它把DESKeySpec转换成 一个SecretKey对象
        SecretKeyFactory keyFactory = SecretKeyFactory.getInstance("DES");
        SecretKey key1 = keyFactory.generateSecret(dks);
        // Cipher对象实际完成加密操作
        Cipher cipher = Cipher.getInstance("DES");
        // 用密匙初始化Cipher对象
        cipher.init(Cipher.DECRYPT_MODE, key1, sr);
        // 将加密报文用BASE64算法转化为字节数组
        byte[] encryptedData = new BASE64Decoder().decodeBuffer(souce);
        // 用DES算法解密报文
        byte decryptedData[] = cipher.doFinal(encryptedData);
        return new String(decryptedData,"UTF-8");
    }

}

2. PHP（其中$key为密钥）

class SecretUtilTools  
{     
    //加密算法       
    function encryptForDES($input,$key)   
    {         
       $size = mcrypt_get_block_size('des','ecb');  
       $input = $this->pkcs5_pad($input, $size);  
       $td = mcrypt_module_open('des', '', 'ecb', '');  
       $iv = @mcrypt_create_iv (mcrypt_enc_get_iv_size($td), MCRYPT_RAND);  
       @mcrypt_generic_init($td, $key, $iv);  
       $data = mcrypt_generic($td, $input);  
       mcrypt_generic_deinit($td);  
       mcrypt_module_close($td);  
       $data = base64_encode($data);  
       return $data;  
    }   
    //解密算法      
    function decryptForDES($encrypted,$key)  
    {         
       $encrypted = base64_decode($encrypted);  
       $td = mcrypt_module_open('des','','ecb','');   
       //使用MCRYPT_DES算法,cbc模式  
       $iv = @mcrypt_create_iv(mcrypt_enc_get_iv_size($td), MCRYPT_RAND);  
       $ks = mcrypt_enc_get_key_size($td);  
       @mcrypt_generic_init($td, $key, $iv);  
       //初始处理                 
       $decrypted = mdecrypt_generic($td, $encrypted);  
       //解密  
       mcrypt_generic_deinit($td);  
       //结束               
       mcrypt_module_close($td);  
       $y=$this->pkcs5_unpad($decrypted);  
       return $y;     
    }
             
    function pkcs5_pad ($text, $blocksize)   
    {         
       $pad = $blocksize - (strlen($text) % $blocksize);  
       return $text . str_repeat(chr($pad), $pad);  
    } 
        
    function pkcs5_unpad($text)   
    {         
       $pad = ord($text{strlen($text)-1});  
       if ($pad > strlen($text))  
       {  
           return false;  
       }  
       if (strspn($text, chr($pad), strlen($text) - $pad) != $pad)  
       {  
          return false;  
       }  
       return substr($text, 0, -1 * $pad);  
    }  
}

3. C#（其中key为密钥）

using System;  
using System.IO;  
using System.Text;  
using System.Globalization;  
using System.Collections.Generic;  
using System.Security.Cryptography;  
using System.Diagnostics;  
   
namespace ConsoleAPI  
{  
    class Program  
    {  
        static void Main(string[] args)  
        {  
            //密钥  
            string key = "12345678";  
   
            //待加密字符串  
            string s1 = "{"name":"fda","fdsag":"gdasdg"}";  
   
            //加密  
            string s2 = DesEncrypt(s1, key);  
   
            //解密  
            string s3 = DesDecrypt("g6AtgJul6q0=", key);  
   
            //加密、解密输出  
            Debug.WriteLine("加密前:" + s1);  
            Debug.WriteLine("加密后:" + s2);  
            Debug.WriteLine("解密后：" + s3);  
        }  
   
        ///   
        /// 加密字符串  
        ///   
        /// 明文  
        /// 密钥  
        ///   
        static string DesEncrypt(string strText, string encryptKey)  
        {  
            string outString = "";  
            byte[] byKey = null;  
            byte[] IV = Encoding.Default.GetBytes(encryptKey);  
            try  
            {  
                byKey = Encoding.UTF8.GetBytes(encryptKey.Substring(0, encryptKey.Length));  
                DESCryptoServiceProvider des = new DESCryptoServiceProvider();  
                des.Mode = CipherMode.ECB;  
                byte[] inputByteArray = Encoding.UTF8.GetBytes(strText);  
                MemoryStream ms = new MemoryStream();  
                CryptoStream cs = new CryptoStream(ms, des.CreateEncryptor(byKey, IV), CryptoStreamMode.Write);  
                cs.Write(inputByteArray, 0, inputByteArray.Length);  
                cs.FlushFinalBlock();  
                outString = Convert.ToBase64String(ms.ToArray());  
            }  
            catch (System.Exception)  
            {  
                outString = "";  
            }  
            return outString;  
        }  
   
        ///   
        /// 解密字符串  
        ///   
        /// 密文  
        /// 密钥  
        ///   
        static string DesDecrypt(string strText, string decryptKey)  
        {  
            string outString = "";  
            byte[] byKey = null;  
            byte[] IV = Encoding.Default.GetBytes(decryptKey);  
            byte[] inputByteArray = new Byte[strText.Length];  
            try  
            {  
                byKey = System.Text.Encoding.UTF8.GetBytes(decryptKey.Substring(0, decryptKey.Length));  
                DESCryptoServiceProvider des = new DESCryptoServiceProvider();  
                des.Mode = CipherMode.ECB;  
                inputByteArray = Convert.FromBase64String(strText);  
                MemoryStream ms = new MemoryStream();  
                CryptoStream cs = new CryptoStream(ms, des.CreateDecryptor(byKey, IV), CryptoStreamMode.Write);  
                cs.Write(inputByteArray, 0, inputByteArray.Length);  
                cs.FlushFinalBlock();  
                System.Text.Encoding encoding = new System.Text.UTF8Encoding();  
                outString = encoding.GetString(ms.ToArray());  
            }  
            catch (System.Exception)  
            {  
                outString = "";  
            }  
            return outString;  
        }  
    }  
}