一段js MD5。加密 转换C#语法过程

最新推荐文章于 2022-07-07 17:12:19 发布
最新推荐文章于 2022-07-07 17:12:19 发布
阅读量262 收藏
点赞数
文章标签： c# javascript php ViewUI
原文链接：http://www.cnblogs.com/y112102/p/11024421.html
版权

A 帮忙把这段js脚本转换 c#语言.

JS:

 function md5 (bit,sMessage) {debugger
    //var sMessage = this;
    function RotateLeft(lValue, iShiftBits) { return (lValue << iShiftBits) | (lValue >>> (32 - iShiftBits)); }
    function AddUnsigned(lX, lY) {
        var lX4, lY4, lX8, lY8, lResult;
        lX8 = (lX & 0x80000000);
        lY8 = (lY & 0x80000000);
        lX4 = (lX & 0x40000000);
        lY4 = (lY & 0x40000000);
        lResult = (lX & 0x3FFFFFFF) + (lY & 0x3FFFFFFF);
        if (lX4 & lY4) return (lResult ^ 0x80000000 ^ lX8 ^ lY8);
        if (lX4 | lY4) {
            if (lResult & 0x40000000) return (lResult ^ 0xC0000000 ^ lX8 ^ lY8);
            else return (lResult ^ 0x40000000 ^ lX8 ^ lY8);
        } else return (lResult ^ lX8 ^ lY8);
    }
    function F(x, y, z) { return (x & y) | ((~x) & z); }
    function G(x, y, z) { return (x & z) | (y & (~z)); }
    function H(x, y, z) { return (x ^ y ^ z); }
    function I(x, y, z) { return (y ^ (x | (~z))); }
    function FF(a, b, c, d, x, s, ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    }
    function GG(a, b, c, d, x, s, ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    }
    function HH(a, b, c, d, x, s, ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    }
    function II(a, b, c, d, x, s, ac) {
        a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
        return AddUnsigned(RotateLeft(a, s), b);
    }
    function ConvertToWordArray(sMessage) {
        var lWordCount;
        var lMessageLength = sMessage.length;
        var lNumberOfWords_temp1 = lMessageLength + 8;
        var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
        var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
        var lWordArray = Array(lNumberOfWords - 1);
        var lBytePosition = 0;
        var lByteCount = 0;
        while (lByteCount < lMessageLength) {
            lWordCount = (lByteCount - (lByteCount % 4)) / 4;
            lBytePosition = (lByteCount % 4) * 8;
            lWordArray[lWordCount] = (  lWordArray[lWordCount] | (sMessage.charCodeAt(lByteCount) << lBytePosition));
            lByteCount++;
        }
        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
        lBytePosition = (lByteCount % 4) * 8;
        lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
        lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
        lWordArray[lNumberOfWords - 1] = lMessageLength >>> 29;
        return lWordArray;
    }
    function WordToHex(lValue) {
        var WordToHexValue = "", WordToHexValue_temp = "", lByte, lCount;
        for (lCount = 0; lCount <= 3; lCount++) {
            lByte = (lValue >>> (lCount * 8)) & 255;
            WordToHexValue_temp = "0" + lByte.toString(16);
            WordToHexValue = WordToHexValue + WordToHexValue_temp.substr(WordToHexValue_temp.length - 2, 2);
        }
        return WordToHexValue;
    }
    debugger
    var x = Array();
    var k, AA, BB, CC, DD, a, b, c, d
    var S11 = 7, S12 = 12, S13 = 17, S14 = 22;
    var S21 = 5, S22 = 9, S23 = 14, S24 = 20;
    var S31 = 4, S32 = 11, S33 = 16, S34 = 23;
    var S41 = 6, S42 = 10, S43 = 15, S44 = 21;
    // Steps 1 and 2. Append padding bits and length and convert to words 
    x = ConvertToWordArray(sMessage);
    // Step 3. Initialise 
    a = 0x67452301; b = 0xEFCDAB89; c = 0x98BADCFE; d = 0x10325476;
    // Step 4. Process the message in 16-word blocks 
    for (k = 0; k < x.length; k += 16) {
        AA = a; BB = b; CC = c; DD = d;
        a = FF(a, b, c, d, x[k + 0], S11, 0xD76AA478);
        d = FF(d, a, b, c, x[k + 1], S12, 0xE8C7B756);
        c = FF(c, d, a, b, x[k + 2], S13, 0x242070DB);
        b = FF(b, c, d, a, x[k + 3], S14, 0xC1BDCEEE);
        a = FF(a, b, c, d, x[k + 4], S11, 0xF57C0FAF);
        d = FF(d, a, b, c, x[k + 5], S12, 0x4787C62A);
        c = FF(c, d, a, b, x[k + 6], S13, 0xA8304613);
        b = FF(b, c, d, a, x[k + 7], S14, 0xFD469501);
        a = FF(a, b, c, d, x[k + 8], S11, 0x698098D8);
        d = FF(d, a, b, c, x[k + 9], S12, 0x8B44F7AF);
        c = FF(c, d, a, b, x[k + 10], S13, 0xFFFF5BB1);
        b = FF(b, c, d, a, x[k + 11], S14, 0x895CD7BE);
        a = FF(a, b, c, d, x[k + 12], S11, 0x6B901122);
        d = FF(d, a, b, c, x[k + 13], S12, 0xFD987193);
        c = FF(c, d, a, b, x[k + 14], S13, 0xA679438E);
        b = FF(b, c, d, a, x[k + 15], S14, 0x49B40821);
        a = GG(a, b, c, d, x[k + 1], S21, 0xF61E2562);
        d = GG(d, a, b, c, x[k + 6], S22, 0xC040B340);
        c = GG(c, d, a, b, x[k + 11], S23, 0x265E5A51);
        b = GG(b, c, d, a, x[k + 0], S24, 0xE9B6C7AA);
        a = GG(a, b, c, d, x[k + 5], S21, 0xD62F105D);
        d = GG(d, a, b, c, x[k + 10], S22, 0x2441453);
        c = GG(c, d, a, b, x[k + 15], S23, 0xD8A1E681);
        b = GG(b, c, d, a, x[k + 4], S24, 0xE7D3FBC8);
        a = GG(a, b, c, d, x[k + 9], S21, 0x21E1CDE6);
        d = GG(d, a, b, c, x[k + 14], S22, 0xC33707D6);
        c = GG(c, d, a, b, x[k + 3], S23, 0xF4D50D87);
        b = GG(b, c, d, a, x[k + 8], S24, 0x455A14ED);
        a = GG(a, b, c, d, x[k + 13], S21, 0xA9E3E905);
        d = GG(d, a, b, c, x[k + 2], S22, 0xFCEFA3F8);
        c = GG(c, d, a, b, x[k + 7], S23, 0x676F02D9);
        b = GG(b, c, d, a, x[k + 12], S24, 0x8D2A4C8A);
        a = HH(a, b, c, d, x[k + 5], S31, 0xFFFA3942);
        d = HH(d, a, b, c, x[k + 8], S32, 0x8771F681);
        c = HH(c, d, a, b, x[k + 11], S33, 0x6D9D6122);
        b = HH(b, c, d, a, x[k + 14], S34, 0xFDE5380C);
        a = HH(a, b, c, d, x[k + 1], S31, 0xA4BEEA44);
        d = HH(d, a, b, c, x[k + 4], S32, 0x4BDECFA9);
        c = HH(c, d, a, b, x[k + 7], S33, 0xF6BB4B60);
        b = HH(b, c, d, a, x[k + 10], S34, 0xBEBFBC70);
        a = HH(a, b, c, d, x[k + 13], S31, 0x289B7EC6);
        d = HH(d, a, b, c, x[k + 0], S32, 0xEAA127FA);
        c = HH(c, d, a, b, x[k + 3], S33, 0xD4EF3085);
        b = HH(b, c, d, a, x[k + 6], S34, 0x4881D05);
        a = HH(a, b, c, d, x[k + 9], S31, 0xD9D4D039);
        d = HH(d, a, b, c, x[k + 12], S32, 0xE6DB99E5);
        c = HH(c, d, a, b, x[k + 15], S33, 0x1FA27CF8);
        b = HH(b, c, d, a, x[k + 2], S34, 0xC4AC5665);
        a = II(a, b, c, d, x[k + 0], S41, 0xF4292244);
        d = II(d, a, b, c, x[k + 7], S42, 0x432AFF97);
        c = II(c, d, a, b, x[k + 14], S43, 0xAB9423A7);
        b = II(b, c, d, a, x[k + 5], S44, 0xFC93A039);
        a = II(a, b, c, d, x[k + 12], S41, 0x655B59C3);
        d = II(d, a, b, c, x[k + 3], S42, 0x8F0CCC92);
        c = II(c, d, a, b, x[k + 10], S43, 0xFFEFF47D);
        b = II(b, c, d, a, x[k + 1], S44, 0x85845DD1);
        a = II(a, b, c, d, x[k + 8], S41, 0x6FA87E4F);
        d = II(d, a, b, c, x[k + 15], S42, 0xFE2CE6E0);
        c = II(c, d, a, b, x[k + 6], S43, 0xA3014314);
        b = II(b, c, d, a, x[k + 13], S44, 0x4E0811A1);
        a = II(a, b, c, d, x[k + 4], S41, 0xF7537E82);
        d = II(d, a, b, c, x[k + 11], S42, 0xBD3AF235);
        c = II(c, d, a, b, x[k + 2], S43, 0x2AD7D2BB);
        b = II(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 (bit == 32) {
        return WordToHex(a) + WordToHex(b) + WordToHex(c) + WordToHex(d);
    }
    else {
        return WordToHex(b) + WordToHex(c);
    }
}

开始一看都是 &，^，>> 16进制头晕。中间想过 c# 执行js  http://www.voidcn.com/article/p-aydnjind-be.html 后面老大说 方案不通过。只能翻译了。

过程：

第一步 ：内心思考 有没有JavaScript转换c#的 在线工具 一搜 发现http://www.m2h.nl/files/js_to_c.php

第二步：工具也不能完全修正 有些语法 JavaScript存在 c#不存在的，只能人工修改错误了。

第3步：js参数 在c#是需要类型的 统一 dynamic 动态编译运行。参数 问题解决。

第4步：c#不存在>>>无符号运行符号

对应的c#代码：

            /// <summary>
            /// 无符号右移，与JS中的>>>等价
            /// </summary>
            /// <param name="x">要移位的数</param>
            /// <param name="y">移位数</param>
            /// <returns></returns>
            private static dynamic UIntMoveRight(dynamic x, dynamic y)
            {
                dynamic mask = 0x7fffffff; //Integer.MAX_VALUE
                for (dynamic i = 0; i < y; i++)
                {
                    x >>= 1;
                    x &= mask;
                }
                return x;
            }

第5步：c#不存在 CharCodeAt  https://stackoverflow.com/questions/22550825/what-is-the-charcodeat-equivalent-in-c

            /// <summary>
            /// js charCodeAt=>c#
            /// </summary>
            /// <param name="inpString"> </param>
            /// <param name="index"></param>
            /// <returns></returns>
            private static string CharCodeAt(string inpString,int index)
            {
                string outString = "";
                for (var i = 0; i < inpString.Length; i++)
                {
                    if (i==index)
                    {
                        outString = ((int)inpString[i]).ToString();
                        break;
                    }
                }
                return outString;
            }

剩下的 js的Array对应c#ArrayList 申明的是 初始化 长度 所以值赋值o；(js中不需要)， lX4 & lY4修改 （lX4 & lY4）!=0，length 大小写问题等等

最终版本 

using System;
using System.CodeDom.Compiler;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;
using Jint;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            md5CS ms = new md5CS();
            var sss = ms.md5(2, "dfdfddddfffff#$%%^111113333");

            Console.WriteLine(sss);
            Console.ReadKey();
        }


        public class md5CS
        {
            public dynamic md5(dynamic bit, dynamic sMessage)
            {

                dynamic RotateLeft(dynamic lValue, dynamic iShiftBits)
                {
                    return (lValue << iShiftBits) | UIntMoveRight(lValue, 32 - iShiftBits);
                }

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

                dynamic F(dynamic xx, dynamic y, dynamic z)
                {
                    return (xx & y) | ((~xx) & z);
                }

                dynamic G(dynamic xx, dynamic y, dynamic z)
                {
                    return (xx & z) | (y & (~z));
                }

                dynamic H(dynamic xx, dynamic y, dynamic z)
                {
                    return (xx ^ y ^ z);
                }

                dynamic I(dynamic xx, dynamic y, dynamic z)
                {
                    return (y ^ (xx | (~z)));
                }

                dynamic FF(dynamic a, dynamic b, dynamic c, dynamic d, dynamic x, dynamic s, dynamic ac)
                {
                    var ax = AddUnsigned(a, AddUnsigned(AddUnsigned(F(b, c, d), x), ac));
                    return AddUnsigned(RotateLeft(ax, s), b);
                }

                dynamic GG(dynamic a, dynamic b, dynamic c, dynamic d, dynamic x, dynamic s, dynamic ac)
                {
                    a = AddUnsigned(a, AddUnsigned(AddUnsigned(G(b, c, d), x), ac));
                    return AddUnsigned(RotateLeft(a, s), b);
                }

                dynamic HH(dynamic a, dynamic b, dynamic c, dynamic d, dynamic x, dynamic s, dynamic ac)
                {
                    a = AddUnsigned(a, AddUnsigned(AddUnsigned(H(b, c, d), x), ac));
                    return AddUnsigned(RotateLeft(a, s), b);
                }

                dynamic II(dynamic a, dynamic b, dynamic c, dynamic d, dynamic x, dynamic s, dynamic ac)
                {
                    a = AddUnsigned(a, AddUnsigned(AddUnsigned(I(b, c, d), x), ac));
                    return AddUnsigned(RotateLeft(a, s), b);
                }

                ArrayList ConvertToWordArray(string sMessagex)
                {
                    dynamic lWordCount;
                    var lMessageLength = sMessagex.Length;
                    var lNumberOfWords_temp1 = lMessageLength + 8;
                    var lNumberOfWords_temp2 = (lNumberOfWords_temp1 - (lNumberOfWords_temp1 % 64)) / 64;
                    var lNumberOfWords = (lNumberOfWords_temp2 + 1) * 16;
                    //js ArrayList
                    //var lWordArray = Array(lNumberOfWords - 1);
                    //Array转换ArrayList 默认需要全部赋值0
                    var lWordArray = new ArrayList(lNumberOfWords - 1);
                    for (int i = 0; i < lNumberOfWords; i++)
                    {
                        lWordArray.Add(0);
                    }
                    dynamic lBytePosition = 0;
                    dynamic lByteCount = 0;
                    while (lByteCount < lMessageLength)
                    {
                        lWordCount = (lByteCount - (lByteCount % 4)) / 4;
                        lBytePosition = (lByteCount % 4) * 8;
                        var lWordArrayValue = 0;
                        if (lWordArray.Count > 0)
                        {
                            lWordArrayValue = lWordArray[lWordCount];
                        }
                        //Unicode 编码
                        var CharCodeAtx = int.Parse(CharCodeAt(sMessagex, lByteCount));
                        var tempValue = lWordArrayValue | (CharCodeAtx << lBytePosition);
                        lWordArray[lWordCount] = tempValue;
                        //js charCodeAt=》CharCodeAt
                        //lWordArray[lWordCount] = (lWordArray[lWordCount] | (sMessage.charCodeAt(lByteCount) << lBytePosition));
                        lByteCount++;
                    }

                    lWordCount = (lByteCount - (lByteCount % 4)) / 4;
                    lBytePosition = (lByteCount % 4) * 8;
                    lWordArray[lWordCount] = lWordArray[lWordCount] | (0x80 << lBytePosition);
                    //倒数第2位
                    lWordArray[lNumberOfWords - 2] = lMessageLength << 3;
                    //数组最后一位
                    lWordArray[lNumberOfWords - 1] = UIntMoveRight(lMessageLength, 29);
                    return lWordArray;
                }

                string WordToHex(dynamic lValue)
                {
                    string WordToHexValue = "", WordToHexValue_temp = "";
                    dynamic lCount;
                    for (lCount = 0; lCount <= 3; lCount++)
                    {
                        dynamic lByte = UIntMoveRight(lValue, lCount * 8) & 255;

                        WordToHexValue_temp = "0" + Convert.ToString(lByte, 16);
                        //WordToHexValue_temp = "0" + lByte.ToString(16);
                        //js substr=>Substring
                        WordToHexValue = WordToHexValue +
                                         WordToHexValue_temp.Substring(WordToHexValue_temp.Length - 2, 2);
                    }

                    return WordToHexValue;
                }

                var arrList = new ArrayList();

                dynamic k, AA, BB, CC, DD;
                dynamic S11 = 7, S12 = 12, S13 = 17, S14 = 22;
                dynamic S21 = 5, S22 = 9, S23 = 14, S24 = 20;
                dynamic S31 = 4, S32 = 11, S33 = 16, S34 = 23;
                dynamic S41 = 6, S42 = 10, S43 = 15, S44 = 21;
                // Steps 1 and 2. Append padding bits and length and convert to words 
                arrList = ConvertToWordArray(sMessage);
                // Step 3. Initialise 
                dynamic aa = 0x67452301;
                dynamic bb = 0xEFCDAB89;
                dynamic cc = 0x98BADCFE;
                dynamic dd = 0x10325476;
                // Step 4. Process the message in 16-word blocks 
                for (k = 0; k < arrList.Count; k += 16)
                {
                    AA = aa;
                    BB = bb;
                    CC = cc;
                    DD = dd;
                    aa = FF(aa, bb, cc, dd, arrList[k + 0], S11, 0xD76AA478);
                    dd = FF(dd, aa, bb, cc, arrList[k + 1], S12, 0xE8C7B756);
                    cc = FF(cc, dd, aa, bb, arrList[k + 2], S13, 0x242070DB);
                    bb = FF(bb, cc, dd, aa, arrList[k + 3], S14, 0xC1BDCEEE);
                    aa = FF(aa, bb, cc, dd, arrList[k + 4], S11, 0xF57C0FAF);
                    dd = FF(dd, aa, bb, cc, arrList[k + 5], S12, 0x4787C62A);
                    cc = FF(cc, dd, aa, bb, arrList[k + 6], S13, 0xA8304613);
                    bb = FF(bb, cc, dd, aa, arrList[k + 7], S14, 0xFD469501);
                    aa = FF(aa, bb, cc, dd, arrList[k + 8], S11, 0x698098D8);
                    dd = FF(dd, aa, bb, cc, arrList[k + 9], S12, 0x8B44F7AF);
                    cc = FF(cc, dd, aa, bb, arrList[k + 10], S13, 0xFFFF5BB1);
                    bb = FF(bb, cc, dd, aa, arrList[k + 11], S14, 0x895CD7BE);
                    aa = FF(aa, bb, cc, dd, arrList[k + 12], S11, 0x6B901122);
                    dd = FF(dd, aa, bb, cc, arrList[k + 13], S12, 0xFD987193);
                    cc = FF(cc, dd, aa, bb, arrList[k + 14], S13, 0xA679438E);
                    bb = FF(bb, cc, dd, aa, arrList[k + 15], S14, 0x49B40821);
                    aa = GG(aa, bb, cc, dd, arrList[k + 1], S21, 0xF61E2562);
                    dd = GG(dd, aa, bb, cc, arrList[k + 6], S22, 0xC040B340);
                    cc = GG(cc, dd, aa, bb, arrList[k + 11], S23, 0x265E5A51);
                    bb = GG(bb, cc, dd, aa, arrList[k + 0], S24, 0xE9B6C7AA);
                    aa = GG(aa, bb, cc, dd, arrList[k + 5], S21, 0xD62F105D);
                    dd = GG(dd, aa, bb, cc, arrList[k + 10], S22, 0x2441453);
                    cc = GG(cc, dd, aa, bb, arrList[k + 15], S23, 0xD8A1E681);
                    bb = GG(bb, cc, dd, aa, arrList[k + 4], S24, 0xE7D3FBC8);
                    aa = GG(aa, bb, cc, dd, arrList[k + 9], S21, 0x21E1CDE6);
                    dd = GG(dd, aa, bb, cc, arrList[k + 14], S22, 0xC33707D6);
                    cc = GG(cc, dd, aa, bb, arrList[k + 3], S23, 0xF4D50D87);
                    bb = GG(bb, cc, dd, aa, arrList[k + 8], S24, 0x455A14ED);
                    aa = GG(aa, bb, cc, dd, arrList[k + 13], S21, 0xA9E3E905);
                    dd = GG(dd, aa, bb, cc, arrList[k + 2], S22, 0xFCEFA3F8);
                    cc = GG(cc, dd, aa, bb, arrList[k + 7], S23, 0x676F02D9);
                    bb = GG(bb, cc, dd, aa, arrList[k + 12], S24, 0x8D2A4C8A);
                    aa = HH(aa, bb, cc, dd, arrList[k + 5], S31, 0xFFFA3942);
                    dd = HH(dd, aa, bb, cc, arrList[k + 8], S32, 0x8771F681);
                    cc = HH(cc, dd, aa, bb, arrList[k + 11], S33, 0x6D9D6122);
                    bb = HH(bb, cc, dd, aa, arrList[k + 14], S34, 0xFDE5380C);
                    aa = HH(aa, bb, cc, dd, arrList[k + 1], S31, 0xA4BEEA44);
                    dd = HH(dd, aa, bb, cc, arrList[k + 4], S32, 0x4BDECFA9);
                    cc = HH(cc, dd, aa, bb, arrList[k + 7], S33, 0xF6BB4B60);
                    bb = HH(bb, cc, dd, aa, arrList[k + 10], S34, 0xBEBFBC70);
                    aa = HH(aa, bb, cc, dd, arrList[k + 13], S31, 0x289B7EC6);
                    dd = HH(dd, aa, bb, cc, arrList[k + 0], S32, 0xEAA127FA);
                    cc = HH(cc, dd, aa, bb, arrList[k + 3], S33, 0xD4EF3085);
                    bb = HH(bb, cc, dd, aa, arrList[k + 6], S34, 0x4881D05);
                    aa = HH(aa, bb, cc, dd, arrList[k + 9], S31, 0xD9D4D039);
                    dd = HH(dd, aa, bb, cc, arrList[k + 12], S32, 0xE6DB99E5);
                    cc = HH(cc, dd, aa, bb, arrList[k + 15], S33, 0x1FA27CF8);
                    bb = HH(bb, cc, dd, aa, arrList[k + 2], S34, 0xC4AC5665);
                    aa = II(aa, bb, cc, dd, arrList[k + 0], S41, 0xF4292244);
                    dd = II(dd, aa, bb, cc, arrList[k + 7], S42, 0x432AFF97);
                    cc = II(cc, dd, aa, bb, arrList[k + 14], S43, 0xAB9423A7);
                    bb = II(bb, cc, dd, aa, arrList[k + 5], S44, 0xFC93A039);
                    aa = II(aa, bb, cc, dd, arrList[k + 12], S41, 0x655B59C3);
                    dd = II(dd, aa, bb, cc, arrList[k + 3], S42, 0x8F0CCC92);
                    cc = II(cc, dd, aa, bb, arrList[k + 10], S43, 0xFFEFF47D);
                    bb = II(bb, cc, dd, aa, arrList[k + 1], S44, 0x85845DD1);
                    aa = II(aa, bb, cc, dd, arrList[k + 8], S41, 0x6FA87E4F);
                    dd = II(dd, aa, bb, cc, arrList[k + 15], S42, 0xFE2CE6E0);
                    cc = II(cc, dd, aa, bb, arrList[k + 6], S43, 0xA3014314);
                    bb = II(bb, cc, dd, aa, arrList[k + 13], S44, 0x4E0811A1);
                    aa = II(aa, bb, cc, dd, arrList[k + 4], S41, 0xF7537E82);
                    dd = II(dd, aa, bb, cc, arrList[k + 11], S42, 0xBD3AF235);
                    cc = II(cc, dd, aa, bb, arrList[k + 2], S43, 0x2AD7D2BB);
                    bb = II(bb, cc, dd, aa, arrList[k + 9], S44, 0xEB86D391);
                    aa = AddUnsigned(aa, AA);
                    bb = AddUnsigned(bb, BB);
                    cc = AddUnsigned(cc, CC);
                    dd = AddUnsigned(dd, DD);
                }
                if (bit == 32)
                {
                    return WordToHex(aa) + WordToHex(bb) + WordToHex(cc) + WordToHex(dd);
                }
                else
                {
                    return WordToHex(bb) + WordToHex(cc);
                }
            }

            /// <summary>
            /// 无符号右移，与JS中的>>>等价
            /// </summary>
            /// <param name="x">要移位的数</param>
            /// <param name="y">移位数</param>
            /// <returns></returns>
            private static dynamic UIntMoveRight(dynamic x, dynamic y)
            {
                dynamic mask = 0x7fffffff; //Integer.MAX_VALUE
                for (dynamic i = 0; i < y; i++)
                {
                    x >>= 1;
                    x &= mask;
                }
                return x;
            }


            /// <summary>
            /// js charCodeAt=>c#
            /// </summary>
            /// <param name="inpString"> </param>
            /// <param name="index"></param>
            /// <returns></returns>
            private static string CharCodeAt(string inpString,int index)
            {
                string outString = "";
                for (var i = 0; i < inpString.Length; i++)
                {
                    if (i==index)
                    {
                        outString = ((int)inpString[i]).ToString();
                        break;
                    }
                }
                return outString;
            }
        }

    }
}

