Linux C/C++ 入侵检测系统（IDS绕过技巧）

入侵检测系统（IDS）是一种网络安全设备，其主要功能是对网络传输进行即时监视，并在入侵检测系统（IDS）是一种网络安全设备，其主要功能是对网络传输进行即时监视，并在发现可疑传输时发出警报或者采取主动反应措施。相较于其他网络安全设备，IDS的主要特性在于其积极主动的安全防护技术。它不会跨越多个物理网段，通常只监听一个端口，不需要转发任何流量，只需在网络上被动、无声地收集所关心的报文。

在具体实现上，IDS首先提取收集到的流量统计特征值，并利用内置的入侵知识库对这些流量特征进行智能分析比较匹配。如果某个报文流量与预设阀值的匹配度较高，则该报文将被认为可能是攻击行为，此时，IDS将根据相应的配置进行报警或进行有限度的反击。

IDS实现原理及作用

IDS实现原理：

  - 网络流量分析：IDS监视网络上的数据流量，分析数据包的内容、来源、目标等信息，以寻找异常迹象。
  - 特征检测：IDS使用特定的规则或特征签名来检测已知的攻击模式或恶意行为。这些规则可以基于数字签名、统计学、行为分析等技术实现。
  - 异常检测：IDS还可以通过建模正常的系统和网络活动情况，然后检测出与正常行为明显不同的异常情况。

IDS作用：

 - 攻击检测：IDS可以检测到诸如网络扫描、拒绝服务攻击、恶意软件传播等各种类型的攻击行为。
 - 恶意行为分析：IDS能够发现系统内的恶意活动，如非法访问、异常登录行为等。
 - 事后审计：IDS记录异常事件和攻击行为，便于事后审计和安全调查。

总的来说，IDS的作用是帮助组织监控和保护其网络和系统，及时发现潜在的安全问题，并采取相应的措施来应对。IDS通常与其他安全解决方案如防火墙、入侵预防系统（IPS）等配合使用，形成全面的安全防护体系。

IDS 和iptables 配合使用

iptables 是一个 Linux 系统中用于配置和管理防火墙规则的工具，而入侵检测系统（IDS）则用于监测网络攻击行为并做出相应反应。在使用 iptables 时，可以与 IDS 配合使用，以提高系统的安全性和防护能力。
以下是一些使用 iptables 配合 IDS：

  • 启用 iptables 日志：iptables 可以记录防火墙的日志信息，包括拒绝的连接、异常流量等。将这些日志信息发送给 IDS，可以帮助 IDS 检测和分析攻击行为。在 iptables 规则中，使用 LOG 目标记录日志信息，然后通过 syslog
    或其他方式将日志发送给 IDS。
  • 定义自定义的 iptables 规则：使用 iptables 可以定义自定义的规则，以针对特定的攻击行为或异常流量进行过滤和阻断。可以将这些规则与 IDS 集成，以便在检测到攻击时自动应用相应的规则。
  • 与 IDS 进行联动：iptables 和 IDS 可以进行联动，以实现自动化的防御和响应。例如，当 IDS 检测到攻击行为时，可以触发
    iptables 规则的自动应用，以快速阻断攻击流量或隔离攻击者。同样，当 iptables 规则触发时，也可以通知 IDS
    进行进一步的分析和处理。
  • 管理和维护：在使用 iptables 和 IDS
    的过程中，需要定期管理和维护这些工具。例如，更新规则库、检查日志文件、修复配置错误等。确保定期进行安全审计和漏洞扫描，以确保系统的安全性。

总之，iptables 和 IDS 是 Linux 系统安全性的重要组成部分。通过合理的配置和管理这些工具，可以增强系统的防护能力，并提高对攻击行为的响应速度。

