精华内容
下载资源
问答
  • IP白名单
    千次阅读
    2019-06-04 17:13:00
    import lombok.extern.slf4j.Slf4j;
    
    import java.util.ArrayList;
    import java.util.HashSet;
    import java.util.List;
    import java.util.Set;
    import java.util.regex.Pattern;
    
    /**
     * @ Author     :sunpz
     * @ Date       :Created in 15:20 2019-06-04
     * @ Description:ip 对比检查
     *            1.设置单个IP的白名单, 2.设置ip通配符,对一个ip段进行匹配 3.设置一个IP范围(*和-不能组合使用,只能有一组 *)
     *            如: 192.168.**.1 ; 如果 192.168.**.* ,则会匹配错误
     * @ Modified By:
     * @ Version    : 1.0
     */
    @Slf4j
    public class IpFIlterUtils {
    
        /**
         * IP的正则校验
         */
        private static final  Pattern PATTERN = Pattern.compile("(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})");
    
        /**
         * 分割符号
         */
        private static final String SPLICT = ";";
        /**
         * ip 连接范围符号
         */
        private static final String CONNECT_SYMBOL = "-";
        /**
         * 单个ip分割最大值
         */
        private static final int MAX_IP_SPLICT = 255;
    
        /**
         * @Auther sunpz
         * @DateTime 2019-06-04 15:31
         * @Description: 根据IP白名单设置获取可用的IP列表
         * @Param allowIp
         * @Return: java.util.Set<java.lang.String>
         */
        private static Set<String> getAvaliIpList(String allowIp) {
    
            Set<String> ipList = new HashSet<>();
            for (String allow : allowIp.replaceAll("\\s", "").split(SPLICT)) {
                //如果带有 * 需要特殊处理
                if (allow.contains("*")) {
                    String[] ips = allow.split("\\.");
                    String[] from = new String[] { "0", "0", "0", "0" };
                    String[] end = new String[] { "255", "255", "255", "255" };
                    List<String> tem = new ArrayList<>();
                    for (int i = 0; i < ips.length; i++){
                        if (ips[i].contains("*")) {
                            tem = complete(ips[i]);
                            from[i] = null;
                            end[i] = null;
                        } else {
                            from[i] = ips[i];
                            end[i] = ips[i];
                        }
                    }
                    StringBuilder fromIP = new StringBuilder();
                    StringBuilder endIP = new StringBuilder();
                    for (int i = 0; i < 4; i++){
                        if (from[i] != null) {
                            fromIP.append(from[i]).append(".");
                            endIP.append(end[i]).append(".");
                        } else {
                            fromIP.append("[*].");
                            endIP.append("[*].");
                        }
                    }
                    fromIP.deleteCharAt(fromIP.length() - 1);
                    endIP.deleteCharAt(endIP.length() - 1);
    
                    for (String s : tem) {
                        String ip = fromIP.toString().replace("[*]", s.split(SPLICT)[0])
                                + CONNECT_SYMBOL
                                + endIP.toString().replace("[*]", s.split(SPLICT)[1]);
                        if (validate(ip)) {
                            ipList.add(ip);
                        }
                    }
                } else {
                    if (validate(allow)) {
                        ipList.add(allow);
                    }
                }
    
            }
    
            return ipList;
        }
    
       /**
        * @Auther sunpz
        * @DateTime 2019-06-04 17:13
        * @Description: 对单个IP节点进行范围限定
        * @Param null
        * @Return: 回限定后的IP范围,格式为List[10;19, 100;199]
        */
        private static List<String> complete(String arg) {
            List<String> com = new ArrayList<>();
            if (arg.length() == 1) {
                com.add("0;255");
            } else if (arg.length() == 2) {
                String s1 = complete(arg, 1);
                if (s1 != null){
                    com.add(s1);
                }
                String s2 = complete(arg, 2);
                if (s2 != null){
                    com.add(s2);
                }
            } else {
                String s1 = complete(arg, 1);
                if (s1 != null){
                    com.add(s1);
                }
            }
            return com;
        }
        
        /**
         * @Auther sunpz
         * @DateTime 2019-06-04 17:13
         * @Description: 获取 ip范围
         * @Param arg
         * @Param length
         * @Return: java.lang.String
         */
        private static String complete(String arg, int length) {
            String from;
            String end;
            if (length == 1) {
                from = arg.replace("*", "0");
                end = arg.replace("*", "9");
            } else {
                from = arg.replace("*", "00");
                end = arg.replace("*", "99");
            }
            if (Integer.valueOf(from) > MAX_IP_SPLICT){
                return null;
            }
            if (Integer.valueOf(end) > MAX_IP_SPLICT){
                end = "255";
            }
            return from + SPLICT + end;
        }
    
        /**
         * @Auther sunpz
         * @DateTime 2019-06-04 17:13
         * @Description: 对ip进行格式校验
         * @Param ip
         * @Return: boolean
         */
        private static boolean validate(String ip) {
            for (String s : ip.split(CONNECT_SYMBOL)){
                if (!PATTERN.matcher(s).matches()) {
                    return false;
                }
            }
            return true;
        }
    
         /**
          * @Auther sunpz
          * @DateTime 2019-06-04 15:33
          * @Description: 根据IP,及可用Ip列表来判断ip是否包含在白名单之中
          * @Param ip
          * @Param ipList
          * @Return: boolean: boolean
          */
        private static boolean checkLoginIP(String ip, Set<String> ipList) {
            log.info("[检查IP] 处理后 : {} ,list {}", ip, ipList);
            if (ipList.isEmpty() || ipList.contains(ip)){
                return true;
            }
            //如果含有 "-" 则需要逐段比较
            else {
                for (String allow : ipList) {
                    if (allow.contains(CONNECT_SYMBOL)) {
                        String[] from = allow.split(CONNECT_SYMBOL)[0].split("\\.");
                        String[] end = allow.split(CONNECT_SYMBOL)[1].split("\\.");
                        String[] tag = ip.split("\\.");
    
                        // 对IP从左到右进行逐段匹配
                        boolean check = true;
                        for (int i = 0; i < 4; i++) {
                            int s = Integer.valueOf(from[i]);
                            int t = Integer.valueOf(tag[i]);
                            int e = Integer.valueOf(end[i]);
                            if (!(s <= t && t <= e)) {
                                check = false;
                                break;
                            }
                        }
                        if (check) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    
        /**
         *
         * checkLoginIP:(根据IP地址,及IP白名单设置规则判断IP是否包含在白名单).
         * @date 2017-4-17 下午03:01:37
         * @param ip
         * @param ipWhiteConfig
         * @return
         */
        public static boolean checkLoginIP(String ip,String ipWhiteConfig){
            log.info("[检查IP] {} ,list {}", ip, ipWhiteConfig);
            Set<String> ipList = getAvaliIpList(ipWhiteConfig);
            return checkLoginIP(ip, ipList);
        }
    
    
        public static void main(String[] args) {
            //
            String ipWhilte = "192.168.1.1;" +
                    "192.168.2.*;" +
                    "192.168.3.17-192.168.3.38";
    
    
            System.out.println(checkLoginIP("192.168.1.3", ipWhilte));
        }
    }

    代码部分来自网络,有修改 http://www.itdaan.com/blog/2017/01/23/973ee9c4c156ddcbd1992fc7bd2edb79.html

    转载于:https://www.cnblogs.com/mlfz/p/10974727.html

    更多相关内容
  • 今天小编就为大家分享一篇nginx设置目录白名单、ip白名单的实现方法,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 本文给大家分享了2个php用于实现黑白名单的实用函数,分别是安全IP检测函数和获取客户端IP函数,注释里解释的非常清楚,这里我就不多废话了。
  • 还是需要自己看看配置好防火墙和如何配置白名单的。 1、阿里云的服务器,本身并没有防火墙,但是我们可以安装一个IPtable防火墙(这里阿里云的服务器系统为Centos),这样的话,就需要防火墙和阿里云网址配置的白名单...
  • 企业日常实践当中,当我们开设网站需要对某些黑名单IP端里面启用白名单,也就是说,允许其他网段访问,但是该网站需要禁止某个网段(10.10.0.0/16)IP访问,但是必须同时也允许10.10.10.10、10.10.11.11 访问网站,...
  • 微巨科技:“获取access_token”接口新增IP白名单保护
  • IP白名单校验工具

    千次阅读 2022-02-07 17:01:15
    import java.util.*; import java.util.regex.Pattern; /** * @author Suqi * @version 1.0 ... * @desc 配置白名单工具类 */ public final class IpWhiteCheckUtil { // IP的正则 private static Patt
    package com.chinaentropy.screen.common.utils;
    
    import java.util.*;
    import java.util.regex.Pattern;
    
    /**
     * @author Suqi
     * @version 1.0
     * @date 2022/2/7 14:45
     * @desc 配置白名单工具类
     */
    public final class IpWhiteCheckUtil {
        // IP的正则
        private static Pattern pattern = Pattern
                .compile("(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\." + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\." + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})");
        public static final String DEFAULT_ALLOW_ALL_FLAG = "*";// 允许所有ip标志位
        public static final String DEFAULT_DENY_ALL_FLAG = "0"; // 禁止所有ip标志位
    
        /**
         *
         * getAvaliIpList:(根据IP白名单设置获取可用的IP列表).
         * System.out.println(getAvaliIpList("1.168.1.*;" +"192.168.3.*"));
         * //[1.168.1.0-1.168.1.255, 192.168.3.0-192.168.3.255]
         * @param
         * @return
         */
    
        private static Set<String> getAvaliIpList(String allowIp) {
            String[] splitRex = allowIp.split(";");// 拆分出白名单正则
            Set<String> ipList = new HashSet<String>(splitRex.length);
            for (String allow : splitRex) {
                if (allow.contains("*")) {// 处理通配符 *
                    String[] ips = allow.split("\\.");
                    String[] from = new String[] { "0", "0", "0", "0" };
                    String[] end = new String[] { "255", "255", "255", "255" };
                    List<String> tem = new ArrayList<String>();
                    for (int i = 0; i < ips.length; i++)
                        if (ips[i].indexOf("*") > -1) {
                            tem = complete(ips[i]);
                            from[i] = null;
                            end[i] = null;
                        } else {
                            from[i] = ips[i];
                            end[i] = ips[i];
                        }
    
                    StringBuilder fromIP = new StringBuilder();
                    StringBuilder endIP = new StringBuilder();
                    for (int i = 0; i < 4; i++)
                        if (from[i] != null) {
                            fromIP.append(from[i]).append(".");
                            endIP.append(end[i]).append(".");
                        } else {
                            fromIP.append("[*].");
                            endIP.append("[*].");
                        }
                    fromIP.deleteCharAt(fromIP.length() - 1);
                    endIP.deleteCharAt(endIP.length() - 1);
    
                    for (String s : tem) {
                        String ip = fromIP.toString().replace("[*]", s.split(";")[0]) + "-"
                                + endIP.toString().replace("[*]", s.split(";")[1]);
                        if (validate(ip)) {
                            ipList.add(ip);
                        }
                    }
                } else if (allow.contains("/")) {// 处理 网段 xxx.xxx.xxx./24
                    ipList.add(allow);
                } else {// 处理单个 ip 或者 范围
                    if (validate(allow)) {
                        ipList.add(allow);
                    }
                }
    
            }
    
            return ipList;
        }
    
        /**
         * 对单个IP节点进行范围限定
         *
         * @param arg
         * @return 返回限定后的IP范围,格式为List[10;19, 100;199]
         */
        private static List<String> complete(String arg) {
            List<String> com = new ArrayList<String>();
            int len = arg.length();
            if (len == 1) {
                com.add("0;255");
            } else if (len == 2) {
                String s1 = complete(arg, 1);
                if (s1 != null)
                    com.add(s1);
                String s2 = complete(arg, 2);
                if (s2 != null)
                    com.add(s2);
            } else {
                String s1 = complete(arg, 1);
                if (s1 != null)
                    com.add(s1);
            }
            return com;
        }
    
        private static String complete(String arg, int length) {
            String from = "";
            String end = "";
            if (length == 1) {
                from = arg.replace("*", "0");
                end = arg.replace("*", "9");
            } else {
                from = arg.replace("*", "00");
                end = arg.replace("*", "99");
            }
            if (Integer.valueOf(from) > 255)
                return null;
            if (Integer.valueOf(end) > 255)
                end = "255";
            return from + ";" + end;
        }
    
        /**
         * 在添加至白名单时进行格式校验
         *
         * @param ip
         * @return
         */
        private static boolean validate(String ip) {
            String[] temp = ip.split("-");
            for (String s : temp)
                if (!pattern.matcher(s).matches()) {
                    return false;
                }
            return true;
        }
    
        /**
         *
         * isPermited:(根据IP,及可用Ip列表来判断ip是否包含在白名单之中).
         *
         * @date 2017-4-17 下午03:01:03
         * @param ip
         * @param ipList
         * @return
         */
        private static boolean isPermited(String ip, Set<String> ipList) {
            if (ipList.isEmpty() || ipList.contains(ip))
                return true;
            for (String allow : ipList) {
                if (allow.indexOf("-") > -1) {// 处理 类似 192.168.0.0-192.168.2.1
                    String[] tempAllow = allow.split("-");
                    String[] from = tempAllow[0].split("\\.");
                    String[] end = tempAllow[1].split("\\.");
                    String[] tag = ip.split("\\.");
                    boolean check = true;
                    for (int i = 0; i < 4; i++) {// 对IP从左到右进行逐段匹配
                        int s = Integer.valueOf(from[i]);
                        int t = Integer.valueOf(tag[i]);
                        int e = Integer.valueOf(end[i]);
                        if (!(s <= t && t <= e)) {
                            check = false;
                            break;
                        }
                    }
                    if (check)
                        return true;
                } else if (allow.contains("/")) {// 处理 网段 xxx.xxx.xxx.*/24
                    String[] ips = ip.split("\\.");
                    int ipAddr = (Integer.parseInt(ips[0]) << 24)
                            | (Integer.parseInt(ips[1]) << 16)
                            | (Integer.parseInt(ips[2]) << 8) | Integer.parseInt(ips[3]);
                    int type = Integer.parseInt(allow.replaceAll(".*/", ""));
                    int mask = 0xFFFFFFFF << (32 - type);
                    String cidrIp = allow.replaceAll("/.*", "");
                    String[] cidrIps = cidrIp.split("\\.");
                    int cidrIpAddr = (Integer.parseInt(cidrIps[0]) << 24)
                            | (Integer.parseInt(cidrIps[1]) << 16)
                            | (Integer.parseInt(cidrIps[2]) << 8)
                            | Integer.parseInt(cidrIps[3]);
    
                    return (ipAddr & mask) == (cidrIpAddr & mask);
                }
            }
            return false;
        }
    
        /**
         *
         * isPermited:(根据IP地址,及IP白名单设置规则判断IP是否包含在白名单).
         *
         * @date 2017-4-17 下午03:01:37
         * @param ip
         * @param ipWhiteConfig
         * @return
         */
        public static boolean isPermited(String ip, String ipWhiteConfig) {
            if (null == ip || "".equals(ip))
                return false;
            //ip格式不对
            if(!pattern.matcher(ip).matches())return false;
            if (DEFAULT_ALLOW_ALL_FLAG.equals(ipWhiteConfig))
                return true;
            if (DEFAULT_DENY_ALL_FLAG.equals(ipWhiteConfig))
                return false;
            Set<String> ipList = getAvaliIpList(ipWhiteConfig);
            return isPermited(ip, ipList);
        }
    
        public static void main(String[] args) {
    
    //        System.out.println("192.168.0".matches("192.*"));
    //        System.out.println(IpWhiteCheckUtil.isPermited("192.168.0.1","192.*"));
    
            String ipWhilte = "1.168.1.1;" + //设置单个IP的白名单
                    // "192.*;" //设置ip通配符,对一个ip段进行匹配
                    "192.168.3.17-192.168.3.38;" //设置一个IP范围
                    +"192.168.4.0/26;"; //設置一个网段
    //          System.out.println(IpWhiteCheckUtil.isPermited("1.168.1.1",ipWhilte)); //true
    //          System.out.println(IpWhiteCheckUtil.isPermited("192.168.1.2",ipWhilte)); //false
    //          System.out.println(IpWhiteCheckUtil.isPermited("192.168.3.16",ipWhilte)); //false
    //          System.out.println(IpWhiteCheckUtil.isPermited("192.168.3.37",ipWhilte)); //true
    //          System.out.println(IpWhiteCheckUtil.isPermited("192.168.4.1",ipWhilte));//true
    
    //        System.out.println(getAvaliIpList("1.168.1.*;" +"192.168.3.*")); //[1.168.1.0-1.168.1.255, 192.168.3.0-192.168.3.255]
    
        }
    
    }
    
    
    展开全文
  • nginx配置IP白名单

    千次阅读 2022-08-08 14:43:56
    分析nginx访问日志,有哪些IP访问过nginx。

    分析nginx访问日志,有哪些IP访问过nginx。

    命令参考:awk '{print $1}' logs/access.log | sort | uniq -c | sort -nr -k1

    输出的效果案例:

    1053 192.168.3.15
    893 192.168.3.10
    818 192.168.0.8

    1、添加IP白名单文件

    在nginx目录的 conf 中添加文件 ip.conf

    vi ip.conf

    # 分析nginx的access.log出来的,案例
    192.168.3.11 1;
    192.168.3.10 1;
    192.168.0.112 1;
     
    # 自身的业务IP地址
    
    # 其他业务IP地址
    

    2、配置nginx.conf

    编辑http节点:

    http {
        # ...
        # geo IP whitelist
        geo $remote_addr $ip_whitelist {
           default 0;
           include ip.conf;
        }
     
        # ...
    }
    

    编辑server节点:

    server {
        listen       80;
        # ...
        # IP whitelist
        set $whitelist_flag 1;
        if ( $ip_whitelist != 1 ) {
           set $whitelist_flag "${whitelist_flag}0";
        }
        if ( $request_uri !~* '/warn_navigate_page' ) {
           set $whitelist_flag "${whitelist_flag}0";
        }
        if ( $whitelist_flag = "100" ) {
           #return 403;
           rewrite ^(.*)$ $scheme://$host:$server_port/warn_navigate_page break; #白名单的提示页面
        }
     
        # ...
    }
    

    也可以在location节点中编辑,示例:

    编辑location节点:

    location /test {
        proxy_pass  http://IP/test;
        # ...
        # IP whitelist
        set $whitelist_flag 1;
                    if ( $ip_whitelist != 1 ) {
                            set $whitelist_flag "${whitelist_flag}0";
                    }
                    if ( $request_uri !~* '/warn_navigate_page' ) {
                            set $whitelist_flag "${whitelist_flag}0";
                    }
                    if ( $whitelist_flag = "100" ) {
                            #return 403;
                            rewrite ^(.*)$ $scheme://$host:$server_port/warn_navigate_page break; #白名单的提示页面
                    }
     
        # ...
    }
    

    添加导航的提示页 /warn_navigate_page

    server {
        listen       80;
        # ...
     
     
        # 白名单的提示导航页面
        location /warn_navigate_page {
                        root /home/java/nginx/bizapp/warn_navigate_page;
                        index  warn_navigate_page.html warn_navigate_page.htm;
                        rewrite ^(.*)$ /warn_navigate_page.html break;
                    }
    }
    

    3、编辑白名单的提示导航页面

    /home/java/nginx/bizapp/warn_navigate_page 中编辑页面warn_navigate_page.html

    参考:

    <!DOCTYPE html>
    <html lang="en">
    
    <head>
        <meta charset="utf-8">
        <meta name="viewport" content="width=device-width,initial-scale=1.0,maximum-scale=1.0,user-scalable=no">
        <meta content="yes" name="apple-mobile-web-app-capable">
        <meta content="black" name="apple-mobile-web-app-status-bar-style">
        <meta content="telephone=no" name="format-detection">
        <meta content="email=no" name="format-detection">
        <title>系统通知</title>
        <style type="text/css">
            body {
                background: url(https://www.baidu.com/img/PCtm_d9c8750bed0b3c7d089fa7d55720d6cf.png) no-repeat;
                background-size: 100% 100%;
                background-attachment: fixed;
            }
        </style>
    </head>
    
    <body>
        <div>
            <pre>                                                                                     【通知公告】
            尊敬的用户您好,系统已不提供IP地址直接访问,请联系管理员添加白名单。互联网的域名访问地址:<a href="https://www.baidu.com">跳转https://www.baidu.com</a>
            </pre>
        </div>
    
    </body>
    <script type="text/javascript">
    </script>
    
    </html>
    

    预计效果图

    在这里插入图片描述

    展开全文
  • 下面小编就为大家带来一篇centOS7 下利用iptables配置IP地址白名单的方法。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java实现 对ip白名单的限制

    千次阅读 2021-11-03 09:01:00
    有些项目的接口是需要权限访问,比如限制IP、做权限控制,等等方案,本文是限制ip权限设置访问策略。 先看测试效果: 测试: 注意访问需要输入:http://127.0.0.1:8981/ 在配置文件加上本地的ip 10.9.160.135 去掉...

    有些项目的接口是需要权限访问,比如限制IP、做权限控制,等等方案,本文是限制ip权限设置访问策略。

    先看测试效果:

    测试:

    注意访问需要输入:http://127.0.0.1:8981/

    在配置文件加上本地的ip 10.9.160.135
    在这里插入图片描述
    去掉本地ip 10.9.160.135 提示非法字符
    在这里插入图片描述
    看一下项目结构,新建一个创建IPLimitInterceptor类,在springmvc配置文件配置、新建一个ip校验工具类 IPWhiteListUtil、ip配置文件: ipwhite.properties。
    在这里插入图片描述再看代码实现

    创建IPLimitInterceptor类
    PLimitInterceptor继承HandlerInterceptorAdapter父类

    import java.net.InetAddress;
    
    import java.util.Properties;
    
    import javax.servlet.http.HttpServletRequest;
    
    import javax.servlet.http.HttpServletResponse;
    
    import org.springframework.core.io.support.PropertiesLoaderUtils;
    
    import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
    
    public class IPLimitInterceptor extends HandlerInterceptorAdapter {
    
             @Override
             public boolean preHandle(HttpServletRequest request,
    
                                HttpServletResponse response, Object handler) throws Exception {undefined
    
                               String ip = getIpAddress(request);
    
                               //读取ip白名单配置文件ipwhite.properties
    
                               Properties properties = PropertiesLoaderUtils.loadAllProperties("ipwhite.properties");
    
                                String ipWhilte = properties.getProperty("ipWhilte");
    
                                System.out.println(ipWhilte);
    
                                //判断请求ip地址 是否在白名单呢
    
                     if(IPWhiteListUtil.checkLoginIP(ip,ipWhilte)) {undefined
    
                         return super.preHandle(request, response, handler);
    
                     }
    
                     throw new Exception("IP非法访问!");
    
     
    
             }
    
             //获取配置请求的ip地址
    
             private String getIpAddress(HttpServletRequest request) {undefined
    
            String ip = request.getHeader("x-forwarded-for");
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("Proxy-Client-IP");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("WL-Proxy-Client-IP");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("HTTP_CLIENT_IP");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getHeader("HTTP_X_FORWARDED_FOR");
    
            }
    
            if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {undefined
    
                ip = request.getRemoteAddr();
    
                System.out.println("访问ip="+ip);
    
                if(ip.equals("127.0.0.1")){    
    
                    //根据网卡取本机配置的IP    
    
                    InetAddress inet=null;    
    
                    try {    
    
                        inet = InetAddress.getLocalHost();    
    
                    } catch (Exception e) {    
    
                        e.printStackTrace();    
    
                    }    
    
                    ip= inet.getHostAddress();    
    
                } 
    
            }
    
            //对于通过多个代理的情况,第一个IP为客户端真实IP,多个IP按照','分割   
    
            if(ip!=null && ip.length()>15){ //"***.***.***.***".length() = 15   
    
                if(ip.indexOf(",")>0){   
    
                    ip = ip.substring(0,ip.indexOf(","));   
    
                }   
    
            }   
    
            System.out.println("访问ip========="+ip);
    
            return ip;
    
        }
    
    }
    

    在springmvc配置文件配置:

    <mvc:interceptors>
    
        <!-- IP鉴权拦截器 -->
    
         <mvc:interceptor>
    
            <mvc:mapping path="/**"/>
    
            <bean class="com.*.*.ipwhite.IPLimitInterceptor"></bean>
    
         </mvc:interceptor>
    
       </mvc:interceptors>
    

    在这里插入图片描述
    再新建一个ip校验类 IPWhiteListUtil

    /**
     * IP校验类的方法
     */
    import java.util.ArrayList;
    
    import java.util.HashSet;
    
    import java.util.List;
    
    import java.util.Set;
    
    import java.util.regex.Pattern;
    
    
    
    public class IPWhiteListUtil {
        // IP的正则
        private static Pattern pattern = Pattern
                .compile("(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})\\."
                        + "(1\\d{1,2}|2[0-4]\\d|25[0-5]|\\d{1,2})");
        /**
         *
         * getAvaliIpList:(根据IP白名单设置获取可用的IP列表).
         * @return
         */
    
        private static Set getAvaliIpList(String allowIp) {
            Set<String> ipList = new HashSet();
            for (String allow : allowIp.replaceAll("\\s", "").split(";")) {
                if (allow.indexOf("*") > -1) {
                    String[] ips = allow.split("\\.");
                    String[] from = new String[] { "0", "0", "0", "0" };
                    String[] end = new String[] { "255", "255", "255", "255" };
                    List<String> tem = new ArrayList();
                    for (int i = 0; i < ips.length; i++)
                        if (ips[i].indexOf("*") > -1) {
                                tem = complete(ips[i]);
                            from[i] = null;
                            end[i] = null;
                        } else {
                            from[i] = ips[i];
                            end[i] = ips[i];
                        }
                    StringBuffer fromIP = new StringBuffer();
                    StringBuffer endIP = new StringBuffer();
                    for (int i = 0; i < 4; i++){
                        if (from[i] != null) {
                            fromIP.append(from[i]).append(".");
                            endIP.append(end[i]).append(".");
                        } else {
                            fromIP.append("[*].");
                            endIP.append("[*].");
                        }
                    }
                    fromIP.deleteCharAt(fromIP.length() - 1);
                    endIP.deleteCharAt(endIP.length() - 1);
                    for (String s : tem) {
                        String ip = fromIP.toString().replace("[*]",
                                s.split(";")[0])
                                + "-"
                                + endIP.toString().replace("[*]", s.split(";")[1]);
    
                        if (validate(ip)) {
                            ipList.add(ip);
                        }
                    }
    
                } else {
                    if (validate(allow)) {
                        ipList.add(allow);
                    }
                }
            }
            return ipList;
        }
    
        private static Set getAvaliIpList(Set<String> ipSet) {
            Set<String> ipList = new HashSet();
            for (String allow : ipSet) {
                if (allow.indexOf("*") > -1) {
                    String[] ips = allow.split("\\.");
                    String[] from = new String[] { "0", "0", "0", "0" };
                    String[] end = new String[] { "255", "255", "255", "255" };
                    List<String> tem = new ArrayList();
                    for (int i = 0; i < ips.length; i++)
                        if (ips[i].indexOf("*") > -1) {
                                tem = complete(ips[i]);
                            from[i] = null;
                            end[i] = null;
                        } else {
                            from[i] = ips[i];
                            end[i] = ips[i];
                        }
                    StringBuffer fromIP = new StringBuffer();
                    StringBuffer endIP = new StringBuffer();
                    for (int i = 0; i < 4; i++) {
                        if (from[i] != null) {
                            fromIP.append(from[i]).append(".");
                            endIP.append(end[i]).append(".");
                        } else {
                            fromIP.append("[*].");
                            endIP.append("[*].");
                        }
                    }
                    fromIP.deleteCharAt(fromIP.length() - 1);
    
                    endIP.deleteCharAt(endIP.length() - 1);
    
    
    
                    for (String s : tem) {
                        String ip = fromIP.toString().replace("[*]",
                                s.split(";")[0])
                                + "-"
                                + endIP.toString().replace("[*]", s.split(";")[1]);
                        if (validate(ip)) {
                            ipList.add(ip);
                        }
                    }
                } else {
                    if (validate(allow)) {
                        ipList.add(allow);
                    }
                }
            }
            return ipList;
        }
    
        /**
    
         * 对单个IP节点进行范围限定
    
         *
    
         * @param arg
    
         * @return 返回限定后的IP范围,格式为List[10;19, 100;199]
    
         */
    
        private static List complete(String arg) {
            List com = new ArrayList();
            if (arg.length() == 1) {
                com.add("0;255");
            } else if (arg.length() == 2) {
                String s1 = complete(arg, 1);
                if (s1 != null){
                    com.add(s1);
                }
                String s2 = complete(arg, 2);
                if (s2 != null){
                    com.add(s2);
                }
            } else {
                String s1 = complete(arg, 1);
                if (s1 != null){
                    com.add(s1);
                }
            }
            return com;
        }
        private static String complete(String arg, int length) {
    
            String from = "";
    
            String end = "";
    
            if (length == 1) {
    
                    from = arg.replace("*", "0");
    
                end = arg.replace("*", "9");
    
            } else {
    
                    from = arg.replace("*", "00");
    
                end = arg.replace("*", "99");
    
            }
    
            if (Integer.valueOf(from) > 255){
                return null;
            }
            if (Integer.valueOf(end) > 255){
                end = "255";
            }
            return from + ";" + end;
    
        }
    
    
    
        /**
    
         * 在添加至白名单时进行格式校验
    
         *
    
         * @param ip
    
         * @return
    
         */
    
        private static boolean validate(String ip) {
    
            for (String s : ip.split("-")){
                if (!pattern.matcher(s).matches()) {
    
                    return false;
    
                }
            }
            return true;
    
        }
    
    
    
        /**
    
         *
    
         * checkLoginIP:(根据IP,及可用Ip列表来判断ip是否包含在白名单之中).
    
         * @param ip
    
         * @param ipList
    
         * @return
    
         */
    
        private static boolean checkLoginIP(String ip, Set<String> ipList) {
            if (ipList.contains(ip)){
                return true;
            }else {
                for (String allow : ipList) {
                    if (allow.indexOf("-") > -1) {
                        String[] from = allow.split("-")[0].split("\\.");
                        String[] end = allow.split("-")[1].split("\\.");
                        String[] tag = ip.split("\\.");
                        // 对IP从左到右进行逐段匹配
                        boolean check = true;
                        for (int i = 0; i < 4; i++) {
                            int s = Integer.valueOf(from[i]);
                            int t = Integer.valueOf(tag[i]);
                            int e = Integer.valueOf(end[i]);
                            if (!(s <= t && t <= e)) {
                                check = false;
                                break;
                            }
                        }
                        if (check) {
                            return true;
                        }
                    }
                }
            }
            return false;
        }
    
    
    
        /**
    
         *
    
         * checkLoginIP:(根据IP地址,及IP白名单设置规则判断IP是否包含在白名单).
    
         * @param ip
    
         * @param ipWhiteConfig
    
         * @return
    
         */
    
        public static boolean checkLoginIP(String ip,String ipWhiteConfig){
    
            Set ipList = getAvaliIpList(ipWhiteConfig);
    
            return checkLoginIP(ip, ipList);
    
        }
    
    
    
        /**
    
         *
    
         * ip在ipList中,则返回true
    
         * @param ip
    
         * @param ipList
    
         * @return
    
         */
    
        public static boolean checkIpList(String ip,List<String> ipList){
    
            Set<String> ipSet = new HashSet();
    
            for(String ipStr : ipList){
    
                if(!ipStr.trim().startsWith("#")){
    
                    ipSet.add(ipStr.trim());
    
                }
    
            }
    
            ipSet = getAvaliIpList(ipSet);
    
            return checkLoginIP(ip, ipSet);
    
        }
    
        // 测试
    
        public static void main(String[] args) {
    
            String ipWhilte = "192.168.1.1;" +                 //设置单个IP的白名单
                    "192.168.2.*;" +                 //设置ip通配符,对一个ip段进行匹配
                    "192.168.3.17-192.168.3.38";     //设置一个IP范围
            System.out.println(ipWhilte);
            boolean flag = checkLoginIP("192.168.2.2",ipWhilte);
            boolean flag2 = checkLoginIP("192.168.1.2",ipWhilte);
            boolean flag3 = checkLoginIP("192.168.3.16",ipWhilte);
            boolean flag4 = checkLoginIP("192.168.3.17",ipWhilte);
            System.out.println(flag);  //true
            System.out.println(flag2);  //false
            System.out.println(flag3);  //false
            System.out.println(flag4);  //true
        }
    }
    
    

    #配置白名单-可改成数据库获取或配置文件配置

    #//设置单个IP的白名单 “192.168.1.1;”

    #//设置ip通配符,对一个ip段进行匹配 “192.168.2.*;”

    #//设置一个IP范围 “192.168.12.17-192.168.12.150”

    ipWhilte = 192.168.1.1;192.168.2.*;192.168.2.17-192.168.12.150;10.9.160.135;

    测试:

    注意访问需要输入:http://127.0.0.1:8981/hello

    在配置文件加上本地的ip 10.9.160.135
    在这里插入图片描述
    去掉本地ip 10.9.160.135 提示非法字符
    在这里插入图片描述

    展开全文
  • 当使用了知道创宇云安全,在进行网站管理等敏感操作时,如果发现被拦截,且确认操作可信,可以通过添加IP白名单、网址白名单、策略白名单的方式解决,这三种白名单相互独立发挥作用,可按需添加。知道创宇云安全的...
  • 怎么设置防火墙白名单?1。首先,导航到控制面板并在控制面板中找到windows防火墙选项。如果找不到,请切换到左侧菜单中的经典视图;2。双击“windows防火墙”弹出一个新对话框。默认情况下,“常规”选项卡处于选中...
  • 查询IP白名单

    2021-01-18 19:17:09
    示例请求示例http(s)://rds.aliyuncs....DBInstanceId=rm-uf6wjk5xxxxxxx&正常返回示例XML 格式rds_defaultVPC192.168.1.0/24IPv4E2B6AF71-DC32-4055-B477-43B348798D10JSON 格式{"I...
  • 如何解决防火墙加白名单?1、首先定位到控制面板中,在控制面板中找到windows防火墙这个选项,如果找不到请在左侧的菜单中切换到经典视图;2、双击windows防火墙会弹出新的对话框,对话框默认选中常规标签,通常情况...
  • 最简单的java接口IP白名单限制

    千次阅读 2022-06-07 15:40:33
    如何获取请求中的公网ip, 如何将该方法运用到自己的接口上
  • iptables ip 白名单操作

    2022-06-21 14:35:13
    iptables 常用操作
  • LinuxIP白名单设置

    千次阅读 2022-01-02 23:32:29
    但是最近一个问题也显现出来,就是当自己几次操作失误之后,自己的ip也会进黑名单,造成连不上服务器的情况,就想能不能把自己ip设个白名单来进行规避呢,果不其然,还是有的,其实在/etc目录下还有一个host.allow...
  • 您可以将IP地址列入白名单或黑名单。根据您的要求在第二步中找到的行下添加以下行。从受限IP访问Tomcat时HTTPERROR500将作为响应返回。-只允许访问与正则表达式模式匹配的特定IP集。-拒绝访问与正则表达式模式匹配的...
  • 白名单设置,访问根目录 location / { allow 123.34.22.155; allow 33.56.32.1/100; deny all; } 黑名单设置,访问根目录 location / { deny 123.34.22.155; } 特定目录访问限制 location /tree/list { allow...
  • 为了防止错误拦截CDN节点,缙哥哥这里找到了知道创宇云加速的CDN节点IP段(免费版),并一个个手动加入宝塔防火墙IP白名单,为了方便自己方便大家,特意导出一份供大伙使用!如果您的网站有防火墙,建议您将知道创宇云...
  • IP白名单内的IP地址作为来源,获取access_token接口才可调用成功。而想要调用公众号相关API,就必须获取access_token,即白名单必须配置。如果没有配置,则会返回错误码40164(调用接口的IP地址不在白名单中,请在...
  • ip白名单绕过

    2021-11-17 12:59:33
    ip白名单绕过方式 请求头绕过: X-Real-ip:xxxx x-forwarded-for:xxxx x-remote-IP:xxxx
  • nginx IP白名单设置

    千次阅读 2021-07-22 15:20:22
    在server中加: if ($remote_addr !~ ^(222.128.111.*|100.110.15.16|127.0.0.1)) { return 404; } 则222.128.111.*可访问该网站
  • 查看白名单端口列表 firewall-cmd --zone=public --list-ports # 作用域 --zone # 永久生效,没有此参数重启后失效 --permanent #获取本机服务器的公网出口ip curl http://myip.fireflysoft.net/ 关于ssh端口爆破 ...
  • 由于宝塔Nginx/Apache防火墙的规则也是非常强的,如果不将云盾(YUNDUN)高防CDN节点IP段列入宝塔防火墙白名单的话,访客容易出现502等错误。推荐使用宝塔Linux控制面板你还没开始用?缙哥哥推荐使用宝塔服务器面板,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,484
精华内容 17,793
关键字:

IP白名单