portier/ipv6_util.cc - chromiumos/platform2 - Git at Google

 // Copyright 2018 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "portier/ipv6_util.h"

 #include <arpa/inet.h>
 #include <limits.h>

 #include <algorithm>

 #include <base/logging.h>

 namespace portier {

 using shill::ByteString;
 using shill::IPAddress;

 using Code = Status::Code;

 namespace {

 // Used to mask the lower 16 bits of a 32-bit number.
 constexpr uint32_t kMask16 = 0xffff;

 // Length of a EUI-48 (MAC) address.
 constexpr int32_t kEui48Length = 6;
 // The byte offset of the last 32-bits (4 bytes) of an IPv6 address.
 constexpr int32_t kIPv6Low32BitsOffset = 12;
 // Number of bytes copied from the IPv6 multicast address to the
 // link-layer mulicast address.
 constexpr int32_t kMulticastIPv6ComponentSize = 4;

 // The address prefix for the IPv6 link-local subnet.
 const IPAddress kLinkLocalSubnet("fe80::");
 // IPv6 link-local subnet mask (10 bits).
 const IPAddress kLinkLocalSubnetMask("ffc0::");

 // Value of the first byte of multicast IPv6 addresses.
 constexpr uint8_t kMulticastIdentifier = 0xff;

 // The subnet and mask for solicited-node multicast addresses.
 const IPAddress kSolicitedNodeSubnet("ff02:0:0:0:0:1:ff00:0");
 const IPAddress kSolicitedNodeSubnetMask(
     "ffff:ffff:ffff:ffff:ffff:ffff:ff00:0");

 // IPv6 Pseudo-Header.
 // This struct is created in such a way that it is byte-aligned with the
 // actual pseudo header format.
 struct IPv6PseudoHeader {
   struct in6_addr ip6_pseudo_src;
   struct in6_addr ip6_pseudo_dst;
   uint32_t ip6_pseudo_len;  // Upper-layer data length.
   uint8_t ip6_pseudo_st_zeros[3];
   uint8_t ip6_pseudo_nxt;
 };
 static_assert(sizeof(IPv6PseudoHeader) == 40,
               "IPv6PseudoHeader size is not correct");

 // Calculates the 16-bit one's complement of the provided data.
 uint16_t InternetChecksum16(const uint8_t* data, size_t data_length) {
   uint32_t sum = 0;
   // Iterate over each 16-bits of data and add to sum.  Checking
   // (i + 1) < data_length to avoid the case where there is an odd
   // mumber of bytes.
   for (size_t i = 0; (i + 1) < data_length; i += 2) {
     const uint16_t* dptr = reinterpret_cast<const uint16_t*>(&data[i]);
     sum += static_cast<uint32_t>(*dptr);
   }

   if ((data_length & 1) == 1) {
     // Accommodate the final byte.
     uint16_t value = 0;
     // This works for both big endian vs little endian architectures.
     uint8_t* vptr = reinterpret_cast<uint8_t*>(&value);
     *vptr = data[data_length - 1];
     sum += static_cast<uint32_t>(value);
   }

   // Add all the 16-bit overflows back into the 16-bit sum.
   sum = (sum & kMask16) + (sum >> 16);
   if (sum == kMask16) {
     sum = 0;
   }

   return static_cast<uint16_t>(sum);
 }

 // Calculates the 16-bit one's complement sum of two numbers.
 //  Note: Do not try to call this repeatedly, it is not very
 //  efficient for large arrays.
 uint16_t InternetChecksum16Pair(uint16_t a, uint16_t b) {
   uint32_t sum = static_cast<uint32_t>(a) + static_cast<uint32_t>(b);
   if (sum > kMask16) {
     // Any 16-bit overflow can only have a carry of 1.
     sum = (sum & kMask16) + 1;
   }
   if (sum == kMask16) {
     sum = 0;
   }
   return static_cast<uint16_t>(sum);
 }

 }  // namespace

 Status IPv6UpperLayerChecksum16(const IPAddress& source_address,
                                 const IPAddress& destination_address,
                                 uint8_t next_header,
                                 const uint8_t* upper_layer_data,
                                 size_t data_length,
                                 uint16_t* checksum_out) {
   // A null pointer for upper_layer_data is ok if the length is zero.
   // In that case, the checksum will be of the pseudo header only.
   DCHECK(upper_layer_data == 0 || upper_layer_data != nullptr)
       << "Expected non-null value for `upper_layer_data'";
   DCHECK(checksum_out != nullptr)
       << "Expected non-null value for `checksum_out'";
   DCHECK(source_address.family() == IPAddress::kFamilyIPv6 &&
          destination_address.family() == IPAddress::kFamilyIPv6)
       << "The source and destination addresses must be IPv6";
   DCHECK(data_length < (1 << 17))
       << "Cannot accurately compute checksum for 2^17 or more bytes of data";

   // Populate the IPv6 pseudo header.
   IPv6PseudoHeader ip6_pseudo_hdr;
   memset(&ip6_pseudo_hdr, 0, sizeof(IPv6PseudoHeader));

   memcpy(&ip6_pseudo_hdr.ip6_pseudo_src, source_address.GetConstData(),
          sizeof(ip6_pseudo_hdr.ip6_pseudo_src));
   memcpy(&ip6_pseudo_hdr.ip6_pseudo_dst, destination_address.GetConstData(),
          sizeof(ip6_pseudo_hdr.ip6_pseudo_dst));
   ip6_pseudo_hdr.ip6_pseudo_len = htonl(data_length);
   ip6_pseudo_hdr.ip6_pseudo_nxt = next_header;

   // Get the checksum of the header.
   const uint16_t pseudo_checksum =
       InternetChecksum16(reinterpret_cast<const uint8_t*>(&ip6_pseudo_hdr),
                          sizeof(IPv6PseudoHeader));

   // Get the checksum of the upper layer.
   if (data_length > 0) {
     const uint16_t upper_layer_checksum =
         InternetChecksum16(upper_layer_data, data_length);
     *checksum_out =
         InternetChecksum16Pair(pseudo_checksum, upper_layer_checksum);
   } else {
     *checksum_out = pseudo_checksum;
   }

   return Status();
 }

 Status IPv6UpperLayerChecksum16(const IPAddress& source_address,
                                 const IPAddress& destination_address,
                                 uint8_t next_header,
                                 const ByteString& upper_layer_data,
                                 uint16_t* checksum_out) {
   return IPv6UpperLayerChecksum16(source_address, destination_address,
                                   next_header, upper_layer_data.GetConstData(),
                                   upper_layer_data.GetLength(), checksum_out);
 }

 bool IPv6AddressIsUnspecified(const IPAddress& ip_address) {
   DCHECK(ip_address.family() == IPAddress::kFamilyIPv6);
   const ByteString& bytes = ip_address.address();
   return std::all_of(bytes.GetConstData(),
                      bytes.GetConstData() + bytes.GetLength(),
                      [](unsigned char byte) { return (0 == byte); });
 }

 bool IPv6AddressIsLinkLocal(const IPAddress& ip_address) {
   DCHECK(ip_address.family() == IPAddress::kFamilyIPv6);
   return kLinkLocalSubnet.Equals(ip_address.MaskWith(kLinkLocalSubnetMask));
 }

 bool IPv6AddressIsSolicitedNodeMulticast(const IPAddress& multicast_address,
                                          const IPAddress& solicited_address) {
   DCHECK(multicast_address.family() == IPAddress::kFamilyIPv6);
   DCHECK(solicited_address.family() == IPAddress::kFamilyIPv6);
   // Check that |multicast_address| is of the same subnet.
   const bool solicited_node_net_match = kSolicitedNodeSubnet.Equals(
       multicast_address.MaskWith(kSolicitedNodeSubnetMask));
   // Check that the least-significant 24-bits of both address match.
   const bool solicited_bottom_bits_match =
       kSolicitedNodeSubnetMask.MergeWith(multicast_address)
           .Equals(kSolicitedNodeSubnetMask.MergeWith(solicited_address));
   // If both conditions are true, then |multicast_address| is the
   // solicited-node multicast address of |solicited_address|.
   return solicited_node_net_match && solicited_bottom_bits_match;
 }

 bool IPv6AddressIsMulticast(const shill::IPAddress& multicast_address) {
   DCHECK(multicast_address.family() == IPAddress::kFamilyIPv6);
   // Only the first byte needs to be checked to determine if the
   // address is a mulicast address.
   const uint8_t* first_byte = multicast_address.GetConstData();
   return *first_byte == kMulticastIdentifier;
 }

 bool IPv6GetMulticastLinkLayerAddress(const IPAddress& ip_address,
                                       LLAddress* multicast_ll_out) {
   DCHECK(ip_address.family() == IPAddress::kFamilyIPv6);
   DCHECK(multicast_ll_out != nullptr);
   // Form an address of 33:33:xx:xx:xx:xx.
   uint8_t raw_address[kEui48Length];
   raw_address[0] = raw_address[1] = 0x33;
   memcpy(&raw_address[2], ip_address.GetConstData() + kIPv6Low32BitsOffset,
          kMulticastIPv6ComponentSize);
   *multicast_ll_out = LLAddress(LLAddress::Type::kEui48,
                                 ByteString(raw_address, sizeof(raw_address)));
   return true;
 }

 }  // namespace portier
	// Copyright 2018 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "portier/ipv6_util.h"

	#include <arpa/inet.h>
	#include <limits.h>

	#include <algorithm>

	#include <base/logging.h>

	namespace portier {

	using shill::ByteString;
	using shill::IPAddress;

	using Code = Status::Code;

	namespace {

	// Used to mask the lower 16 bits of a 32-bit number.
	constexpr uint32_t kMask16 = 0xffff;

	// Length of a EUI-48 (MAC) address.
	constexpr int32_t kEui48Length = 6;
	// The byte offset of the last 32-bits (4 bytes) of an IPv6 address.
	constexpr int32_t kIPv6Low32BitsOffset = 12;
	// Number of bytes copied from the IPv6 multicast address to the
	// link-layer mulicast address.
	constexpr int32_t kMulticastIPv6ComponentSize = 4;

	// The address prefix for the IPv6 link-local subnet.
	const IPAddress kLinkLocalSubnet("fe80::");
	// IPv6 link-local subnet mask (10 bits).
	const IPAddress kLinkLocalSubnetMask("ffc0::");

	// Value of the first byte of multicast IPv6 addresses.
	constexpr uint8_t kMulticastIdentifier = 0xff;

	// The subnet and mask for solicited-node multicast addresses.
	const IPAddress kSolicitedNodeSubnet("ff02:0:0:0:0:1:ff00:0");
	const IPAddress kSolicitedNodeSubnetMask(
	"ffff:ffff:ffff:ffff:ffff:ffff:ff00:0");

	// IPv6 Pseudo-Header.
	// This struct is created in such a way that it is byte-aligned with the
	// actual pseudo header format.
	struct IPv6PseudoHeader {
	struct in6_addr ip6_pseudo_src;
	struct in6_addr ip6_pseudo_dst;
	uint32_t ip6_pseudo_len; // Upper-layer data length.
	uint8_t ip6_pseudo_st_zeros[3];
	uint8_t ip6_pseudo_nxt;
	};
	static_assert(sizeof(IPv6PseudoHeader) == 40,
	"IPv6PseudoHeader size is not correct");

	// Calculates the 16-bit one's complement of the provided data.
	uint16_t InternetChecksum16(const uint8_t* data, size_t data_length) {
	uint32_t sum = 0;
	// Iterate over each 16-bits of data and add to sum. Checking
	// (i + 1) < data_length to avoid the case where there is an odd
	// mumber of bytes.
	for (size_t i = 0; (i + 1) < data_length; i += 2) {
	const uint16_t* dptr = reinterpret_cast<const uint16_t*>(&data[i]);
	sum += static_cast<uint32_t>(*dptr);
	}

	if ((data_length & 1) == 1) {
	// Accommodate the final byte.
	uint16_t value = 0;
	// This works for both big endian vs little endian architectures.
	uint8_t* vptr = reinterpret_cast<uint8_t*>(&value);
	*vptr = data[data_length - 1];
	sum += static_cast<uint32_t>(value);
	}

	// Add all the 16-bit overflows back into the 16-bit sum.
	sum = (sum & kMask16) + (sum >> 16);
	if (sum == kMask16) {
	sum = 0;
	}

	return static_cast<uint16_t>(sum);
	}

	// Calculates the 16-bit one's complement sum of two numbers.
	// Note: Do not try to call this repeatedly, it is not very
	// efficient for large arrays.
	uint16_t InternetChecksum16Pair(uint16_t a, uint16_t b) {
	uint32_t sum = static_cast<uint32_t>(a) + static_cast<uint32_t>(b);
	if (sum > kMask16) {
	// Any 16-bit overflow can only have a carry of 1.
	sum = (sum & kMask16) + 1;
	}
	if (sum == kMask16) {
	sum = 0;
	}
	return static_cast<uint16_t>(sum);
	}

	} // namespace

	Status IPv6UpperLayerChecksum16(const IPAddress& source_address,
	const IPAddress& destination_address,
	uint8_t next_header,
	const uint8_t* upper_layer_data,
	size_t data_length,
	uint16_t* checksum_out) {
	// A null pointer for upper_layer_data is ok if the length is zero.
	// In that case, the checksum will be of the pseudo header only.
	DCHECK(upper_layer_data == 0 \|\| upper_layer_data != nullptr)
	<< "Expected non-null value for `upper_layer_data'";
	DCHECK(checksum_out != nullptr)
	<< "Expected non-null value for `checksum_out'";
	DCHECK(source_address.family() == IPAddress::kFamilyIPv6 &&
	destination_address.family() == IPAddress::kFamilyIPv6)
	<< "The source and destination addresses must be IPv6";
	DCHECK(data_length < (1 << 17))
	<< "Cannot accurately compute checksum for 2^17 or more bytes of data";

	// Populate the IPv6 pseudo header.
	IPv6PseudoHeader ip6_pseudo_hdr;
	memset(&ip6_pseudo_hdr, 0, sizeof(IPv6PseudoHeader));

	memcpy(&ip6_pseudo_hdr.ip6_pseudo_src, source_address.GetConstData(),
	sizeof(ip6_pseudo_hdr.ip6_pseudo_src));
	memcpy(&ip6_pseudo_hdr.ip6_pseudo_dst, destination_address.GetConstData(),
	sizeof(ip6_pseudo_hdr.ip6_pseudo_dst));
	ip6_pseudo_hdr.ip6_pseudo_len = htonl(data_length);
	ip6_pseudo_hdr.ip6_pseudo_nxt = next_header;

	// Get the checksum of the header.
	const uint16_t pseudo_checksum =
	InternetChecksum16(reinterpret_cast<const uint8_t*>(&ip6_pseudo_hdr),
	sizeof(IPv6PseudoHeader));

	// Get the checksum of the upper layer.
	if (data_length > 0) {
	const uint16_t upper_layer_checksum =
	InternetChecksum16(upper_layer_data, data_length);
	*checksum_out =
	InternetChecksum16Pair(pseudo_checksum, upper_layer_checksum);
	} else {
	*checksum_out = pseudo_checksum;
	}

	return Status();
	}

	Status IPv6UpperLayerChecksum16(const IPAddress& source_address,
	const IPAddress& destination_address,
	uint8_t next_header,
	const ByteString& upper_layer_data,
	uint16_t* checksum_out) {
	return IPv6UpperLayerChecksum16(source_address, destination_address,
	next_header, upper_layer_data.GetConstData(),
	upper_layer_data.GetLength(), checksum_out);
	}

	bool IPv6AddressIsUnspecified(const IPAddress& ip_address) {
	DCHECK(ip_address.family() == IPAddress::kFamilyIPv6);
	const ByteString& bytes = ip_address.address();
	return std::all_of(bytes.GetConstData(),
	bytes.GetConstData() + bytes.GetLength(),
	[](unsigned char byte) { return (0 == byte); });
	}

	bool IPv6AddressIsLinkLocal(const IPAddress& ip_address) {
	DCHECK(ip_address.family() == IPAddress::kFamilyIPv6);
	return kLinkLocalSubnet.Equals(ip_address.MaskWith(kLinkLocalSubnetMask));
	}

	bool IPv6AddressIsSolicitedNodeMulticast(const IPAddress& multicast_address,
	const IPAddress& solicited_address) {
	DCHECK(multicast_address.family() == IPAddress::kFamilyIPv6);
	DCHECK(solicited_address.family() == IPAddress::kFamilyIPv6);
	// Check that \|multicast_address\| is of the same subnet.
	const bool solicited_node_net_match = kSolicitedNodeSubnet.Equals(
	multicast_address.MaskWith(kSolicitedNodeSubnetMask));
	// Check that the least-significant 24-bits of both address match.
	const bool solicited_bottom_bits_match =
	kSolicitedNodeSubnetMask.MergeWith(multicast_address)
	.Equals(kSolicitedNodeSubnetMask.MergeWith(solicited_address));
	// If both conditions are true, then \|multicast_address\| is the
	// solicited-node multicast address of \|solicited_address\|.
	return solicited_node_net_match && solicited_bottom_bits_match;
	}

	bool IPv6AddressIsMulticast(const shill::IPAddress& multicast_address) {
	DCHECK(multicast_address.family() == IPAddress::kFamilyIPv6);
	// Only the first byte needs to be checked to determine if the
	// address is a mulicast address.
	const uint8_t* first_byte = multicast_address.GetConstData();
	return *first_byte == kMulticastIdentifier;
	}

	bool IPv6GetMulticastLinkLayerAddress(const IPAddress& ip_address,
	LLAddress* multicast_ll_out) {
	DCHECK(ip_address.family() == IPAddress::kFamilyIPv6);
	DCHECK(multicast_ll_out != nullptr);
	// Form an address of 33:33:xx:xx:xx:xx.
	uint8_t raw_address[kEui48Length];
	raw_address[0] = raw_address[1] = 0x33;
	memcpy(&raw_address[2], ip_address.GetConstData() + kIPv6Low32BitsOffset,
	kMulticastIPv6ComponentSize);
	*multicast_ll_out = LLAddress(LLAddress::Type::kEui48,
	ByteString(raw_address, sizeof(raw_address)));
	return true;
	}

	} // namespace portier