3des 加密解密算

最新推荐文章于 2023-05-05 09:39:59 发布
原创 最新推荐文章于 2023-05-05 09:39:59 发布 · 673 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#加密 #解密 #string #byte #buffer #exception

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

 


namespace Common.nx
{
    /// <summary>
    /// tangwf 2011-04-08
    /// 宁夏单点登录加密解密算法
    /// 接口方法为：
    /// http://xxx.xxx.xxx/Logon?SPTokenRequest＝SPTokenRequestValue
    /// SPTokenRequestValue的生成算法如下：
    /// Digest = Base64(Hash(ReturnURL + “$”+ TimeStamp))
    /// 其中，Hash算法采用SHA-1。
    /// SPTokenRequestValue = URLEncoding(SPID + “$”+ Base64(Encrypt(ReturnURL + “$”+ TimeStamp + “$”+ Digest)))
    /// 其中，加密算法采用3DES，Key=SPSecret，SPSecret是宁夏WO门户颁发给该SP的密钥。
    /// </summary>
    public class SSOUtil
    {
        /// <summary>
        /// SPSecret是宁夏WO门户颁发给该SP的密钥
        /// </summary>
        //private string nxwoKeyx = "SPSecret";


        /// <summary>
        /// 宁夏3des加密算法
        /// </summary>
        /// <param name="strTobeEnCrypted"></param>
        /// <returns></returns>
        public static string Encrypt(string strTobeEnCrypted)
        {
            string sKey = "D5CDEA8ACEB315089BF7D504D9D0FDE3A77F7526C876526E";
            string sIV = "0102030405060708";

            string str = "";
            if (strTobeEnCrypted == "")
            {
                return "";
            }
            try
            {
                byte[] buffer3;
                byte[] kEY = HexStringToByteArray(sKey);
                byte[] iV = HexStringToByteArray(sIV);
                if (Encrypt(kEY, iV, ConvertStringToByteArray(strTobeEnCrypted), out buffer3))
                {
                    return ToBase64String(buffer3);
                }
                str = "";
            }
            catch
            {
            }
            return str;
        }

