001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS,
013: * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014: * See the License for the specific language governing permissions and
015: * limitations under the License.
016: */
017:
018: /**
019: * @author Alexander Y. Kleymenov
020: * @version $Revision$
021: */package javax.crypto.spec;
022:
023: import java.io.Serializable;
024: import java.security.spec.KeySpec;
025: import java.util.Arrays;
026: import javax.crypto.SecretKey;
027:
028: import org.apache.harmony.crypto.internal.nls.Messages;
029:
030: /**
031: * @com.intel.drl.spec_ref
032: */
033: public class SecretKeySpec implements SecretKey, KeySpec, Serializable {
034:
035: // The 5.0 spec. doesn't declare this serialVersionUID field
036: // In order to be compatible it is explicitly declared here
037: // for details see HARMONY-233
038: private static final long serialVersionUID = 6577238317307289933L;
039:
040: private final byte[] key;
041: private final String algorithm;
042: private final String format = "RAW"; //$NON-NLS-1$
043:
044: /**
045: * @com.intel.drl.spec_ref
046: */
047: public SecretKeySpec(byte[] key, String algorithm) {
048: if (key == null) {
049: throw new IllegalArgumentException(Messages
050: .getString("crypto.05")); //$NON-NLS-1$
051: }
052: if (key.length == 0) {
053: throw new IllegalArgumentException(Messages
054: .getString("crypto.35")); //$NON-NLS-1$
055: }
056: if (algorithm == null) {
057: throw new IllegalArgumentException(Messages
058: .getString("crypto.02")); //$NON-NLS-1$
059: }
060:
061: this .algorithm = algorithm;
062: this .key = new byte[key.length];
063: System.arraycopy(key, 0, this .key, 0, key.length);
064: }
065:
066: /**
067: * @com.intel.drl.spec_ref
068: */
069: public SecretKeySpec(byte[] key, int offset, int len,
070: String algorithm) {
071: if (key == null) {
072: throw new IllegalArgumentException(Messages
073: .getString("crypto.05")); //$NON-NLS-1$
074: }
075: if (key.length == 0) {
076: throw new IllegalArgumentException(Messages
077: .getString("crypto.35")); //$NON-NLS-1$
078: }
079: if (len < 0) {
080: throw new ArrayIndexOutOfBoundsException(Messages
081: .getString("crypto.36")); //$NON-NLS-1$
082: }
083: if ((key.length - offset < len)) {
084: throw new IllegalArgumentException(Messages
085: .getString("crypto.37")); //$NON-NLS-1$
086: }
087: if (algorithm == null) {
088: throw new IllegalArgumentException(Messages
089: .getString("crypto.02")); //$NON-NLS-1$
090: }
091: this .algorithm = algorithm;
092: this .key = new byte[len];
093: System.arraycopy(key, offset, this .key, 0, len);
094: }
095:
096: /**
097: * @com.intel.drl.spec_ref
098: */
099: public String getAlgorithm() {
100: return algorithm;
101: }
102:
103: /**
104: * @com.intel.drl.spec_ref
105: */
106: public String getFormat() {
107: return format;
108: }
109:
110: /**
111: * @com.intel.drl.spec_ref
112: */
113: public byte[] getEncoded() {
114: byte[] result = new byte[key.length];
115: System.arraycopy(key, 0, result, 0, key.length);
116: return result;
117: }
118:
119: /**
120: * @com.intel.drl.spec_ref
121: */
122: @Override
123: public int hashCode() {
124: int result = algorithm.length();
125: for (byte element : key) {
126: result += element;
127: }
128: return result;
129: }
130:
131: /**
132: * @com.intel.drl.spec_ref
133: */
134: @Override
135: public boolean equals(Object obj) {
136: if (obj == this ) {
137: return true;
138: }
139: if (!(obj instanceof SecretKeySpec)) {
140: return false;
141: }
142: SecretKeySpec ks = (SecretKeySpec) obj;
143: return (algorithm.equalsIgnoreCase(ks.algorithm))
144: && (Arrays.equals(key, ks.key));
145: }
146: }
|