通用权限底层研究：Web应用限制IP访问的功能实现

如果你的web应用受到恶意扫描或攻击，你会怎么处理呢？大多数时候从应用日志里可以看到恶意扫描或攻击，遇到此类情况，如有一个可以进行IP访问控制的功能就好些了。

现将在MVC下实现的一个IP访问限制功能分享一下：

1、通过路由规则配置来设置禁止IP访问

    public class RouteConfig
    {
        public static void RegisterRoutes(RouteCollection routes)
        {
            routes.IgnoreRoute("{resource}.axd/{*pathInfo}");

            //通过路由规则配置来设置禁止IP访问
            routes.MapRoute(
                name: "Abandon",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Account", action = "AbandonIP", id = UrlParameter.Optional },
                constraints: new { customConstraint = new AbandonIPConstraint() }//自定义限制路由
            );

            routes.MapRoute(
                name: "Default",
                url: "{controller}/{action}/{id}",
                defaults: new { controller = "Account", action = "Index", id = UrlParameter.Optional }
            );

            //GlobalHost.Configuration.ConnectionTimeout = TimeSpan.FromSeconds(50);

        }
    }

 2、自定义限制路由的实现

    public class AbandonIPConstraint : IRouteConstraint
    {
        public bool Match(HttpContextBase httpContext, Route route, string parameterName,
         RouteValueDictionary values, RouteDirection routeDirection)
        {
            var currentIp = httpContext.Request.UserHostAddress;
            //如果当前访问用户的ip是127.0.0.1，则匹配Abandon路由,如果不是则匹配其他路由
            // return currentIp == "110.19.222.144";
            bool result = SecurityHelper.CheckIPAddress(currentIp);
            return result;
        }
    }

 3、IP检查功能

        /// <summary>
        /// 检查用户IP地址是否被限制登录系统
        /// </summary>
        /// <param name="ipAddress">IP地址</param>
        /// <returns>是否符合限制</returns>
        public static bool CheckIPAddress(string ipAddress)
        {
            bool result = false;
            var list = GetCacheAbandonIpAddressList();
            if (list != null && list.Count > )
            {
                foreach (AbandonIpaddressEntity model in list)
                {
                    //删除的或者没有启用的排除掉
                    if (model.DeletionStateCode ==  || model.Enabled==)
                    {
                        continue;
                    }
                    string ipAddressType = model.IpAddressType;
                    string ipAddressContent = model.IpAddressContent;
                    if (string.Equals(ipAddressType, "Single",StringComparison.OrdinalIgnoreCase))
                    {
                        // 匹配单个IP
                        result = CheckSingleIPAddress(ipAddress, ipAddressContent);
                    }
                    else if (string.Equals(ipAddressType, "Range", StringComparison.OrdinalIgnoreCase))
                    {
                        // 匹配ip地址段
                        result = CheckIPAddressWithRange(ipAddress, ipAddressContent);
                    }
                    else if (string.Equals(ipAddressType, "Mask", StringComparison.OrdinalIgnoreCase))
                    {
                        // 匹配带掩码的地址段
                        result = CheckIPAddressWithMask(ipAddress, ipAddressContent);
                    }
                    if (result)
                    {
                        break;
                    }
                }
            }
            return result;
        }
        /// <summary>
        /// 检查是否匹配单个IP
        /// </summary>
        /// <param name="ipAddress"></param>
        /// <param name="sourceIp"></param>
        /// <returns></returns>
        public static bool CheckSingleIPAddress(string ipAddress, string sourceIp)
        {
            return ipAddress.Equals(sourceIp);
        }

        /// <summary>
        /// 检查是否匹配地址段
        /// </summary>
        /// <param name="ipAddress">192.168.0.8</param>
        /// <param name="ipRange">192.168.0.1-192.168.0.10</param>
        /// <returns></returns>
        public static bool CheckIPAddressWithRange(string ipAddress, string ipRange)
        {
            //先判断符合192.168.0.1-192.168.0.10 的正则表达式
            //在判断ipAddress是否有效
            string startIp = ipRange.Split('-')[];
            string endIp = ipRange.Split('-')[];
            //如果大于等于 startip 或者 小于等于endip
            if (CompareIp(ipAddress, startIp) ==  && CompareIp(ipAddress, endIp) ==  || CompareIp(ipAddress, startIp) ==  || CompareIp(ipAddress, endIp) == )
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 比较两个IP地址，比较前可以先判断是否是IP地址
        /// </summary>
        /// <param name="ip1"></param>
        /// <param name="ip2"></param>
        /// <returns>1：相等;  0：ip1小于ip2 ; 2：ip1大于ip2；-1 不符合ip正则表达式 </returns>
        public static int CompareIp(string ip1, string ip2)
        {
            String[] arr1 = ip1.Split('.');
            String[] arr2 = ip2.Split('.');
            for (int i = ; i < arr1.Length; i++)
            {
                int a1 = int.Parse(arr1[i]);
                int a2 = int.Parse(arr2[i]);
                if (a1 > a2)
                {
                    return ;
                }
                else if (a1 < a2)
                {
                    return ;
                }
            }
            return ;
        }

        /// <summary>
        /// 检查是否匹配带通配符的IP地址
        /// </summary>
        /// <param name="ipAddress">192.168.1.1</param>
        /// <param name="ipWithMask">192.168.1.*</param>
        /// <returns></returns>
        public static bool CheckIPAddressWithMask(string ipAddress, string ipWithMask)
        {
            //先判断是否符合192.168.1.*
            //然后判断
            string[] arr1 = ipAddress.Split('.');
            string[] arr2 = ipWithMask.Split('.');
            for (int i = ; i < arr1.Length; i++)
            {
                if (!(arr2[i].Equals("*") || arr1[i].Equals(arr2[i])))
                {
                    return false;
                }
            }
            return true;
        }

4、限制的IP做了缓存，缓存的实现大家可以自己按照具体环境去实现

        /// <summary>
        /// 移除IP缓存数据
        /// </summary>
        public static void RemoveCacheAbandonIpAddressList()
        {
            //移除
            DataCacheHelper.RemoveCache("GetCacheAbandonIpAddressList");
        }
        /// <summary>
        /// 获取缓存的数据
        /// </summary>
        /// <returns></returns>
        public static List<AbandonIpaddressEntity> GetCacheAbandonIpAddressList()
        {
            string cacheKey = "GetCacheAbandonIpAddressList";
            if (null == DataCacheHelper.GetCache(cacheKey))
            {
                lock (Locker)
                {
                    if (null == DataCacheHelper.GetCache(cacheKey))
                    {
                        try
                        {
                            IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                            AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper);
                            List<KeyValuePair<string, object>> parameters = new List<KeyValuePair<string, object>>();
                            var list = manager.GetList<AbandonIpaddressEntity>(parameters);
                            DataCacheHelper.SetCache(cacheKey, list, null, DateTime.Now.AddMinutes(), Cache.NoSlidingExpiration, CacheItemPriority.NotRemovable, null);
                            return list;
                        }
                        catch (Exception ex)
                        {
                            LogHelper.WriteErrorLog("private List<AbandonIpaddressEntity> GetCacheAbandonIpAddressList()", ex);
                            return null;
                        }
                    }
                }
            }
            return DataCacheHelper.GetCache(cacheKey) as List<AbandonIpaddressEntity>;
        }