        /// <summary>
        /// 带密钥与向量参数的加密方法 输出byte数组形的加密值
        /// </summary>
        /// <param name="KEY"></param>
        /// <param name="IV"></param>
        /// <param name="TobeEncrypted"></param>
        /// <param name="Encrypted"></param>
        /// <returns></returns>
        private static bool Encrypt(byte[] KEY, byte[] IV, byte[] TobeEncrypted, out byte[] Encrypted)
        {
            TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
            Encrypted = null;
            try
            {
                byte[] rgbIV = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
                for (int i = 0; i < 8; i++)
                {
                    rgbIV[i] = IV[i];
                }
                byte[] rgbKey = new byte[] {
                    0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
                    0, 1, 2, 3, 4, 5, 6, 7
                 };
                for (int j = 0; j < 0x18; j++)
                {
                    rgbKey[j] = KEY[j];
                }
                Encrypted = des.CreateEncryptor(rgbKey, rgbIV).TransformFinalBlock(TobeEncrypted, 0, TobeEncrypted.Length);
                des.Clear();
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }


        /// <summary>
        /// 宁夏解密方法
        /// </summary>
        /// <param name="strTobeDeCrypted"></param>
        /// <returns></returns>
        public static string Decryp(string strTobeDeCrypted)
        {
            string sKey = "D5CDEA8ACEB315089BF7D504D9D0FDE3A77F7526C876526E";
            string sIV = "0102030405060708";
            string str = "";
            if (strTobeDeCrypted == "")
            {
                return "";
            }
            try
            {
                byte[] buffer3;
                byte[] kEY = HexStringToByteArray(sKey);
                byte[] iV = HexStringToByteArray(sIV);
                if (Decrypt(kEY, iV, FromBase64String(strTobeDeCrypted), out buffer3))
                {
                    return ConvertByteArrayToString(buffer3);
                }
                str = "";
            }
            catch
            {
            }
            return str;
        }
        /// <summary>
        /// 带向量与密钥的解密　
        /// </summary>
        /// <param name="KEY"></param>
        /// <param name="IV"></param>
        /// <param name="TobeDecrypted"></param>
        /// <param name="Decrypted"></param>
        /// <returns></returns>
        private static bool Decrypt(byte[] KEY, byte[] IV, byte[] TobeDecrypted, out byte[] Decrypted)
        {
            TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
            Decrypted = null;
            try
            {
                byte[] rgbIV = new byte[] { 0, 1, 2, 3, 4, 5, 6, 7 };
                for (int i = 0; i < 8; i++)
                {
                    rgbIV[i] = IV[i];
                }
                byte[] rgbKey = new byte[] {
                    0, 1, 2, 3, 4, 5, 6, 7, 0, 1, 2, 3, 4, 5, 6, 7,
                    0, 1, 2, 3, 4, 5, 6, 7
                 };
                for (int j = 0; j < 0x18; j++)
                {
                    rgbKey[j] = KEY[j];
                }
                Decrypted = des.CreateDecryptor(rgbKey, rgbIV).TransformFinalBlock(TobeDecrypted, 0, TobeDecrypted.Length);
                des.Clear();
            }
            catch (Exception)
            {
                return false;
            }
            return true;
        }


        /// <summary>
        /// byte数组到字符串
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static string ConvertByteArrayToString(byte[] buf)
        {
            return Encoding.GetEncoding("utf-8").GetString(buf);
        }

        /// <summary>
        /// 64位字符串到byte数组
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private static byte[] FromBase64String(string s)
        {
            return Convert.FromBase64String(s);
        }
        /// <summary>
        /// 16进制字符串转byte
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private static byte[] HexStringToByteArray(string s)
        {
            byte[] buffer = new byte[s.Length / 2];
            for (int i = 0; i < buffer.Length; i++)
            {
                buffer[i] = (byte)((chr2hex(s.Substring(i * 2, 1)) * 0x10) + chr2hex(s.Substring((i * 2) + 1, 1)));
            }
            return buffer;
        }

        /// <summary>
        /// 16进制到byte转换
        /// </summary>
        /// <param name="chr"></param>
        /// <returns></returns>
        private static byte chr2hex(string chr)
        {
            switch (chr)
            {
                case "0":
                    return 0;

                case "1":
                    return 1;

                case "2":
                    return 2;

                case "3":
                    return 3;

                case "4":
                    return 4;

                case "5":
                    return 5;

                case "6":
                    return 6;

                case "7":
                    return 7;

                case "8":
                    return 8;

                case "9":
                    return 9;

                case "A":
                    return 10;

                case "B":
                    return 11;

                case "C":
                    return 12;

                case "D":
                    return 13;

                case "E":
                    return 14;

                case "F":
                    return 15;
            }
            return 0;
        }
       
        /// <summary>
        /// 字符串到byte数组
        /// </summary>
        /// <param name="s"></param>
        /// <returns></returns>
        private static byte[] ConvertStringToByteArray(string s)
        {
            return Encoding.GetEncoding("utf-8").GetBytes(s);
        }
        /// <summary>
        /// byte数组到base64字符串
        /// </summary>
        /// <param name="buf"></param>
        /// <returns></returns>
        private static string ToBase64String(byte[] buf)
        {
            return Convert.ToBase64String(buf);
        }


        /// <summary>
        /// 32位加密　
        /// </summary>
        /// <param name="source"></param>
        /// <returns></returns>
        public static string EncryptDes(string source)
        {
            ICryptoTransform ct;
            MemoryStream ms;
            CryptoStream cs;
            byte[] byt;
            string str = null;

            SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();
            string sKey = "qJzGEh6hESZDVJeCnFPGuxzaiB7NLQM3";
            string sIV = "qcDY6X+aPLw=";
            //string sIV = Base64StringToString("0102030405060708");
            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(source);
            ms = new MemoryStream();
            cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
            cs.Write(byt, 0, byt.Length);
            cs.FlushFinalBlock();
            cs.Close();
            str = Convert.ToBase64String(ms.ToArray());

            return str;

        }


        public static string DecryptDes(string source)
        {
            ICryptoTransform ct;
            MemoryStream ms;
            CryptoStream cs;
            byte[] byt;
            string str = null;

            SymmetricAlgorithm mCSP = new TripleDESCryptoServiceProvider();
            int i = mCSP.BlockSize;
            int blocksize = i;
            string sKey = "qJzGEh6hESZDVJeCnFPGuxzaiB7NLQM3";
            string sIV = "qcDY6X+aPLw="; //IV的字节数必须等于SymmetricAlgorithm.BlockSize/8
            //string sIV = Base64StringToString("0102030405060708");

            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(source);
            ms = new MemoryStream();
            cs = new CryptoStream(ms, ct, CryptoStreamMode.Write);
            cs.Write(byt, 0, byt.Length);
            cs.FlushFinalBlock();
            cs.Close();
            str = Encoding.UTF8.GetString(ms.ToArray());
            return str;

        }


        /// <summary>
        /// tangwf 2011-04-11 des3加密算法
        /// </summary>
        /// <param name="desText">加密串</param>
        /// <param name="desKey">key</param>
        /// <returns></returns>
        public static string DES3Encrypt(string desText, string desKey)
        {
            string strRtnValue = "";
            try
            {
                TripleDES threedes = new TripleDESCryptoServiceProvider();

                //默认的TripleDESCryptoServiceProvider的key为24字节，IV为8字节，加密数据块为8字节
                threedes.Key = StringToByte(desKey, 24); // convert to 24 characters - 192 bits
                //threedes.Key = StringToByteForHex(desKey);
                //threedes.Key = StringToByte(desKey, 48);
                //初始向量
                threedes.IV = StringToByte("12345678");
                //threedes.IV = StringToByteForHex("0102030405060708");
                //threedes.IV = StringToByte("0102030405060708");
                byte[] key = threedes.Key;
                byte[] IV = threedes.IV;

                ICryptoTransform encryptor = threedes.CreateEncryptor(key, IV);

                MemoryStream msEncrypt = new MemoryStream();
                CryptoStream csEncrypt = new CryptoStream(msEncrypt, encryptor, CryptoStreamMode.Write);

                // Write all data to the crypto stream and flush it.
                csEncrypt.Write(StringToByte(desText), 0, StringToByte(desText).Length);
                csEncrypt.FlushFinalBlock();

                // Get the encrypted array of bytes.
                byte[] encrypted = msEncrypt.ToArray();
               
                //加密后的字符串
                strRtnValue = ByteToString(encrypted);

               
            }
            catch (Exception ex)
            {
                ex.ToString();
                strRtnValue =  "";
            }
            return strRtnValue;
        }


        /// <summary>
        /// tangwf 2011-04-11 des3解密算法
        /// </summary>
        /// <param name="desText">加密串</param>
        /// <param name="desKey">key</param>
        /// <returns></returns>
        public static string DES3Decrypt(string DecText, string DecKey)
        {
            string strRtnValue = "";
            try
            {
                TripleDESCryptoServiceProvider threedes = new TripleDESCryptoServiceProvider();

                //默认的TripleDESCryptoServiceProvider的key为24字节，IV为8字节，加密数据块为8字节
                threedes.Key = StringToByte(DecKey, 24);
                //threedes.Key = StringToByteForHex(DecKey);
                //threedes.Key = StringToByte(DecKey, 48);
                //初始向量
                threedes.IV = StringToByte("12345678");
                //threedes.IV = StringToByteForHex("0102030405060708");
                //threedes.IV = StringToByte("0102030405060708");

                byte[] key = threedes.Key;
                byte[] IV = threedes.IV;
                //threedes.Mode = CipherMode.ECB;
                //threedes.Padding = PaddingMode.PKCS7;

                byte[] decryptarry = StringToByteForHex(DecText);

                ICryptoTransform decryptor = threedes.CreateDecryptor(key, IV);


                MemoryStream msDecrypt = new MemoryStream(decryptarry);

                //CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);

                CryptoStream csDecrypt = new CryptoStream(msDecrypt, decryptor, CryptoStreamMode.Read);

                //StreamReader reader = new StreamReader(csDecrypt, System.Text.Encoding.Unicode);
                ///return reader.ReadToEnd();
                //解 密字符串s =  ByteToString(csDecrypt);
                //strRtnValue = ByteToString(csDecrypt);
                strRtnValue = ByteToString(csDecrypt);
                //byte[] DecryptDataArray = new byte[DecText.Length];

                //csDecrypt.Read(DecryptDataArray, 0, DecryptDataArray.Length);

                msDecrypt.Close();

                csDecrypt.Close();

 

            }
            catch (Exception ex)
            {
                ex.ToString();
                strRtnValue = "";
            }
            return strRtnValue;
        }


        #region 字符串与byte互相转换
        /*------------------------------------------------------------------------------------------------------------------------------------------*/
        /// <summary>
        /// 将普通文本转换成Base64编码的文本
        /// </summary>
        /// <param name="value">普通文本</param>
        /// <returns></returns>
        public static string StringToBase64String(String value)
        {
            byte[] binBuffer = (new UnicodeEncoding()).GetBytes(value);
            int base64ArraySize = (int)Math.Ceiling(binBuffer.Length / 3d) * 4;
            char[] charBuffer = new char[base64ArraySize];
            Convert.ToBase64CharArray(binBuffer, 0, binBuffer.Length, charBuffer, 0);
            string s = new string(charBuffer);
            return s;
        }

        /// <summary>
        /// 将Base64编码的文本转换成普通文本
        /// </summary>
        /// <param name="base64">Base64编码的文本</param>
        /// <returns></returns>
        public static string Base64StringToString(string base64)
        {
            char[] charBuffer = base64.ToCharArray();
            byte[] bytes = Convert.FromBase64CharArray(charBuffer, 0, charBuffer.Length);
            return (new UnicodeEncoding()).GetString(bytes);
        }

        /// <summary>
        /// 将Byte[]转换成Base64编码文本
        /// </summary>
        /// <param name="binBuffer">Byte[]</param>
        /// <returns></returns>
        public string toBase64(byte[] binBuffer)
        {
            int base64ArraySize = (int)Math.Ceiling(binBuffer.Length / 3d) * 4;
            char[] charBuffer = new char[base64ArraySize];
            Convert.ToBase64CharArray(binBuffer, 0, binBuffer.Length, charBuffer, 0);
            string s = new string(charBuffer);
            return s;
        }

        /// <summary>
        /// 将Base64编码文本转换成Byte[]
        /// </summary>
        /// <param name="base64">Base64编码文本</param>
        /// <returns></returns>
        public Byte[] Base64ToBytes(string base64)
        {
            char[] charBuffer = base64.ToCharArray();
            byte[] bytes = Convert.FromBase64CharArray(charBuffer, 0, charBuffer.Length);
            return bytes;
        }


        /// <summary>
        /// 十六进制内容转换为byte数组
        /// </summary>
        /// <param name="StringToConvert"></param>
        /// <returns></returns>
        public static byte[] StringToByteForHex(string StringToConvert)
        {
           
            char[] CharArray = StringToConvert.ToCharArray();
            byte[] ByteArray = new byte[CharArray.Length/2];
            int j = 0;
            for (int i = 0; i < CharArray.Length; i=i+2)
            {
                int intValue = Convert.ToInt32(CharArray[i].ToString() + CharArray[i + 1].ToString(), 16);
                byte b = Convert.ToByte(intValue);
                ByteArray[j] = b;
                j++;
            }
            return ByteArray;
        }
        public static byte[] StringToByte(string StringToConvert)
        {

            char[] CharArray = StringToConvert.ToCharArray();
            byte[] ByteArray = new byte[CharArray.Length];
            for (int i = 0; i < CharArray.Length; i++)
            {
                ByteArray[i] = Convert.ToByte(CharArray[i]);
            }
            return ByteArray;
        }
        public static byte[] StringToByte(string StringToConvert, int length)
        {

            char[] CharArray = StringToConvert.ToCharArray();
            byte[] ByteArray = new byte[length];
            for (int i = 0; i < CharArray.Length; i++)
            {
                ByteArray[i] = Convert.ToByte(CharArray[i]);
            }
            return ByteArray;
        }
        public static string ByteToString(CryptoStream buff)
        {
            string sbinary = "";
            int b = 0;
            do
            {
                b = buff.ReadByte();
                if (b != -1) sbinary += ((char)b);

            } while (b != -1);
            return (sbinary);
        }
        public static string ByteToString(byte[] buff)
        {
            string sbinary = "";
            for (int i = 0; i < buff.Length; i++)
            {
                sbinary += buff[i].ToString("X2"); // hex format
            }
            return (sbinary);
        }


        #endregion 字符串与byte互相转换
    }
}

java 3des解密_Java进行3DES加密解密详解
weixin_42227736的博客
02-12 1533
package com.shanhy.tools.packers;import java.security.Security;import javax.crypto.Cipher;import javax.crypto.SecretKey;import javax.crypto.spec.SecretKeySpec;/*** 3DES加密** @author SHANHY([emailprote...
3DES在线加密工具
最新发布
迷失蒲公英
08-06 1054
3DES（Triple Data Encryption Standard，三重数据加密标准）是一种基于DES（Data Encryption Standard，数据加密标准）的对称密钥块加密算法。3DES是对原始DES算法的一种改进，旨在提供更强的安全性。一些开发还经常需要用到3DES进行加解密，为了方便进行验证测试，可以使用在线工具。
3DES加密解密
qq_42289686的博客
06-11 1498
//3des加密 OPENSSL_RAW_DATA 为Pkcs7填充模式 static function des_encrypt($data,$key = ENCRYPT_KEY, $iv = ENCRYPT_IV) { $key = md5($key); //32位长度 $iv = substr(md5($iv),...
DES加密解密
封神之路~
05-05 1246
为了更方便地进行DES加密的操作，现在有一款方便易用的在线DES加密工具，它就是DES加密/解密工具。DES加密/解密工具非常方便，只需要在网页上输入明文和密钥，就可以快速实现DES加密和解密操作。总之，如果您需要完成一个DES加密任务，那么不妨去试一试DES加密/解密工具，使用它，您可以快速、安全地完成加密任务，让数据获得更好的保护。值得一提的是DES加密/解密工具还提供了友好的界面和使用说明，使不懂加密的用户全方位了解加密操作流程，很适合新手使用。
Java实现DES加密解密
热门推荐
king的专栏
11-09 10万+
DES(Data Encryption Standard)是一种对称加密算法，所谓对称加密就是加密和解密都是使用同一个密钥。 加密原理： DES 使用一个 56 位的密钥以及附加的 8 位奇偶校验位，产生最大 64 位的分组大小。这是一个迭代的分组密码，使用称为 Feistel 的技术，其中将加密的文本块分成两半。使用子密钥对其中一半应用循环功能，然后将输出与另一半进行"异或"运算;接着交换这...
C#之DES加密解密
AI的博客
10-24 3702
DES算法是一种最通用的对称算法，因为算法本身是公开的，所以其安全性在于的安全性。基于的算法通常有两类：对称算法和公开算法。对称算法的对称性体现在加能够从解推算出来，反之亦然。在大多数对称算法中，加解密的是相同的，DES就是这样。可见，对称算法的加解都是保密的。而公开算法的加是公开的，解是保密的。
使用Java实现3DES加密解密
Fantasy
07-10 2513
3DES又称TripleDES，是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。密钥长度是128位(bit)和192位(bit)。原版DES容易被破解，新的3DES出现，增加了加密安全性，避免被暴力破解。它同样是对称性加密，同样涉及到加密模式和填充方式。加密模式有ECB、CBC、CTR、OFB、CFB。填充方式有PKCS5Padding、PKCS7Padding、ZeroPadding、ISO101
用java实现3DES加密解密算法
qq_38883271的博客
10-24 5303
3DES加密也称三重加密，其底层加密算法与DES相同，只不过它的密钥长度是168位。由于在DES加密算法中，64位密钥中每一个字节的第8位是奇偶校验位，所以每个字节中只有后7位起密钥作用，实际是56位密钥长度。但是在3DES加密算法中，需要三个这样的密钥长度才能实现三重加密操作，所以3DES的密钥长度是56✖3=168，算上每个字节的奇偶校验位，则应该输入的密钥长度是168+24=192，即24个...
3DES 加密解密
天天water的专栏
11-07 5642
版权声明：本文为博主原创文章，未经博主允许不得转载。         3DES（或称为Triple DES）是三重数据加密算法（TDEA，Triple Data Encryption Algorithm）块密码的通称。它相当于是对每个数据块应用三次DES加密算法。由于计算机运算能力的增强，原版DES密码的密钥长度变得容易被暴力破解；3DES即是设计用来提供一种相对简单
Python 3DES 加密解密
11-06 2325
3DES 加密解密 import pyDes import base64 from Crypto.Cipher import DES3 import codecs import base64 class EncryptDate: def __init__(self, key): self.key = key # 初始化密钥 self.iv = b'0...
Java实现的3des加密解密工具类示例
08-29
Java实现的3DES加密解密工具类示例 【Java实现的3DES加密解密工具类】 Java实现的3DES加密解密工具类是指使用Java语言实现的三重数据加密算法工具类，该工具类提供了加密和解密两种操作模式，通过设置密钥和加密/...
des加密解密_Des加密解密_DES加密_
10-03
在给定的“des加密例程”中，可能包含了一个调用动态链接库（DLL）实现DES加密解密的示例代码。DLL是Windows操作系统中的一种共享库，可以被多个程序同时调用，节省内存资源并便于代码复用。这个示例可能涉及以下...
Delphi Lazarus C实现的DES、3DES加密解密
09-20
Delphi、Lazarus、C语言实现DES、3DES对称加密解密模块，支持单倍长和双倍长密钥。
visual c++ VC实现3DES加解密 加密解密.zip
01-29
总之，Visual C++实现3DES加解密需要理解3DES算法原理，导入相应的加密库，设置密钥和加密模式，编写加解密函数，进行测试并处理文件操作。这个项目提供的源代码和资源文件可以帮助开发者深入理解并实践3DES在C++...
matlab实现DES加密解密算法
12-12
加密为直接输入十六进制的（消息，密钥，1）；解密为（密文，密钥，2）；Index=1为加密，不为1为解密
sqlserver中全文检索与csw(测试版)实现分词查询测试
05-16 5440
分词搜索后台准备工作一、将数据1,2020,1,海口君澜商贸有限公司                                                                                ,海南省海口市机场路群芳花园４号                                                                     
mysql中处理指定分隔符分隔的字符串,取范围例子
04-22 3046
函数主要实现指定标点符号分隔的各数据间处理.适用于类似打页面面范围等数据的精确提取.如打印范围1-3,8,9-12之类的情况.示例中对处理手机号段进行了处理,第一行中的1300,1301等为手机前四位号码.其余各行为手机子号段范围.以,及-符号分隔.为精确取到手机整个号段.需要将手机子号段范围精确到每一个值,如970-972,980需要处理为1300970,13009
windows搭建apache,php,mysql环境并设置虚拟目录
11-21 2333
1.在d盘下新建web文件夹,新建apache mysql php 三个子目录2.双击mysqlforwindows.exe安装mysql，选择自定义（custom）安装，安装至d盘web/mysql下3.双击apache_2.2.4-win32-x86-no_ssl.msi安装apache服务器,选择自定义（custom）安装，安装至d盘web/apche下4.双击php-5.1.4-insta
mysql中的动态行转列
11-23 1927
mysql 中设置为支持中文vi etc/my.cnf   [mysqld]   #adddefault-character-set =gb2312   建表drop table table_namecreate table table_name( mon varchar(10),per varchar(10),value int)插入数据insert into table_nameselec
VC++环境下的3DES加密解密实现
综上所述，3DES加密解密是一种历史上广泛使用的加密技术，其在实际应用中需要综合考虑密钥管理、加密模式选择、性能、兼容性和安全性等多方面因素。随着技术的发展，虽然3DES逐渐被更安全的加密标准如AES所取代，但...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值