大部分修改的都保留了原来的js注释。 中间过程 运行看结果 发现值不对 一步一步调试  c#调试到 ，js就调试到那一步一步 确保每一步的值都相同 。在调试过程 找问题 那个变量值不对 。慢慢修正。

转载于:https://www.cnblogs.com/y112102/p/11024421.html

c#学习笔记
m0_70062945的博客
11-22 737
C#语言基础学习
前段JavaScript学习---狂神说java笔记
rzz65452064的博客
05-12 1327
前段 JavaScript 狂神说java（JavaScript）原视频地址 解译 归属 备注 Script 脚本 脚本语言 alert 警觉，弹窗 Script console 控制台 Script log 日志，打印 console. Element 基本部分,测试 浏览器调试 Source 源码 浏览器调试 Network 网络 浏览器调试 Application 应用 浏览器调试 var 全局变量 Script let 局部变量
解决java 与C# MD5 不一致问题 代码
06-25
解决java 与C# MD5 不一致问题
MD5加密C#代码
wr6521941的专栏
09-03 392
不用添加任何包，只需一个代码即可
JS MD5对应C#的MD5加密方法
欧巴酱的CSDN
12-23 1636
JS： js文件：https://mp.csdn.net/postedit/103660692 var md5str = b64_md5(str) C#： /// <summary> /// 对字符串进MD5加密 /// </summary> /// <param name="sourceSt...
C# js asp.net 字符串MD5加密GetMD5Hash
weixin_30393907的博客
10-29 170
杨中科老师 C# /// <summary> /// 把字符转换成MD5 /// </summary> /// <param name="input"></param> /// <returns></returns> ...
C# MD5加密
jsrgckf的专栏
10-30 750
using System; using System.Collections.Generic; using System.Configuration; using System.Linq; using System.Security.Cryptography; using System.Text; using Newtonsoft.Json; public static string Bul...
2022Java基础、语法最全面试题，为秋招做好准备
a6636656的博客
07-07 872
1.Java跨平台原理（字节码文件、虚拟机）C/C++语言都直接编译成针对特定平台机器码。如果要跨平台，需要使用相应的编译器重新编译。Java源程序（.java）要先编译成与平台无关的字节码文件(.class)，然后字节码文件再解释成机器码运行。解释是通过Java虚拟机来执行的。字节码文件不面向任何具体平台，只面向虚拟机。Java虚拟机是可运行Java字节码文件的虚拟计算机。不同平台的虚拟机是不同的，但它们都提供了相同的接口。Java语言具有一次编译，到处运行的特点。就是说编译后的.class可以跨平台运行
C#编程使用技巧
UP的专栏
02-04 3295
展开注册表到[HKEY＿CURRENT＿USER/keyboardlayout/preload]分支，在preload主键下面会有数个以序列号1、2、3、4命名的子键，子键的数目和计算机上安装的输入法一一对应，其中的1、2、3、4代表的是输入法的排列顺序。所以，要调整输入法的顺序，只需修改和1、2、3、4对应的键值即可。例如，想让微软拼音和五笔字型互换位置，就可以在子键2上右击，选择“重命名”选项，先把它改为“w”或其他不存在的名称，接着将子键4改名为2，最后将w改名为4即可。
.Net 面试题整理(一)
热门推荐
fuchenxuan blog
05-22 1万+
.Net 面试题整理(一) 好久的资料了，拿出来分享给大家，主要是记录一些面试题整理。Main函数是什么？在程序中使用Main函数有什么需要注意的地方？ Q：程序的入口函数！函数名字不能改变；一个程序中有且只有一个Main函数。 CLR是什么？程序集是什么？当运行一个程序集的时候，CLR做了什么事情？ Q:Common Language RunTime 公共语言运行时。 编译后代码的集合
JS版MD5加密
11-13
可以直接调用 我试验了 可以使用
汉字MD5加密JS与C#后台不一致问题
piaochong2006的博客
02-07 767
在编写前端接口MD5加密的时候出现一个问题，前端如何更改，始终与后台的MD5加密不同，最后发现是因为汉字问题。 网上找了很多解决方案都不行，看到有一个人说利用另类编码加密，然后再进行MD5加密可以完成。我利用这个思路，首先肯定想到用BASE64先给字符串编码，发现JSON字符串JSBASE64编码无法正常使用，然后又想到用**encodeURI()**来实现，最后发现它不编码的字符太多，所以又改成**encodeURIComponent()**.不过它不编码的字符也挺多，当前检查他对双引号，反斜...
C#Winform调用JS方法、以QQ登录密码的md5为例
dicheng7683的博客
08-10 118
C# 调用代码 ScriptControlClass js = new ScriptControlClass(); js.Language = "JScript"; js.AddCode(textBox2.Text);//JS代码 string result = null; result = js.Eval(textBox1.Text).ToString(); //调用函数...
MD5：js，java，C#三种语言加密结果不同解决办法
bannieji5236的博客
09-20 1670
最近遇到前端js MD5加密与后端C#与Java MD5加密结果不一致的问题，所以写个关于此问题的解决办法 前端js引用的md5类库，类库地址：https://blueimp.github.io/JavaScript-MD5/ 这个是没有办法动的 所以修改了一下java与C#的md5算法，代码如下： C#代码 #region 获取MD5加密 public ...
C#编程实现MD5加密方法详解
"C# 实现MD5加密技术用于增强数据安全性" 在计算机科学领域，数据安全至关重要，尤其是在网络通信和存储中。MD5（Message-Digest Algorithm 5）是一种广泛使用的散列函数，它能够将任意长度的数据转化为固定长度的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值