5、受限IP维护功能

    /// <summary>
    /// AbandonController
    ///
    /// 禁止登录系统的控制器
    ///
    /// 修改纪录
    ///
    /// 2015-10-10 版本：1.0 SongBiao 创建文件。   ///
    /// <author>
    ///     <name>SongBiao</name>
    ///     <date>2015-10-10</date>
    /// </author>
    /// </summary>

    public class AbandonController : BaseController
    {
        //
        // GET: /Abandon/
        [AjaxRequest]
        [CustomAuthorizeAttribute]
        public ActionResult Index()
        {
            return View();
        }

        [AjaxRequest]
        [CustomAuthorizeAttribute]
        public ActionResult ListIPAddress(Pager pager, string sort, string direction)
        {
            Hashtable result = new Hashtable();
            DataTable dt = new DataTable();
            List<KeyValuePair<string, object>> dbParameters = new List<KeyValuePair<string, object>>();
            List<string> listWhere = new List<string>();
            string conditions = string.Empty;
            string tableName = AbandonIpaddressEntity.TableName;
            string selectField = " * ";
            int totalRows = ;
            string orderBy = sort + " " + direction;
            try
            {
                IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
                dt = DbLogic.GetDataTableByPage(dbHelper, out totalRows, tableName, selectField, pager.pageNo, pager.pageSize, conditions, dbHelper.MakeParameters(dbParameters), orderBy);
                pager.totalPages = totalRows;
                result.Add("status", "true");
                result.Add("message", "成功获取数据。");
                result.Add("pager.pageNo", pager.pageNo);
                result.Add("rows", dt);//DataTableHelper.DataTable2Json(dt)
                result.Add("pager.totalRows", pager.totalPages);
                result.Add("sort", sort);
                result.Add("direction", direction);
            }
            catch (Exception ex)
            {
                result.Add("status", "false");
                result.Add("message", "系统异常：" + ex.Message);
                result.Add("pager.pageNo", pager.pageNo);
                result.Add("rows", dt);//DataTableHelper.DataTable2Json(dt)
                result.Add("pager.totalRows", pager.totalPages);
                result.Add("sort", sort);
                result.Add("direction", direction);
                LogHelper.OracleWarn(OperateContext.Current.UserInfo, "获取限制IP数据出现异常", ex.Message, "ListIPAddress", typeof(AbandonController), ex);
            }
            result.Add("span", (DateTime.Now - begin).TotalMilliseconds);
            return Json(result, JsonRequestBehavior.AllowGet);
        }

        /// <summary>
        /// IP地址是否限制
        /// </summary>
        /// <param name="ipAddress"></param>
        /// <returns></returns>
        public ActionResult CheckIPAddress(string ipAddress)
        {
            if (SecurityHelper.CheckIPAddress(ipAddress))
            {
                return Content(ipAddress + "不允许登录系统");
            }
            else
            {
                return Content(ipAddress + "可以登录系统");
            }
        }

        /// <summary>
        /// 添加受限的IP地址
        /// </summary>
        /// <returns></returns>
        public ActionResult AddIP()
        {
            return View();
        }

        /// <summary>
        /// 显示受限IP地址
        /// </summary>
        /// <returns></returns>
        public ActionResult ShowIP(string id)
        {
            IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
            AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
            AbandonIpaddressEntity entity = manager.GetObject(id);
            //ViewBag.AbandonIpaddressEntity = entity;
            return View(entity);
        }

        /// <summary>
        /// 显示受限IP地址
        /// </summary>
        /// <returns></returns>
        public ActionResult EditIP(string id)
        {
            IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
            AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
            AbandonIpaddressEntity entity = manager.GetObject(id);
            //ViewBag.AbandonIpaddressEntity = entity;
            return View(entity);
        }

        /// <summary>
        /// 添加受限的IP
        /// </summary>
        /// <param name="abandonIpaddress"></param>
        /// <returns></returns>
        [HttpPost]
        public ActionResult SaveIP(AbandonIpaddressEntity abandonIpaddress)
        {
            //Hashtable result = new Hashtable();
            BaseResult baseResult = new BaseResult();
            baseResult.Status = false;
            AbandonIpaddressEntity entity = new AbandonIpaddressEntity();
            if (string.IsNullOrWhiteSpace(abandonIpaddress.Id))
            {
                entity.Id = Guid.NewGuid().ToString();
                entity.DeletionStateCode = ;
                entity.Enabled = ;
            }
            entity.IpAddressType = abandonIpaddress.IpAddressType;
            entity.IpAddressContent = abandonIpaddress.IpAddressContent;
            IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
            AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
            //判断IP是否已受限
            var list = SecurityHelper.GetCacheAbandonIpAddressList();
            bool hasIP = false;
            AbandonIpaddressEntity hasModel = null;
            if (list != null && list.Count > )
            {
                foreach (AbandonIpaddressEntity model in list)
                {
                    string ipAddressType = model.IpAddressType;
                    string ipAddressContent = model.IpAddressContent;//IP检查是否存在
                    if (string.Equals(ipAddressContent, abandonIpaddress.IpAddressContent, StringComparison.OrdinalIgnoreCase))
                    {
                        hasIP = true;
                        hasModel = model;
                        break;
                    }
                }
            }
            if (hasIP)
            {
                //已存在受限的IP 不允许再添加了  更新一下状态即可
                if (string.IsNullOrWhiteSpace(abandonIpaddress.Id))
                {
                    hasModel.DeletionStateCode = ;
                    hasModel.Enabled = ;
                }
                else
                {
                    hasModel.DeletionStateCode = abandonIpaddress.DeletionStateCode;
                    hasModel.Enabled = abandonIpaddress.Enabled;
                }
                manager.Update(hasModel);
                baseResult.Status = true;
                baseResult.StatusMessage = "IP已受限，不允许重复添加！";
            }
            else
            {
                if (string.IsNullOrWhiteSpace(abandonIpaddress.Id))
                {
                    string result = manager.Add(entity, false, true);
                    if (!string.IsNullOrWhiteSpace(result))
                    {
                        baseResult.Status = true;
                        baseResult.StatusMessage = "添加成功。";
                    }
                    else
                    {
                        baseResult.StatusMessage = "添加失败了。";
                    }
                }
                else
                {
                    //状态更新 IP类型和值 是不允许修改的
                    entity.Id = abandonIpaddress.Id;
                    entity.DeletionStateCode = abandonIpaddress.DeletionStateCode;
                    entity.Enabled = abandonIpaddress.Enabled;
                    manager.Update(entity);
                    baseResult.Status = true;
                    baseResult.StatusMessage = "更新成功。";
                }
            }
            //操作成功 清除一下缓存
            if (baseResult.Status)
            {
                SecurityHelper.RemoveCacheAbandonIpAddressList();
            }
            return Json(baseResult, JsonRequestBehavior.AllowGet);
        }

        /// <summary>
        /// 删除受限的IP
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public ActionResult DeleteIP(string id)
        {
            BaseResult baseResult = new BaseResult();
            baseResult.Status = false;
            IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
            AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
            if (manager.Delete(id) == )
            {
                baseResult.Status = true;
                baseResult.StatusMessage = "删除成功。";
                SecurityHelper.RemoveCacheAbandonIpAddressList();
            }
            else
            {
                baseResult.Status = false;
                baseResult.StatusMessage = "删除失败。";
            }

            return Json(baseResult, JsonRequestBehavior.AllowGet);
        }

        /// <summary>
        /// 批量删除受限的IP
        /// </summary>
        /// <param name="ids"></param>
        /// <returns></returns>
        public ActionResult DeleteIPBatch(string[] ids)
        {
            BaseResult baseResult = new BaseResult();
            baseResult.Status = false;
            IDbHelper dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
            AbandonIpaddressManager manager = new AbandonIpaddressManager(dbHelper, OperateContext.Current.UserInfo);
            if (manager.Delete(ids) == )
            {
                baseResult.Status = true;
                baseResult.StatusMessage = "删除成功。";
                SecurityHelper.RemoveCacheAbandonIpAddressList();
            }
            else
            {
                baseResult.Status = false;
                baseResult.StatusMessage = "删除失败。";
            }
            return Json(baseResult, JsonRequestBehavior.AllowGet);
        }

    }

