C#16位MD5加密算法

最新推荐文章于 2024-07-10 17:10:45 发布
最新推荐文章于 2024-07-10 17:10:45 发布
阅读量2k 收藏 1
点赞数
分类专栏： .Net

    MD5 = LCase(WordToHex(a) & WordToHex(b) & WordToHex(c) & WordToHex(d)) '32位 
    MD5 = LCase(WordToHex(b) & WordToHex(c))  '16位 
    在asp中我们可以通过以上的 获取到16和32位的md5加密码
    在C#中可以通过string strUserPwd = FormsAuthentication.HashPasswordForStoringInConfigFile(txtAdminPwd.Text,"md5"); 
    获得32位加密码，现在我需要16位C#加密的算法，在网上看了些人家写的始终没有弄出来，各位大虾帮忙啊！

using System; 
using System.Collections.Generic; 
using System.Text;

namespace MYMD5 
{ 
    public class MD5 
    { 
        const int BITS_TO_A_BYTE = 8; 
        const int BYTES_TO_A_WORD = 4; 
        const int BITS_TO_A_WORD = 32; 
        private static long[] m_lOnBits = new long[30 + 1]; 
        private static long[] m_l2Power = new long[30 + 1];

        private static long LShift(long lValue, long iShiftBits) 
        { 
            long LShift = 0; 
            if (iShiftBits == 0) 
            { 
                LShift = lValue; 
                return LShift; 
            } 
            else 
            { 
                if (iShiftBits == 31) 
                { 
                    if (Convert.ToBoolean(lValue & 1)) 
                    { 
                        LShift = 0x80000000; 
                    } 
                    else 
                    { 
                        LShift = 0; 
                    } 
                    return LShift; 
                } 
                else 
                { 
                    if (iShiftBits < 0 || iShiftBits > 31) 
                    { 
                        // Err.Raise 6; 
                    } 
                } 
            }

            if (Convert.ToBoolean((lValue & m_l2Power[31 - iShiftBits]))) 
            { 
                LShift = ((lValue & m_lOnBits[31 - (iShiftBits + 1)]) * m_l2Power[iShiftBits]) | 0x80000000; 
            } 
            else 
            { 
                LShift = ((lValue & m_lOnBits[31 - iShiftBits]) * m_l2Power[iShiftBits]); 
            }

            return LShift; 
        }

        private static long RShift(long lValue, long iShiftBits) 
        { 
            long RShift = 0; 
            if (iShiftBits == 0) 
            { 
                RShift = lValue; 
                return RShift; 
            } 
            else 
            { 
                if (iShiftBits == 31) 
                { 
                    if (Convert.ToBoolean(lValue & 0x80000000)) 
                    { 
                        RShift = 1; 
                    } 
                    else 
                    { 
                        RShift = 0; 
                    } 
                    return RShift; 
                } 
                else 
                { 
                    if (iShiftBits < 0 || iShiftBits > 31) 
                    { 
                        // Err.Raise 6; 
                    } 
                } 
            }

            RShift = (lValue & 0x7FFFFFFE) / m_l2Power[iShiftBits];

            if (Convert.ToBoolean((lValue & 0x80000000))) 
            { 
                RShift = (RShift | (0x40000000 / m_l2Power[iShiftBits - 1])); 
            }

            return RShift; 
        }

        private static long RotateLeft(long lValue, long iShiftBits) 
        { 
            long RotateLeft = 0; 
            RotateLeft = LShift(lValue, iShiftBits) | RShift(lValue, (32 - iShiftBits)); 
            return RotateLeft; 
        }

