1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31 package org.apache.commons.httpclient.auth;
32
33 import org.apache.commons.codec.binary.Base64;
34 import org.apache.commons.httpclient.Credentials;
35 import org.apache.commons.httpclient.HttpMethod;
36 import org.apache.commons.httpclient.UsernamePasswordCredentials;
37 import org.apache.commons.httpclient.util.EncodingUtil;
38 import org.apache.commons.logging.Log;
39 import org.apache.commons.logging.LogFactory;
40
41 /***
42 * <p>
43 * Basic authentication scheme as defined in RFC 2617.
44 * </p>
45 *
46 * @author <a href="mailto:remm@apache.org">Remy Maucherat</a>
47 * @author Rodney Waldhoff
48 * @author <a href="mailto:jsdever@apache.org">Jeff Dever</a>
49 * @author Ortwin Gl?ck
50 * @author Sean C. Sullivan
51 * @author <a href="mailto:adrian@ephox.com">Adrian Sutton</a>
52 * @author <a href="mailto:mbowler@GargoyleSoftware.com">Mike Bowler</a>
53 * @author <a href="mailto:oleg@ural.ru">Oleg Kalnichevski</a>
54 */
55
56 public class BasicScheme extends RFC2617Scheme {
57
58 /*** Log object for this class. */
59 private static final Log LOG = LogFactory.getLog(BasicScheme.class);
60
61 /*** Whether the basic authentication process is complete */
62 private boolean complete;
63
64 /***
65 * Default constructor for the basic authetication scheme.
66 *
67 * @since 3.0
68 */
69 public BasicScheme() {
70 super();
71 this.complete = false;
72 }
73
74 /***
75 * Constructor for the basic authetication scheme.
76 *
77 * @param challenge authentication challenge
78 *
79 * @throws MalformedChallengeException is thrown if the authentication challenge
80 * is malformed
81 *
82 * @deprecated Use parameterless constructor and {@link AuthScheme#processChallenge(String)}
83 * method
84 */
85 public BasicScheme(final String challenge) throws MalformedChallengeException {
86 super(challenge);
87 this.complete = true;
88 }
89
90 /***
91 * Returns textual designation of the basic authentication scheme.
92 *
93 * @return <code>basic</code>
94 */
95 public String getSchemeName() {
96 return "basic";
97 }
98
99 /***
100 * Processes the Basic challenge.
101 *
102 * @param challenge the challenge string
103 *
104 * @throws MalformedChallengeException is thrown if the authentication challenge
105 * is malformed
106 *
107 * @since 3.0
108 */
109 public void processChallenge(String challenge)
110 throws MalformedChallengeException
111 {
112 super.processChallenge(challenge);
113 this.complete = true;
114 }
115
116 /***
117 * Tests if the Basic authentication process has been completed.
118 *
119 * @return <tt>true</tt> if Basic authorization has been processed,
120 * <tt>false</tt> otherwise.
121 *
122 * @since 3.0
123 */
124 public boolean isComplete() {
125 return this.complete;
126 }
127
128 /***
129 * Produces basic authorization string for the given set of
130 * {@link Credentials}.
131 *
132 * @param credentials The set of credentials to be used for athentication
133 * @param method Method name is ignored by the basic authentication scheme
134 * @param uri URI is ignored by the basic authentication scheme
135 * @throws InvalidCredentialsException if authentication credentials
136 * are not valid or not applicable for this authentication scheme
137 * @throws AuthenticationException if authorization string cannot
138 * be generated due to an authentication failure
139 *
140 * @return a basic authorization string
141 *
142 * @deprecated Use {@link #authenticate(Credentials, HttpMethod)}
143 */
144 public String authenticate(Credentials credentials, String method, String uri)
145 throws AuthenticationException {
146
147 LOG.trace("enter BasicScheme.authenticate(Credentials, String, String)");
148
149 UsernamePasswordCredentials usernamepassword = null;
150 try {
151 usernamepassword = (UsernamePasswordCredentials) credentials;
152 } catch (ClassCastException e) {
153 throw new InvalidCredentialsException(
154 "Credentials cannot be used for basic authentication: "
155 + credentials.getClass().getName());
156 }
157 return BasicScheme.authenticate(usernamepassword);
158 }
159
160 /***
161 * Returns <tt>false</tt>. Basic authentication scheme is request based.
162 *
163 * @return <tt>false</tt>.
164 *
165 * @since 3.0
166 */
167 public boolean isConnectionBased() {
168 return false;
169 }
170
171 /***
172 * Produces basic authorization string for the given set of {@link Credentials}.
173 *
174 * @param credentials The set of credentials to be used for athentication
175 * @param method The method being authenticated
176 * @throws InvalidCredentialsException if authentication credentials
177 * are not valid or not applicable for this authentication scheme
178 * @throws AuthenticationException if authorization string cannot
179 * be generated due to an authentication failure
180 *
181 * @return a basic authorization string
182 *
183 * @since 3.0
184 */
185 public String authenticate(Credentials credentials, HttpMethod method) throws AuthenticationException {
186
187 LOG.trace("enter BasicScheme.authenticate(Credentials, HttpMethod)");
188
189 if (method == null) {
190 throw new IllegalArgumentException("Method may not be null");
191 }
192 UsernamePasswordCredentials usernamepassword = null;
193 try {
194 usernamepassword = (UsernamePasswordCredentials) credentials;
195 } catch (ClassCastException e) {
196 throw new InvalidCredentialsException(
197 "Credentials cannot be used for basic authentication: "
198 + credentials.getClass().getName());
199 }
200 return BasicScheme.authenticate(
201 usernamepassword,
202 method.getParams().getCredentialCharset());
203 }
204
205 /***
206 * @deprecated Use {@link #authenticate(UsernamePasswordCredentials, String)}
207 *
208 * Returns a basic <tt>Authorization</tt> header value for the given
209 * {@link UsernamePasswordCredentials}.
210 *
211 * @param credentials The credentials to encode.
212 *
213 * @return a basic authorization string
214 */
215 public static String authenticate(UsernamePasswordCredentials credentials) {
216 return authenticate(credentials, "ISO-8859-1");
217 }
218
219 /***
220 * Returns a basic <tt>Authorization</tt> header value for the given
221 * {@link UsernamePasswordCredentials} and charset.
222 *
223 * @param credentials The credentials to encode.
224 * @param charset The charset to use for encoding the credentials
225 *
226 * @return a basic authorization string
227 *
228 * @since 3.0
229 */
230 public static String authenticate(UsernamePasswordCredentials credentials, String charset) {
231
232 LOG.trace("enter BasicScheme.authenticate(UsernamePasswordCredentials, String)");
233
234 if (credentials == null) {
235 throw new IllegalArgumentException("Credentials may not be null");
236 }
237 if (charset == null || charset.length() == 0) {
238 throw new IllegalArgumentException("charset may not be null or empty");
239 }
240 StringBuffer buffer = new StringBuffer();
241 buffer.append(credentials.getUserName());
242 buffer.append(":");
243 buffer.append(credentials.getPassword());
244
245 return "Basic " + EncodingUtil.getAsciiString(
246 Base64.encodeBase64(EncodingUtil.getBytes(buffer.toString(), charset)));
247 }
248
249 }