检测网络中的异常行为及代码实现

  • 入侵检测系统（IDS）可以通过在TCP三次握手时注入服务器来检测网络中的异常行为。具体来说，当客户端向服务器发起TCP连接请求时，IDS可以在中间插入自己的IP地址和端口号，与服务器进行通信。这样，IDS就可以截获并分析TCP连接过程中的所有数据包，以检测是否存在恶意攻击或异常行为。

    在TCP三次握手的过程中，客户端首先发送一个SYN包给服务器，表示请求建立连接。服务器收到SYN包后，会回复一个SYN-ACK包，表示同意建立连接。最后，客户端再回复一个ACK包，表示确认建立连接。在这个过程中，IDS可以截获并分析这些数据包，以检测是否存在恶意攻击或异常行为。

iptables -A OUTPUT -p tcp --sport 80 --tcp-flags RST RST -j DROP

这个命令的作用是在iptables防火墙规则中添加一条规则，用于阻止所有从本地主机（源IP地址）发出的TCP连接请求，这些请求的目标端口是80，并且具有RST标志。当满足这些条件时，该规则将丢弃这些连接请求。

...

#define DATA "HTTP/1.1 200 OK\r\nContent-Type: text/plain\r\nContent-Length: 21\r\n\r\nyou have been hacked!"

...
pcap_t* open_pcap_socket(char* device, const char* bpfstr)
{
    char errbuf[PCAP_ERRBUF_SIZE];
    pcap_t* pd;
    uint32_t  srcip, netmask;
    struct bpf_program  bpf;

    // 如果没有指定网络接口（设备），请获取第一个
    if (!*device && !(device = pcap_lookupdev(errbuf)))
    {
        printf("pcap_lookupdev(): %s\n", errbuf);
        return NULL;
    }
    
    // 打开设备进行实时捕获，而不是读取数据包捕获文件
    if ((pd = pcap_open_live(device, BUFSIZ, 1, 0, errbuf)) == NULL)
    {
        printf("pcap_open_live(): %s\n", errbuf);
        return NULL;
    }

    // 获取网络设备源IP地址和网络掩码
    if (pcap_lookupnet(device, &srcip, &netmask, errbuf) < 0)
    {
        printf("pcap_lookupnet: %s\n", errbuf);
        return NULL;
    }

    if (pcap_compile(pd, &bpf, (char*)bpfstr, 0, netmask))
    {
        printf("pcap_compile(): %s\n", pcap_geterr(pd));
        return NULL;
    }

    // 将数据包筛选器分配给给定的libpcap套接字
    if (pcap_setfilter(pd, &bpf) < 0)
    {
        printf("pcap_setfilter(): %s\n", pcap_geterr(pd));
        return NULL;
    }

    return pd;
}

