001 /* MessageDigest.java --- The message digest interface. 002 Copyright (C) 1999, 2002, 2003, 2006 Free Software Foundation, Inc. 003 004 This file is part of GNU Classpath. 005 006 GNU Classpath is free software; you can redistribute it and/or modify 007 it under the terms of the GNU General Public License as published by 008 the Free Software Foundation; either version 2, or (at your option) 009 any later version. 010 011 GNU Classpath is distributed in the hope that it will be useful, but 012 WITHOUT ANY WARRANTY; without even the implied warranty of 013 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 014 General Public License for more details. 015 016 You should have received a copy of the GNU General Public License 017 along with GNU Classpath; see the file COPYING. If not, write to the 018 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 019 02110-1301 USA. 020 021 Linking this library statically or dynamically with other modules is 022 making a combined work based on this library. Thus, the terms and 023 conditions of the GNU General Public License cover the whole 024 combination. 025 026 As a special exception, the copyright holders of this library give you 027 permission to link this library with independent modules to produce an 028 executable, regardless of the license terms of these independent 029 modules, and to copy and distribute the resulting executable under 030 terms of your choice, provided that you also meet, for each linked 031 independent module, the terms and conditions of the license of that 032 module. An independent module is a module which is not derived from 033 or based on this library. If you modify this library, you may extend 034 this exception to your version of the library, but you are not 035 obligated to do so. If you do not wish to do so, delete this 036 exception statement from your version. */ 037 038 package java.security; 039 040 import gnu.java.lang.CPStringBuilder; 041 042 import gnu.java.security.Engine; 043 import java.nio.ByteBuffer; 044 045 import java.lang.reflect.InvocationTargetException; 046 047 /** 048 * Message digests are secure one-way hash functions that take arbitrary-sized 049 * data and output a fixed-length hash value. 050 * 051 * @see MessageDigestSpi 052 * @since JDK 1.1 053 */ 054 public abstract class MessageDigest extends MessageDigestSpi 055 { 056 /** The service name for message digests. */ 057 private static final String MESSAGE_DIGEST = "MessageDigest"; 058 059 private String algorithm; 060 Provider provider; 061 private byte[] lastDigest; 062 063 /** 064 * Constructs a new instance of <code>MessageDigest</code> representing the 065 * specified algorithm. 066 * 067 * @param algorithm 068 * the name of the digest algorithm to use. 069 */ 070 protected MessageDigest(String algorithm) 071 { 072 this.algorithm = algorithm; 073 provider = null; 074 } 075 076 /** 077 * Returns a new instance of <code>MessageDigest</code> representing the 078 * specified algorithm. 079 * 080 * @param algorithm the name of the digest algorithm to use. 081 * @return a new instance representing the desired algorithm. 082 * @throws NoSuchAlgorithmException if the algorithm is not implemented by any 083 * provider. 084 * @throws IllegalArgumentException if <code>algorithm</code> is 085 * <code>null</code> or is an empty string. 086 */ 087 public static MessageDigest getInstance(String algorithm) 088 throws NoSuchAlgorithmException 089 { 090 Provider[] p = Security.getProviders(); 091 NoSuchAlgorithmException lastException = null; 092 for (int i = 0; i < p.length; i++) 093 try 094 { 095 return getInstance(algorithm, p[i]); 096 } 097 catch (NoSuchAlgorithmException x) 098 { 099 lastException = x; 100 } 101 if (lastException != null) 102 throw lastException; 103 throw new NoSuchAlgorithmException(algorithm); 104 } 105 106 /** 107 * Returns a new instance of <code>MessageDigest</code> representing the 108 * specified algorithm from a named provider. 109 * 110 * @param algorithm the name of the digest algorithm to use. 111 * @param provider the name of the provider to use. 112 * @return a new instance representing the desired algorithm. 113 * @throws NoSuchAlgorithmException if the algorithm is not implemented by the 114 * named provider. 115 * @throws NoSuchProviderException if the named provider was not found. 116 * @throws IllegalArgumentException if either <code>algorithm</code> or 117 * <code>provider</code> is <code>null</code> or empty. 118 */ 119 public static MessageDigest getInstance(String algorithm, String provider) 120 throws NoSuchAlgorithmException, NoSuchProviderException 121 { 122 if (provider == null) 123 throw new IllegalArgumentException("provider MUST NOT be null"); 124 provider = provider.trim(); 125 if (provider.length() == 0) 126 throw new IllegalArgumentException("provider MUST NOT be empty"); 127 Provider p = Security.getProvider(provider); 128 if (p == null) 129 throw new NoSuchProviderException(provider); 130 return getInstance(algorithm, p); 131 } 132 133 /** 134 * Returns a new instance of <code>MessageDigest</code> representing the 135 * specified algorithm from a designated {@link Provider}. 136 * 137 * @param algorithm the name of the digest algorithm to use. 138 * @param provider the {@link Provider} to use. 139 * @return a new instance representing the desired algorithm. 140 * @throws NoSuchAlgorithmException if the algorithm is not implemented by 141 * {@link Provider}. 142 * @throws IllegalArgumentException if either <code>algorithm</code> or 143 * <code>provider</code> is <code>null</code>, or if 144 * <code>algorithm</code> is an empty string. 145 * @since 1.4 146 * @see Provider 147 */ 148 public static MessageDigest getInstance(String algorithm, Provider provider) 149 throws NoSuchAlgorithmException 150 { 151 CPStringBuilder sb = new CPStringBuilder("MessageDigest for algorithm [") 152 .append(algorithm).append("] from provider[") 153 .append(provider).append("] "); 154 Object o; 155 try 156 { 157 o = Engine.getInstance(MESSAGE_DIGEST, algorithm, provider); 158 } 159 catch (InvocationTargetException x) 160 { 161 Throwable cause = x.getCause(); 162 if (cause instanceof NoSuchAlgorithmException) 163 throw (NoSuchAlgorithmException) cause; 164 if (cause == null) 165 cause = x; 166 sb.append("could not be created"); 167 NoSuchAlgorithmException y = new NoSuchAlgorithmException(sb.toString()); 168 y.initCause(cause); 169 throw y; 170 } 171 MessageDigest result; 172 if (o instanceof MessageDigestSpi) 173 result = new DummyMessageDigest((MessageDigestSpi) o, algorithm); 174 else if (o instanceof MessageDigest) 175 { 176 result = (MessageDigest) o; 177 result.algorithm = algorithm; 178 } 179 else 180 { 181 sb.append("is of an unexpected Type: ").append(o.getClass().getName()); 182 throw new NoSuchAlgorithmException(sb.toString()); 183 } 184 result.provider = provider; 185 return result; 186 } 187 188 /** 189 * Returns the {@link Provider} of this instance. 190 * 191 * @return the {@link Provider} of this instance. 192 */ 193 public final Provider getProvider() 194 { 195 return provider; 196 } 197 198 /** 199 * Updates the digest with the byte. 200 * 201 * @param input byte to update the digest with. 202 */ 203 public void update(byte input) 204 { 205 engineUpdate(input); 206 } 207 208 /** 209 * Updates the digest with the bytes from the array starting from the 210 * specified offset and using the specified length of bytes. 211 * 212 * @param input 213 * bytes to update the digest with. 214 * @param offset 215 * the offset to start at. 216 * @param len 217 * length of the data to update with. 218 */ 219 public void update(byte[] input, int offset, int len) 220 { 221 engineUpdate(input, offset, len); 222 } 223 224 /** 225 * Updates the digest with the bytes of an array. 226 * 227 * @param input bytes to update the digest with. 228 */ 229 public void update(byte[] input) 230 { 231 engineUpdate(input, 0, input.length); 232 } 233 234 /** 235 * Updates the digest with the remaining bytes of a buffer. 236 * 237 * @param input The input byte buffer. 238 * @since 1.5 239 */ 240 public final void update (ByteBuffer input) 241 { 242 engineUpdate (input); 243 } 244 245 /** 246 * Computes the final digest of the stored data. 247 * 248 * @return a byte array representing the message digest. 249 */ 250 public byte[] digest() 251 { 252 return lastDigest = engineDigest(); 253 } 254 255 /** 256 * Computes the final digest of the stored bytes and returns the result. 257 * 258 * @param buf 259 * an array of bytes to store the result in. 260 * @param offset 261 * an offset to start storing the result at. 262 * @param len 263 * the length of the buffer. 264 * @return Returns the length of the buffer. 265 */ 266 public int digest(byte[] buf, int offset, int len) throws DigestException 267 { 268 return engineDigest(buf, offset, len); 269 } 270 271 /** 272 * Computes a final update using the input array of bytes, then computes a 273 * final digest and returns it. It calls {@link #update(byte[])} and then 274 * {@link #digest(byte[])}. 275 * 276 * @param input 277 * an array of bytes to perform final update with. 278 * @return a byte array representing the message digest. 279 */ 280 public byte[] digest(byte[] input) 281 { 282 update(input); 283 return digest(); 284 } 285 286 /** 287 * Returns a string representation of this instance. 288 * 289 * @return a string representation of this instance. 290 */ 291 public String toString() 292 { 293 return (getClass()).getName() + " Message Digest <" + digestToString() + ">"; 294 } 295 296 /** 297 * Does a simple byte comparison of the two digests. 298 * 299 * @param digesta 300 * first digest to compare. 301 * @param digestb 302 * second digest to compare. 303 * @return <code>true</code> if both are equal, <code>false</code> 304 * otherwise. 305 */ 306 public static boolean isEqual(byte[] digesta, byte[] digestb) 307 { 308 if (digesta.length != digestb.length) 309 return false; 310 311 for (int i = digesta.length - 1; i >= 0; --i) 312 if (digesta[i] != digestb[i]) 313 return false; 314 315 return true; 316 } 317 318 /** Resets this instance. */ 319 public void reset() 320 { 321 engineReset(); 322 } 323 324 /** 325 * Returns the name of message digest algorithm. 326 * 327 * @return the name of message digest algorithm. 328 */ 329 public final String getAlgorithm() 330 { 331 return algorithm; 332 } 333 334 /** 335 * Returns the length of the message digest. The default is zero which means 336 * that the concrete implementation does not implement this method. 337 * 338 * @return length of the message digest. 339 * @since 1.2 340 */ 341 public final int getDigestLength() 342 { 343 return engineGetDigestLength(); 344 } 345 346 /** 347 * Returns a clone of this instance if cloning is supported. If it does not 348 * then a {@link CloneNotSupportedException} is thrown. Cloning depends on 349 * whether the subclass {@link MessageDigestSpi} implements {@link Cloneable} 350 * which contains the actual implementation of the appropriate algorithm. 351 * 352 * @return a clone of this instance. 353 * @throws CloneNotSupportedException 354 * the implementation does not support cloning. 355 */ 356 public Object clone() throws CloneNotSupportedException 357 { 358 return super.clone(); 359 } 360 361 private String digestToString() 362 { 363 byte[] digest = lastDigest; 364 365 if (digest == null) 366 return "incomplete"; 367 368 CPStringBuilder buf = new CPStringBuilder(); 369 int len = digest.length; 370 for (int i = 0; i < len; ++i) 371 { 372 byte b = digest[i]; 373 byte high = (byte) ((b & 0xff) >>> 4); 374 byte low = (byte) (b & 0xf); 375 376 buf.append(high > 9 ? ('a' - 10) + high : '0' + high); 377 buf.append(low > 9 ? ('a' - 10) + low : '0' + low); 378 } 379 380 return buf.toString(); 381 } 382 }