        private static long AddUnsigned(long lX, long lY) 
        { 
            long AddUnsigned = 0; 
            long lX4 = 0; 
            long lY4 = 0; 
            long lX8 = 0; 
            long lY8 = 0; 
            long lResult = 0;

            lX8 = lX & 0x80000000; 
            lY8 = lY & 0x80000000; 
            lX4 = lX & 0x40000000; 
            lY4 = lY & 0x40000000;

            lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF); 
            if (Convert.ToBoolean(lX4 & lY4)) 
            { 
                lResult = lResult ^ 0x80000000 ^ lX8 ^ lY8; 
            } 
            else if (Convert.ToBoolean(lX4 | lY4)) 
            { 
                if (Convert.ToBoolean(lResult & 0x40000000)) 
                { 
                    lResult = lResult ^ 0xC0000000 ^ lX8 ^ lY8; 
                } 
                else 
                { 
                    lResult = lResult ^ 0x40000000 ^ lX8 ^ lY8; 
                } 
            } 
            else 
            { 
                lResult = lResult ^ lX8 ^ lY8; 
            } 
            AddUnsigned = lResult; 
            return AddUnsigned; 
        }

        private static long md5_F(long x, long y, long z) 
        { 
            long md5_F = 0; 
            md5_F = (x & y) | ((~x) & z); 
            return md5_F; 
        }

        private static long md5_G(long x, long y, long z) 
        { 
            long md5_G = 0; 
            md5_G = (x & z) | (y & (~z)); 
            return md5_G; 
        }

        private static long md5_H(long x, long y, long z) 
        { 
            long md5_H = 0; 
            md5_H = (x ^ y ^ z); 
            return md5_H; 
        }

        private static long md5_I(long x, long y, long z) 
        { 
            long md5_I = 0; 
            md5_I = (y ^ (x | (~z))); 
            return md5_I; 
        }