void capture_loop(pcap_t* pd, int packets, pcap_handler func)
{
    int linktype;
 
    // 确定数据链路层类型。
    if ((linktype = pcap_datalink(pd)) < 0)
    {
        printf("pcap_datalink(): %s\n", pcap_geterr(pd));
        return;
    }
 
    //设置数据链路层标头大小
    switch (linktype)
    {
    case DLT_NULL:
        linkhdrlen = 4;
        break;
 
    case DLT_EN10MB:
        linkhdrlen = 14;
        break;
 
    case DLT_SLIP:
    case DLT_PPP:
        linkhdrlen = 24;
        break;
 
    default:
        printf("Unsupported datalink (%d)\n", linktype);
        return;
    }
 
    // 开始捕获数据包
    if (pcap_loop(pd, packets, func, 0) < 0)
        printf("pcap_loop failed: %s\n", pcap_geterr(pd));
}
...
void parse_packet(u_char *user, struct pcap_pkthdr *packethdr, 
                  u_char *packetptr)
{
...
    // 跳过数据链路层标头并获取IP标头字段
    packetptr += linkhdrlen;
    iphdr = (struct ip*)packetptr;
    strcpy(srcip, inet_ntoa(iphdr->ip_src));
    strcpy(dstip, inet_ntoa(iphdr->ip_dst));
    sprintf(iphdrInfo, "ID:%d TOS:0x%x, TTL:%d IpLen:%d DgLen:%d",
            ntohs(iphdr->ip_id), iphdr->ip_tos, iphdr->ip_ttl,
            4*iphdr->ip_hl, ntohs(iphdr->ip_len));
 

    packetptr += 4*iphdr->ip_hl;
    if (iphdr->ip_p == IPPROTO_TCP )
    {
        tcphdr = (struct tcphdr*)packetptr;
            
        addr_in.sin_family = AF_INET;
        addr_in.sin_port = tcphdr->source;
        addr_in.sin_addr.s_addr = iphdr->ip_src.s_addr;
        
        if (debug_output)
        {
            printf("[*] TCP  %s:%d -> %s:%d\t", srcip, ntohs(tcphdr->source), dstip, ntohs(tcphdr->dest));
            printf( "%c%c%c%c%c%c Seq: 0x%x Ack: 0x%x Win: 0x%x TcpLen: %d\n",
                (tcphdr->urg ? 'U' : '*'), (tcphdr->ack ? 'A' : '*'),
                (tcphdr->psh ? 'P' : '*'), (tcphdr->rst ? 'R' : '*'),
                (tcphdr->syn ? 'S' : '*'), (tcphdr->fin ? 'F' : '*'),
                ntohl(tcphdr->seq), ntohl(tcphdr->ack_seq), ntohs(tcphdr->window), 4*tcphdr->doff
            );
        }
        
        sender_port = ntohs(tcphdr->source);
        seq_number = rand();

        memset(synack_packet, 0, sizeof(synack_packet));
        memset(pshack_packet, 0, sizeof(pshack_packet));
        memset(finack_packet, 0, sizeof(finack_packet));
        memset(ack_packet, 0, sizeof(ack_packet));
        
        // 正在准备SYN-ACK数据包
        ipHdr = (struct iphdr *) synack_packet;
        tcpHdr = (struct tcphdr *) (synack_packet + sizeof(struct iphdr));

        ipHdr->ihl = 5;
        ipHdr->version = 4;
        ipHdr->tos = 0;
        ipHdr->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
        ipHdr->id = htons(rand());
        ipHdr->frag_off = 0x00; 
        ipHdr->ttl = 0xFF;
        ipHdr->protocol = IPPROTO_TCP;
        ipHdr->check = 0;
        ipHdr->saddr = iphdr->ip_dst.s_addr;
        ipHdr->daddr = iphdr->ip_src.s_addr;

        ipHdr->check = csum((unsigned short *) synack_packet, ipHdr->tot_len); 

        tcpHdr->source = tcphdr->dest; 
        tcpHdr->dest = tcphdr->source;
        tcpHdr->seq = htonl(seq_number);
        seq_number += 1; // 递增序列号
        tcpHdr->ack_seq = htonl(ntohl(tcphdr->seq) + 1);
        tcpHdr->doff = 5;
        tcpHdr->res1 = 0;
        tcpHdr->cwr = 0; 
        tcpHdr->ece = 0;
        tcpHdr->urg = 0;
        tcpHdr->ack = 1; 
        tcpHdr->psh = 0;
        tcpHdr->rst = 0;
        tcpHdr->syn = 1;
        tcpHdr->fin = 0; 
        tcpHdr->window = htons(15500);
        tcpHdr->check = 0; 
        tcpHdr->urg_ptr = 0;
        tcpHdr->check = tcp_checksum(tcpHdr, sizeof(struct tcphdr), iphdr->ip_dst.s_addr, iphdr->ip_src.s_addr);
            
        // 准备DATA数据包
        memcpy(pshack_packet, synack_packet, sizeof(struct iphdr) + sizeof(struct tcphdr));
        ipHdr = (struct iphdr *) pshack_packet;
        tcpHdr = (struct tcphdr *) (pshack_packet + sizeof(struct iphdr));
        data = (char *) (pshack_packet + sizeof(struct iphdr) + sizeof(struct tcphdr));
        strcpy(data, DATA);
        ipHdr->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr) + strlen(data);
        tcpHdr->seq = htonl(seq_number);
        seq_number += strlen(data);// Increment seq number
        tcpHdr->syn = 0;
        tcpHdr->psh = 1;
        tcpHdr->check = 0x0;
        tcpHdr->check = tcp_checksum(tcpHdr, sizeof(struct tcphdr) + strlen(data), iphdr->ip_dst.s_addr, iphdr->ip_src.s_addr);
            
        // 准备FIN数据包
        memcpy(finack_packet, pshack_packet, sizeof(struct iphdr) + sizeof(struct tcphdr) + strlen(data));
        ipHdr = (struct iphdr *) finack_packet;
        tcpHdr = (struct tcphdr *) (finack_packet + sizeof(struct iphdr));
        tcpHdr->seq = htonl(seq_number);
        seq_number += 1; // Increment seq number
        ipHdr->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
        tcpHdr->fin = 1;
        tcpHdr->psh = 0;
        tcpHdr->check = 0x0;
        tcpHdr->check = tcp_checksum(tcpHdr, sizeof(struct tcphdr), iphdr->ip_dst.s_addr, iphdr->ip_src.s_addr);
        
        // 正在准备ACK数据包
        memcpy(ack_packet, synack_packet, sizeof(struct iphdr) + sizeof(struct tcphdr));
        ipHdr = (struct iphdr *) ack_packet;
        tcpHdr = (struct tcphdr *) (ack_packet + sizeof(struct iphdr));
        tcpHdr->seq = tcphdr->ack_seq;
        tcpHdr->ack_seq = htonl(ntohl(tcphdr->seq) + 1);
        if (strlen((char*) tcphdr + 4*tcphdr->doff) > 0)
            tcpHdr->ack_seq = htonl(ntohl(tcpHdr->ack_seq) - 1 + strlen((char*) tcphdr + 4*tcphdr->doff));
        ipHdr->tot_len = sizeof(struct iphdr) + sizeof(struct tcphdr);
        tcpHdr->ack = 1; 
        tcpHdr->psh = 0;
        tcpHdr->rst = 0;
        tcpHdr->syn = 0;
        tcpHdr->fin = 0; 
        tcpHdr->check = 0x0;
        tcpHdr->check = tcp_checksum(tcpHdr, sizeof(struct tcphdr), iphdr->ip_dst.s_addr, iphdr->ip_src.s_addr);
        
        if (tcphdr->syn && !tcphdr->ack )
        {
...
            ipHdr = (struct iphdr *) pshack_packet;            
            if((bytes = sendto(sock, pshack_packet, ipHdr->tot_len, 0, (struct sockaddr *) &addr_in, sizeof(addr_in))) < 0)
                perror("Error on sendto()");
            else {
                printf("\t[+] [%s:%d] Sending HTTP response data\n", srcip, ntohs(tcphdr->source));
            }
            ipHdr = (struct iphdr *) finack_packet;            
            if((bytes = sendto(sock, finack_packet, ipHdr->tot_len, 0, (struct sockaddr *) &addr_in, sizeof(addr_in))) < 0)
                perror("Error on sendto()");
            else {
                printf("\t[+] [%s:%d] Closing connection. Sending FIN-ACK\n", srcip, ntohs(tcphdr->source));
            }
        }
        else if (tcphdr->ack && (tcphdr->psh || tcphdr->fin) && send_ack)
        {            
            ipHdr = (struct iphdr *) ack_packet;
            if((bytes = sendto(sock, ack_packet, ipHdr->tot_len, 0, (struct sockaddr *) &addr_in, sizeof(addr_in))) < 0)
                perror("Error on sendto()");
            else
                printf("[+] ACKing to [%s:%d]\n", srcip, ntohs(tcphdr->source));
        }
    }
    ...
}


