httpModel 实现页面url加密

     这其实是以前工作中的一个功能，当时觉得很好奇，是如何实现自动加密页面中的url的，如GridView中的链接绑定等。通过加密后的url的表现形式就如page.aspx?EncodingQuery=2IYZ2UW1bS2rPAuKZf4WWw==。今天在复习asp.net的基础常识时，既然想起，就来看看是如何实现的（这里主要还是参考DC.Web.HttpCompress）。

    1、首先，新建一个asp.net网站项目，在默认的页面上我们来绑定一个Gridview控件。

   

  <div>
        <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="False" Height="285px" Width="638px">
            <Columns>
                <asp:HyperLinkField DataNavigateUrlFields="Id" DataNavigateUrlFormatString="~/page.aspx?id={0}" HeaderText="Title" DataTextField="Name" />
            </Columns>
        </asp:GridView>
    </div>

 2、 在页面的后台方法中进行绑定数据：

   List<LinkModel> list = new List<LinkModel>(2);
                list.Add(new LinkModel()
                    {
                        Id ="11",
                        Name = "ltq"
                    });
                list.Add(new LinkModel()
                {
                    Id = "12"
                    ,Name = "hb"
                });
                GridView1.DataSource = list;
                GridView1.DataBind();

3、 点击F5，然后查看生成的源代码：

可以看到，这里还是原始的未加密的url字符串。

