मैं अपने ASP.NET MVC आधारित साइट के कुछ पृष्ठों के लिए HTTPS का उपयोग कैसे करूँ?
स्टीव सैंडरसन के पास पूर्वावलोकन 4 पर DRY तरीके से ऐसा करने के लिए बहुत अच्छा ट्यूटोरियल है:
http://blog.codeville.net/2008/08/05/adding-httpsssl-support-to-aspnet-mvc-rout/
क्या पूर्वावलोकन 5 के साथ एक बेहतर / अद्यतन तरीका है ?,
जवाबों:
यदि आप ASP.NET MVC 2 पूर्वावलोकन 2 या उच्चतर का उपयोग कर रहे हैं , तो आप अब बस उपयोग कर सकते हैं:
[RequireHttps]
public ActionResult Login()
{
return View();
}
हालांकि, ऑर्डर पैरामीटर ध्यान देने योग्य है, जैसा कि यहां बताया गया है ।
MVCFutures में एक 'आवश्यकताएँ' विशेषता है।
( आपके अपडेटेड ब्लॉगपोस्ट में इंगित करने के लिए एडम का धन्यवाद )
यदि आप http: // अनुरोध को स्वचालित रूप से https: // करना चाहते हैं, तो इसे अपनी कार्रवाई पद्धति पर 'पुनर्निर्देशित = सत्य' के साथ लागू करें:
[RequireSsl(Redirect = true)]
इसे भी देखें: ASP.NET MVC आवश्यकता केवल उत्पादन में
जैसा कि अमाडिएरे ने लिखा , [आवश्यकताएं] HTTPS में प्रवेश के लिए MVC 2 में शानदार काम करता है । लेकिन अगर आप केवल कुछ पृष्ठों के लिए HTTPS का उपयोग करना चाहते हैं , जैसा कि आपने कहा था, MVC 2 आपको कोई प्यार नहीं देता है - एक बार जब यह HTTPS के लिए एक उपयोगकर्ता को स्विच करता है तो वे वहां अटक जाते हैं जब तक कि आप उन्हें मैन्युअल रूप से पुनर्निर्देशित नहीं करते हैं।
मैंने जिस दृष्टिकोण का उपयोग किया है वह एक और कस्टम विशेषता का उपयोग करना है, [ExitHttpsIfNotRequired]। जब किसी कंट्रोलर या एक्शन से जुड़ा हो तो यह HTTP पर रीडायरेक्ट करेगा यदि:
यहां पोस्ट करना थोड़ा बड़ा है, लेकिन आप यहां कोड को देख सकते हैं और कुछ अतिरिक्त विवरण भी देख सकते हैं ।
इस पर डेन वाहलिन की हालिया पोस्ट इस प्रकार है:
http://weblogs.asp.net/dwahlin/archive/2009/08/25/requiring-ssl-for-asp-net-mvc-controllers.aspx
वह एक ActionFilter विशेषता का उपयोग करता है।
कुछ ActionLink एक्सटेंशन: http://www.squaredroot.com/post/2008/06/11/MVC-and-SSL.aspx या एक नियंत्रक एक्शन विशेषता जो https: // http://forums.asp.net पर रीडायरेक्ट करती है । /p/1260198/2358380.aspx#2358380
जो लोग विशेषता-उन्मुख विकास के दृष्टिकोण के प्रशंसक नहीं हैं, उनके लिए यहां एक कोड है जो मदद कर सकता है:
public static readonly string[] SecurePages = new[] { "login", "join" };
protected void Application_AuthorizeRequest(object sender, EventArgs e)
{
var pageName = RequestHelper.GetPageNameOrDefault();
if (!HttpContext.Current.Request.IsSecureConnection
&& (HttpContext.Current.Request.IsAuthenticated || SecurePages.Contains(pageName)))
{
Response.Redirect("https://" + Request.ServerVariables["HTTP_HOST"] + HttpContext.Current.Request.RawUrl);
}
if (HttpContext.Current.Request.IsSecureConnection
&& !HttpContext.Current.Request.IsAuthenticated
&& !SecurePages.Contains(pageName))
{
Response.Redirect("http://" + Request.ServerVariables["HTTP_HOST"] + HttpContext.Current.Request.RawUrl);
}
}
विशेषताओं से बचने के कई कारण हैं और उनमें से एक है यदि आप सभी सुरक्षित पृष्ठों की सूची देखना चाहते हैं तो आपको समाधान में सभी नियंत्रकों पर कूदना होगा।
मैं इस सवाल पर आगे बढ़ा और आशा करता हूं कि मेरा समाधान किसी की मदद कर सकता है।
हमें कुछ समस्याएं मिलीं: - हमें "खाता" में "लॉगऑन" उदाहरण के लिए, विशिष्ट कार्यों को सुरक्षित करने की आवश्यकता है। हम बिल्ड का उपयोग आवश्यकताएँ आवश्यकताएँ में कर सकते हैं, जो बहुत अच्छा है - लेकिन यह हमें https: // के साथ वापस भेज देगा। - हमें अपने लिंक, फॉर्म और इस तरह के "एसएसएल को अवगत" कराना चाहिए।
आम तौर पर, मेरा समाधान उन मार्गों को निर्दिष्ट करने की अनुमति देता है जो प्रोटोकॉल को निर्दिष्ट करने की क्षमता के अलावा, पूर्ण यूआरएल का उपयोग करेंगे। "Https" प्रोटोकॉल को निर्दिष्ट करने के लिए आप इस दृष्टिकोण का उपयोग कर सकते हैं।
तो, सबसे पहले मैंने एक कनेक्शनप्रोटोकॉल एनम बनाया है:
/// <summary>
/// Enum representing the available secure connection requirements
/// </summary>
public enum ConnectionProtocol
{
/// <summary>
/// No secure connection requirement
/// </summary>
Ignore,
/// <summary>
/// No secure connection should be used, use standard http request.
/// </summary>
Http,
/// <summary>
/// The connection should be secured using SSL (https protocol).
/// </summary>
Https
}
अब, मैंने NeedSsl का हैंड-रोल्ड वर्जन बनाया है। मैंने http: // urls पर पुनर्निर्देशन की अनुमति देने के लिए मूल आवश्यकताएँ एसएलएसएल स्रोत कोड को संशोधित किया है। इसके अलावा, मैंने एक फ़ील्ड डाल दी है जो हमें यह निर्धारित करने की अनुमति देता है कि क्या हमें एसएसएल की आवश्यकता है या नहीं (मैं इसका उपयोग डेबग प्री-प्रोसेसर के साथ कर रहा हूं)।
/* Note:
* This is hand-rolled version of the original System.Web.Mvc.RequireHttpsAttribute.
* This version contains three improvements:
* - Allows to redirect back into http:// addresses, based on the <see cref="SecureConnectionRequirement" /> Requirement property.
* - Allows to turn the protocol scheme redirection off based on given condition.
* - Using Request.IsCurrentConnectionSecured() extension method, which contains fix for load-balanced servers.
*/
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method, Inherited = true, AllowMultiple = false)]
public sealed class RequireHttpsAttribute : FilterAttribute, IAuthorizationFilter
{
public RequireHttpsAttribute()
{
Protocol = ConnectionProtocol.Ignore;
}
/// <summary>
/// Gets or sets the secure connection required protocol scheme level
/// </summary>
public ConnectionProtocol Protocol { get; set; }
/// <summary>
/// Gets the value that indicates if secure connections are been allowed
/// </summary>
public bool SecureConnectionsAllowed
{
get
{
#if DEBUG
return false;
#else
return true;
#endif
}
}
public void OnAuthorization(System.Web.Mvc.AuthorizationContext filterContext)
{
if (filterContext == null)
{
throw new ArgumentNullException("filterContext");
}
/* Are we allowed to use secure connections? */
if (!SecureConnectionsAllowed)
return;
switch (Protocol)
{
case ConnectionProtocol.Https:
if (!filterContext.HttpContext.Request.IsCurrentConnectionSecured())
{
HandleNonHttpsRequest(filterContext);
}
break;
case ConnectionProtocol.Http:
if (filterContext.HttpContext.Request.IsCurrentConnectionSecured())
{
HandleNonHttpRequest(filterContext);
}
break;
}
}
private void HandleNonHttpsRequest(AuthorizationContext filterContext)
{
// only redirect for GET requests, otherwise the browser might not propagate the verb and request
// body correctly.
if (!String.Equals(filterContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException("The requested resource can only be accessed via SSL.");
}
// redirect to HTTPS version of page
string url = "https://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
filterContext.Result = new RedirectResult(url);
}
private void HandleNonHttpRequest(AuthorizationContext filterContext)
{
if (!String.Equals(filterContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
{
throw new InvalidOperationException("The requested resource can only be accessed without SSL.");
}
// redirect to HTTP version of page
string url = "http://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
filterContext.Result = new RedirectResult(url);
}
}
अब, यह आवश्यकताएँ आपकी आवश्यकताओं विशेषता मूल्य के आधार पर निम्नलिखित कार्य करेगी: - ध्यान न दें: कुछ भी न करें। - Http: http प्रोटोकॉल में पुनर्निर्देशन के लिए बाध्य करेगा। - Https: https प्रोटोकॉल में पुनर्निर्देशन को मजबूर करेगा।
आपको अपना आधार नियंत्रक बनाना चाहिए और इस विशेषता को Http पर सेट करना चाहिए।
[RequireSsl(Requirement = ConnectionProtocol.Http)]
public class MyController : Controller
{
public MyController() { }
}
अब, प्रत्येक cpntroller / कार्रवाई में आपको SSL की आवश्यकता होगी - बस इस विशेषता को ConnectionProtocol.Https के साथ सेट करें।
अब URLs पर जाने देता है: हमें url रूटिंग इंजन के साथ कुछ समस्याएँ हुईं। आप उनके बारे में http://blog.stevensanderson.com/2008/08/05/adding-httpsssl-support-to-aspnet-mvc-rout/ पर अधिक पढ़ सकते हैं । इस पोस्ट में सुझाया गया समाधान सैद्धांतिक रूप से अच्छा है, लेकिन पुराना है और मुझे यह पसंद नहीं है।
मेरे समाधान निम्नलिखित हैं: मूल "रूट" वर्ग का एक उपवर्ग बनाएँ:
सार्वजनिक वर्ग AbsoluteUrlRoute: रूट {#region ctor
/// <summary>
/// Initializes a new instance of the System.Web.Routing.Route class, by using
/// the specified URL pattern and handler class.
/// </summary>
/// <param name="url">The URL pattern for the route.</param>
/// <param name="routeHandler">The object that processes requests for the route.</param>
public AbsoluteUrlRoute(string url, IRouteHandler routeHandler)
: base(url, routeHandler)
{
}
/// <summary>
/// Initializes a new instance of the System.Web.Routing.Route class, by using
/// the specified URL pattern and handler class.
/// </summary>
/// <param name="url">The URL pattern for the route.</param>
/// <param name="defaults">The values to use for any parameters that are missing in the URL.</param>
/// <param name="routeHandler">The object that processes requests for the route.</param>
public AbsoluteUrlRoute(string url, RouteValueDictionary defaults, IRouteHandler routeHandler)
: base(url, defaults, routeHandler)
{
}
/// <summary>
/// Initializes a new instance of the System.Web.Routing.Route class, by using
/// the specified URL pattern and handler class.
/// </summary>
/// <param name="url">The URL pattern for the route.</param>
/// <param name="defaults">The values to use for any parameters that are missing in the URL.</param>
/// <param name="constraints">A regular expression that specifies valid values for a URL parameter.</param>
/// <param name="routeHandler">The object that processes requests for the route.</param>
public AbsoluteUrlRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints,
IRouteHandler routeHandler)
: base(url, defaults, constraints, routeHandler)
{
}
/// <summary>
/// Initializes a new instance of the System.Web.Routing.Route class, by using
/// the specified URL pattern and handler class.
/// </summary>
/// <param name="url">The URL pattern for the route.</param>
/// <param name="defaults">The values to use for any parameters that are missing in the URL.</param>
/// <param name="constraints">A regular expression that specifies valid values for a URL parameter.</param>
/// <param name="dataTokens">Custom values that are passed to the route handler, but which are not used
/// to determine whether the route matches a specific URL pattern. These values
/// are passed to the route handler, where they can be used for processing the
/// request.</param>
/// <param name="routeHandler">The object that processes requests for the route.</param>
public AbsoluteUrlRoute(string url, RouteValueDictionary defaults, RouteValueDictionary constraints,
RouteValueDictionary dataTokens, IRouteHandler routeHandler)
: base(url, defaults, constraints, dataTokens, routeHandler)
{
}
#endregion
public override VirtualPathData GetVirtualPath(RequestContext requestContext, RouteValueDictionary values)
{
var virtualPath = base.GetVirtualPath(requestContext, values);
if (virtualPath != null)
{
var scheme = "http";
if (this.DataTokens != null && (string)this.DataTokens["scheme"] != string.Empty)
{
scheme = (string) this.DataTokens["scheme"];
}
virtualPath.VirtualPath = MakeAbsoluteUrl(requestContext, virtualPath.VirtualPath, scheme);
return virtualPath;
}
return null;
}
#region Helpers
/// <summary>
/// Creates an absolute url
/// </summary>
/// <param name="requestContext">The request context</param>
/// <param name="virtualPath">The initial virtual relative path</param>
/// <param name="scheme">The protocol scheme</param>
/// <returns>The absolute URL</returns>
private string MakeAbsoluteUrl(RequestContext requestContext, string virtualPath, string scheme)
{
return string.Format("{0}://{1}{2}{3}{4}",
scheme,
requestContext.HttpContext.Request.Url.Host,
requestContext.HttpContext.Request.ApplicationPath,
requestContext.HttpContext.Request.ApplicationPath.EndsWith("/") ? "" : "/",
virtualPath);
}
#endregion
}
"रूट" वर्ग का यह संस्करण पूर्ण यूआरएल बनाएगा। यहाँ पर ट्रिक, ब्लॉग पोस्ट लेखक के सुझाव के बाद, स्कीम को निर्दिष्ट करने के लिए DataToken का उपयोग करना है (उदाहरण के अंत में :))।
अब, यदि हम एक url उत्पन्न करेंगे, उदाहरण के लिए "खाता / लॉगऑन" मार्ग के लिए "हम प्राप्त करेंगे" / http://example.com/Account/LogOn "- चूंकि UrlRoutModule सभी url को सापेक्ष रूप में देखता है। हम कस्टम HttpModule का उपयोग करके इसे ठीक कर सकते हैं:
public class AbsoluteUrlRoutingModule : UrlRoutingModule
{
protected override void Init(System.Web.HttpApplication application)
{
application.PostMapRequestHandler += application_PostMapRequestHandler;
base.Init(application);
}
protected void application_PostMapRequestHandler(object sender, EventArgs e)
{
var wrapper = new AbsoluteUrlAwareHttpContextWrapper(((HttpApplication)sender).Context);
}
public override void PostResolveRequestCache(HttpContextBase context)
{
base.PostResolveRequestCache(new AbsoluteUrlAwareHttpContextWrapper(HttpContext.Current));
}
private class AbsoluteUrlAwareHttpContextWrapper : HttpContextWrapper
{
private readonly HttpContext _context;
private HttpResponseBase _response = null;
public AbsoluteUrlAwareHttpContextWrapper(HttpContext context)
: base(context)
{
this._context = context;
}
public override HttpResponseBase Response
{
get
{
return _response ??
(_response =
new AbsoluteUrlAwareHttpResponseWrapper(_context.Response));
}
}
private class AbsoluteUrlAwareHttpResponseWrapper : HttpResponseWrapper
{
public AbsoluteUrlAwareHttpResponseWrapper(HttpResponse response)
: base(response)
{
}
public override string ApplyAppPathModifier(string virtualPath)
{
int length = virtualPath.Length;
if (length > 7 && virtualPath.Substring(0, 7) == "/http:/")
return virtualPath.Substring(1);
else if (length > 8 && virtualPath.Substring(0, 8) == "/https:/")
return virtualPath.Substring(1);
return base.ApplyAppPathModifier(virtualPath);
}
}
}
}
चूंकि यह मॉड्यूल UrlRoutModule के आधार कार्यान्वयन को ओवरराइड कर रहा है, इसलिए हमें आधार httpModule को हटा देना चाहिए और web.config में अपना पंजीकरण करना चाहिए। तो, "system.web" सेट के तहत:
<httpModules>
<!-- Removing the default UrlRoutingModule and inserting our own absolute url routing module -->
<remove name="UrlRoutingModule-4.0" />
<add name="UrlRoutingModule-4.0" type="MyApp.Web.Mvc.Routing.AbsoluteUrlRoutingModule" />
</httpModules>
बस :)।
मार्ग का निरपेक्ष / प्रोटोकॉल दर्ज करने के लिए, आपको यह करना चाहिए:
routes.Add(new AbsoluteUrlRoute("Account/LogOn", new MvcRouteHandler())
{
Defaults = new RouteValueDictionary(new {controller = "Account", action = "LogOn", area = ""}),
DataTokens = new RouteValueDictionary(new {scheme = "https"})
});
आपकी प्रतिक्रिया + सुधार सुनना पसंद करेंगे। आशा है कि यह मदद कर सकता है! :)
संपादित करें: मैं IsCurrentConnectionSecured () विस्तार विधि (बहुत अधिक स्निपेट: पी) शामिल करना भूल गया। यह एक विस्तार विधि है जो आम तौर पर Request.IsSecuredConnection का उपयोग करती है। हालांकि, लोड-बैलेंसिंग का उपयोग करते समय यह एप्रोच काम नहीं करेगा - इसलिए यह विधि इस को बायपास कर सकती है (nopCommerce से लिया गया)।
/// <summary>
/// Gets a value indicating whether current connection is secured
/// </summary>
/// <param name="request">The base request context</param>
/// <returns>true - secured, false - not secured</returns>
/// <remarks><![CDATA[ This method checks whether or not the connection is secured.
/// There's a standard Request.IsSecureConnection attribute, but it won't be loaded correctly in case of load-balancer.
/// See: <a href="http://nopcommerce.codeplex.com/SourceControl/changeset/view/16de4a113aa9#src/Libraries/Nop.Core/WebHelper.cs">nopCommerce WebHelper IsCurrentConnectionSecured()</a>]]></remarks>
public static bool IsCurrentConnectionSecured(this HttpRequestBase request)
{
return request != null && request.IsSecureConnection;
// when your hosting uses a load balancer on their server then the Request.IsSecureConnection is never got set to true, use the statement below
// just uncomment it
//return request != null && request.ServerVariables["HTTP_CLUSTER_HTTPS"] == "on";
}
यहाँ जनवरी 2009 से पाब्लो एम। सिब्रानो द्वारा एक ब्लॉग पोस्ट है जो एक HttpModule और विस्तार विधियों सहित कुछ तकनीकों को इकट्ठा करता है।
यहाँ एडम साल्वो द्वारा एक ब्लॉग पोस्ट है जो एक्शनफिल्टर का उपयोग करता है।
यह आवश्यक रूप से MVC विशिष्ट नहीं है, लेकिन यह समाधान ASP.NET WebForms और MVC दोनों के लिए काम करता है:
http://www.codeproject.com/KB/web-security/WebPageSecurity_v2.aspx
मैंने इसे कई वर्षों तक उपयोग किया है और वेब.कॉन्फिग फ़ाइल के माध्यम से चिंताओं और प्रबंधन के अलगाव की तरह है।
MVC 6 (ASP.NET Core 1.0) Startup.cs के साथ थोड़ा अलग काम कर रहा है।
सभी पन्नों पर NeedHttpsAttribute ( Amadiere द्वारा उत्तर में उल्लेख किया गया है ) का उपयोग करने के लिए , आप इसे प्रत्येक नियंत्रक पर विशेषता शैली का उपयोग करने के बजाय (या अपने सभी नियंत्रकों से विरासत के लिए एक BaseController बनाने के बजाय) Startup.cs में जोड़ सकते हैं।
Startup.cs - फ़िल्टर फ़िल्टर करें:
public void ConfigureServices(IServiceCollection services)
{
// TODO: Register other services
services.AddMvc(options =>
{
options.Filters.Add(typeof(RequireHttpsAttribute));
});
}
उपरोक्त दृष्टिकोण के लिए डिजाइन निर्णयों के बारे में अधिक जानकारी के लिए, इस तरह के सवाल पर मेरा जवाब देखें कि स्थानीयहोस्ट रिक्वेस्ट को आवश्यकताएँ से कैसे हटाया जाए ।
वैकल्पिक रूप से Global.asax.cs पर एक फ़िल्टर जोड़ें
GlobalFilters.Filters.Add (नई आवश्यकताएंअभिव्यक्ति ());
using System.Web.Mvc;
using System.Web.Optimization;
using System.Web.Routing;
namespace xxxxxxxx
{
public class MvcApplication : System.Web.HttpApplication
{
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters);
GlobalFilters.Filters.Add(new RequireHttpsAttribute());
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
}
}
}