int main(int argc, char **argv)
{
...
    
    sprintf(help, "usage: %s -i <interface> -p <port: 1..65535> [-d] [-a]\n\t-d\tenable debug output\n\t-a\tsend ACK packet to every incoming data packet\n\n", argv[0]);
    
    if((sock = socket(PF_INET, SOCK_RAW, IPPROTO_RAW)) < 0) {
        perror("Error while creating socket");
        exit(-1);
    }

    if(setsockopt(sock, IPPROTO_IP, IP_HDRINCL, (char *)&one, sizeof(one)) < 0) {
        perror("Error while setting socket options");
        exit(-1);
    }
    
    while ((c = getopt (argc, argv, "hadi:p:")) != -1)
    {
        switch (c)
        {
        case 'i':
            strcpy(interface, optarg);
            break;
        case 'p':
            strcpy(port, optarg);
            break;
        case 'd':
            debug_output = 1;
            break;
        case 'a':
            send_ack = 1;
            break;
        case 'h':
        default:
            printf("%s", help);
            exit(0);
            break;
        }
    }
    
    if (atoi(port) < 1 || atoi(port) > 65535 || interface[0] == 0x0)
    {
        printf("%s", help);
        exit(0);
    }
    
    strcat(bpfstr, "tcp and dst port ");
    strcat(bpfstr, port);
    
    if ((pd = open_pcap_socket(interface, bpfstr)))
    {
        capture_loop(pd, 0, (pcap_handler)parse_packet);
    }
...
}