        private static void md5_FF(ref long a, long b, long c, long d, long x, long s, long ac) 
        { 
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_F(b, c, d), x), ac)); 
            a = RotateLeft(a, s); 
            a = AddUnsigned(a, b); 
        }

        private static void md5_GG(ref long a, long b, long c, long d, long x, long s, long ac) 
        { 
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_G(b, c, d), x), ac)); 
            a = RotateLeft(a, s); 
            a = AddUnsigned(a, b); 
        }

        private static void md5_HH(ref long a, long b, long c, long d, long x, long s, long ac) 
        { 
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_H(b, c, d), x), ac)); 
            a = RotateLeft(a, s); 
            a = AddUnsigned(a, b); 
        }

        private static void md5_II(ref long a, long b, long c, long d, long x, long s, long ac) 
        { 
            a = AddUnsigned(a, AddUnsigned(AddUnsigned(md5_I(b, c, d), x), ac)); 
            a = RotateLeft(a, s); 
            a = AddUnsigned(a, b); 
        }

        private static long[] ConvertToWordArray(string sMessage) 
        { 
            long[] ConvertToWordArray = null; 
            int lMessageLength = 0; 
            int lNumberOfWords = 0; 
            long[] lWordArray = null; 
            int lBytePosition = 0; 
            int lByteCount = 0; 
            int lWordCount = 0;

            const int MODULUS_BITS = 512; 
            const int CONGRUENT_BITS = 448;

            lMessageLength = sMessage.Length; 
            lNumberOfWords = (((lMessageLength + ((MODULUS_BITS - CONGRUENT_BITS) / BITS_TO_A_BYTE)) / (MODULUS_BITS / BITS_TO_A_BYTE)) + 1) * (MODULUS_BITS / BITS_TO_A_WORD); 
            lWordArray = new long[lNumberOfWords];

            lBytePosition = 0; 
            lByteCount = 0;

            while (lByteCount < lMessageLength) 
            { 
                lWordCount = lByteCount / BYTES_TO_A_WORD; 
                lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE; 
                lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(Convert.ToByte(sMessage.Substring(lByteCount, 1).ToCharArray()[0]), lBytePosition); 
                lByteCount = lByteCount + 1; 
            }

            lWordCount = lByteCount / BYTES_TO_A_WORD; 
            lBytePosition = (lByteCount % BYTES_TO_A_WORD) * BITS_TO_A_BYTE; 
            lWordArray[lWordCount] = lWordArray[lWordCount] | LShift(0x80, lBytePosition); 
            lWordArray[lNumberOfWords - 2] = LShift(lMessageLength, 3); 
            lWordArray[lNumberOfWords - 1] = RShift(lMessageLength, 29); 
            ConvertToWordArray = lWordArray;

            return ConvertToWordArray; 
        }

        private static string WordToHex(long lValue) 
        { 
            string WordToHex = ""; 
            long lByte = 0; 
            int lCount = 0; 
            for (lCount = 0; lCount <= 3; lCount++) 
            { 
                lByte = RShift(lValue, lCount * BITS_TO_A_BYTE) & m_lOnBits[BITS_TO_A_BYTE - 1]; 
                WordToHex = WordToHex + (("0" + ToHex(lByte)).Substring(("0" + ToHex(lByte)).Length - 2)); 
            } 
            return WordToHex; 
        }

        private static string ToHex(long dec) 
        { 
            string strhex = ""; 
            while (dec > 0) 
            { 
                strhex = tohex(dec % 16) + strhex; 
                dec = dec / 16; 
            } 
            return strhex; 
        }

        private static string tohex(long hex) 
        { 
            string strhex = ""; 
            switch (hex) 
            { 
                case 10: strhex = "a"; break; 
                case 11: strhex = "b"; break; 
                case 12: strhex = "c"; break; 
                case 13: strhex = "d"; break; 
                case 14: strhex = "e"; break; 
                case 15: strhex = "f"; break; 
                default: strhex = hex.ToString(); break; 
            } 
            return strhex; 
        }


        public static string Encrypt(string sMessage, int stype) 
        { 
            string MD5 = "";

            for (int i = 0; i <= 30; i++) 
            { 
                m_lOnBits[i] = Convert.ToInt64(Math.Pow(2, i + 1) - 1); 
                m_l2Power[i] = Convert.ToInt64(Math.Pow(2, i)); 
            }

            long[] x = null; 
            int k = 0; 
            long AA = 0; 
            long BB = 0; 
            long CC = 0; 
            long DD = 0; 
            long a = 0; 
            long b = 0; 
            long c = 0; 
            long d = 0;

            const int S11 = 7; 
            const int S12 = 12; 
            const int S13 = 17; 
            const int S14 = 22; 
            const int S21 = 5; 
            const int S22 = 9; 
            const int S23 = 14; 
            const int S24 = 20; 
            const int S31 = 4; 
            const int S32 = 11; 
            const int S33 = 16; 
            const int S34 = 23; 
            const int S41 = 6; 
            const int S42 = 10; 
            const int S43 = 15; 
            const int S44 = 21;

            x = ConvertToWordArray(sMessage);

            a = 0x67452301; 
            b = 0xEFCDAB89; 
            c = 0x98BADCFE; 
            d = 0x10325476;

            for (k = 0; k < x.Length; k += 16) 
            { 
                AA = a; 
                BB = b; 
                CC = c; 
                DD = d;

                md5_FF(ref a, b, c, d, x[k + 0], S11, 0xD76AA478); 
                md5_FF(ref d, a, b, c, x[k + 1], S12, 0xE8C7B756); 
                md5_FF(ref c, d, a, b, x[k + 2], S13, 0x242070DB); 
                md5_FF(ref b, c, d, a, x[k + 3], S14, 0xC1BDCEEE); 
                md5_FF(ref a, b, c, d, x[k + 4], S11, 0xF57C0FAF); 
                md5_FF(ref d, a, b, c, x[k + 5], S12, 0x4787C62A); 
                md5_FF(ref c, d, a, b, x[k + 6], S13, 0xA8304613); 
                md5_FF(ref b, c, d, a, x[k + 7], S14, 0xFD469501); 
                md5_FF(ref a, b, c, d, x[k + 8], S11, 0x698098D8); 
                md5_FF(ref d, a, b, c, x[k + 9], S12, 0x8B44F7AF); 
                md5_FF(ref c, d, a, b, x[k + 10], S13, 0xFFFF5BB1); 
                md5_FF(ref b, c, d, a, x[k + 11], S14, 0x895CD7BE); 
                md5_FF(ref a, b, c, d, x[k + 12], S11, 0x6B901122); 
                md5_FF(ref d, a, b, c, x[k + 13], S12, 0xFD987193); 
                md5_FF(ref c, d, a, b, x[k + 14], S13, 0xA679438E); 
                md5_FF(ref b, c, d, a, x[k + 15], S14, 0x49B40821); 
                md5_GG(ref a, b, c, d, x[k + 1], S21, 0xF61E2562); 
                md5_GG(ref d, a, b, c, x[k + 6], S22, 0xC040B340); 
                md5_GG(ref c, d, a, b, x[k + 11], S23, 0x265E5A51); 
                md5_GG(ref b, c, d, a, x[k + 0], S24, 0xE9B6C7AA); 
                md5_GG(ref a, b, c, d, x[k + 5], S21, 0xD62F105D); 
                md5_GG(ref d, a, b, c, x[k + 10], S22, 0x2441453); 
                md5_GG(ref c, d, a, b, x[k + 15], S23, 0xD8A1E681); 
                md5_GG(ref b, c, d, a, x[k + 4], S24, 0xE7D3FBC8); 
                md5_GG(ref a, b, c, d, x[k + 9], S21, 0x21E1CDE6); 
                md5_GG(ref d, a, b, c, x[k + 14], S22, 0xC33707D6); 
                md5_GG(ref c, d, a, b, x[k + 3], S23, 0xF4D50D87); 
                md5_GG(ref b, c, d, a, x[k + 8], S24, 0x455A14ED); 
                md5_GG(ref a, b, c, d, x[k + 13], S21, 0xA9E3E905); 
                md5_GG(ref d, a, b, c, x[k + 2], S22, 0xFCEFA3F8); 
                md5_GG(ref c, d, a, b, x[k + 7], S23, 0x676F02D9); 
                md5_GG(ref b, c, d, a, x[k + 12], S24, 0x8D2A4C8A); 
                md5_HH(ref a, b, c, d, x[k + 5], S31, 0xFFFA3942); 
                md5_HH(ref d, a, b, c, x[k + 8], S32, 0x8771F681); 
                md5_HH(ref c, d, a, b, x[k + 11], S33, 0x6D9D6122); 
                md5_HH(ref b, c, d, a, x[k + 14], S34, 0xFDE5380C); 
                md5_HH(ref a, b, c, d, x[k + 1], S31, 0xA4BEEA44); 
                md5_HH(ref d, a, b, c, x[k + 4], S32, 0x4BDECFA9); 
                md5_HH(ref c, d, a, b, x[k + 7], S33, 0xF6BB4B60); 
                md5_HH(ref b, c, d, a, x[k + 10], S34, 0xBEBFBC70); 
                md5_HH(ref a, b, c, d, x[k + 13], S31, 0x289B7EC6); 
                md5_HH(ref d, a, b, c, x[k + 0], S32, 0xEAA127FA); 
                md5_HH(ref c, d, a, b, x[k + 3], S33, 0xD4EF3085); 
                md5_HH(ref b, c, d, a, x[k + 6], S34, 0x4881D05); 
                md5_HH(ref a, b, c, d, x[k + 9], S31, 0xD9D4D039); 
                md5_HH(ref d, a, b, c, x[k + 12], S32, 0xE6DB99E5); 
                md5_HH(ref c, d, a, b, x[k + 15], S33, 0x1FA27CF8); 
                md5_HH(ref b, c, d, a, x[k + 2], S34, 0xC4AC5665); 
                md5_II(ref a, b, c, d, x[k + 0], S41, 0xF4292244); 
                md5_II(ref d, a, b, c, x[k + 7], S42, 0x432AFF97); 
                md5_II(ref c, d, a, b, x[k + 14], S43, 0xAB9423A7); 
                md5_II(ref b, c, d, a, x[k + 5], S44, 0xFC93A039); 
                md5_II(ref a, b, c, d, x[k + 12], S41, 0x655B59C3); 
                md5_II(ref d, a, b, c, x[k + 3], S42, 0x8F0CCC92); 
                md5_II(ref c, d, a, b, x[k + 10], S43, 0xFFEFF47D); 
                md5_II(ref b, c, d, a, x[k + 1], S44, 0x85845DD1); 
                md5_II(ref a, b, c, d, x[k + 8], S41, 0x6FA87E4F); 
                md5_II(ref d, a, b, c, x[k + 15], S42, 0xFE2CE6E0); 
                md5_II(ref c, d, a, b, x[k + 6], S43, 0xA3014314); 
                md5_II(ref b, c, d, a, x[k + 13], S44, 0x4E0811A1); 
                md5_II(ref a, b, c, d, x[k + 4], S41, 0xF7537E82); 
                md5_II(ref d, a, b, c, x[k + 11], S42, 0xBD3AF235); 
                md5_II(ref c, d, a, b, x[k + 2], S43, 0x2AD7D2BB); 
                md5_II(ref b, c, d, a, x[k + 9], S44, 0xEB86D391);

                a = AddUnsigned(a, AA); 
                b = AddUnsigned(b, BB); 
                c = AddUnsigned(c, CC); 
                d = AddUnsigned(d, DD); 
            }

            if (stype == 32) 
            { 
                MD5 = ((((WordToHex(a)) + (WordToHex(b))) + (WordToHex(c))) + (WordToHex(d))).ToLower(); 
            } 
            else 
            { 
                MD5 = ((WordToHex(b)) + (WordToHex(c))).ToLower(); 
            } 
            return MD5; 
        } 
    } 
} 
刚找了个算法，问题解决了贴出来给大家看看， 
调用的时候直接 string strUserpwd =MD5.Encrypt(txtUserPwd.Text,16); 
就可以，上面是16位，要32直接换成32就可以！

