精华内容
下载资源
问答
  • sha16
    千次阅读
    2017-12-07 17:00:06
    function SHA1 (msg) {
      function rotate_left(n,s) {
        var t4 = ( n<<s ) | (n>>>(32-s));
        return t4;
      };
      function lsb_hex(val) {
        var str="";
        var i;
        var vh;
        var vl;
        for( i=0; i<=6; i+=2 ) {
          vh = (val>>>(i*4+4))&0x0f;
          vl = (val>>>(i*4))&0x0f;
          str += vh.toString(16) + vl.toString(16);
        }
        return str;
      };
      function cvt_hex(val) {
        var str="";
        var i;
        var v;
        for( i=7; i>=0; i-- ) {
          v = (val>>>(i*4))&0x0f;
          str += v.toString(16);
        }
        return str;
      };
      function Utf8Encode(string) {
        string = string.replace(/\r\n/g,"\n");
        var utftext = "";
        for (var n = 0; n < string.length; n++) {
          var c = string.charCodeAt(n);
          if (c < 128) {
            utftext += String.fromCharCode(c);
          }
          else if((c > 127) && (c < 2048)) {
            utftext += String.fromCharCode((c >> 6) | 192);
            utftext += String.fromCharCode((c & 63) | 128);
          }
          else {
            utftext += String.fromCharCode((c >> 12) | 224);
            utftext += String.fromCharCode(((c >> 6) & 63) | 128);
            utftext += String.fromCharCode((c & 63) | 128);
          }
        }
        return utftext;
      };
      var blockstart;
      var i, j;
      var W = new Array(80);
      var H0 = 0x67452301;
      var H1 = 0xEFCDAB89;
      var H2 = 0x98BADCFE;
      var H3 = 0x10325476;
      var H4 = 0xC3D2E1F0;
      var A, B, C, D, E;
      var temp;
      msg = Utf8Encode(msg);
      var msg_len = msg.length;
      var word_array = new Array();
      for( i=0; i<msg_len-3; i+=4 ) {
        j = msg.charCodeAt(i)<<24 | msg.charCodeAt(i+1)<<16 |
        msg.charCodeAt(i+2)<<8 | msg.charCodeAt(i+3);
        word_array.push( j );
      }
      switch( msg_len % 4 ) {
        case 0:
          i = 0x080000000;
        break;
        case 1:
          i = msg.charCodeAt(msg_len-1)<<24 | 0x0800000;
        break;
        case 2:
          i = msg.charCodeAt(msg_len-2)<<24 | msg.charCodeAt(msg_len-1)<<16 | 0x08000;
        break;
        case 3:
          i = msg.charCodeAt(msg_len-3)<<24 | msg.charCodeAt(msg_len-2)<<16 | msg.charCodeAt(msg_len-1)<<8  | 0x80;
        break;
      }
      word_array.push( i );
      while( (word_array.length % 16) != 14 ) word_array.push( 0 );
      word_array.push( msg_len>>>29 );
      word_array.push( (msg_len<<3)&0x0ffffffff );
      for ( blockstart=0; blockstart<word_array.length; blockstart+=16 ) {
        for( i=0; i<16; i++ ) W[i] = word_array[blockstart+i];
        for( i=16; i<=79; i++ ) W[i] = rotate_left(W[i-3] ^ W[i-8] ^ W[i-14] ^ W[i-16], 1);
        A = H0;
        B = H1;
        C = H2;
        D = H3;
        E = H4;
        for( i= 0; i<=19; i++ ) {
          temp = (rotate_left(A,5) + ((B&C) | (~B&D)) + E + W[i] + 0x5A827999) & 0x0ffffffff;
          E = D;
          D = C;
          C = rotate_left(B,30);
          B = A;
          A = temp;
        }
        for( i=20; i<=39; i++ ) {
          temp = (rotate_left(A,5) + (B ^ C ^ D) + E + W[i] + 0x6ED9EBA1) & 0x0ffffffff;
          E = D;
          D = C;
          C = rotate_left(B,30);
          B = A;
          A = temp;
        }
        for( i=40; i<=59; i++ ) {
          temp = (rotate_left(A,5) + ((B&C) | (B&D) | (C&D)) + E + W[i] + 0x8F1BBCDC) & 0x0ffffffff;
          E = D;
          D = C;
          C = rotate_left(B,30);
          B = A;
          A = temp;
        }
        for( i=60; i<=79; i++ ) {
          temp = (rotate_left(A,5) + (B ^ C ^ D) + E + W[i] + 0xCA62C1D6) & 0x0ffffffff;
          E = D;
          D = C;
          C = rotate_left(B,30);
          B = A;
          A = temp;
        }
        H0 = (H0 + A) & 0x0ffffffff;
        H1 = (H1 + B) & 0x0ffffffff;
        H2 = (H2 + C) & 0x0ffffffff;
        H3 = (H3 + D) & 0x0ffffffff;
        H4 = (H4 + E) & 0x0ffffffff;
      }
      var temp = cvt_hex(H0) + cvt_hex(H1) + cvt_hex(H2) + cvt_hex(H3) + cvt_hex(H4);
      return temp.toUpperCase();
    }

    本文转自:http://www.jb51.net/article/79041.htm

    更多相关内容
  • SHA常用算法实现(SHA-1, SHA256, SHA384, SHA512),使用C语言,包含4个相对独立的算法,并有demo调用示例。
  • 话不多说,直接上码 加密服务类: using System; using System.Security.Cryptography; using System.Text; using System.Web.Security; namespace ConsoleApp.Services ... /// Sha加密和Md5加密 Cr...

    话不多说,直接上码

     

    加密服务类:

    using System;
    using System.Security.Cryptography;
    using System.Text;
    using System.Web.Security;
    
    namespace ConsoleApp.Services
    {
        /// <summary>
        /// Sha加密和Md5加密   CreateDate:2020-01-04 16:00:13;Author:wenhao.zhang
        /// Sha1和Md5加密对比:
        /// Sha1加密更不易被破解
        /// Md5加密运算更快
        /// </summary>
        public class TestEncrypt1Service
        {
            /// <summary>
            /// Sha1加密(加密之后长度为40)   CreateDate:2020-01-04 15:51:37;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="isUpper"></param>
            /// <param name="encoding"></param>
            /// <returns></returns>
            public static string Sha1(string source, bool isUpper, Encoding encoding = null)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    if (encoding == null)
                    {
                        encoding = Encoding.UTF8;
                    }
                    var bytes = encoding.GetBytes(source);
                    var data = SHA1.Create().ComputeHash(bytes);
                    var sb = new StringBuilder();
                    string o = "x2";
                    if (isUpper)
                    {
                        o = o.ToUpper();
                    }
                    foreach (var s in data)
                    {
                        string t = s.ToString(o);
                        sb.Append(t);
                    }
                    result = sb.ToString();
                    Console.WriteLine($"加密前:{source}(长度{source.Length})");
                    Console.WriteLine($"加密后:{result}(长度{result.Length})");
                });
                return result;
            }
    
            /// <summary>
            /// Sha加密(加密之后长度为44)   CreateDate:2020-01-04 15:52:50;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="key"></param>
            /// <param name="encoding"></param>
            /// <returns></returns>
            public static string Sha(string source, string key, Encoding encoding = null)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    string secret = "HMACSHA256";
                    if (encoding == null)
                    {
                        encoding = Encoding.UTF8;
                    }
                    using (var instance = KeyedHashAlgorithm.Create(secret))
                    {
                        instance.Key = encoding.GetBytes(key.ToCharArray());
                        var bytes = encoding.GetBytes(source);
                        var bytesHash = instance.ComputeHash(bytes);
                        result = Convert.ToBase64String(bytesHash);
                    }
                });
                Console.WriteLine($"加密前:{source}(长度{source.Length})");
                Console.WriteLine($"加密后:{result}(长度{result.Length})");
                return result;
            }
    
            /// <summary>
            /// Md5加密(加密之后长度为32)   CreateDate:2020-01-04 15:53:30;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="isUpper"></param>
            /// <param name="encoding"></param>
            /// <returns></returns>
            public static string Md5Old32(string source, bool isUpper, Encoding encoding = null)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    if (encoding == null)
                    {
                        encoding = Encoding.UTF8;
                    }
                    var provider = new MD5CryptoServiceProvider();
                    var bytes = encoding.GetBytes(source);
                    var hashBytes = provider.ComputeHash(bytes);
                    string o = "x2";
                    if (isUpper)
                    {
                        o = o.ToUpper();
                    }
                    var sb = new StringBuilder();
                    foreach (var b in hashBytes)
                    {
                        string t = b.ToString(o);
                        sb.Append(t);
                    }
                    result = sb.ToString();
                });
                Console.WriteLine($"加密前:{source}(长度{source.Length})");
                Console.WriteLine($"加密后:{result}(长度{result.Length})");
                return result;
            }
    
            /// <summary>
            /// Md5-16加密(加密之后长度为32,但是加密结果上述结果不同)   CreateDate:2020-01-04 15:54:22;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="encoding"></param>
            /// <returns></returns>
            public static string Md5New16(string source, Encoding encoding = null)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    if (encoding == null)
                    {
                        encoding = Encoding.UTF8;
                    }
                    var provider = new MD5CryptoServiceProvider();
                    var bytes = encoding.GetBytes(source);
                    var hashBytes = provider.ComputeHash(bytes, 4, 8);
                    string t = BitConverter.ToString(hashBytes);
                    result = t.Replace("-", string.Empty);
                });
                Console.WriteLine($"加密前:{source}(长度{source.Length})");
                Console.WriteLine($"加密后:{result}(长度{result.Length})");
                return result;
            }
    
            /// <summary>
            /// Md5加密(加密之后长度为32,加密结果和上述的Md5加密结果相同,只是实现方式不同罢了)   CreateDate:2020-01-04 15:55:08;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="isUpper"></param>
            /// <param name="encoding"></param>
            /// <returns></returns>
            public static string Md5New32(string source, bool isUpper, Encoding encoding = null)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    if (encoding == null)
                    {
                        encoding = Encoding.UTF8;
                    }
                    var instance = MD5.Create();
                    var bytes = encoding.GetBytes(source);
                    var hashBytes = instance.ComputeHash(bytes);
                    string o = "x2";
                    if (isUpper)
                    {
                        o = o.ToUpper();
                    }
                    var sb = new StringBuilder();
                    foreach (var b in hashBytes)
                    {
                        string t = b.ToString(o);
                        sb.Append(t);
                    }
                    result = sb.ToString();
                });
                Console.WriteLine($"加密前:{source}(长度{source.Length})");
                Console.WriteLine($"加密后:{result}(长度{result.Length})");
                return result;
            }
    
            /// <summary>
            /// Md5-64加密(加密之后长度为24,加密结果和上述的Md5加密结果不同)   CreateDate:2020-01-04 15:56:33;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="encoding"></param>
            /// <returns></returns>
            public static string Md5New64(string source, Encoding encoding = null)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    if (encoding == null)
                    {
                        encoding = Encoding.UTF8;
                    }
                    var instance = MD5.Create();
                    var bytes = encoding.GetBytes(source);
                    var hashBytes = instance.ComputeHash(bytes);
                    result = Convert.ToBase64String(hashBytes);
                });
                Console.WriteLine($"加密前:{source}(长度{source.Length})");
                Console.WriteLine($"加密后:{result}(长度{result.Length})");
                return result;
            }
    
            /// <summary>
            /// Md5加密(加密之后长度为32,加密结果和上述的Md5加密结果相同,只是实现方式不同,该方法已过时,需要引用System.Web)   CreateDate:2020-01-04 15:57:32;Author:wenhao.zhang
            /// </summary>
            /// <param name="source"></param>
            /// <param name="isUpper"></param>
            /// <returns></returns>
            public static string Md5New32Overtime(string source, bool isUpper)
            {
                string result = string.Empty;
                if (string.IsNullOrWhiteSpace(source))
                {
                    return result;
                }
                LingbugService.RunTry(() =>
                {
                    string type = "MD5";
                    var t = FormsAuthentication.HashPasswordForStoringInConfigFile(source, type);
                    result = isUpper ? t : t.ToLower();
                });
                Console.WriteLine($"加密前:{source}(长度{source.Length})");
                Console.WriteLine($"加密后:{result}(长度{result.Length})");
                return result;
            }
        }
    }
    

     

    测试代码:

                string password = "testPassword123.0";
                Console.WriteLine("Sha1(大写):" + TestEncrypt1Service.Sha1(password, true));
                Console.WriteLine();
                Console.WriteLine("Sha1(小写):" + TestEncrypt1Service.Sha1(password, false));
                Console.WriteLine();
                Console.WriteLine("Sha:" + TestEncrypt1Service.Sha(password, "zwh"));
                Console.WriteLine();
                Console.WriteLine("Md5Old(大写):" + TestEncrypt1Service.Md5Old32(password, true));
                Console.WriteLine();
                Console.WriteLine("Md5Old(小写):" + TestEncrypt1Service.Md5Old32(password, false));
                Console.WriteLine();
                Console.WriteLine("Md5-16:" + TestEncrypt1Service.Md5New16(password));
                Console.WriteLine();
                Console.WriteLine("Md5New(大写):" + TestEncrypt1Service.Md5New32(password, true));
                Console.WriteLine();
                Console.WriteLine("Md5New(小写):" + TestEncrypt1Service.Md5New32(password, false));
                Console.WriteLine();
                Console.WriteLine("Md5-64:" + TestEncrypt1Service.Md5New64(password));
                Console.WriteLine();
                Console.WriteLine("过时的Md5-32(大写):" + TestEncrypt1Service.Md5New32Overtime(password, true));
                Console.WriteLine();
                Console.WriteLine("过时的Md5-32(小写):" + TestEncrypt1Service.Md5New32Overtime(password, false));
                Console.WriteLine();

     

    运行结果:

    展开全文
  • SHA256加密.zip

    2021-06-30 18:22:59
    特别干净的SHA256加密工具,加密加过的值可直接在百度在线SHA256加密结果完全一致 ,实现原理用java原生的摘要实现SHA256加密。
  • Vue-常用加密(MD5,DES,SHA256,BASE64,SHA1,RSA)
  • 支付宝签名,SHA256WithRsa签名,SHA1WithRSA签名, delph所有源码,有需要的朋友绝对值这个分数!
  • MD5、SHA1、SHA256以及SHA512加解密算法实现源码。 实现语言:C代码实现
  • SHA-1_dsa_C++_VS2019_SHA1_

    2021-09-30 09:04:23
    密码学实验SHA1 算法简介 安全哈希算法(Secure Hash Algorithm)主要适用于数字签名标准(Digital Signature Standard DSS)里面定义的数字签名算法(Digital Signature Algorithm DSA)。对于长度小于 2^64 位的...
  • SHA-1算法的C语言实现,学校专业课实验内容。
  • 主要介绍了Java SHA-256加密的两种实现方法,结合实例形式分析了java实现SHA-256加密的实现代码与相关注意事项,需要的朋友可以参考下
  • PIC汇编实现SHA加密算法。在PIC16F73上实现
  • SHA-1 到底是什么?(介绍和用法)

    万次阅读 2019-12-27 19:30:19
    SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出...

    参考:blog.sina.com.cn/s/blog_a42c4c6c0102woq9.html

    安全哈希算法(Secure Hash Algorithm)

         SHA-1是一种数据加密算法,该算法的思想是接收一段明文,然后以一种不可逆的方式将它转换成一段(通常更小)密文,也可以简单的理解为取一串输入码(称为预映射或信息),并把它们转化为长度较短、位数固定的输出序列即散列值(也称为信息摘要或信息认证代码)的过程。 

          该算法输入报文的长度不限,产生的输出是一个160位的报文摘要。输入是按512 位的分组进行处理的。SHA-1是不可逆的、防冲突,并具有良好的雪崩效应。

           数字签名的原理是将要传送的明文通过一种函数运算(Hash)转换成报文摘要(不同的明文对应不同的报文摘要),报文摘要加密后与明文一起传送给接受方,接受方将接受的明文产生新的报文摘要与发送方的发来报文摘要解密比较,比较结果一致表示明文未被改动,如果不一致表示明文已被篡改

    简单文字描述:

    客户端:

    在APP 与 后端服务器接口调用的时候,将需要传输的参数进行关键参数(如:String A,String B)进行SHA1加密,获取加密之后的摘要(C);然后在接口调用的时候将参数原文(A,B) 和 加密的摘要(C) 一起传输给后台服务器;

    服务器:

    后台接口接受相关参数,然后将(A,B) 在后台进行SHA1加密,获取加密摘要D,最后将D与C进行比较,如果C == D ,则 A和B 在传输过程中参数没有被窃取改变;如果 C != D,则说明A和B已经在传输过程中发生了改变,最好不要使用!

    注:需要在前后端共同定义一个加密额外秘钥,在进行SHA1加密的过程中添加进去,这样即使在客户端拦截到我们需要传输的参数,进行SHA1 加密,但是由于其不知道 秘钥,所以进行SHA1加密出来的摘要肯定和后端用相关参数、秘钥计算出来的结果不同

    关键SHA1加密代码简单举例:

     public static String createSignature(String... arr) {

            try {

                Arrays.sort(arr);

                StringBuilder content = new StringBuilder();

                for (int i = 0; i < arr.length; i++) {

                    content.append(arr[i]);

                }

                MessageDigest md = MessageDigest.getInstance("SHA-1");

                byte[] digest = md.digest(content.toString().getBytes());

                return byteToStr(digest);

            } catch (Exception e) {

            }

            return null;

        }

    展开全文
  • void sha256_get(uint8_t hash[32], const uint8_t *message, int length);/*此函数用于对消息计算摘要值,输入任意大小消息,输出32字节摘要值*/ void hmac_sha256_get(uint8_t digest[32], uint8_t *message, int...
  • ---SHA1--- DATA: 3a81f749059c9ace07e63d613857b21e2f42145b BASE64: OoH3SQWcms4H5j1hOFeyHi9CFFs= ---HMACSHA1--- DATA: 0a7ec5f83fbeb938f155a265c431a09457c43a76 BASE64: Cn7F+D++uTjxVaJlxDGglFfEOnY= --...
  • SHA256withRSA 为SHA256withRSA生成签名,验证签名,创建密钥对并保存密钥对
  • SHA256.rar

    2019-05-17 17:05:33
    无需将消息一次读入内存,通过循环调用sha256_update1即可计算摘要值,摘要值最后存储在hash[32]中;可以利用SHA256在线工具验证; sha256_init(&ctx;); sha256_update1(&ctx;, message1, 64); sha256_update1(&ctx;...
  • C#实现字符串SHA-256加密算法,非常好用,供大家学习参考。
  • 可以计算文件的SM3,MD5, SHA1,SHA256摘要值工具,支持拖拽到编辑框自动计算,也可以手动选择,支持保存到剪贴板和保存到文本文件
  • 字符串SHA256

    2018-09-18 09:04:43
    一个简单的字符串转SHA256的小程序,转换结果是大写的
  • 在utils中的util.js 文件中增加 函数 实现 字符串转换为16进制加密后的字符串 function encodeUTF8(s) { var i, r = [], c, x; for (i = 0; i < s xss=removed>> 6 & 0x1F), 0x80 + (c & 0x3F)); else { if ((x...
  • 线上工具请转到接触该项目的网站位于 作者:
  • spring框架中关于RSA sha-256加密解密,加签验签工具类
  • 主要为大家详细介绍了JavaScript SHA-256加密算法代码,具有一定的参考价值,感兴趣的朋友可以参考一下
  • 阿里云物联网套件设备登录里的加密算法,C语言源代码 用于C语言平台的子设备登录密码计算
  • Java实现SHA-1算法实例

    2020-09-03 21:49:28
    主要介绍了Java实现SHA-1算法,实例分析了java实现SHA-1算法的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
  • sha256不含盐值 sha256含盐值 sha256含盐值的校验 生成秘钥 加密AES128 解密AES128
  • HMAC-sha256.zip

    2020-03-27 16:26:31
    HMACsha256 c++实现,HMAC_SHA256(const char * msg, const char * key);
  • SHA (Secure Hash Algorithm,译作安全散列算法) 是美国国家安全局 (NSA) 设计,美国国家标准与技术研究院(NIST) 发布的一系列密码散列函数
  • 应用程序必须将要散列的消息拆分为16个字(每个32位),并通过符合AXI Lite主站发送到设备。 它们必须遵循消息的原始顺序,并根据SHA256标准进行包装。 例如,必须拆分“ abc”并按以下顺序发送 M0 M1 M1

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 113,328
精华内容 45,331
关键字:

sha16