运行效果：
If you need the complete source code, please add the WeChat number (c17865354792)

抓包效果：

IDS（入侵检测系统）绕过技巧

IDS（入侵检测系统）绕过技巧是指利用各种方法来规避或欺骗入侵检测系统的技术手段。IDS是一种网络安全设备，用于监测和检测网络中的入侵行为。它可以根据定义的规则识别可能的攻击行为并提供相应的警报。然而，攻击者可能会尝试绕过IDS以隐藏其攻击活动并规避被检测的风险。

以下是一些可能的IDS绕过技巧的原理和作用：

  1. 基于流量特征的绕过：攻击者可以利用特定协议或传输方式的特征来规避IDS的检测。例如，攻击者可以使用分片或隧道技术来分割或隐藏攻击流量，使其不容易被IDS检测到。

  2. 加密和隐蔽通信：攻击者可以使用加密通信方式或隐蔽通道来隐藏其攻击流量。这可以防止IDS对传输的内容进行检测和分析。

  3. 基于缺陷的攻击：攻击者可以利用IDS本身的漏洞或缺陷来绕过其检测机制。例如，攻击者可能发现IDS的规则规则不完善或配置错误，从而在不被检测到的情况下执行攻击。

  4. 欺骗：攻击者可能试图欺骗IDS来规避被检测。例如，攻击者可以发送特制的数据包以模拟合法流量，从而使IDS无法发现其中的恶意行为。

这些绕过技巧的目的是使攻击者的行为隐蔽，使其能够成功地进行攻击而不被检测或阻止。对抗这些绕过技巧的关键在于不断更新和改进IDS的检测规则和技术，以及加强网络安全防御的整体能力。

总结

入侵检测系统（IDS）是一种用于检测和识别网络攻击的网络安全工具。IDS可以监视网络流量，检测各种攻击行为，并发出警报或采取相应的防御措施。

Welcome to follow WeChat official account【程序猿编码】

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/132376.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

python升级pip的时候一直失败

python升级pip的时候一直失败

如图,一直提示使用 python.exe -m pip install --upgrade pip 进行升级pip,但是执行这句命令又不成功.然后综合了几篇文章以后使用了下面的命令可以升级了 python -m pip install --upgrade pip --user -i https://mirrors.aliyun.com/pypi/simple/ 主要是在推荐的语句上使用…
阅读更多...
赶紧收藏！阿里内部使用的127页k8s实战手册，不能再详细了！

赶紧收藏！阿里内部使用的127页k8s实战手册，不能再详细了！

2022 年 12 月 8 号Kubernetes 发布了1.26新版本&#xff0c;此版本中有两个突出的新功能&#xff0c;它们有可能改变用户与 Kubernetes 交互的方式&#xff0c;此外&#xff0c;其他功能将使集群管理员的工作更轻松。 说起来&#xff0c;Kubernetes从诞生初期就广泛受到业界的…
阅读更多...
金字塔原理小节