6、业务和实体底层代码使用了通用权限管理系统中的代码生成器生成；

aaarticlea/png;base64,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" alt="" />

业务层

    /// <summary>
    /// AbabdonIpaddressManager
    /// 禁止访问系统的IP数据表
    ///
    /// 修改纪录
    ///
    /// 2015-10-10 版本：1.0 SongBiao 创建文件。
    ///
    /// <author>
    ///     <name>SongBiao</name>
    ///     <date>2015-10-10</date>
    /// </author>
    /// </summary>
    public partial class AbandonIpaddressManager : BaseManager, IBaseManager
    {
        /// <summary>
        /// 构造函数
        /// </summary>
        public AbandonIpaddressManager()
        {
            if (base.dbHelper == null)
            {
                base.dbHelper = DbHelperFactory.GetHelper(BaseSystemInfo.UserCenterDbType, BaseSystemInfo.UserCenterDbConnection);
            }
            if (string.IsNullOrEmpty(base.CurrentTableName))
            {
                base.CurrentTableName = AbandonIpaddressEntity.TableName;
            }
            base.PrimaryKey = "Id";
        }

        /// <summary>
        /// 构造函数
        /// <param name="tableName">指定表名</param>
        /// </summary>
        public AbandonIpaddressManager(string tableName)
        {
            base.CurrentTableName = tableName;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dbHelper">数据库连接</param>
        public AbandonIpaddressManager(IDbHelper dbHelper)
            : this()
        {
            DbHelper = dbHelper;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        public AbandonIpaddressManager(BaseUserInfo userInfo)
            : this()
        {
            UserInfo = userInfo;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="userInfo">用户信息</param>
        /// <param name="tableName">指定表名</param>
        public AbandonIpaddressManager(BaseUserInfo userInfo, string tableName)
            : this(userInfo)
        {
            base.CurrentTableName = tableName;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dbHelper">数据库连接</param>
        /// <param name="userInfo">用户信息</param>
        public AbandonIpaddressManager(IDbHelper dbHelper, BaseUserInfo userInfo)
            : this(dbHelper)
        {
            UserInfo = userInfo;
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="dbHelper">数据库连接</param>
        /// <param name="userInfo">用户信息</param>
        /// <param name="tableName">指定表名</param>
        public AbandonIpaddressManager(IDbHelper dbHelper, BaseUserInfo userInfo, string tableName)
            : this(dbHelper, userInfo)
        {
            base.CurrentTableName = tableName;
        }

        /// <summary>
        /// 添加, 这里可以人工干预，提高程序的性能
        /// </summary>
        /// <param name="entity">实体</param>
        /// <param name="identity">自增量方式，表主键是否采用自增的策略</param>
        /// <param name="returnId">返回主键，不返回程序允许速度会快，主要是为了主细表批量插入数据优化用的</param>
        /// <returns>主键</returns>
        public string Add(AbandonIpaddressEntity entity, bool identity = true, bool returnId = true)
        {
            this.Identity = identity;
            this.ReturnId = returnId;
            entity.Id = this.AddObject(entity);
            return entity.Id.ToString();
        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="entity">实体</param>
        public int Update(AbandonIpaddressEntity entity)
        {
            return this.UpdateObject(entity);
        }

        /// <summary>
        /// 获取实体
        /// </summary>
        /// <param name="id">主键</param>
        public AbandonIpaddressEntity GetObject(string id)
        {
            return BaseEntity.Create<AbandonIpaddressEntity>(this.GetDataTable(new KeyValuePair<string, object>(this.PrimaryKey, id)));
            //return GetObject(id);
        }

        //public AbandonIpaddressEntity GetObject(int id)
        //{
        //    return BaseEntity.Create<AbandonIpaddressEntity>(this.GetDataTable(new KeyValuePair<string, object>(this.PrimaryKey, id)));
        //}

        /// <summary>
        /// 添加实体
        /// </summary>
        /// <param name="entity">实体</param>
        public string AddObject(AbandonIpaddressEntity entity)
        {
            string key = entity.Id;
            SQLBuilder sqlBuilder = new SQLBuilder(DbHelper, this.Identity, this.ReturnId);
            sqlBuilder.BeginInsert(this.CurrentTableName, this.PrimaryKey);
            if (!this.Identity)
            {
                // 这里已经是指定了主键了，所以不需要返回主键了
                sqlBuilder.ReturnId = false;
                sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
            }
            else
            {
                if (!this.ReturnId && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
                {
                    if (DbHelper.CurrentDbType == CurrentDbType.Oracle)
                    {
                        sqlBuilder.SetFormula(this.PrimaryKey, "SEQ_" + this.CurrentTableName.ToUpper() + ".NEXTVAL ");
                    }
                    if (DbHelper.CurrentDbType == CurrentDbType.DB2)
                    {
                        sqlBuilder.SetFormula(this.PrimaryKey, "NEXT VALUE FOR SEQ_" + this.CurrentTableName.ToUpper());
                    }
                }
                else
                {
                    if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
                    {
                        BaseSequenceManager sequenceManager = new BaseSequenceManager(DbHelper);
                        entity.Id = sequenceManager.Increment(this.CurrentTableName);
                        sqlBuilder.SetValue(this.PrimaryKey, entity.Id);
                    }
                }
            }
            this.SetObject(sqlBuilder, entity);
            if (UserInfo != null)
            {
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldCreateUserId, UserInfo.Id);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldCreateBy, UserInfo.RealName);
            }
            else
            {
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldCreateBy, entity.CreateBy);
            }
            sqlBuilder.SetDBNow(AbandonIpaddressEntity.FieldCreateOn);
            if (UserInfo != null)
            {
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedUserId, UserInfo.Id);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedBy, UserInfo.RealName);
            }
            sqlBuilder.SetDBNow(AbandonIpaddressEntity.FieldModifiedon);
            if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.SqlServer || DbHelper.CurrentDbType == CurrentDbType.Access))
            {
                key = sqlBuilder.EndInsert().ToString();
            }
            else
            {
                sqlBuilder.EndInsert();
            }
            if (this.Identity && (DbHelper.CurrentDbType == CurrentDbType.Oracle || DbHelper.CurrentDbType == CurrentDbType.DB2))
            {
                return entity.Id.ToString();
            }
            return key;
        }

        /// <summary>
        /// 更新实体
        /// </summary>
        /// <param name="entity">实体</param>
        public int UpdateObject(AbandonIpaddressEntity entity)
        {
            SQLBuilder sqlBuilder = new SQLBuilder(DbHelper);
            sqlBuilder.BeginUpdate(this.CurrentTableName);
            this.SetObject(sqlBuilder, entity);
            if (UserInfo != null)
            {
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedUserId, UserInfo.Id);
                sqlBuilder.SetValue(AbandonIpaddressEntity.FieldModifiedBy, UserInfo.RealName);
            }
            sqlBuilder.SetDBNow(AbandonIpaddressEntity.FieldModifiedon);
            sqlBuilder.SetWhere(this.PrimaryKey, entity.Id);
            return sqlBuilder.EndUpdate();
        }

        // 这个是声明扩展方法
        partial void SetObjectExpand(SQLBuilder sqlBuilder, AbandonIpaddressEntity entity);

        /// <summary>
        /// 设置实体
        /// </summary>
        /// <param name="entity">实体</param>
        private void SetObject(SQLBuilder sqlBuilder, AbandonIpaddressEntity entity)
        {
            SetObjectExpand(sqlBuilder, entity);
            sqlBuilder.SetValue(AbandonIpaddressEntity.FieldIpaddresstype, entity.IpAddressType);
            sqlBuilder.SetValue(AbandonIpaddressEntity.FieldDescription, entity.Description);
            sqlBuilder.SetValue(AbandonIpaddressEntity.FieldEnabled, entity.Enabled);
            sqlBuilder.SetValue(AbandonIpaddressEntity.FieldDeletionStateCode, entity.DeletionStateCode);
            sqlBuilder.SetValue(AbandonIpaddressEntity.FieldIpaddresscontent, entity.IpAddressContent);
        }

        /// <summary>
        /// 删除实体
        /// </summary>
        /// <param name="id">主键</param>
        /// <returns>影响行数</returns>
        public int Delete(int id)
        {
            return this.Delete(new KeyValuePair<string, object>(this.PrimaryKey, id));
        }
    }

