libjava/classpath/gnu/javax/crypto/keyring/PrivateKeyEntry.java

   1 /* PrivateKeyEntry.java --
   2    Copyright (C) 2003, 2006 Free Software Foundation, Inc.
   3
   4 This file is a 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 of the License, or (at
   9 your option) 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; if not, write to the Free Software
  18 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301
  19 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 gnu.javax.crypto.keyring;
  40
  41 import gnu.java.security.key.IKeyPairCodec;
  42 import gnu.java.security.key.KeyPairCodecFactory;
  43 import gnu.java.security.key.dss.DSSPrivateKey;
  44 import gnu.java.security.key.rsa.GnuRSAPrivateKey;
  45
  46 import gnu.javax.crypto.key.GnuSecretKey;
  47 import gnu.javax.crypto.key.dh.GnuDHPrivateKey;
  48
  49 import java.io.DataInputStream;
  50 import java.io.DataOutputStream;
  51 import java.io.IOException;
  52 import java.security.Key;
  53 import java.security.KeyFactory;
  54 import java.security.PrivateKey;
  55 import java.security.spec.PKCS8EncodedKeySpec;
  56 import java.util.Date;
  57
  58 /**
  59  * <p>An immutable class representing a private or secret key entry.</p>
  60  *
  61  * @version $Revision: 1.1 $
  62  */
  63 public final class PrivateKeyEntry extends PrimitiveEntry
  64 {
  65
  66   // Constants and variables
  67   // -------------------------------------------------------------------------
  68
  69   public static final int TYPE = 7;
  70
  71   /** The key. */
  72   private Key key;
  73
  74   // Constructor(s)
  75   // -------------------------------------------------------------------------
  76
  77   /**
  78    * <p>Creates a new key entry.</p>
  79    *
  80    * @param key The key.
  81    * @param creationDate The entry creation date.
  82    * @param properties The entry properties.
  83    * @throws IllegalArgumentException If any parameter is null.
  84    */
  85   public PrivateKeyEntry(Key key, Date creationDate, Properties properties)
  86   {
  87     super(TYPE, creationDate, properties);
  88
  89     if (key == null)
  90       {
  91         throw new IllegalArgumentException("no private key");
  92       }
  93     if (!(key instanceof PrivateKey) && !(key instanceof GnuSecretKey))
  94       {
  95         throw new IllegalArgumentException("not a private or secret key");
  96       }
  97     this.key = key;
  98   }
  99
 100   private PrivateKeyEntry()
 101   {
 102     super(TYPE);
 103   }
 104
 105   // Class methods
 106   // -------------------------------------------------------------------------
 107
 108   public static PrivateKeyEntry decode(DataInputStream in) throws IOException
 109   {
 110     PrivateKeyEntry entry = new PrivateKeyEntry();
 111     entry.defaultDecode(in);
 112     String type = entry.properties.get("type");
 113     if (type == null)
 114       {
 115         throw new MalformedKeyringException("no key type");
 116       }
 117     if (type.equalsIgnoreCase("RAW-DSS"))
 118       {
 119         IKeyPairCodec coder = KeyPairCodecFactory.getInstance("dss");
 120         entry.key = coder.decodePrivateKey(entry.payload);
 121       }
 122     else if (type.equalsIgnoreCase("RAW-RSA"))
 123       {
 124         IKeyPairCodec coder = KeyPairCodecFactory.getInstance("rsa");
 125         entry.key = coder.decodePrivateKey(entry.payload);
 126       }
 127     else if (type.equalsIgnoreCase("RAW-DH"))
 128       {
 129         IKeyPairCodec coder = KeyPairCodecFactory.getInstance("dh");
 130         entry.key = coder.decodePrivateKey(entry.payload);
 131       }
 132     else if (type.equalsIgnoreCase("RAW"))
 133       {
 134         entry.key = new GnuSecretKey(entry.payload, null);
 135       }
 136     else if (type.equalsIgnoreCase("PKCS8"))
 137       {
 138         try
 139           {
 140             KeyFactory kf = KeyFactory.getInstance("RSA");
 141             entry.key = kf.generatePrivate(new PKCS8EncodedKeySpec(
 142                                                                    entry.payload));
 143           }
 144         catch (Exception x)
 145           {
 146           }
 147         if (entry.key == null)
 148           {
 149             try
 150               {
 151                 KeyFactory kf = KeyFactory.getInstance("DSA");
 152                 entry.key = kf.generatePrivate(new PKCS8EncodedKeySpec(
 153                                                                        entry.payload));
 154               }
 155             catch (Exception x)
 156               {
 157               }
 158             if (entry.key == null)
 159               {
 160                 throw new MalformedKeyringException(
 161                                                     "could not decode PKCS#8 key");
 162               }
 163           }
 164       }
 165     else
 166       {
 167         throw new MalformedKeyringException("unsupported key type " + type);
 168       }
 169     return entry;
 170   }
 171
 172   // Instance methods
 173   // -------------------------------------------------------------------------
 174
 175   /**
 176    * <p>Returns this entry's key.</p>
 177    *
 178    * @return The key.
 179    */
 180   public Key getKey()
 181   {
 182     return key;
 183   }
 184
 185   protected void encodePayload() throws IOException
 186   {
 187     String format = key.getFormat();
 188     if (key instanceof DSSPrivateKey)
 189       {
 190         properties.put("type", "RAW-DSS");
 191         IKeyPairCodec coder = KeyPairCodecFactory.getInstance("dss");
 192         payload = coder.encodePrivateKey((PrivateKey) key);
 193       }
 194     else if (key instanceof GnuRSAPrivateKey)
 195       {
 196         properties.put("type", "RAW-RSA");
 197         IKeyPairCodec coder = KeyPairCodecFactory.getInstance("rsa");
 198         payload = coder.encodePrivateKey((PrivateKey) key);
 199       }
 200     else if (key instanceof GnuDHPrivateKey)
 201       {
 202         properties.put("type", "RAW-DH");
 203         IKeyPairCodec coder = KeyPairCodecFactory.getInstance("dh");
 204         payload = coder.encodePrivateKey((PrivateKey) key);
 205       }
 206     else if (key instanceof GnuSecretKey)
 207       {
 208         properties.put("type", "RAW");
 209         payload = key.getEncoded();
 210       }
 211     else if (format != null && format.equals("PKCS#8"))
 212       {
 213         properties.put("type", "PKCS8");
 214         payload = key.getEncoded();
 215       }
 216     else
 217       {
 218         throw new IllegalArgumentException("unsupported private key");
 219       }
 220   }
 221 }