金字塔原理小节

目录 第1章 为什么要用金字塔结构 一、归类分组&#xff0c;将思想组织成金字塔 二、奇妙的数字“7” 三、归类分组搭建金字塔 四、找出逻辑关系&#xff0c;抽象概括 五、自上而下表达&#xff0c;结论先行 第1章 为什么要用金字塔结构 如果受众希望通过阅读你的文章、听…
阅读更多...
玩了个锤子游戏小程序搭建流程：探索深度与逻辑的结合

玩了个锤子游戏小程序搭建流程：探索深度与逻辑的结合

随着移动互联网的普及&#xff0c;小程序已经成为了越来越多用户的选择。在这个背景下&#xff0c;玩了个锤子游戏小程序应运而生&#xff0c;它为用户提供了一个全新的游戏体验。那么&#xff0c;如何搭建这样一个小程序呢&#xff1f;本文将为大家详细介绍玩了个锤子游戏小程…
阅读更多...
WPS数组

WPS数组

一、创建数组方法和数组的读取、修改、写入 数组是值的有序集合&#xff0c;其中的值叫作元素。每个元素有一个数值表示的位置&#xff0c;叫作索引&#xff0c;数组中的不同元素可以是不同数据类型。 function demo(){var arr1[99,"人","abc",[3,4,5]];…
阅读更多...
【tgowt】更新thirdparty

【tgowt】更新thirdparty

更新完毕后是这样的 之前有过构建但是不能用在owt-p2p项目中，会有崩溃？ 【tgowt】cmake转ninja vs构建现在好像都更新到108了 submodule比较麻烦 只修改这里的还不行：一旦git submodule init 后，再改这里的似乎晚了？如果能成功clone就有生成 还必须要改这里的 折腾好几次才…
阅读更多...
由于找不到 d3dx9_43.dll，无法继续执行代码。重新安装程序可能会解决此问题

由于找不到 d3dx9_43.dll，无法继续执行代码。重新安装程序可能会解决此问题

电脑出现d3dx9_43.dll缺失的问题&#xff0c;通常是由于DirectX组件未安装或损坏导致的。为了解决这个问题&#xff0c;我为您提供了以下四个解决方法&#xff1a; d3dx9_43.dll解决方法1. 使用dll修复程序修复 首先&#xff0c;使用系统文件程序dll进行修复操作非常简单&…
阅读更多...
Python进行多维数据分析

Python进行多维数据分析

多维数据分析是对数据的信息分析&#xff0c;它考虑了许多关系。让我们来介绍一些使用Python分析多维/多变量数据的基本技术。 从这里找到用于说明的数据的链接。&#xff08;https://archive.ics.uci.edu/dataset/111/zoo&#xff09; 以下代码用于从zoo_data. csv读取2D表格…
阅读更多...
Spring Cloud学习（三）【Nacos注册中心】

Spring Cloud学习（三）【Nacos注册中心】

文章目录 认识 NacosNacos 安装使用 Nacos 完成服务注册Nacos 服务分级存储模型集群负载均衡策略 NacosRule根据权重负载均衡Nacos 环境隔离&#xff08;命名空间&#xff09;Nacos 和 Eureka 的区别 认识 Nacos Nacos 是阿里巴巴的产品&#xff0c;现在是 SpringCloud 中的一…
阅读更多...
arcsinx的导数

arcsinx的导数

阅读更多...
高频SQL50题（基础版）-3

高频SQL50题（基础版）-3

文章目录 主要内容一.SQL练习题1.1174-即时食物配送代码如下&#xff08;示例&#xff09;: 2.550-游戏玩法分析代码如下&#xff08;示例&#xff09;: 3.2356-每位教师所教授的科目种类的数量代码如下&#xff08;示例&#xff09;: 4.1141-查询近30天活跃用户数代码如下&…
阅读更多...
@CreateCache：深度解析其功能与优势

@CreateCache：深度解析其功能与优势

