/// <summary>
 /// Create instance of the filter attribute
 /// </summary>
 /// <param name="sslRequirement">Whether the page should be secured</param>
 public HttpsRequirementAttribute(SslRequirement sslRequirement) : base(typeof(HttpsRequirementFilter))
 {
     this._sslRequirement = sslRequirement;
     this.Arguments       = new object[] { sslRequirement };
 }
Example #2
0
 public NopHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
 public AgileEAPHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
 public RequireHttpsByConfigAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
Example #5
0
 public YStoryHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
Example #6
0
 public ApolloHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
Example #7
0
        public void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException("filterContext");
            }

            //don't apply filter to child methods
            if (filterContext.IsChildAction)
            {
                return;
            }

            // 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))
            {
                return;
            }

            if (!DataSettingsHelper.DatabaseIsInstalled())
            {
                return;
            }
            var securitySettings = EngineContext.Current.Resolve <SecuritySettings>();

            if (securitySettings.ForceSslForAllPages)
            {
                //all pages are forced to be SSL no matter of the specified value
                this.SslRequirement = SslRequirement.Yes;
            }

            switch (this.SslRequirement)
            {
            case SslRequirement.Yes:
            {
                var webHelper = EngineContext.Current.Resolve <IWebHelper>();
                var currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                if (!currentConnectionSecured)
                {
                    var storeContext = EngineContext.Current.Resolve <IStoreContext>();
                    if (storeContext.CurrentStore.SslEnabled)
                    {
                        //redirect to HTTPS version of page
                        //string url = "https://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
                        string url = webHelper.GetThisPageUrl(true, true);

                        //301 (permanent) redirection
                        filterContext.Result = new RedirectResult(url, true);
                    }
                }
            }
            break;

            case SslRequirement.No:
            {
                var webHelper = EngineContext.Current.Resolve <IWebHelper>();
                var currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                if (currentConnectionSecured)
                {
                    //redirect to HTTP version of page
                    //string url = "http://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
                    string url = webHelper.GetThisPageUrl(true, false);
                    //301 (permanent) redirection
                    filterContext.Result = new RedirectResult(url, true);
                }
            }
            break;

            case SslRequirement.NoMatter:
            {
                //do nothing
            }
            break;

            default:
                throw new NopException("Not supported SslProtected parameter");
            }
        }
 public BaseEamHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null) throw new ArgumentNullException("filterContext");

            // don't apply filter to child method
            if (filterContext.IsChildAction) return;

            // 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.InvariantCultureIgnoreCase))
                return;

            if (!DataSettingsHelper.DatabaseIsInstalled()) return;

            var enginerContext = EngineContext.Current;
            // get securitySettings for current store
            var securitySettings = enginerContext.Resolve<SecuritySettings>();
            // all pages are forced to be SSL no matter of the specified value
            if (securitySettings.ForceSslForAllPages) SslRequirement = SslRequirement.Yes;

            switch (SslRequirement)
            {
                case SslRequirement.Yes:
                {
                    var webHelper = enginerContext.Resolve<IWebHelper>();
                    bool currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                    if (!currentConnectionSecured)
                    {
                        var storeContext = enginerContext.Resolve<IStoreContext>();
                        if (storeContext.CurrentStore.SslEnabled)
                        {
                            // redirect to HTTPS version of page
                            string url = webHelper.GetThisPageUrl(true, true);
                            // 301 redirection
                            filterContext.Result = new RedirectResult(url, true);
                        }
                    }
                }

                    break;
                case SslRequirement.No:
                {
                    var webHelper = enginerContext.Resolve<IWebHelper>();
                    bool currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                    if (currentConnectionSecured)
                    {
                        // redirect to HTTPS version of page
                        string url = webHelper.GetThisPageUrl(true, false);
                        // 301 redirection
                        filterContext.Result = new RedirectResult(url, true);

                    }
                }
                    break;
                case SslRequirement.NoMatter:
                    break;
                default:
                    throw new ResearchException("Not support SslProtected parameter");
            }
        }