4、 好，现在新增一个HttpModel.cs:

   public class HttpModule : IHttpModule
    {
        public void Dispose()
        {

        }

        public void Init(HttpApplication context)
        {
            
            context.BeginRequest += context_BeginRequest;
           
            context.PostReleaseRequestState += context_PostReleaseRequestState;
        }


        void context_BeginRequest(object sender, EventArgs e)
        {
            HttpApplication app = (HttpApplication) sender;
            HttpContext context = app.Context;
            string currentPath = context.Request.Url.PathAndQuery;
            int index = currentPath.IndexOf("?EncodingQuery=");
            if(index>0)
            {
                string eQuery = currentPath.Substring(index+1);
                string encryptQuery = currentPath.Substring(index + 15);
                string query = AESUtil.Decrypt(encryptQuery,CommonUtil.AesKey );
                currentPath = currentPath.Replace(eQuery,   query);
                context .RewritePath(currentPath);
            }
        }
       
        private void context_PostReleaseRequestState(object sender, EventArgs e)
        {
            HttpApplication app = (HttpApplication) sender;
          
            if (app.Request["HTTP_X_MICROSOFTAJAX"] != null)
                return;

            // fix to handle caching appropriately
            // see http://www.pocketsoap.com/weblog/2003/07/1330.html
            // Note, this header is added only when the request
            // has the possibility of being compressed...
            // i.e. it is not added when the request is excluded from
            // compression by CompressionLevel, Path, or MimeType            
            string realPath = "";
            Configuration settings = null;
            // get the config settings
          
            app.Context.Response.Cache.VaryByHeaders["Accept-Encoding"] = true;
            string acceptedTypes = app.Request.Headers["Accept-Encoding"];

            // if we couldn't find the header, bail out
            if (acceptedTypes == null)
                return;

            // Current response stream

            //Stream baseStream = app.Response.Filter;
            CompressionPageFilter filter = new CompressionPageFilter(app.Response.Filter);
            filter .AesKey =CommonUtil .AesKey;
            
            filter.App = app;
            app.Response.Filter = filter;

            // check for buggy versions of Internet Explorer
            if (app.Context.Request.Browser.Browser == "IE")
            {
                if (app.Context.Request.Browser.MajorVersion < 6)
                    return;
                else if (app.Context.Request.Browser.MajorVersion == 6 &&
                         !string.IsNullOrEmpty(app.Context.Request.ServerVariables["HTTP_USER_AGENT"]) &&
                         app.Context.Request.ServerVariables["HTTP_USER_AGENT"].Contains("EV1"))
                    return;
            }
            acceptedTypes = acceptedTypes.ToLower();
          
            if (filter.Compress != "none")
                app.Response.AppendHeader("Content-Encoding", filter.Compress);
        }

        private class CompressionPageFilter : Stream
        {

            public string AesKey { get; set; }
            private HttpApplication app;

            public HttpApplication App
            {
                get { return app; }
                set { app = value; }
            }

            private string compress = "none";

            public string Compress
            {
                get { return compress; }
                set { compress = value; }
            }

            private StringBuilder responseHtml;

     

            private const string _linkPattern =
                "(?<HTML><a[^>]*href\\s*=\\s*[\\\"\\']?(?<HREF>[^\"'>\\s]*)[\\\"\\']?[^>]*>)";

            public CompressionPageFilter(Stream sink)
            {
                _sink = sink;
                responseHtml = new StringBuilder();
            }

            private Stream _sink;

            #region Properites

            public override bool CanRead
            {
                get { return true; }
            }

            public override bool CanSeek
            {
                get { return true; }
            }

            public override bool CanWrite
            {
                get { return true; }
            }

            public override void Flush()
            {
                _sink.Flush();
            }

            public override long Length
            {
                get { return 0; }
            }

            private long _position;

            public override long Position
            {
                get { return _position; }
                set { _position = value; }
            }

            #endregion

            #region Methods

            public override int Read(byte[] buffer, int offset, int count)
            {
                return _sink.Read(buffer, offset, count);
            }

            public override long Seek(long offset, SeekOrigin origin)
            {
                return _sink.Seek(offset, origin);
            }

            public override void SetLength(long value)
            {
                _sink.SetLength(value);
            }

            public override void Close()
            {
                _sink.Close();
            }

            public override void Write(byte[] buffer, int offset, int count)
            {
                string strBuffer = UTF8Encoding.UTF8.GetString(buffer, offset, count);

                // ---------------------------------
                // Wait for the closing </html> tag
                // ---------------------------------
                Regex eof = new Regex("</html>", RegexOptions.IgnoreCase);

                responseHtml.Append(strBuffer);

                if (eof.IsMatch(strBuffer))
                {
                    // when compressing the html, some end characters are cut off.  Add some spaces so it cuts the spaces off instead of important characters
                    responseHtml.Append(Environment.NewLine + Environment.NewLine + Environment.NewLine +
                                        Environment.NewLine + Environment.NewLine + Environment.NewLine +
                                        Environment.NewLine + Environment.NewLine);
                    string html = responseHtml.ToString();

                    // replace the css and js with HttpHandlers that compress the output       
                    html = ReplaceLink(html);


                    byte[] data = UTF8Encoding.UTF8.GetBytes(html);


                    _sink.Write(data, 0, data.Length);
                }
            }

            public string ReplaceLink(string html)
            {
                // create a list of the stylesheets
                List<string> stylesheets = new List<string>();
                // create a dictionary used for combining css in the same directory
                Dictionary<string, List<string>> css = new Dictionary<string, List<string>>();

                // create a base uri which will be used to get the uris to the css
                Uri baseUri = new Uri(app.Request.Url.AbsoluteUri);

                // loop through each match
                foreach (Match match in Regex.Matches(html, _linkPattern, RegexOptions.IgnoreCase))
                {
                    // this is the enire match and will be used to replace the link
                    string linkHtml = match.Groups[0].Value;
                    // this is the href of the link
                    string href = match.Groups[2].Value;

                    // get a uri from the base uri, this will resolve any relative and absolute links
                    Uri uri = new Uri(baseUri, href);
                    string file = "";
                    // check to see if it is a link to a local file
                    if (uri.Host == baseUri.Host)
                    {
                        // check to see if it is local to the application
                        if (uri.AbsolutePath.ToLower().StartsWith(app.Context.Request.ApplicationPath.ToLower()))
                        {
                            // this combines css files in the same directory into one file (actual combining done in HttpHandler)
                            int index = uri.AbsolutePath.LastIndexOf("/");
                            string path = uri.AbsolutePath.Substring(0, index + 1);
                            file = uri.AbsolutePath.Substring(index + 1);
                            if (!css.ContainsKey(path))
                                css.Add(path, new List<string>());
                            css[path].Add(file + (href.Contains("?") ? href.Substring(href.IndexOf("?")) : ""));
                            // replace the origianl links with blanks
                            var query = uri.Query;
                            if (query != "")
                            {
                                string temp = query.Substring(1);
                                string encryQuery = "?EncodingQuery=" + AESUtil.Encrypt(temp, AesKey);
                                string newlinkHtml = linkHtml.Replace(query, encryQuery);
                                html = html.Replace(linkHtml, newlinkHtml);

                            }

                            continue;
                        }
                         
                    }
                
                }

                return html;
            }





            #endregion

        }
    }

代码较长，但应该很清晰，在代码中是通过AES加解密链接字符串的参数的。

5、注册这个HttpModel，在web.config中添加即可:

  <system.webServer>
    <handlers>
    </handlers>
    <modules>
      <add name="HttpCompressModule" type="HttpModelTest.HttpModule"/>
    </modules>
  </system.webServer>

因为是在Vs2012下进行的测试，配置文件与在iis6中的配置是不同的。

6、再次F5进入调试，查看源代码:

可以看到，这里的参数都已经被加密了。

7、 我们再来测试看看能不能正确解密这个字符串，在page.aspx的后台代码中添加如下代码：

  protected void Page_Load(object sender, EventArgs e)
        {
            string id = Request["id"];
            Response.Write(id);
        }

F5进入测试：

可以看到，正确输出id值。

8、总结：

a）加解密算法的选择是否正确，这个还得研究，毕竟感觉加密后的url的字符太多了。

b）正则获取url的是否正确，会不会把其他文本内容中的url也加密了？

c）性能，每次这样的遍历页面，进行匹配，对性能的影响有多大？