用正则表达式检查是IP否为内网地址

🕗 发布于 2024-11-14 09:52 正则表达式 java PHP golang C

用正则表达式检查是ip否为内网地址

function isIntranet($ip)
{
    /* IPV4内网地址
    A 类10.0.0.0～10.255.255.255
    B 类172.16.0.0～172.31.255.255
    C 类192.168.0.0～192.168.255.255
    */

    // 检查是否为 IPv4 内网地址
    if (preg_match('/^10\./', $ip)) return true;
    if (preg_match('/^172\.(1[6-9]|2[0-9]|3[0-1])\./', $ip)) return true;
    if (preg_match('/^192\.168\./', $ip)) return true;

    /* IPV6内网地址
    ULA地址: fc00::/7 (fc00:: - fdff:ffff:ffff:ffff:ffff:ffff:ffff:ffff)
    链路本地地址: fe80::/10 (fe80:: - febf:ffff:ffff:ffff:ffff:ffff:ffff:ffff)
    */

    // 检查是否为 IPv6 内网地址
    if (preg_match('/^f[c-d][0-9a-f]{2}:/i', $ip)) return true;  // 匹配 fc00::/7 (包括 fc00:: 和 fdff:: 范围)
    if (preg_match('/^fe[89ab][0-9a-f]:/i', $ip)) return true;   // 匹配 fe80::/10 (包括 fe80:: 到 febf:: 范围)

    return false;
}

Java

import java.util.regex.Pattern;

public class IPUtils {
    public static boolean isIntranet(String ip) {
        // IPV4 内网地址正则表达式
        String ipv4Pattern10 = "^10\\.";
        String ipv4Pattern172 = "^172\\.(1[6-9]|2[0-9]|3[0-1])\\.";
        String ipv4Pattern192 = "^192\\.168\\.";

        // IPV6 内网地址正则表达式
        String ipv6PatternFC = "^f[c-d][0-9a-f]{2}:";
        String ipv6PatternFE = "^fe[89ab][0-9a-f]:";

        // 匹配 IPv4 内网地址
        if (Pattern.matches(ipv4Pattern10, ip)) return true;
        if (Pattern.matches(ipv4Pattern172, ip)) return true;
        if (Pattern.matches(ipv4Pattern192, ip)) return true;

        // 匹配 IPv6 内网地址
        if (Pattern.matches(ipv6PatternFC, ip)) return true;
        if (Pattern.matches(ipv6PatternFE, ip)) return true;

        return false;
    }

    public static void main(String[] args) {
        System.out.println(isIntranet("10.0.0.1"));       // true
        System.out.println(isIntranet("fc00::1"));        // true
        System.out.println(isIntranet("172.16.0.1"));     // true
        System.out.println(isIntranet("192.168.0.1"));    // true
        System.out.println(isIntranet("fe80::1"));        // true
        System.out.println(isIntranet("8.8.8.8"));        // false
    }
}

Golang

package main

import (
    "fmt"
    "regexp"
)

func isIntranet(ip string) bool {
    // 定义 IPv4 内网地址的正则表达式
    ipv4Pattern10 := `^10\.`
    ipv4Pattern172 := `^172\.(1[6-9]|2[0-9]|3[0-1])\.`
    ipv4Pattern192 := `^192\.168\.`

    // 定义 IPv6 内网地址的正则表达式
    ipv6PatternFC := `^f[c-d][0-9a-f]{2}:`
    ipv6PatternFE := `^fe[89ab][0-9a-f]:`

    // 匹配 IPv4 内网地址
    if matched, _ := regexp.MatchString(ipv4Pattern10, ip); matched {
        return true
    }
    if matched, _ := regexp.MatchString(ipv4Pattern172, ip); matched {
        return true
    }
    if matched, _ := regexp.MatchString(ipv4Pattern192, ip); matched {
        return true
    }

    // 匹配 IPv6 内网地址
    if matched, _ := regexp.MatchString(ipv6PatternFC, ip); matched {
        return true
    }
    if matched, _ := regexp.MatchString(ipv6PatternFE, ip); matched {
        return true
    }

    return false
}

func main() {
    fmt.Println(isIntranet("10.0.0.1"))      // true
    fmt.Println(isIntranet("fc00::1"))       // true
    fmt.Println(isIntranet("172.16.0.1"))    // true
    fmt.Println(isIntranet("192.168.0.1"))   // true
    fmt.Println(isIntranet("fe80::1"))       // true
    fmt.Println(isIntranet("8.8.8.8"))       // false
}

#include <stdio.h>
#include <stdbool.h>
#include <regex.h>

bool isIntranet(const char *ip) {
    // 定义正则表达式的模式和个数
    const char *patterns[] = {
        "^10\\.",                     // IPv4 10.x.x.x
        "^172\\.(1[6-9]|2[0-9]|3[0-1])\\.",  // IPv4 172.16.x.x - 172.31.x.x
        "^192\\.168\\.",              // IPv4 192.168.x.x
        "^f[c-d][0-9a-f]{2}:",        // IPv6 fc00::/7
        "^fe[89ab][0-9a-f]:"          // IPv6 fe80::/10
    };
    const int pattern_count = sizeof(patterns) / sizeof(patterns[0]);
    
    regex_t regex[pattern_count];
    bool result = false;

    // 编译所有正则表达式
    for (int i = 0; i < pattern_count; i++) {
        if (regcomp(&regex[i], patterns[i], REG_EXTENDED | REG_ICASE) != 0) {
            // 编译失败时释放已分配的正则表达式资源
            for (int j = 0; j < i; j++) regfree(&regex[j]);
            return false;
        }
    }

    // 匹配所有模式
    for (int i = 0; i < pattern_count; i++) {
        if (regexec(&regex[i], ip, 0, NULL, 0) == 0) {
            result = true;
            break;
        }
    }

    // 释放正则表达式资源
    for (int i = 0; i < pattern_count; i++) {
        regfree(&regex[i]);
    }

    return result;
}