Example #10
0
 public HttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     SslRequirement = sslRequirement;
 }
 public ResearchHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     SslRequirement = sslRequirement;
 }
Example #12
0
 public RewriteUrlAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
     this.Order          = 100;
 }
Example #13
0
        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
            {
                throw new ArgumentNullException(nameof(filterContext));
            }

            if (filterContext.IsChildAction)
            {
                return;
            }

            if (!string.Equals(filterContext.HttpContext.Request.HttpMethod, "GET", StringComparison.OrdinalIgnoreCase))
            {
                return;
            }

            if (!DataSettingsHelper.DatabaseIsInstalled())
            {
                return;
            }
            var securitySettings = EngineContext.Current.Resolve <SecuritySettings>();

            if (securitySettings.ForceSslForAllPages)
            {
                //不管指定的值是多少,所有页面都必须是SSL
                this.SslRequirement = SslRequirement.Yes;
            }

            switch (this.SslRequirement)
            {
            case SslRequirement.Yes:
            {
                var webHelper = EngineContext.Current.Resolve <IWebHelper>();
                var currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                if (!currentConnectionSecured)
                {
                    if (securitySettings.SslEnabled)
                    {
                        string url = webHelper.GetThisPageUrl(true, true);
                        filterContext.Result = new RedirectResult(url, true);
                    }
                }
            }
            break;

            case SslRequirement.No:
            {
                var webHelper = EngineContext.Current.Resolve <IWebHelper>();
                var currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                if (currentConnectionSecured)
                {
                    string url = webHelper.GetThisPageUrl(true, false);
                    filterContext.Result = new RedirectResult(url, true);
                }
            }
            break;

            case SslRequirement.NoMatter:
            {
                //do nothing
            }
            break;

            default:
                throw new SiteException("Not supported SslProtected parameter");
            }
        }
 public NopHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
 public RequireHttpsByConfigAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }
        public virtual void OnAuthorization(AuthorizationContext filterContext)
        {
            if (filterContext == null)
                throw new ArgumentNullException("filterContext");

            //don't apply filter to child methods
            if (filterContext.IsChildAction)
                return;

            // 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))
                return;

            if (!DataSettingsHelper.DatabaseIsInstalled())
                return;
            var securitySettings = EngineContext.Current.Resolve<SecuritySettings>();
            if (securitySettings.ForceSslForAllPages)
                //all pages are forced to be SSL no matter of the specified value
                this.SslRequirement = SslRequirement.Yes;

            switch (this.SslRequirement)
            {
                case SslRequirement.Yes:
                    {
                        var webHelper = EngineContext.Current.Resolve<IWebHelper>();
                        var currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                        if (!currentConnectionSecured)
                        {
                            var storeContext = EngineContext.Current.Resolve<IStoreContext>();
                            if (storeContext.CurrentStore.SslEnabled)
                            {
                                //redirect to HTTPS version of page
                                //string url = "https://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
                                string url = webHelper.GetThisPageUrl(true, true);

                                //301 (permanent) redirection
                                filterContext.Result = new RedirectResult(url, true);
                            }
                        }
                    }
                    break;
                case SslRequirement.No:
                    {
                        var webHelper = EngineContext.Current.Resolve<IWebHelper>();
                        var currentConnectionSecured = webHelper.IsCurrentConnectionSecured();
                        if (currentConnectionSecured)
                        {
                            //redirect to HTTP version of page
                            //string url = "http://" + filterContext.HttpContext.Request.Url.Host + filterContext.HttpContext.Request.RawUrl;
                            string url = webHelper.GetThisPageUrl(true, false);
                            //301 (permanent) redirection
                            filterContext.Result = new RedirectResult(url, true);
                        }
                    }
                    break;
                case SslRequirement.NoMatter:
                    {
                        //do nothing
                    }
                    break;
                default:
                    throw new NopException("Not supported SslProtected parameter");
            }
        }
Example #17
0
 public ExploreHttpsRequirementAttribute(SslRequirement sslRequirement)
 {
     this.SslRequirement = sslRequirement;
 }