实体层

    /// <summary>
    /// AbabdonIpaddressEntity
    /// 禁止访问系统的IP数据表
    ///
    /// 修改纪录
    ///
    /// 2015-09-24 版本：1.0 SongBiao 创建文件。
    ///
    /// <author>
    ///     <name>SongBiao</name>
    ///     <date>2015-09-24</date>
    /// </author>
    /// </summary>
    [Serializable]
    public partial class AbandonIpaddressEntity : BaseEntity
    {
        private string ipaddresstype = string.Empty;
        /// <summary>
        /// 类型：Single，Range，Mask
        /// </summary>
        public string IpAddressType
        {
            get
            {
                return ipaddresstype;
            }
            set
            {
                ipaddresstype = value;
            }
        }

        private DateTime? modifiedOn = null;
        /// <summary>
        /// 修改日期
        /// </summary>
        public DateTime? ModifiedOn
        {
            get
            {
                return modifiedOn;
            }
            set
            {
                modifiedOn = value;
            }
        }

        private string description = string.Empty;
        /// <summary>
        /// 描述信息
        /// </summary>
        public string Description
        {
            get
            {
                return description;
            }
            set
            {
                description = value;
            }
        }

        private Decimal enabled;
        /// <summary>
        /// 有效标志
        /// </summary>
        public Decimal Enabled
        {
            get
            {
                return enabled;
            }
            set
            {
                enabled = value;
            }
        }

        private string modifiedUserId = string.Empty;
        /// <summary>
        /// 修改用户主键
        /// </summary>
        public string ModifiedUserId
        {
            get
            {
                return modifiedUserId;
            }
            set
            {
                modifiedUserId = value;
            }
        }

        private string id = string.Empty;
        /// <summary>
        /// 主键
        /// </summary>
        public string Id
        {
            get
            {
                return id;
            }
            set
            {
                id = value;
            }
        }

        private string modifiedBy = string.Empty;
        /// <summary>
        /// 修改用户
        /// </summary>
        public string ModifiedBy
        {
            get
            {
                return modifiedBy;
            }
            set
            {
                modifiedBy = value;
            }
        }

        private string createBy = string.Empty;
        /// <summary>
        /// 创建用户
        /// </summary>
        public string CreateBy
        {
            get
            {
                return createBy;
            }
            set
            {
                createBy = value;
            }
        }

        private DateTime? createOn = null;
        /// <summary>
        /// 创建日期
        /// </summary>
        public DateTime? CreateOn
        {
            get
            {
                return createOn;
            }
            set
            {
                createOn = value;
            }
        }

        private Decimal? deletionStateCode = null;
        /// <summary>
        /// 删除标记
        /// </summary>
        public Decimal? DeletionStateCode
        {
            get
            {
                return deletionStateCode;
            }
            set
            {
                deletionStateCode = value;
            }
        }

        private string createUserId = string.Empty;
        /// <summary>
        /// 创建用户主键
        /// </summary>
        public string CreateUserId
        {
            get
            {
                return createUserId;
            }
            set
            {
                createUserId = value;
            }
        }

        private string ipaddresscontent = string.Empty;
        /// <summary>
        /// 具体IP内容
        /// </summary>
        public string IpAddressContent
        {
            get
            {
                return ipaddresscontent;
            }
            set
            {
                ipaddresscontent = value;
            }
        }

        /// <summary>
        /// 从数据行读取
        /// </summary>
        /// <param name="dr">数据行</param>
        protected override BaseEntity GetFrom(IDataRow dr)
        {
            GetFromExpand(dr);
            IpAddressType = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldIpaddresstype]);
            modifiedOn = BaseBusinessLogic.ConvertToNullableDateTime(dr[AbandonIpaddressEntity.FieldModifiedon]);
            Description = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldDescription]);
            Enabled = BaseBusinessLogic.ConvertToDecimal(dr[AbandonIpaddressEntity.FieldEnabled]);
            modifiedUserId = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldModifiedUserId]);
            Id = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldId]);
            modifiedBy = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldModifiedBy]);
            createBy = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldCreateBy]);
            createOn = BaseBusinessLogic.ConvertToNullableDateTime(dr[AbandonIpaddressEntity.FieldCreateOn]);
            deletionStateCode = BaseBusinessLogic.ConvertToNullableDecimal(dr[AbandonIpaddressEntity.FieldDeletionStateCode]);
            createUserId = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldCreateUserId]);
            IpAddressContent = BaseBusinessLogic.ConvertToString(dr[AbandonIpaddressEntity.FieldIpaddresscontent]);
            return this;
        }

        ///<summary>
        /// 禁止访问系统的IP数据表
        ///</summary>
        [NonSerialized]
        public static string TableName = "ABANDON_IPADDRESS";

        ///<summary>
        /// 类型：Single，Range，Mask
        ///</summary>
        [NonSerialized]
        public static string FieldIpaddresstype = "IPADDRESSTYPE";

        ///<summary>
        /// 修改日期
        ///</summary>
        [NonSerialized]
        public static string FieldModifiedon = "ModifiedOn";

        ///<summary>
        /// 描述信息
        ///</summary>
        [NonSerialized]
        public static string FieldDescription = "DESCRIPTION";

        ///<summary>
        /// 有效标志
        ///</summary>
        [NonSerialized]
        public static string FieldEnabled = "Enabled";

        ///<summary>
        /// 修改用户主键
        ///</summary>
        [NonSerialized]
        public static string FieldModifiedUserId = "ModifiedUserId";

        ///<summary>
        /// 主键
        ///</summary>
        [NonSerialized]
        public static string FieldId = "Id";

        ///<summary>
        /// 修改用户
        ///</summary>
        [NonSerialized]
        public static string FieldModifiedBy = "ModifiedBy";

        ///<summary>
        /// 创建用户
        ///</summary>
        [NonSerialized]
        public static string FieldCreateBy = "CreateBy";

        ///<summary>
        /// 创建日期
        ///</summary>
        [NonSerialized]
        public static string FieldCreateOn = "CreateOn";

        ///<summary>
        /// 删除标记
        ///</summary>
        [NonSerialized]
        public static string FieldDeletionStateCode = "DeletionStateCode";

        ///<summary>
        /// 创建用户主键
        ///</summary>
        [NonSerialized]
        public static string FieldCreateUserId = "CreateUserId";

        ///<summary>
        /// 具体IP内容
        ///</summary>
        [NonSerialized]
        public static string FieldIpaddresscontent = "IPADDRESSCONTENT";
    }

