1 /* 2 * Copyright (C) 2022 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.testutils; 18 19 import static android.system.OsConstants.IPPROTO_ICMPV6; 20 21 import static com.android.net.module.util.NetworkStackConstants.ETHER_TYPE_IPV6; 22 import static com.android.net.module.util.NetworkStackConstants.ICMPV6_ND_OPTION_TLLA; 23 import static com.android.net.module.util.NetworkStackConstants.ICMPV6_NEIGHBOR_SOLICITATION; 24 import static com.android.net.module.util.NetworkStackConstants.ICMPV6_ROUTER_SOLICITATION; 25 import static com.android.net.module.util.NetworkStackConstants.IPV6_ADDR_ALL_NODES_MULTICAST; 26 import static com.android.net.module.util.NetworkStackConstants.NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE; 27 import static com.android.net.module.util.NetworkStackConstants.NEIGHBOR_ADVERTISEMENT_FLAG_ROUTER; 28 import static com.android.net.module.util.NetworkStackConstants.NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED; 29 import static com.android.net.module.util.NetworkStackConstants.PIO_FLAG_AUTONOMOUS; 30 import static com.android.net.module.util.NetworkStackConstants.PIO_FLAG_ON_LINK; 31 32 import android.net.InetAddresses; 33 import android.net.IpPrefix; 34 import android.net.MacAddress; 35 import android.util.ArrayMap; 36 import android.util.Pair; 37 38 import com.android.net.module.util.Ipv6Utils; 39 import com.android.net.module.util.Struct; 40 import com.android.net.module.util.structs.EthernetHeader; 41 import com.android.net.module.util.structs.Icmpv6Header; 42 import com.android.net.module.util.structs.Ipv6Header; 43 import com.android.net.module.util.structs.LlaOption; 44 import com.android.net.module.util.structs.NsHeader; 45 import com.android.net.module.util.structs.PrefixInformationOption; 46 import com.android.net.module.util.structs.RdnssOption; 47 48 import java.io.IOException; 49 import java.net.Inet6Address; 50 import java.nio.ByteBuffer; 51 import java.util.Map; 52 import java.util.Objects; 53 import java.util.Random; 54 55 /** 56 * ND (RA & NA) responder class useful for tests that require a provisioned IPv6 interface. 57 * TODO: rename to NdResponder 58 */ 59 public class RouterAdvertisementResponder extends PacketResponder { 60 private static final String TAG = "RouterAdvertisementResponder"; 61 private static final Inet6Address DNS_SERVER = 62 (Inet6Address) InetAddresses.parseNumericAddress("2001:4860:4860::64"); 63 private final TapPacketReader mPacketReader; 64 // Maps IPv6 address to MacAddress and isRouter boolean. 65 private final Map<Inet6Address, Pair<MacAddress, Boolean>> mNeighborMap = new ArrayMap<>(); 66 private final IpPrefix mPrefix; 67 RouterAdvertisementResponder(TapPacketReader packetReader, IpPrefix prefix)68 public RouterAdvertisementResponder(TapPacketReader packetReader, IpPrefix prefix) { 69 super(packetReader, RouterAdvertisementResponder::isRsOrNs, TAG); 70 mPacketReader = packetReader; 71 mPrefix = Objects.requireNonNull(prefix); 72 } 73 RouterAdvertisementResponder(TapPacketReader packetReader)74 public RouterAdvertisementResponder(TapPacketReader packetReader) { 75 this(packetReader, makeRandomPrefix()); 76 } 77 makeRandomPrefix()78 private static IpPrefix makeRandomPrefix() { 79 final byte[] prefixBytes = new IpPrefix("2001:db8::/64").getAddress().getAddress(); 80 final Random r = new Random(); 81 for (int i = 4; i < 8; i++) { 82 prefixBytes[i] = (byte) r.nextInt(); 83 } 84 return new IpPrefix(prefixBytes, 64); 85 } 86 87 /** Returns true if the packet is a router solicitation or neighbor solicitation message. */ isRsOrNs(byte[] packet)88 private static boolean isRsOrNs(byte[] packet) { 89 final ByteBuffer buffer = ByteBuffer.wrap(packet); 90 final EthernetHeader ethHeader = Struct.parse(EthernetHeader.class, buffer); 91 if (ethHeader.etherType != ETHER_TYPE_IPV6) { 92 return false; 93 } 94 final Ipv6Header ipv6Header = Struct.parse(Ipv6Header.class, buffer); 95 if (ipv6Header.nextHeader != IPPROTO_ICMPV6) { 96 return false; 97 } 98 final Icmpv6Header icmpv6Header = Struct.parse(Icmpv6Header.class, buffer); 99 return icmpv6Header.type == ICMPV6_ROUTER_SOLICITATION 100 || icmpv6Header.type == ICMPV6_NEIGHBOR_SOLICITATION; 101 } 102 103 /** 104 * Adds a new router to be advertised. 105 * @param mac the mac address of the router. 106 * @param ip the link-local address of the router. 107 */ addRouterEntry(MacAddress mac, Inet6Address ip)108 public void addRouterEntry(MacAddress mac, Inet6Address ip) { 109 mNeighborMap.put(ip, new Pair<>(mac, true)); 110 } 111 112 /** 113 * Adds a new neighbor to be advertised. 114 * @param mac the mac address of the neighbor. 115 * @param ip the link-local address of the neighbor. 116 */ addNeighborEntry(MacAddress mac, Inet6Address ip)117 public void addNeighborEntry(MacAddress mac, Inet6Address ip) { 118 mNeighborMap.put(ip, new Pair<>(mac, false)); 119 } 120 121 /** 122 * @return the prefix that is announced in the Router Advertisements sent by this object. 123 */ getPrefix()124 public IpPrefix getPrefix() { 125 return mPrefix; 126 } 127 buildPrefixOption()128 private ByteBuffer buildPrefixOption() { 129 return PrefixInformationOption.build( 130 mPrefix, (byte) (PIO_FLAG_ON_LINK | PIO_FLAG_AUTONOMOUS), 131 3600 /* valid lifetime */, 3600 /* preferred lifetime */); 132 } 133 buildRdnssOption()134 private ByteBuffer buildRdnssOption() { 135 return RdnssOption.build(3600/*lifetime, must be at least 120*/, DNS_SERVER); 136 } 137 buildRaPacket(MacAddress srcMac, MacAddress dstMac, Inet6Address srcIp)138 private ByteBuffer buildRaPacket(MacAddress srcMac, MacAddress dstMac, Inet6Address srcIp) { 139 return Ipv6Utils.buildRaPacket(srcMac, dstMac, srcIp, IPV6_ADDR_ALL_NODES_MULTICAST, 140 (byte) 0 /*M=0, O=0*/, 3600 /*lifetime*/, 0 /*reachableTime, unspecified*/, 141 0/*retransTimer, unspecified*/, buildPrefixOption(), buildRdnssOption()); 142 } 143 sendResponse(TapPacketReader reader, ByteBuffer buffer)144 private static void sendResponse(TapPacketReader reader, ByteBuffer buffer) { 145 try { 146 reader.sendResponse(buffer); 147 } catch (IOException e) { 148 throw new RuntimeException("Failed to send buffer."); 149 } 150 } 151 replyToRouterSolicitation(TapPacketReader reader, MacAddress dstMac)152 private void replyToRouterSolicitation(TapPacketReader reader, MacAddress dstMac) { 153 for (Map.Entry<Inet6Address, Pair<MacAddress, Boolean>> it : mNeighborMap.entrySet()) { 154 final boolean isRouter = it.getValue().second; 155 if (!isRouter) { 156 continue; 157 } 158 final ByteBuffer raResponse = buildRaPacket(it.getValue().first, dstMac, it.getKey()); 159 sendResponse(reader, raResponse); 160 } 161 } 162 replyToNeighborSolicitation(TapPacketReader reader, MacAddress dstMac, Inet6Address dstIp, Inet6Address targetIp)163 private void replyToNeighborSolicitation(TapPacketReader reader, MacAddress dstMac, 164 Inet6Address dstIp, Inet6Address targetIp) { 165 final Pair<MacAddress, Boolean> neighbor = mNeighborMap.get(targetIp); 166 if (neighbor == null) { 167 return; 168 } 169 170 final MacAddress srcMac = neighbor.first; 171 final boolean isRouter = neighbor.second; 172 int flags = NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED | NEIGHBOR_ADVERTISEMENT_FLAG_OVERRIDE; 173 if (isRouter) { 174 flags |= NEIGHBOR_ADVERTISEMENT_FLAG_ROUTER; 175 } 176 177 final ByteBuffer tlla = LlaOption.build((byte) ICMPV6_ND_OPTION_TLLA, srcMac); 178 final ByteBuffer naResponse = Ipv6Utils.buildNaPacket(srcMac, dstMac, targetIp, dstIp, 179 flags, targetIp, tlla); 180 sendResponse(reader, naResponse); 181 } 182 183 @Override replyToPacket(byte[] packet, TapPacketReader reader)184 protected void replyToPacket(byte[] packet, TapPacketReader reader) { 185 final ByteBuffer buf = ByteBuffer.wrap(packet); 186 // Messages are filtered by parent class, so it is safe to assume that packet is either an 187 // RS or NS. 188 final EthernetHeader ethHdr = Struct.parse(EthernetHeader.class, buf); 189 final Ipv6Header ipv6Hdr = Struct.parse(Ipv6Header.class, buf); 190 final Icmpv6Header icmpv6Header = Struct.parse(Icmpv6Header.class, buf); 191 192 if (icmpv6Header.type == ICMPV6_ROUTER_SOLICITATION) { 193 replyToRouterSolicitation(reader, ethHdr.srcMac); 194 } else if (icmpv6Header.type == ICMPV6_NEIGHBOR_SOLICITATION) { 195 final NsHeader nsHeader = Struct.parse(NsHeader.class, buf); 196 replyToNeighborSolicitation(reader, ethHdr.srcMac, ipv6Hdr.srcIp, nsHeader.target); 197 } 198 } 199 } 200