my98800
关注
专栏目录
C#实现MD5加密(16位和32位)算法
05-04
c#语言实现的原始MD5加密算法,支持16位加密和32位加密.
C# MD5加密:16位
12-04 1802
using System; using System.Collections.Generic; using System.Security.Cryptography; using System.Text; namespace MD4M {     class Program     {         static void Main(string[] args)
C#中的MD5摘要算法与哈希算法
最新发布
qq_35320456的博客
07-10 1341
MD5（Message Digest Algorithm 5）是一种广泛使用的密码散列函数，可以产生一个128位（16字节）的散列值（hash value），用于确保信息传输完整一致。MD5算法于1991年由Ronald Rivest设计，是被广泛使用的摘要算法之一。MD5算法将输入的消息（任意长）转换成一个固定长度的散列值。在转换过程中，算法会使用一系列的加密操作，如循环移位和异或运算，以生成最终的散列值。
C# md5加密，MD5转16位
the_heart_is_die的博客
08-28 2552
字符串MD5加密 public static string MD5Encrypt(string EncryptString) { if (string.IsNullOrEmpty(EncryptString)) { throw (new Exception("密文不得为空")); } var clearBytes = Encoding.UTF8.Ge...
C#实现MD5加密
聖輝
03-28 1万+
                                        方法一首先,先简单介绍一下MD5MD5的全称是message-digest algorithm 5(信息-摘要算法，在90年代初由mit laboratory for computer science和rsa data security inc的ronald l. rivest开发出来， 经md2、md3和md
C# MD5-16位加密和MD5-32位加密
a32232730的博客
06-14 169
1.MD5　16位加密 MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider(); string MD5_PWD= BitConverter.ToString(md5.ComputeHash(UTF8Encoding.Default.GetBytes("加密字符串")), 4...
C#实现MD5加密(16位或32位)算法.txt
07-07
这是一个MD5加密的算法，可以是16位，也可以是32位。算法不需C#的内核引用即可实现，是学习MD5算法的一个很好的例子。
C# MD5加密 实例源码（加密解密）
04-21
在IT行业中，数据安全是至关重要的，特别是在网络通信和存储敏感信息时。MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它能够将任意长度的...在实际项目中，根据需求选择合适的加密算法是至关重要的。
MD5加密算法(16位，32) .zip_C# MD5_CSharp MD5 32_MD5 CSharp_md5_md5 32
09-21
1. "MD5加密算法(16位，32位)的C#实现 .txt" - 这很可能包含了一个或多个C#方法，用于计算MD5哈希，可能还包括了如何使用这些方法的示例。 2. "www.pudn.com.txt" - 这个文件名看起来像是来源于一个网站，可能是提供...
c# MD5加密算法的实例
weixin_30911451的博客
01-08 253
环境：vs.net2005/sqlserver2000/xp测试通过1.MD5　16位加密实例usingSystem;usingSystem.Collections.Generic;usingSystem.Text;usingSystem.Security.Cryptography;namespacemd5{classProgram{st...
c# md5加密16进制
11-03
简单几行代码实现了md5加密方式，返回16进制的字符串，封装了函数
MD5加密（支持32位和16位加密）
08-08
应用环境：win7 32位，.net framework4.0平台 软件支持MD5的32位和16位加密，同时支持大小写。使用简单方便。欢迎各位使用，提出宝贵意见。
MD5 16位和32位的加密方式
08-26
现在很流行的数据加密方式MD5，16位和32位的加密方式
C#实现MD5加密（32位md5加密和16位md5加密）
小龙在线
10-22 2047
【代码】C# MD5加密实现（32位md5加密和16位md5加密）
C#实现计算MD5 32位大小写，16位大小写算法（附完整源码）
希望我的博客，能帮上你解决学习中工作中所遇到的问题
03-25 249
C#实现计算MD5 32位大小写，16位大小写算法（附完整源码）
C#对于md5加密的两种方式
u013452440的博客
04-07 6797
16位 public static string GetMd5_16byte(string ConvertString) { string md5Pwd = string.Empty; //使用加密服务提供程序 MD5CryptoServiceProvider md5 = new MD5CryptoServiceProvider();
MD5
weixin_33807284的博客
08-15 94
private string MD5Encrypt32(string str) { string code = str; StringBuilder pwd = new StringBuilder(); MD5 md5 = MD5.Create(); //实例化一个md5对像 // 加密后是一个字节类型的数组...
.Net中实现MD5加密-16位32位
学习
01-03 1769
c#示例 public string md5(string str,int code) {  if(code==16) //16位MD5加密（取32位加密的9~25字符）  {  return System.Web.Security.FormsAuthentication.HashPasswordForStoringInConfigFile(str,"MD5").ToLower().Substri
C#中使用MD5对用户密码加密与解密
热门推荐
u011555996的博客
06-30 1万+
C#中常涉及到对用户密码的加密于解密的算法，其中使用MD5加密是最常见的的实现方式。本文总结了通用的算法并结合了自己的一点小经验，分享给大家。 一.使用16位、32位、64位MD5方法对用户名加密 1）16位的MD5加密 /// <summary> /// 16位MD5加密 /// </summary> /// <param name="password"></param> /// <returns></returns> .
C#实现MD5加密算法详解：16位与32位
本文将介绍如何使用C#语言实现MD5加密算法，包括16位和32位的加密方式。MD5（Message-Digest Algorithm 5）是一种广泛使用的哈希函数，它能够将任意长度的数据转化为固定长度的输出，通常为128位，以16进制表示即32...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值