src/main/java/edu/internet2/middleware/shibboleth/idp/authn/provider/IPAddressLoginHandler.java

   1 /*
   2  * Copyright [2006] [University Corporation for Advanced Internet Development, Inc.]
   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 edu.internet2.middleware.shibboleth.idp.authn.provider;
  18
  19 import java.net.Inet4Address;
  20 import java.net.Inet6Address;
  21 import java.net.InetAddress;
  22 import java.net.UnknownHostException;
  23 import java.util.BitSet;
  24 import java.util.List;
  25 import java.util.concurrent.CopyOnWriteArrayList;
  26
  27 import javax.servlet.ServletRequest;
  28 import javax.servlet.http.HttpServletRequest;
  29 import javax.servlet.http.HttpServletResponse;
  30
  31 import org.slf4j.Logger;
  32 import org.slf4j.LoggerFactory;
  33
  34 import edu.internet2.middleware.shibboleth.idp.authn.AuthenticationEngine;
  35 import edu.internet2.middleware.shibboleth.idp.authn.LoginHandler;
  36
  37 /**
  38  * IP Address authentication handler.
  39  *
  40  * This "authenticates" a user based on their IP address. It operates in either default deny or default allow mode, and
  41  * evaluates a given request against a list of blocked or permitted IPs. It supports both IPv4 and IPv6.
  42  *
  43  * If an Authentication Context Class or DeclRef URI is not specified, it will default to
  44  * "urn:oasis:names:tc:SAML:2.0:ac:classes:InternetProtocol".
  45  */
  46 public class IPAddressLoginHandler extends AbstractLoginHandler {
  47
  48     /** Class logger. */
  49     private final Logger log = LoggerFactory.getLogger(IPAddressLoginHandler.class);
  50
  51     /** The URI of the AuthnContextDeclRef or the AuthnContextClass. */
  52     private String authnMethodURI = "urn:oasis:names:tc:SAML:2.0:ac:classes:InternetProtocol";
  53
  54     /** The username to use for IP-address "authenticated" users. */
  55     private String username;
  56
  57     /** Are the IPs in ipList a permitted list or a deny list. */
  58     private boolean defaultDeny;
  59
  60     /** The list of denied or permitted IPs. */
  61     private List<IPEntry> ipList;
  62
  63     /**
  64      * Set the permitted IP addresses.
  65      *
  66      * If <code>defaultDeny</code> is <code>true</code> then only the IP addresses in <code>ipList</code> will be
  67      * "authenticated." If <code>defaultDeny</code> is <code>false</code>, then all IP addresses except those in
  68      * <code>ipList</code> will be authenticated.
  69      *
  70      * @param entries A list of IP addresses (with CIDR masks).
  71      * @param defaultDeny Does <code>ipList</code> contain a deny or permit list.
  72      */
  73     public void setEntries(final List<String> entries, boolean defaultDeny) {
  74
  75         this.defaultDeny = defaultDeny;
  76         ipList = new CopyOnWriteArrayList<IPEntry>();
  77
  78         for (String addr : entries) {
  79             try {
  80                 ipList.add(new edu.internet2.middleware.shibboleth.idp.authn.provider.IPAddressLoginHandler.IPEntry(
  81                         addr));
  82             } catch (UnknownHostException ex) {
  83                 log.error("IPAddressHandler: Error parsing entry \"" + addr + "\". Ignoring.");
  84             }
  85         }
  86     }
  87
  88     /** {@inheritDoc} */
  89     public boolean supportsPassive() {
  90         return true;
  91     }
  92
  93     /** {@inheritDoc} */
  94     public boolean supportsForceAuthentication() {
  95         return true;
  96     }
  97
  98     /**
  99      * Get the username for all IP-address authenticated users.
 100      *
 101      * @return The username for IP-address authenticated users.
 102      */
 103     public String getUsername() {
 104         return username;
 105     }
 106
 107     /**
 108      * Set the username to use for all IP-address authenticated users.
 109      *
 110      * @param name The username for IP-address authenticated users.
 111      */
 112     public void setUsername(String name) {
 113         username = name;
 114     }
 115
 116     /** {@inheritDoc} */
 117     public void login(HttpServletRequest httpRequest, HttpServletResponse httpResponse) {
 118
 119         if (defaultDeny) {
 120             handleDefaultDeny(httpRequest, httpResponse);
 121         } else {
 122             handleDefaultAllow(httpRequest, httpResponse);
 123         }
 124
 125         AuthenticationEngine.returnToAuthenticationEngine(httpRequest, httpResponse);
 126     }
 127
 128     protected void handleDefaultDeny(HttpServletRequest request, HttpServletResponse response) {
 129
 130         boolean ipAllowed = searchIpList(request);
 131
 132         if (ipAllowed) {
 133             request.setAttribute(LoginHandler.PRINCIPAL_NAME_KEY, username);
 134         }
 135     }
 136
 137     protected void handleDefaultAllow(HttpServletRequest request, HttpServletResponse response) {
 138
 139         boolean ipDenied = searchIpList(request);
 140
 141         if (!ipDenied) {
 142             request.setAttribute(LoginHandler.PRINCIPAL_NAME_KEY, username);
 143         }
 144     }
 145
 146     /**
 147      * Search the list of InetAddresses for the client's address.
 148      *
 149      * @param request The ServletReqeust
 150      *
 151      * @return <code>true</code> if the client's address is in <code>ipList</code>
 152      */
 153     private boolean searchIpList(ServletRequest request) {
 154
 155         boolean found = false;
 156
 157         try {
 158             InetAddress addr = InetAddress.getByName(request.getRemoteAddr());
 159             BitSet addrbits = byteArrayToBitSet(addr.getAddress());
 160
 161             for (IPEntry entry : ipList) {
 162
 163                 BitSet netaddr = entry.getNetworkAddress();
 164                 BitSet netmask = entry.getNetmask();
 165
 166                 addrbits.and(netmask);
 167                 if (addrbits.equals(netaddr)) {
 168                     found = true;
 169                     break;
 170                 }
 171             }
 172
 173         } catch (UnknownHostException ex) {
 174             log.error("IPAddressHandler: Error resolving hostname.", ex);
 175             return false;
 176         }
 177
 178         return found;
 179     }
 180
 181     /**
 182      * Converts a byte array to a BitSet.
 183      *
 184      * The supplied byte array is assumed to have the most signifigant bit in element 0.
 185      *
 186      * @param bytes the byte array with most signifigant bit in element 0.
 187      *
 188      * @return the BitSet
 189      */
 190     protected BitSet byteArrayToBitSet(final byte[] bytes) {
 191
 192         BitSet bits = new BitSet();
 193
 194         for (int i = 0; i < bytes.length * 8; i++) {
 195             if ((bytes[bytes.length - i / 8 - 1] & (1 << (i % 8))) > 0) {
 196                 bits.set(i);
 197             }
 198         }
 199
 200         return bits;
 201     }
 202
 203     /**
 204      * Encapsulates a network address and a netmask on ipList.
 205      */
 206     protected class IPEntry {
 207
 208         /** The network address. */
 209         private final BitSet networkAddress;
 210
 211         /** The netmask. */
 212         private final BitSet netmask;
 213
 214         /**
 215          * Construct a new IPEntry given a network address in CIDR format.
 216          *
 217          * @param entry A CIDR-formatted network address/netmask
 218          *
 219          * @throws UnknownHostException If entry is malformed.
 220          */
 221         public IPEntry(String entry) throws UnknownHostException {
 222
 223             // quick sanity checks
 224             if (entry == null || entry.length() == 0) {
 225                 throw new UnknownHostException("entry is null.");
 226             }
 227
 228             int cidrOffset = entry.indexOf("/");
 229             if (cidrOffset == -1) {
 230                 log.error("IPAddressHandler: invalid entry \"" + entry + "\" -- it lacks a netmask component.");
 231                 throw new UnknownHostException("entry lacks a netmask component.");
 232             }
 233
 234             // ensure that only one "/" is present.
 235             if (entry.indexOf("/", cidrOffset + 1) != -1) {
 236                 log.error("IPAddressHandler: invalid entry \"" + entry + "\" -- too many \"/\" present.");
 237                 throw new UnknownHostException("entry has too many netmask components.");
 238             }
 239
 240             String networkString = entry.substring(0, cidrOffset);
 241             String netmaskString = entry.substring(cidrOffset + 1, entry.length());
 242
 243             InetAddress tempAddr = InetAddress.getByName(networkString);
 244             networkAddress = byteArrayToBitSet(tempAddr.getAddress());
 245
 246             int masklen = Integer.parseInt(netmaskString);
 247             int addrlen = networkAddress.length();
 248
 249             // ensure that the netmask isn't too large
 250             if ((tempAddr instanceof Inet4Address) && (masklen > 32)) {
 251                 throw new UnknownHostException("IPAddressHandler: Netmask is too large for an IPv4 address: " + masklen);
 252             } else if ((tempAddr instanceof Inet6Address) && masklen > 128) {
 253                 throw new UnknownHostException("IPAddressHandler: Netmask is too large for an IPv6 address: " + masklen);
 254             }
 255
 256             netmask = new BitSet(addrlen);
 257             netmask.set(addrlen - masklen, addrlen, true);
 258         }
 259
 260         /**
 261          * Get the network address.
 262          *
 263          * @return the network address.
 264          */
 265         public BitSet getNetworkAddress() {
 266             return networkAddress;
 267         }
 268
 269         /**
 270          * Get the netmask.
 271          *
 272          * @return the netmask.
 273          */
 274         public BitSet getNetmask() {
 275             return netmask;
 276         }
 277     }
 278 }