7、IP限制功能前端展示，可根据自己的需要进行展示，可维护的IP有单个IP，IP段，掩码IP；

8、自动添加恶意访问的IP地址，这里给出一个参考，在通用权限底层里有一个恶意访问判断方法（可以拦截攻击者注入恶意代码，可以防御诸如跨站脚本攻击（XSS）、SQL注入攻击等恶意攻击行为。）

        protected void Application_AcquireRequestState(object sender, EventArgs e)
        {
            HttpContext context = HttpContext.Current;
            string putData;
            if (SecretUtil.CookieData(out putData))
            {
                ResponseWarnMessage(context, "Cookie数据有恶意字符！", putData);
            }
            if (Request.UrlReferrer != null)
            {
                if (SecretUtil.Referer(out putData))
                {
                    ResponseWarnMessage(context, "Referrer数据有恶意字符！", putData);
                }
            }
            if (Request.RequestType.ToUpper() == "POST")
            {
                if (SecretUtil.PostData(out putData))
                {
                    ResponseWarnMessage(context, "Post数据有恶意字符！", putData);
                }
            }
            if (Request.RequestType.ToUpper() == "GET")
            {
                if (SecretUtil.GetData(out putData))
                {
                    ResponseWarnMessage(context, "Get数据有恶意字符！", putData);
                }
            }
        }

