From 6b9048751e91c3c2c300bb57ac24ae8d33c28f14 Mon Sep 17 00:00:00 2001 From: Federico Fissore Date: Fri, 21 Aug 2015 10:38:42 +0200 Subject: [PATCH] Proxy PAC support: SubnetUtils is not IPv6 aware, using CIDRUtils to check if IP is in range --- .../src/cc/arduino/net/PACSupportMethods.java | 5 +- .../edazdarevic/commons/net/CIDRUtils.java | 142 ++++++++++++++++++ 2 files changed, 145 insertions(+), 2 deletions(-) create mode 100644 arduino-core/src/edazdarevic/commons/net/CIDRUtils.java diff --git a/arduino-core/src/cc/arduino/net/PACSupportMethods.java b/arduino-core/src/cc/arduino/net/PACSupportMethods.java index 5ff9f53ae..dfe388029 100644 --- a/arduino-core/src/cc/arduino/net/PACSupportMethods.java +++ b/arduino-core/src/cc/arduino/net/PACSupportMethods.java @@ -29,6 +29,7 @@ package cc.arduino.net; +import edazdarevic.commons.net.CIDRUtils; import org.apache.commons.net.util.SubnetUtils; import java.net.InetAddress; @@ -62,10 +63,10 @@ public class PACSupportMethods { } } - public boolean isInNet(String host, String pattern, String mask) { + public boolean isInNet(String host, String pattern, String mask) throws UnknownHostException { SubnetUtils subnetUtils = new SubnetUtils(pattern, mask); subnetUtils.setInclusiveHostCount(true); - return subnetUtils.getInfo().isInRange(host); + return new CIDRUtils(subnetUtils.getInfo().getCidrSignature()).isInRange(host); } public String dnsResolve(String host) throws UnknownHostException { diff --git a/arduino-core/src/edazdarevic/commons/net/CIDRUtils.java b/arduino-core/src/edazdarevic/commons/net/CIDRUtils.java new file mode 100644 index 000000000..d564209f2 --- /dev/null +++ b/arduino-core/src/edazdarevic/commons/net/CIDRUtils.java @@ -0,0 +1,142 @@ +/* +* The MIT License +* +* Copyright (c) 2013 Edin Dazdarevic (edin.dazdarevic@gmail.com) + +* Permission is hereby granted, free of charge, to any person obtaining a copy +* of this software and associated documentation files (the "Software"), to deal +* in the Software without restriction, including without limitation the rights +* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +* copies of the Software, and to permit persons to whom the Software is +* furnished to do so, subject to the following conditions: + +* The above copyright notice and this permission notice shall be included in +* all copies or substantial portions of the Software. + +* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +* THE SOFTWARE. +* +* */ + +package edazdarevic.commons.net; + +import java.math.BigInteger; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.nio.ByteBuffer; +import java.util.ArrayList; +import java.util.List; + +/** + * A class that enables to get an IP range from CIDR specification. It supports + * both IPv4 and IPv6. + */ +public class CIDRUtils { + private final String cidr; + + private InetAddress inetAddress; + private InetAddress startAddress; + private InetAddress endAddress; + private final int prefixLength; + + + public CIDRUtils(String cidr) throws UnknownHostException { + + this.cidr = cidr; + + /* split CIDR to address and prefix part */ + if (this.cidr.contains("/")) { + int index = this.cidr.indexOf("/"); + String addressPart = this.cidr.substring(0, index); + String networkPart = this.cidr.substring(index + 1); + + inetAddress = InetAddress.getByName(addressPart); + prefixLength = Integer.parseInt(networkPart); + + calculate(); + } else { + throw new IllegalArgumentException("not an valid CIDR format!"); + } + } + + + private void calculate() throws UnknownHostException { + + ByteBuffer maskBuffer; + int targetSize; + if (inetAddress.getAddress().length == 4) { + maskBuffer = + ByteBuffer + .allocate(4) + .putInt(-1); + targetSize = 4; + } else { + maskBuffer = ByteBuffer.allocate(16) + .putLong(-1L) + .putLong(-1L); + targetSize = 16; + } + + BigInteger mask = (new BigInteger(1, maskBuffer.array())).not().shiftRight(prefixLength); + + ByteBuffer buffer = ByteBuffer.wrap(inetAddress.getAddress()); + BigInteger ipVal = new BigInteger(1, buffer.array()); + + BigInteger startIp = ipVal.and(mask); + BigInteger endIp = startIp.add(mask.not()); + + byte[] startIpArr = toBytes(startIp.toByteArray(), targetSize); + byte[] endIpArr = toBytes(endIp.toByteArray(), targetSize); + + this.startAddress = InetAddress.getByAddress(startIpArr); + this.endAddress = InetAddress.getByAddress(endIpArr); + + } + + private byte[] toBytes(byte[] array, int targetSize) { + int counter = 0; + List newArr = new ArrayList(); + while (counter < targetSize && (array.length - 1 - counter >= 0)) { + newArr.add(0, array[array.length - 1 - counter]); + counter++; + } + + int size = newArr.size(); + for (int i = 0; i < (targetSize - size); i++) { + + newArr.add(0, (byte) 0); + } + + byte[] ret = new byte[newArr.size()]; + for (int i = 0; i < newArr.size(); i++) { + ret[i] = newArr.get(i); + } + return ret; + } + + public String getNetworkAddress() { + + return this.startAddress.getHostAddress(); + } + + public String getBroadcastAddress() { + return this.endAddress.getHostAddress(); + } + + public boolean isInRange(String ipAddress) throws UnknownHostException { + InetAddress address = InetAddress.getByName(ipAddress); + BigInteger start = new BigInteger(1, this.startAddress.getAddress()); + BigInteger end = new BigInteger(1, this.endAddress.getAddress()); + BigInteger target = new BigInteger(1, address.getAddress()); + + int st = start.compareTo(target); + int te = target.compareTo(end); + + return (st == -1 || st == 0) && (te == -1 || te == 0); + } +}