int main() {
    printf("%d\n", isIntranet("10.0.0.1"));      // 1 (true)
    printf("%d\n", isIntranet("fc00::1"));       // 1 (true)
    printf("%d\n", isIntranet("172.16.0.1"));    // 1 (true)
    printf("%d\n", isIntranet("192.168.0.1"));   // 1 (true)
    printf("%d\n", isIntranet("fe80::1"));       // 1 (true)
    printf("%d\n", isIntranet("8.8.8.8"));       // 0 (false)
    return 0;
}

#include <iostream>
#include <regex>
#include <string>

bool isIntranet(const std::string& ip) {
    // 定义 IPv4 内网地址的正则表达式
    std::regex ipv4Pattern10("^10\\.");
    std::regex ipv4Pattern172("^172\\.(1[6-9]|2[0-9]|3[0-1])\\.");
    std::regex ipv4Pattern192("^192\\.168\\.");

    // 定义 IPv6 内网地址的正则表达式
    std::regex ipv6PatternFC("^f[c-d][0-9a-f]{2}:", std::regex::icase);
    std::regex ipv6PatternFE("^fe[89ab][0-9a-f]:", std::regex::icase);

    // 匹配 IPv4 内网地址
    if (std::regex_search(ip, ipv4Pattern10)) return true;
    if (std::regex_search(ip, ipv4Pattern172)) return true;
    if (std::regex_search(ip, ipv4Pattern192)) return true;

    // 匹配 IPv6 内网地址
    if (std::regex_search(ip, ipv6PatternFC)) return true;
    if (std::regex_search(ip, ipv6PatternFE)) return true;

    return false;
}

int main() {
    std::cout << isIntranet("10.0.0.1") << std::endl;      // true
    std::cout << isIntranet("fc00::1") << std::endl;       // true
    std::cout << isIntranet("172.16.0.1") << std::endl;    // true
    std::cout << isIntranet("192.168.0.1") << std::endl;   // true
    std::cout << isIntranet("fe80::1") << std::endl;       // true
    std::cout << isIntranet("8.8.8.8") << std::endl;       // false
    return 0;
}

原文地址：https://blog.csdn.net/wangxinwen/article/details/143742554

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：vue 计算属性get set
下一篇：【C++动态规划】2304. 网格中的最小路径代价|1658

【含文档】基于ssm+jsp的高校财务处理系统（含源码+数据库+lw）
管理员登录高校财务处理系统后，能对首页、个人中心、财务管理、会计科目管理、账户管理、财务账簿管理、凭证录入管理、凭证过账管理、初期录入管理、利润统计管理、资产负债管理、现金流量管理等功能进行详细操作。
阅读更多2024-11-14
30道Spring高频面试题，学完吊打面试官(实用干货！！！)
本文旨在为准备参加Spring框架面试的开发者提供全面的指导。Spring作为Java企业级开发的主流框架，以其轻量级、依赖注入、AOP（面向切面编程）和模块化等特性而广受欢迎。
阅读更多2024-11-14
Python代码实现了一个基于YOLOv5-Lite模型的目标检测系统
这段Python代码实现了一个基于YOLOv5-Lite模型的目标检测系统，并结合了舵机控制功能，能够对视频流中的目标（在这里可能是不同类型的垃圾）进行检测，同时可以根据检测结果控制两个舵机的转动。总
阅读更多2024-11-14
力扣662：二叉树的最大宽度
力扣662：二叉树的最大宽度。C语言
阅读更多2024-11-14
Qt 编写插件plugin，支持接口定义信号
本教程基于该链接的内容进行升级，在编写插件的基础上，支持接口类定义信号。环境：Qt5.12.12 + MSVC2017。
阅读更多2024-11-14
【CSS】什么是BFC？
块级格式化上下文（Block Formatting Context，简称BFC）是CSS布局中的一种重要概念，它决定了块级盒子如何在其容器内排列，以及浮动元素对其周围元素的影响。理解BFC可以帮助解决
阅读更多2024-11-14
2024年网络安全（黑客技术）三个月自学手册
网络安全可以基于攻击和防御视角来分类，我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术，而“蓝队”、“安全运营”、“安全运维”则研究防御技术。走安全行业的工程方向的，技术上面其实有很大的重叠
阅读更多2024-11-14
gitlab-development-kit部署gitlab《二》
Brewfile 注释的可以手动安装。
阅读更多2024-11-14
C++builder中的人工智能（28）：FANN: Fast Artificial Neural Networks快速人工神经网络（ANNs）
这篇文章全面介绍了快速人工神经网络（ANNs）的世界，探讨了它们在现代计算智能中的重要地位、核心特点、应用领域以及未来发展。快速人工神经网络库（Fast Artificial Neural Netwo
阅读更多2024-11-14
c++写一个死锁并且自己解锁
刷算法题：第一遍：1.看5分钟，没思路看题解2.通过题解改进自己的解法，并且要写每行的注释以及自己的思路。3.思考自己做到了题解的哪一步，下次怎么才能做对(总结方法)4.整理到自己的自媒体平台。5.再
阅读更多2024-11-14

用正则表达式检查是IP否为内网地址

相关文章