1. CreateCache前言 在现代Web应用程序开发中&#xff0c;缓存是提高性能和响应速度的重要手段之一。CreateCache注解是JetCache框架中用于创建缓存的注解。本文将介绍CreateCache注解以及它在缓存管理中的作用。 2. CreateCache使用示例 以下是使用CreateCache注解的一个简…
阅读更多...
计算机组成原理之处理器(单周期)

计算机组成原理之处理器(单周期)

引言 处理器的实现方式决定了时钟周期长度和CPI。实现方式有单周期与流水线&#xff0c;本篇谈谈单周期处理器。 目前CPU的频率一般是3GHZ/4GHZ&#xff0c;但是频率是有极限值的&#xff0c;受cycletime影响 基本的RISC-V实现 存储指令&#xff1a;ld,sd算术逻辑指令 &…
阅读更多...
python3GUI--QQ音乐By:PyQt5（附下载地址）

python3GUI--QQ音乐By:PyQt5（附下载地址）

文章目录 一&#xff0e;前言二&#xff0e;展示0.播放页1.主界面1.精选2.有声电台3.排行4.歌手5.歌单 2.推荐3.视频1.视频2.分类3.视频分类 4.雷达5.我喜欢1.歌曲2.歌手 6.本地&下载7.最近播放8.歌单1.一般歌单2.自建歌单3.排行榜 9.其他1.搜索词推荐2.搜索结果 三&#x…
阅读更多...
第四节（2）：修改WORD中表格数据的方案

第四节（2）：修改WORD中表格数据的方案

《VBA信息获取与处理》教程(10178984)是我推出第六套教程&#xff0c;目前已经是第一版修订了。这套教程定位于最高级&#xff0c;是学完初级&#xff0c;中级后的教程。这部教程给大家讲解的内容有&#xff1a;跨应用程序信息获得、随机信息的利用、电子邮件的发送、VBA互联网…
阅读更多...
容器网络-Underlay和Overlay

容器网络-Underlay和Overlay

一、主机网络 前面讲了容器内部网络&#xff0c;但是容器最终是要部署在主机上&#xff0c;跨主机间的网络访问又是怎么样的&#xff0c;跨主机网络主要有两种方案。 二、 Underlay 使用现有底层网络&#xff0c;为每一个容器配置可路由的网络IP。也就是说容器网络和主机网络…
阅读更多...
Spring Boot(二)

Spring Boot(二)

1、运行维护 1.1、打包程序 SpringBoot程序是基于Maven创建的&#xff0c;在Maven中提供有打包的指令&#xff0c;叫做package。本操作可以在Idea环境下执行。 mvn package 打包后会产生一个与工程名类似的jar文件&#xff0c;其名称是由模块名版本号.jar组成的。 1.2、程序…
阅读更多...
Docker容器网络

Docker容器网络

一、Docker网络 Docker网络有下面4种配置类型&#xff0c;用的比较多的是Bridge&#xff1a; Null(–netNone) 把容器放入独立的网络空间但不做任何网络配置&#xff1b;用户需要通过运行 docker network 命令来完成网络配置。 Host 使用主机网络名空间&#xff0c;复用主机网…
阅读更多...
万字详解Linux内核内存规整！超详细！

万字详解Linux内核内存规整！超详细！

1.前言 伙伴系统作为内核最基础的物理页内存分配器&#xff0c;具有高效、实现逻辑简介等优点&#xff0c;其原理页也尽可能降低内存外部碎片产生&#xff0c;但依然无法杜绝碎片问题。外部碎片带来的最大影响就是内存足够&#xff0c;但是却无法满足内存分配需求&#xff0c;…
阅读更多...
Spring事务一网打尽

Spring事务一网打尽

Spring事务一网打尽 什么是事务首先说一个坑Spring 中的事务两种用法三大基础设施编程性事务TransactionManager 实现编程性事务TransactionTemplate 实现编程性事务 声明式事务XML配置声明式事务注解配置声明式事务注解XML混合配置声明式事务 什么是事务 这里要额外补充一点&a…
阅读更多...
最新文章

Copyright @ 2022~2023