1 /*

     2  * Copyright 1997-2003 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Sun designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Sun in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    22  * CA 95054 USA or visit www.sun.com if you need additional information or

    23  * have any questions.

    24  */

    25 

    26 package sun.net.www.protocol.http;

    27 

    28 import java.net.URL;

    29 import java.net.URI;

    30 import java.net.URISyntaxException;

    31 import java.net.PasswordAuthentication;

    32 import sun.net.www.HeaderParser;

    33 

    34 

    35 /**

    36  * BasicAuthentication: Encapsulate an http server authentication using

    37  * the "basic" scheme.

    38  *

    39  * @author Bill Foote

    40  */

    41 

    42 

    43 class BasicAuthentication extends AuthenticationInfo {

    44 

    45     private static final long serialVersionUID = 100L;

    46 

    47     static final char BASIC_AUTH = 'B';

    48 

    49     /** The authentication string for this host, port, and realm.  This is

    50         a simple BASE64 encoding of "login:password".    */

    51     String auth;

    52 

    53     /**

    54      * Create a BasicAuthentication

    55      */

    56     public BasicAuthentication(boolean isProxy, String host, int port,

    57                                String realm, PasswordAuthentication pw) {

    58         super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,

    59               BASIC_AUTH, host, port, realm);

    60         String plain = pw.getUserName() + ":";

    61         byte[] nameBytes = null;

    62         try {

    63             nameBytes = plain.getBytes("ISO-8859-1");

    64         } catch (java.io.UnsupportedEncodingException uee) {

    65             assert false;

    66         }

    67 

    68         // get password bytes

    69         char[] passwd = pw.getPassword();

    70         byte[] passwdBytes = new byte[passwd.length];

    71         for (int i=0; i<passwd.length; i++)

    72             passwdBytes[i] = (byte)passwd[i];

    73 

    74         // concatenate user name and password bytes and encode them

    75         byte[] concat = new byte[nameBytes.length + passwdBytes.length];

    76         System.arraycopy(nameBytes, 0, concat, 0, nameBytes.length);

    77         System.arraycopy(passwdBytes, 0, concat, nameBytes.length,

    78                          passwdBytes.length);

    79         this.auth = "Basic " + (new sun.misc.BASE64Encoder()).encode(concat);

    80         this.pw = pw;

    81     }

    82 

    83     /**

    84      * Create a BasicAuthentication

    85      */

    86     public BasicAuthentication(boolean isProxy, String host, int port,

    87                                String realm, String auth) {

    88         super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,

    89               BASIC_AUTH, host, port, realm);

    90         this.auth = "Basic " + auth;

    91     }

    92 

    93     /**

    94      * Create a BasicAuthentication

    95      */

    96     public BasicAuthentication(boolean isProxy, URL url, String realm,

    97                                    PasswordAuthentication pw) {

    98         super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,

    99               BASIC_AUTH, url, realm);

   100         String plain = pw.getUserName() + ":";

   101         byte[] nameBytes = null;

   102         try {

   103             nameBytes = plain.getBytes("ISO-8859-1");

   104         } catch (java.io.UnsupportedEncodingException uee) {

   105             assert false;

   106         }

   107 

   108         // get password bytes

   109         char[] passwd = pw.getPassword();

   110         byte[] passwdBytes = new byte[passwd.length];

   111         for (int i=0; i<passwd.length; i++)

   112             passwdBytes[i] = (byte)passwd[i];

   113 

   114         // concatenate user name and password bytes and encode them

   115         byte[] concat = new byte[nameBytes.length + passwdBytes.length];

   116         System.arraycopy(nameBytes, 0, concat, 0, nameBytes.length);

   117         System.arraycopy(passwdBytes, 0, concat, nameBytes.length,

   118                          passwdBytes.length);

   119         this.auth = "Basic " + (new sun.misc.BASE64Encoder()).encode(concat);

   120         this.pw = pw;

   121     }

   122 

   123     /**

   124      * Create a BasicAuthentication

   125      */

   126     public BasicAuthentication(boolean isProxy, URL url, String realm,

   127                                    String auth) {

   128         super(isProxy ? PROXY_AUTHENTICATION : SERVER_AUTHENTICATION,

   129               BASIC_AUTH, url, realm);

   130         this.auth = "Basic " + auth;

   131     }

   132 

   133     /**

   134      * @return true if this authentication supports preemptive authorization

   135      */

   136     boolean supportsPreemptiveAuthorization() {

   137         return true;

   138     }

   139 

   140     /**

   141      * @return the name of the HTTP header this authentication wants set

   142      */

   143     String getHeaderName() {

   144         if (type == SERVER_AUTHENTICATION) {

   145             return "Authorization";

   146         } else {

   147             return "Proxy-authorization";

   148         }

   149     }

   150 

   151     /**

   152      * Set header(s) on the given connection. This will only be called for

   153      * definitive (i.e. non-preemptive) authorization.

   154      * @param conn The connection to apply the header(s) to

   155      * @param p A source of header values for this connection, if needed.

   156      * @param raw The raw header values for this connection, if needed.

   157      * @return true if all goes well, false if no headers were set.

   158      */

   159     boolean setHeaders(HttpURLConnection conn, HeaderParser p, String raw) {

   160         conn.setAuthenticationProperty(getHeaderName(), getHeaderValue(null,null));

   161         return true;

   162     }

   163 

   164     /**

   165      * @return the value of the HTTP header this authentication wants set

   166      */

   167     String getHeaderValue(URL url, String method) {

   168         /* For Basic the authorization string does not depend on the request URL

   169          * or the request method

   170          */

   171         return auth;

   172     }

   173 

   174     /**

   175      * For Basic Authentication, the security parameters can never be stale.

   176      * In other words there is no possibility to reuse the credentials.

   177      * They are always either valid or invalid.

   178      */

   179     boolean isAuthorizationStale (String header) {

   180         return false;

   181     }

   182 

   183     /**

   184      * For Basic Authentication, there is no security information in the

   185      * response

   186      */

   187     void checkResponse (String header, String method, URL url) {

   188     }

   189 

   190     /**

   191      * @return the common root path between npath and path.

   192      * This is used to detect when we have an authentication for two

   193      * paths and the root of th authentication space is the common root.

   194      */

   195 

   196     static String getRootPath(String npath, String opath) {

   197         int index = 0;

   198         int toindex;

   199 

   200         /* Must normalize so we don't get confused by ../ and ./ segments */

   201         try {

   202             npath = new URI (npath).normalize().getPath();

   203             opath = new URI (opath).normalize().getPath();

   204         } catch (URISyntaxException e) {

   205             /* ignore error and use the old value */

   206         }

   207 

   208         while (index < opath.length()) {

   209             toindex = opath.indexOf('/', index+1);

   210             if (toindex != -1 && opath.regionMatches(0, npath, 0, toindex+1))

   211                 index = toindex;

   212             else

   213                 return opath.substring(0, index+1);

   214         }

   215         /*should not reach here. If we do simply return npath*/

   216         return npath;

   217     }

   218 

   219 }