在上面方法判断过程中就可以动态将恶意访问者的IP添加到限制访问列表中。

9、受限IP表结构

SQL脚本

-- Create table
create table ABANDON_IPADDRESS
(
  ID                VARCHAR2(40),
  IPADDRESSTYPE     VARCHAR2(50),
  IPADDRESSCONTENT  VARCHAR2(200),
  DESCRIPTION       VARCHAR2(200),
  ENABLED           NUMBER(1) default 1 not null,
  DELETIONSTATECODE NUMBER(1) default 0,
  CREATEUSERID      VARCHAR2(50),
  CREATEBY          VARCHAR2(50),
  CREATEON          DATE,
  MODIFIEDON        DATE,
  MODIFIEDUSERID    VARCHAR2(50),
  MODIFIEDBY        VARCHAR2(50)
)
tablespace USERS
  pctfree 10
  initrans 1
  maxtrans 255
  storage
  (
    initial 64K
    next 1M
    minextents 1
    maxextents unlimited
  );
-- Add comments to the table
comment on table ABANDON_IPADDRESS
  is '禁止访问系统的IP数据表';
-- Add comments to the columns
comment on column ABANDON_IPADDRESS.ID
  is '主键';
comment on column ABANDON_IPADDRESS.IPADDRESSTYPE
  is '类型：Single，Range，Mask';
comment on column ABANDON_IPADDRESS.IPADDRESSCONTENT
  is '具体IP内容 ';
comment on column ABANDON_IPADDRESS.DESCRIPTION
  is '描述信息';
comment on column ABANDON_IPADDRESS.ENABLED
  is '有效标志';
comment on column ABANDON_IPADDRESS.DELETIONSTATECODE
  is '删除标记';
comment on column ABANDON_IPADDRESS.CREATEUSERID
  is '创建用户主键';
comment on column ABANDON_IPADDRESS.CREATEBY
  is '创建用户';
comment on column ABANDON_IPADDRESS.CREATEON
  is '创建日期';
comment on column ABANDON_IPADDRESS.MODIFIEDON
  is '修改日期';
comment on column ABANDON_IPADDRESS.MODIFIEDUSERID
  is '修改用户主键';
comment on column ABANDON_IPADDRESS.MODIFIEDBY
  is '修改用户';