cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

xdp_adjust_tail_kern.c (3919B)

      1/* SPDX-License-Identifier: GPL-2.0
      2 * Copyright (c) 2018 Facebook
      3 *
      4 * This program is free software; you can redistribute it and/or
      5 * modify it under the terms of version 2 of the GNU General Public
      6 * License as published by the Free Software Foundation.
      7 *
      8 * This program shows how to use bpf_xdp_adjust_tail() by
      9 * generating ICMPv4 "packet to big" (unreachable/ df bit set frag needed
     10 * to be more preice in case of v4)" where receiving packets bigger then
     11 * 600 bytes.
     12 */
     13#define KBUILD_MODNAME "foo"
     14#include <uapi/linux/bpf.h>
     15#include <linux/in.h>
     16#include <linux/if_ether.h>
     17#include <linux/if_packet.h>
     18#include <linux/if_vlan.h>
     19#include <linux/ip.h>
     20#include <linux/icmp.h>
     21#include <bpf/bpf_helpers.h>
     22
     23#define DEFAULT_TTL 64
     24#define MAX_PCKT_SIZE 600
     25#define ICMP_TOOBIG_SIZE 98
     26#define ICMP_TOOBIG_PAYLOAD_SIZE 92
     27
     28/* volatile to prevent compiler optimizations */
     29static volatile __u32 max_pcktsz = MAX_PCKT_SIZE;
     30
     31struct {
     32	__uint(type, BPF_MAP_TYPE_ARRAY);
     33	__type(key, __u32);
     34	__type(value, __u64);
     35	__uint(max_entries, 1);
     36} icmpcnt SEC(".maps");
     37
     38static __always_inline void count_icmp(void)
     39{
     40	u64 key = 0;
     41	u64 *icmp_count;
     42
     43	icmp_count = bpf_map_lookup_elem(&icmpcnt, &key);
     44	if (icmp_count)
     45		*icmp_count += 1;
     46}
     47
     48static __always_inline void swap_mac(void *data, struct ethhdr *orig_eth)
     49{
     50	struct ethhdr *eth;
     51
     52	eth = data;
     53	memcpy(eth->h_source, orig_eth->h_dest, ETH_ALEN);
     54	memcpy(eth->h_dest, orig_eth->h_source, ETH_ALEN);
     55	eth->h_proto = orig_eth->h_proto;
     56}
     57
     58static __always_inline __u16 csum_fold_helper(__u32 csum)
     59{
     60	return ~((csum & 0xffff) + (csum >> 16));
     61}
     62
     63static __always_inline void ipv4_csum(void *data_start, int data_size,
     64				      __u32 *csum)
     65{
     66	*csum = bpf_csum_diff(0, 0, data_start, data_size, *csum);
     67	*csum = csum_fold_helper(*csum);
     68}
     69
     70static __always_inline int send_icmp4_too_big(struct xdp_md *xdp)
     71{
     72	int headroom = (int)sizeof(struct iphdr) + (int)sizeof(struct icmphdr);
     73
     74	if (bpf_xdp_adjust_head(xdp, 0 - headroom))
     75		return XDP_DROP;
     76	void *data = (void *)(long)xdp->data;
     77	void *data_end = (void *)(long)xdp->data_end;
     78
     79	if (data + (ICMP_TOOBIG_SIZE + headroom) > data_end)
     80		return XDP_DROP;
     81
     82	struct iphdr *iph, *orig_iph;
     83	struct icmphdr *icmp_hdr;
     84	struct ethhdr *orig_eth;
     85	__u32 csum = 0;
     86	__u64 off = 0;
     87
     88	orig_eth = data + headroom;
     89	swap_mac(data, orig_eth);
     90	off += sizeof(struct ethhdr);
     91	iph = data + off;
     92	off += sizeof(struct iphdr);
     93	icmp_hdr = data + off;
     94	off += sizeof(struct icmphdr);
     95	orig_iph = data + off;
     96	icmp_hdr->type = ICMP_DEST_UNREACH;
     97	icmp_hdr->code = ICMP_FRAG_NEEDED;
     98	icmp_hdr->un.frag.mtu = htons(max_pcktsz - sizeof(struct ethhdr));
     99	icmp_hdr->checksum = 0;
    100	ipv4_csum(icmp_hdr, ICMP_TOOBIG_PAYLOAD_SIZE, &csum);
    101	icmp_hdr->checksum = csum;
    102	iph->ttl = DEFAULT_TTL;
    103	iph->daddr = orig_iph->saddr;
    104	iph->saddr = orig_iph->daddr;
    105	iph->version = 4;
    106	iph->ihl = 5;
    107	iph->protocol = IPPROTO_ICMP;
    108	iph->tos = 0;
    109	iph->tot_len = htons(
    110		ICMP_TOOBIG_SIZE + headroom - sizeof(struct ethhdr));
    111	iph->check = 0;
    112	csum = 0;
    113	ipv4_csum(iph, sizeof(struct iphdr), &csum);
    114	iph->check = csum;
    115	count_icmp();
    116	return XDP_TX;
    117}
    118
    119
    120static __always_inline int handle_ipv4(struct xdp_md *xdp)
    121{
    122	void *data_end = (void *)(long)xdp->data_end;
    123	void *data = (void *)(long)xdp->data;
    124	int pckt_size = data_end - data;
    125	int offset;
    126
    127	if (pckt_size > max(max_pcktsz, ICMP_TOOBIG_SIZE)) {
    128		offset = pckt_size - ICMP_TOOBIG_SIZE;
    129		if (bpf_xdp_adjust_tail(xdp, 0 - offset))
    130			return XDP_PASS;
    131		return send_icmp4_too_big(xdp);
    132	}
    133	return XDP_PASS;
    134}
    135
    136SEC("xdp_icmp")
    137int _xdp_icmp(struct xdp_md *xdp)
    138{
    139	void *data_end = (void *)(long)xdp->data_end;
    140	void *data = (void *)(long)xdp->data;
    141	struct ethhdr *eth = data;
    142	__u16 h_proto;
    143
    144	if (eth + 1 > data_end)
    145		return XDP_DROP;
    146
    147	h_proto = eth->h_proto;
    148
    149	if (h_proto == htons(ETH_P_IP))
    150		return handle_ipv4(xdp);
    151	else
    152		return XDP_PASS;
    153}
    154
    155char _license[] SEC("license") = "GPL";