001: /*
002: *
003: *
004: * Copyright 1990-2007 Sun Microsystems, Inc. All Rights Reserved.
005: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER
006: *
007: * This program is free software; you can redistribute it and/or
008: * modify it under the terms of the GNU General Public License version
009: * 2 only, as published by the Free Software Foundation.
010: *
011: * This program 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 version 2 for more details (a copy is
015: * included at /legal/license.txt).
016: *
017: * You should have received a copy of the GNU General Public License
018: * version 2 along with this work; if not, write to the Free Software
019: * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
020: * 02110-1301 USA
021: *
022: * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
023: * Clara, CA 95054 or visit www.sun.com if you need additional
024: * information or have any questions.
025: */
026:
027: package wim_data;
028:
029: import java.security.interfaces.RSAPrivateKey;
030: import java.security.interfaces.RSAPublicKey;
031: import java.security.NoSuchAlgorithmException;
032: import java.security.KeyPairGenerator;
033: import java.security.KeyPair;
034:
035: /**
036: * This class represents RSA key pair.
037: */
038: class Key {
039:
040: /** Private key label. */
041: String label;
042:
043: /** Index of PIN that protects private key. */
044: int pinIndex;
045:
046: /** ID of PIN that protects private key. */
047: int pinId;
048:
049: /**
050: * If true, this is non-repudiation key, otherwise - authentication
051: * key.
052: */
053: boolean nonRepudiation;
054:
055: /** Length of the key. */
056: int keyLen;
057:
058: /** Private key identifier. */
059: int id;
060:
061: /** Path for public key. */
062: short[] PublicPath;
063:
064: /** Path for private key. */
065: short[] PrivatePath;
066:
067: /** Private key. */
068: RSAPrivateKey priv;
069: /** Public key. */
070: RSAPublicKey pub;
071:
072: /** Public key hash used to identify the keys. */
073: byte[] hash;
074:
075: /**
076: * Constructor.
077: * @param label private key label
078: * @param len length of key
079: * @param pinIndex pin index in PINs array
080: * @param nonRepudiation is it non-repudiation key?
081: * @param id private key identifier
082: * @param PublicPath path to file with public key
083: * @param PrivatePath path to file with private key
084: * @param PINs PIN objectd defined for this WIM
085: */
086: Key(String label, int len, int pinIndex, boolean nonRepudiation,
087: int id, short[] PublicPath, short[] PrivatePath, PIN[] PINs) {
088:
089: this .label = label;
090: this .keyLen = len;
091: this .pinIndex = pinIndex;
092: pinId = PINs[pinIndex].id;
093: this .nonRepudiation = nonRepudiation;
094: this .id = id;
095: this .PublicPath = PublicPath;
096: this .PrivatePath = PrivatePath;
097: hash = new byte[20];
098: }
099:
100: /**
101: * Initializes the object.
102: * @throws NoSuchAlgorithmException if RSA algorithm is not supported
103: */
104: void init() throws NoSuchAlgorithmException {
105:
106: KeyPairGenerator kpg = KeyPairGenerator.getInstance("RSA");
107: kpg.initialize(keyLen);
108: KeyPair kp = kpg.generateKeyPair();
109:
110: priv = (RSAPrivateKey) kp.getPrivate();
111: pub = (RSAPublicKey) kp.getPublic();
112:
113: byte[] modulus = pub.getModulus().toByteArray();
114: hash = Utils.getHash(modulus, 0, modulus.length);
115: }
116:
117: /**
118: * Returns TLV structure that represents private key.
119: * @param algorithmId RSA algorithm identifier for this WIM
120: * @return TLV structure that represents private key
121: */
122: TLV getPrivate(byte algorithmId) {
123:
124: TLV prk = TLV.createSequence();
125:
126: TLV t = TLV.createSequence(); // common object attributes
127: prk.setChild(t);
128:
129: t
130: .setChild(Utils.createLabel(label))
131: .setNext(
132: new TLV(TLV.BITSTRING_TYPE, Utils
133: .shortToBytes(0x0780)))
134: .setNext(
135: TLV
136: .createOctetString(new byte[] { (byte) pinId }));
137:
138: t = t.setNext(TLV.createSequence()); // common key attributes
139:
140: t.setChild(TLV.createOctetString(hash)).setNext(
141: new TLV(TLV.BITSTRING_TYPE,
142: nonRepudiation ? new byte[] { 6, 00, 0x40 }
143: : new byte[] { 6, 0x20, 0x00 }))
144: .setNext(TLV.createInteger(id));
145:
146: t.setNext(new TLV(0xa1)). // private RSA key attrs
147: setChild(TLV.createSequence()).setChild(
148: Utils.createPath(PrivatePath)).setNext(
149: TLV.createInteger(keyLen)).setNext(
150: TLV.createInteger(algorithmId));
151:
152: return prk;
153: }
154:
155: /**
156: * Returns TLV structure that represents public key.
157: * @return TLV structure that represents private key
158: */
159: TLV getPublic() {
160:
161: TLV puk = TLV.createSequence();
162: TLV t = TLV.createSequence(); // common object attributes
163: puk.setChild(t);
164:
165: t = t.setNext(TLV.createSequence()); // common key attributes
166: t.setChild(TLV.createOctetString(hash))
167: .setNext(
168: new TLV(TLV.BITSTRING_TYPE, Utils
169: .shortToBytes(0x0102))).setNext(
170: new TLV(TLV.BOOLEAN_TYPE, new byte[] { 0 }));
171:
172: t.setNext(new TLV(0xa1)). // public RSA key attrs
173: setChild(TLV.createSequence()).setChild(
174: Utils.createPath(PublicPath)).setNext(
175: TLV.createInteger(keyLen));
176:
177: return puk;
178: }
179: }
|