private UnknownIpV6NeighborDiscoveryOption(byte[] rawData, int offset, int length)
      throws IllegalRawDataException {
    if (length < 2) {
      StringBuilder sb = new StringBuilder(100);
      sb.append("The raw data length must be more than 1. rawData: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }

    this.type = IpV6NeighborDiscoveryOptionType.getInstance(rawData[offset]);
    this.length = rawData[1 + offset];
    if (length < this.length * 8) {
      StringBuilder sb = new StringBuilder(100);
      sb.append("The raw data is too short to build this option(")
          .append(this.length * 8)
          .append("). data: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }

    this.data = ByteArrays.getSubArray(rawData, 2 + offset, this.length * 8 - 2);
  }
Exemplo n.º 2
0
  /**
   * @param snaplen
   * @param dlt
   * @param bpfExpression
   * @param mode
   * @param netmask
   * @return a {@link org.pcap4j.core.BpfProgram BpfProgram} object.
   * @throws PcapNativeException
   */
  public static BpfProgram compileFilter(
      int snaplen,
      DataLinkType dlt,
      String bpfExpression,
      BpfCompileMode mode,
      Inet4Address netmask)
      throws PcapNativeException {
    if (dlt == null || bpfExpression == null || mode == null || netmask == null) {
      StringBuilder sb = new StringBuilder();
      sb.append("dlt: ")
          .append(dlt)
          .append(" bpfExpression: ")
          .append(bpfExpression)
          .append(" mode: ")
          .append(mode)
          .append(" netmask: ")
          .append(netmask);
      throw new NullPointerException(sb.toString());
    }

    bpf_program prog = new bpf_program();
    int rc =
        NativeMappings.pcap_compile_nopcap(
            snaplen,
            dlt.value(),
            prog,
            bpfExpression,
            mode.getValue(),
            ByteArrays.getInt(ByteArrays.toByteArray(netmask), 0));
    if (rc < 0) {
      throw new PcapNativeException("Failed to compile the BPF expression: " + bpfExpression, rc);
    }
    return new BpfProgram(prog, bpfExpression);
  }
Exemplo n.º 3
0
  private TcpSackOption(byte[] rawData, int offset, int length) throws IllegalRawDataException {
    if (length < 2) {
      StringBuilder sb = new StringBuilder(50);
      sb.append("The raw data length must be more than 1. rawData: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }
    if (rawData[offset] != kind.value()) {
      StringBuilder sb = new StringBuilder(100);
      sb.append("The kind must be: ")
          .append(kind.valueAsString())
          .append(" rawData: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }

    this.length = rawData[1 + offset];
    int lengthFieldAsInt = getLengthAsInt();
    if (lengthFieldAsInt < 2) {
      throw new IllegalRawDataException(
          "The value of length field must be  more than 1 but: " + lengthFieldAsInt);
    }

    if ((lengthFieldAsInt - 2) % (INT_SIZE_IN_BYTES * 2) != 0) {
      StringBuilder sb = new StringBuilder(100);
      sb.append("The value of length field must be an integer multiple of 8 octets long but: ")
          .append(lengthFieldAsInt);
      throw new IllegalRawDataException(sb.toString());
    }
    if (length < lengthFieldAsInt) {
      StringBuilder sb = new StringBuilder(100);
      sb.append("rawData is too short. length field: ")
          .append(lengthFieldAsInt)
          .append(", rawData: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }

    for (int i = 2; i < lengthFieldAsInt; i += INT_SIZE_IN_BYTES * 2) {
      sacks.add(
          new Sack(
              ByteArrays.getInt(rawData, i + offset),
              ByteArrays.getInt(rawData, i + INT_SIZE_IN_BYTES + offset)));
    }
  }
Exemplo n.º 4
0
  private RadiotapDataRate(byte[] rawData, int offset, int length) throws IllegalRawDataException {
    if (length < LENGTH) {
      StringBuilder sb = new StringBuilder(200);
      sb.append("The data is too short to build a RadiotapRate (")
          .append(LENGTH)
          .append(" bytes). data: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }

    this.rate = ByteArrays.getByte(rawData, offset);
  }
Exemplo n.º 5
0
  private IcmpV6EchoReplyPacket(byte[] rawData) {
    this.header = new IcmpV6EchoReplyHeader(rawData);

    byte[] rawPayload =
        ByteArrays.getSubArray(rawData, header.length(), rawData.length - header.length());

    this.payload = UnknownPacket.newPacket(rawPayload);
  }
 public byte[] getRawData() {
   byte[] rawData = new byte[length()];
   Iterator<TimestampWithAddress> iter = timestampsWithAddresses.iterator();
   for (int i = 0; i < rawData.length; i += INT_SIZE_IN_BYTES * 2) {
     TimestampWithAddress twa = iter.next();
     System.arraycopy(ByteArrays.toByteArray(twa.address), 0, rawData, i, INT_SIZE_IN_BYTES);
     if (twa.timestamp != null) {
       System.arraycopy(
           ByteArrays.toByteArray(twa.timestamp),
           0,
           rawData,
           i + INT_SIZE_IN_BYTES,
           INT_SIZE_IN_BYTES);
     }
   }
   return rawData;
 }
Exemplo n.º 7
0
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData rawData
  * @param offset offset
  * @param length length
  * @param cause cause
  * @return a new IllegalIpV6Option object.
  */
 public static IllegalIpV6Option newInstance(
     byte[] rawData, int offset, int length, IllegalRawDataException cause) {
   if (cause == null) {
     throw new NullPointerException("cause is null.");
   }
   ByteArrays.validateBounds(rawData, offset, length);
   return new IllegalIpV6Option(rawData, offset, length, cause);
 }
    private IcmpV6NeighborAdvertisementHeader(byte[] rawData, int offset, int length)
        throws IllegalRawDataException {
      if (length < OPTIONS_OFFSET) {
        StringBuilder sb = new StringBuilder(120);
        sb.append("The raw data must be more than ")
            .append(OPTIONS_OFFSET - 1)
            .append("bytes")
            .append(" to build this header. raw data: ")
            .append(ByteArrays.toHexString(rawData, " "))
            .append(", offset: ")
            .append(offset)
            .append(", length: ")
            .append(length);
        throw new IllegalRawDataException(sb.toString());
      }

      int tmp = ByteArrays.getInt(rawData, R_S_O_RESERVED_OFFSET + offset);
      this.routerFlag = (tmp & 0x80000000) != 0;
      this.solicitedFlag = (tmp & 0x40000000) != 0;
      this.overrideFlag = (tmp & 0x20000000) != 0;
      this.reserved = 0x1FFFFFFF & tmp;
      this.targetAddress = ByteArrays.getInet6Address(rawData, TARGET_ADDRESS_OFFSET + offset);
      this.options = new ArrayList<IpV6NeighborDiscoveryOption>();
      int currentOffsetInHeader = OPTIONS_OFFSET;
      while (currentOffsetInHeader < length) {
        IpV6NeighborDiscoveryOptionType type =
            IpV6NeighborDiscoveryOptionType.getInstance(rawData[currentOffsetInHeader + offset]);
        IpV6NeighborDiscoveryOption newOne;
        try {
          newOne =
              PacketFactories.getFactory(
                      IpV6NeighborDiscoveryOption.class, IpV6NeighborDiscoveryOptionType.class)
                  .newInstance(
                      rawData,
                      currentOffsetInHeader + offset,
                      length - currentOffsetInHeader,
                      type);
        } catch (Exception e) {
          break;
        }

        options.add(newOne);
        currentOffsetInHeader += newOne.length();
      }
    }
Exemplo n.º 9
0
    private IcmpV4RedirectHeader(byte[] rawData, int offset, int length)
        throws IllegalRawDataException {
      if (length < ICMPV4_REDIRECT_HEADER_SIZE) {
        StringBuilder sb = new StringBuilder(80);
        sb.append("The data is too short to build an ICMPv4 Redirect Header(")
            .append(ICMPV4_REDIRECT_HEADER_SIZE)
            .append(" bytes). data: ")
            .append(ByteArrays.toHexString(rawData, " "))
            .append(", offset: ")
            .append(offset)
            .append(", length: ")
            .append(length);
        throw new IllegalRawDataException(sb.toString());
      }

      this.gatewayInternetAddress =
          ByteArrays.getInet4Address(rawData, GATEWAY_INTERNET_ADDRESS_OFFSET + offset);
    }
 @Override
 protected List<byte[]> getRawFields() {
   List<byte[]> rawFields = new ArrayList<byte[]>();
   int tmp = 0x1FFFFFFF & reserved;
   if (routerFlag) {
     tmp |= 0x80000000;
   }
   if (solicitedFlag) {
     tmp |= 0x40000000;
   }
   if (overrideFlag) {
     tmp |= 0x20000000;
   }
   rawFields.add(ByteArrays.toByteArray(tmp));
   rawFields.add(ByteArrays.toByteArray(targetAddress));
   for (IpV6NeighborDiscoveryOption o : options) {
     rawFields.add(o.getRawData());
   }
   return rawFields;
 }
Exemplo n.º 11
0
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   sb.append("[Option Type: ")
       .append(type)
       .append("] [Illegal Raw Data: 0x")
       .append(ByteArrays.toHexString(rawData, ""))
       .append("] [cause: ")
       .append(cause)
       .append("]");
   return sb.toString();
 }
Exemplo n.º 12
0
  @Override
  public byte[] getRawData() {
    byte[] rawData = new byte[length()];
    rawData[0] = kind.value();
    rawData[1] = length;

    int offset = 2;
    for (Sack sack : sacks) {
      System.arraycopy(
          ByteArrays.toByteArray(sack.leftEdge), 0, rawData, offset, INT_SIZE_IN_BYTES);
      System.arraycopy(
          ByteArrays.toByteArray(sack.rightEdge),
          0,
          rawData,
          offset + INT_SIZE_IN_BYTES,
          INT_SIZE_IN_BYTES);
      offset += INT_SIZE_IN_BYTES * 2;
    }

    return rawData;
  }
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   sb.append("[Type: ")
       .append(type)
       .append("] [Length: ")
       .append(getLengthAsInt())
       .append(" bytes] [Data: 0x")
       .append(ByteArrays.toHexString(data, ""))
       .append("]");
   return sb.toString();
 }
Exemplo n.º 14
0
  /**
   * A static factory method. This method validates the arguments by {@link
   * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
   *
   * @param rawData
   * @param offset
   * @param length
   * @return a new IcmpV4RedirectPacket object.
   * @throws IllegalRawDataException
   */
  public static IcmpV4RedirectPacket newPacket(byte[] rawData, int offset, int length)
      throws IllegalRawDataException {
    ByteArrays.validateBounds(rawData, offset, length);

    IcmpV4RedirectHeader header = new IcmpV4RedirectHeader(rawData, offset, length);

    int payloadLength = length - header.length();
    if (payloadLength > 0) {
      return new IcmpV4RedirectPacket(header, rawData, offset + header.length(), payloadLength);
    } else {
      return new IcmpV4RedirectPacket(header);
    }
  }
  private IpV4InternetTimestampOptionTimestampsWithAddresses(byte[] rawData, int offset, int length)
      throws IllegalRawDataException {
    if ((length % INT_SIZE_IN_BYTES) != 0) {
      StringBuilder sb = new StringBuilder(100);
      sb.append("The raw data length must be an integer multiple of 4 octets long." + " rawData: ")
          .append(ByteArrays.toHexString(rawData, " "))
          .append(", offset: ")
          .append(offset)
          .append(", length: ")
          .append(length);
      throw new IllegalRawDataException(sb.toString());
    }

    this.timestampsWithAddresses = new ArrayList<TimestampWithAddress>();
    for (int i = 0; i < length; i += INT_SIZE_IN_BYTES * 2) {
      Inet4Address address = ByteArrays.getInet4Address(rawData, i + offset);
      Integer timestamp = null;
      if (i + INT_SIZE_IN_BYTES < length) {
        timestamp = ByteArrays.getInt(rawData, i + INT_SIZE_IN_BYTES + offset);
      }
      timestampsWithAddresses.add(new TimestampWithAddress(address, timestamp));
    }
  }
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData
  * @param offset
  * @param length
  * @return a new IpV4InternetTimestampOptionTimestampsWithAddresses object.
  * @throws IllegalRawDataException
  */
 public static IpV4InternetTimestampOptionTimestampsWithAddresses newInstance(
     byte[] rawData, int offset, int length) throws IllegalRawDataException {
   ByteArrays.validateBounds(rawData, offset, length);
   return new IpV4InternetTimestampOptionTimestampsWithAddresses(rawData, offset, length);
 }
Exemplo n.º 17
0
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData
  * @param offset
  * @param length
  * @return a new IpV4StrictSourceRouteOption object.
  * @throws IllegalRawDataException
  */
 public static IpV4StrictSourceRouteOption newInstance(byte[] rawData, int offset, int length)
     throws IllegalRawDataException {
   ByteArrays.validateBounds(rawData, offset, length);
   return new IpV4StrictSourceRouteOption(rawData, offset, length);
 }
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData rawData
  * @param offset offset
  * @param length length
  * @return a new UnknownIpV6NeighborDiscoveryOption object.
  * @throws IllegalRawDataException if parsing the raw data fails.
  */
 public static UnknownIpV6NeighborDiscoveryOption newInstance(
     byte[] rawData, int offset, int length) throws IllegalRawDataException {
   ByteArrays.validateBounds(rawData, offset, length);
   return new UnknownIpV6NeighborDiscoveryOption(rawData, offset, length);
 }
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData rawData
  * @param offset offset
  * @param length length
  * @return a new IllegalIpV4InternetTimestampOptionData object.
  */
 public static IllegalIpV4InternetTimestampOptionData newInstance(
     byte[] rawData, int offset, int length) {
   ByteArrays.validateBounds(rawData, offset, length);
   return new IllegalIpV4InternetTimestampOptionData(rawData, offset, length);
 }
Exemplo n.º 20
0
 @Override
 public byte[] getRawData() {
   return ByteArrays.toByteArray(rate);
 }
Exemplo n.º 21
0
 @Override
 protected List<byte[]> getRawFields() {
   List<byte[]> rawFields = new ArrayList<byte[]>();
   rawFields.add(ByteArrays.toByteArray(gatewayInternetAddress));
   return rawFields;
 }
 @Override
 public String toString() {
   StringBuilder sb = new StringBuilder();
   sb.append("[illegal data: ").append(ByteArrays.toHexString(rawData, "")).append("]");
   return sb.toString();
 }
Exemplo n.º 23
0
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData
  * @param offset
  * @param length
  * @return a new EncryptedPacket object.
  */
 public static EncryptedPacket newPacket(byte[] rawData, int offset, int length) {
   ByteArrays.validateBounds(rawData, offset, length);
   return new EncryptedPacket(rawData, offset, length);
 }
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData
  * @param offset
  * @param length
  * @return a new IcmpV6NeighborAdvertisementPacket object.
  * @throws IllegalRawDataException
  */
 public static IcmpV6NeighborAdvertisementPacket newPacket(byte[] rawData, int offset, int length)
     throws IllegalRawDataException {
   ByteArrays.validateBounds(rawData, offset, length);
   return new IcmpV6NeighborAdvertisementPacket(rawData, offset, length);
 }
Exemplo n.º 25
0
  private PcapNetworkInterface(pcap_if pif, boolean local) {
    this.name = pif.name;
    this.description = pif.description;

    for (pcap_addr pcapAddr = pif.addresses; pcapAddr != null; pcapAddr = pcapAddr.next) {
      if (pcapAddr.addr == null
          && pcapAddr.netmask == null
          && pcapAddr.broadaddr == null
          && pcapAddr.dstaddr == null) {
        logger.warn("Empty pcap_addr on {} ({}). Ignore it.", name, description);
        continue;
      }

      short sa_family =
          pcapAddr.addr != null
              ? pcapAddr.addr.getSaFamily()
              : pcapAddr.netmask != null
                  ? pcapAddr.netmask.getSaFamily()
                  : pcapAddr.broadaddr != null
                      ? pcapAddr.broadaddr.getSaFamily()
                      : pcapAddr.dstaddr != null
                          ? pcapAddr.dstaddr.getSaFamily()
                          /* default */ : Inets.AF_UNSPEC; // Never get here.
      if (sa_family == Inets.AF_INET) {
        addresses.add(PcapIpV4Address.newInstance(pcapAddr, sa_family, name));
      } else if (sa_family == Inets.AF_INET6) {
        addresses.add(PcapIpV6Address.newInstance(pcapAddr, sa_family, name));
      } else {
        if (Platform.isLinux() && sa_family == Inets.AF_PACKET) {
          sockaddr_ll sll = new sockaddr_ll(pcapAddr.addr.getPointer());
          byte[] addr = sll.sll_addr;
          int addrLength = sll.sll_halen & 0xFF;
          if (addrLength == 6) {
            linkLayerAddresses.add(ByteArrays.getMacAddress(addr, 0));
          } else if (addr.length == 0) {
            continue;
          } else {
            linkLayerAddresses.add(
                LinkLayerAddress.getByAddress(ByteArrays.getSubArray(addr, 0, addrLength)));
          }
        } else if ((Platform.isMac() || Platform.isFreeBSD() || Platform.isOpenBSD())
            || Platform.iskFreeBSD() && sa_family == Inets.AF_LINK) {
          sockaddr_dl sdl = new sockaddr_dl(pcapAddr.addr.getPointer());
          byte[] addr = sdl.getAddress();
          if (addr.length == 6) {
            linkLayerAddresses.add(MacAddress.getByAddress(addr));
          } else if (addr.length == 0) {
            continue;
          } else {
            linkLayerAddresses.add(LinkLayerAddress.getByAddress(addr));
          }
        } else {
          logger.warn("{} is not supported address family. Ignore it.", sa_family);
        }
      }
    }

    if (pif.flags == PCAP_IF_LOOPBACK) {
      this.loopBack = true;
    } else {
      this.loopBack = false;
    }

    this.local = local;
  }
Exemplo n.º 26
0
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData rawData
  * @param offset offset
  * @param length length
  * @return a new RadiotapRate object.
  * @throws IllegalRawDataException if parsing the raw data fails.
  */
 public static RadiotapDataRate newInstance(byte[] rawData, int offset, int length)
     throws IllegalRawDataException {
   ByteArrays.validateBounds(rawData, offset, length);
   return new RadiotapDataRate(rawData, offset, length);
 }
Exemplo n.º 27
0
 /**
  * A static factory method. This method validates the arguments by {@link
  * ByteArrays#validateBounds(byte[], int, int)}, which may throw exceptions undocumented here.
  *
  * @param rawData
  * @param offset
  * @param length
  * @return a new TcpSackOption object.
  * @throws IllegalRawDataException
  */
 public static TcpSackOption newInstance(byte[] rawData, int offset, int length)
     throws IllegalRawDataException {
   ByteArrays.validateBounds(rawData, offset, length);
   return new TcpSackOption(rawData, offset, length);
 }