libjava/javax/crypto/spec/SecretKeySpec.java

   1 /* SecretKeySpec.java -- Wrapper for secret keys.
   2    Copyright (C) 2004  Free Software Foundation, Inc.
   3
   4 This file is part of GNU Classpath.
   5
   6 GNU Classpath is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU Classpath is distributed in the hope that it will be useful, but
  12 WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU Classpath; see the file COPYING.  If not, write to the
  18 Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19 02111-1307 USA.
  20
  21 Linking this library statically or dynamically with other modules is
  22 making a combined work based on this library.  Thus, the terms and
  23 conditions of the GNU General Public License cover the whole
  24 combination.
  25
  26 As a special exception, the copyright holders of this library give you
  27 permission to link this library with independent modules to produce an
  28 executable, regardless of the license terms of these independent
  29 modules, and to copy and distribute the resulting executable under
  30 terms of your choice, provided that you also meet, for each linked
  31 independent module, the terms and conditions of the license of that
  32 module.  An independent module is a module which is not derived from
  33 or based on this library.  If you modify this library, you may extend
  34 this exception to your version of the library, but you are not
  35 obligated to do so.  If you do not wish to do so, delete this
  36 exception statement from your version. */
  37
  38
  39 package javax.crypto.spec;
  40
  41 import java.security.spec.KeySpec;
  42
  43 import javax.crypto.SecretKey;
  44
  45 /**
  46  * This is a simple wrapper around a raw byte array, for ciphers that do
  47  * not require any key parameters other than the bytes themselves.
  48  *
  49  * <p>Since this class implements {@link javax.crypto.SecretKey}, which
  50  * in turn extends {@link java.security.Key}, so instances of this class
  51  * may be passed directly to the <code>init()</code> methods of {@link
  52  * javax.crypto.Cipher}.
  53  *
  54  * @see javax.crypto.SecretKey
  55  * @see javax.crypto.SecretKeyFactory
  56  */
  57 public class SecretKeySpec implements KeySpec, SecretKey
  58 {
  59
  60   // Constants and fields.
  61   // ------------------------------------------------------------------------
  62
  63   /** Compatible with JDK1.4. */
  64   private static final long serialVersionUID = 6577238317307289933L;
  65
  66   /** The key bytes. */
  67   private byte[] key;
  68
  69   /** The algorithm's name. */
  70   private String algorithm;
  71
  72   // Constructors.
  73   // ------------------------------------------------------------------------
  74
  75   /**
  76    * Create a new secret key spec from an entire byte array.
  77    *
  78    * @param key       The key material.
  79    * @param algorithm The name of the algorithm using this key.
  80    */
  81   public SecretKeySpec(byte[] key, String algorithm)
  82   {
  83     this(key, 0, key.length, algorithm);
  84   }
  85
  86   /**
  87    * Create a new secret key spec from part of a byte array.
  88    *
  89    * @param key       The key material.
  90    * @param off       The offset at which key material begins.
  91    * @param len       The length of key material.
  92    * @param algorithm The name of the algorithm using this key.
  93    */
  94   public SecretKeySpec(byte[] key, int off, int len, String algorithm)
  95   {
  96     this.key = new byte[len];
  97     this.algorithm = algorithm;
  98     System.arraycopy(key, off, this.key, 0, len);
  99   }
 100
 101   // Instance methods.
 102   // ------------------------------------------------------------------------
 103
 104   /**
 105    * Return the name of the algorithm associated with this secret key.
 106    *
 107    * @return The algorithm's name.
 108    */
 109   public String getAlgorithm()
 110   {
 111     return algorithm;
 112   }
 113
 114   /**
 115    * Return the key as a byte array.
 116    *
 117    * @return The key material.
 118    */
 119   public byte[] getEncoded()
 120   {
 121     return key;
 122   }
 123
 124   /**
 125    * This key's format, which is always "RAW".
 126    *
 127    * @return "RAW"
 128    */
 129   public String getFormat()
 130   {
 131     return "RAW";
 132   }
 133
 134   public boolean equals(Object o)
 135   {
 136     byte[] okey = ((SecretKeySpec) o).getEncoded();
 137     if (key.length != okey.length) return false;
 138     for (int i = 0; i < key.length; i++)
 139       {
 140         if (key[i] != okey[i])
 141           return false;
 142       }
 143     return algorithm.equals(((SecretKeySpec) o).getAlgorithm());
 144   }
 145
 146   public int hashCode()
 147   {
 148     int code = 0;
 149     for (int i = 0; i < key.length; i++)
 150       {
 151         code ^= (key[i] & 0xff) << (i << 3 & 31);
 152       }
 153     return code ^ algorithm.hashCode();
 154   }
 155 }