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 com.sun.midp.crypto;
028:
029: /**
030: * Implements RSAKey with methods to set and get RSA exponent
031: * and modulus.
032: */
033: class RSAKey implements Key {
034: /** Local variable to hold the exponent. */
035: byte[] exp = null;
036:
037: /**
038: * The number of bytes allocated to the modulus
039: * is always a multiple of 8.
040: */
041: byte[] mod = null;
042:
043: /**
044: * Constructor for RSA public key.
045: *
046: * @param modulus modulus of key to process
047: * @param modOffset offset of the modulus
048: * @param modLen length of modulus in bytes
049: * @param exponent exponent the key
050: * @param expOffset offset of the exponent
051: * @param expLen length of the exponent in bytes
052: */
053: RSAKey(byte[] modulus, int modOffset, int modLen, byte[] exponent,
054: int expOffset, int expLen) {
055: setModulus(modulus, modOffset, modLen);
056: setExponent(exponent, expOffset, expLen);
057: }
058:
059: /**
060: * Compare the current key as a RSA private key.
061: * @param k the key to compare
062: * @return true if the kesy are the same.
063: */
064: public boolean equals(RSAPrivateKey k) {
065: return equals((RSAKey) k);
066: }
067:
068: /**
069: * Compare the current key as a RSA public key.
070: * @param k the key to compare
071: * @return true if the keys are the same.
072: */
073: public boolean equals(RSAPublicKey k) {
074: return equals((RSAKey) k);
075: }
076:
077: /**
078: * Compare the current key as a generic RSA key.
079: * @param k the key to compare
080: * @return true if the keys are the same.
081: */
082: public boolean equals(RSAKey k) {
083: byte[] kexp = new byte[exp.length];
084: byte[] kmod = new byte[mod.length];
085:
086: if (this .getClass() != k.getClass())
087: return false;
088: if (k.getExponent(kexp, (short) 0) != exp.length)
089: return false;
090: if (k.getModulus(kmod, (short) 0) != mod.length)
091: return false;
092: for (int i = 0; i < exp.length; i++)
093: if (kexp[i] != exp[i])
094: return false;
095: for (int i = 0; i < mod.length; i++)
096: if (kmod[i] != mod[i])
097: return false;
098: return true;
099: }
100:
101: /**
102: * Gets the type of the current key.
103: * @return the type of the key
104: */
105: public String getAlgorithm() {
106: return "RSA";
107: }
108:
109: /**
110: * Returns the name of the encoding format for this key.
111: *
112: * @return the string "RAW".
113: */
114: public String getFormat() {
115: return "RAW";
116: }
117:
118: /**
119: * Returns the encoding of key.
120: *
121: * @return null because there is no encoding
122: */
123: public byte[] getEncoded() {
124: return null;
125: }
126:
127: // The next four are for RSA public/private keys
128: /**
129: * Get the exponent for the key.
130: * @param buf output buffer to hold the exponent
131: * @param off offset in the buffer to copy the exponent
132: * @return length of the data copied
133: */
134: public short getExponent(byte[] buf, short off) {
135: if (off + exp.length > buf.length)
136: return 0;
137:
138: System.arraycopy(exp, 0, buf, off, exp.length);
139: return ((short) exp.length);
140: }
141:
142: /**
143: * Get the length of modulus for the key.
144: *
145: * @return length of the modulus in bytes
146: */
147: public int getModulusLen() {
148: return mod.length;
149: }
150:
151: /**
152: * Get the modulus for the key.
153: * @param buf output buffer to hold the modulus
154: * @param off offset in the buffer to copy the modulus
155: * @return length of the data copied
156: * @see #setModulus
157: */
158: public short getModulus(byte[] buf, short off) {
159: if (off + mod.length > buf.length)
160: return ((short) 0);
161: System.arraycopy(mod, 0, buf, off, mod.length);
162: return ((short) mod.length);
163: }
164:
165: /**
166: * Set the exponent for the key.
167: * @param buf input buffer which hold the exponent
168: * @param off offset in the buffer
169: * @param len length of the data to be copied
170: * @see #getExponent
171: * @exception IllegalArgumentException if exponent is too large
172: */
173: private void setExponent(byte[] buf, int off, int len) {
174: exp = new byte[len];
175: System.arraycopy(buf, off, exp, 0, len);
176: }
177:
178: /**
179: * Set the modulus for the key.
180: * @param buf input buffer which hold the modulus
181: * @param off offset in the buffer
182: * @param len length of the data to be copied in bytes
183: * @see #getModulus
184: */
185: private void setModulus(byte[] buf, int off, int len) {
186: // move modulus len out to a multiple of 64 bits (8 bytes)
187: len = (len + 7) / 8 * 8;
188:
189: mod = new byte[len];
190: System.arraycopy(buf, off, mod, 0, len);
191: }
192:
193: /**
194: * Convert the key to a readable string.
195: * @return string representation of key
196: */
197: public String toString() {
198: return ("[" + (getModulusLen() * 8) + "-bit RSA key"
199: + ", Exponent: 0x" + Util.hexEncode(exp)
200: + ", Modulus: 0x" + Util.hexEncode(mod) + "]");
201: }
202: }
|