Frames | No Frames |
1: /* BlockCipherParameters.java -- 2: Copyright (C) 2002, 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.jce.params; 40: 41: import gnu.java.security.Configuration; 42: import gnu.javax.crypto.jce.spec.BlockCipherParameterSpec; 43: 44: import java.io.IOException; 45: import java.math.BigInteger; 46: 47: import java.security.AlgorithmParametersSpi; 48: import java.security.spec.AlgorithmParameterSpec; 49: import java.security.spec.InvalidParameterSpecException; 50: import java.util.logging.Logger; 51: 52: import javax.crypto.spec.IvParameterSpec; 53: 54: /** 55: * An implementation of algorithm parameters for the GNU block ciphers. This 56: * encompasses the cipher's block size, its key size, and an optional 57: * initialization vector (IV). 58: */ 59: public class BlockCipherParameters 60: extends AlgorithmParametersSpi 61: { 62: private static final Logger log = Logger.getLogger(BlockCipherParameters.class.getName()); 63: /** The underlying block cipher specification. */ 64: protected BlockCipherParameterSpec cipherSpec; 65: private static final String DEFAULT_FORMAT = "ASN.1"; 66: 67: /** 68: * Return these parameters encoded in ASN.1 (DER). 69: * <p> 70: * For GNU block ciphers we will define these parameters as 71: * <pre> 72: * BlockCipherParameters ::= SEQUENCE { 73: * blockSize INTEGER, 74: * keySize INTEGER, 75: * initializationVector OCTET STRING OPTIONAL } 76: * </pre> 77: * 78: * @return The parameters, encoded an an ASN.1 DER sequence. 79: * @throws java.io.IOException If encoding these parameters fails. 80: */ 81: protected byte[] engineGetEncoded() throws IOException 82: { 83: return engineGetEncoded(DEFAULT_FORMAT); 84: } 85: 86: protected byte[] engineGetEncoded(String format) throws IOException 87: { 88: if (! format.equalsIgnoreCase(DEFAULT_FORMAT) 89: && ! format.equalsIgnoreCase("asn1")) 90: throw new IOException("unknown format \"" + format + "\""); 91: DERWriter writer = new DERWriter(); 92: int cipherBlockSize = cipherSpec.getBlockSize(); 93: int cipherKeySize = cipherSpec.getKeySize(); 94: byte[] iv = cipherSpec.getIV(); 95: return writer.joinarrays( 96: writer.writeBigInteger(BigInteger.valueOf(cipherBlockSize)), 97: writer.writeBigInteger(BigInteger.valueOf(cipherKeySize)), 98: (iv != null) ? writer.writeBigInteger(new BigInteger(iv)) 99: : new byte[0]); 100: } 101: 102: protected void engineInit(AlgorithmParameterSpec spec) 103: throws InvalidParameterSpecException 104: { 105: if (spec instanceof BlockCipherParameterSpec) 106: cipherSpec = (BlockCipherParameterSpec) spec; 107: else 108: throw new InvalidParameterSpecException(); 109: } 110: 111: protected void engineInit(byte[] encoded, String format) throws IOException 112: { 113: if (! format.equalsIgnoreCase(DEFAULT_FORMAT) 114: && ! format.equalsIgnoreCase("ASN1")) 115: throw new IOException("invalid format: only accepts ASN.1"); 116: engineInit(encoded); 117: } 118: 119: protected void engineInit(byte[] encoded) throws IOException 120: { 121: DERReader reader = new DERReader(encoded); 122: int bs = reader.getBigInteger().intValue(); 123: int ks = reader.getBigInteger().intValue(); 124: byte[] iv = null; 125: if (reader.hasMorePrimitives()) 126: iv = reader.getBigInteger().toByteArray(); 127: cipherSpec = new BlockCipherParameterSpec(iv, bs, ks); 128: if (Configuration.DEBUG) 129: log.fine("cipherSpec: " + cipherSpec); 130: } 131: 132: protected AlgorithmParameterSpec engineGetParameterSpec(Class c) 133: throws InvalidParameterSpecException 134: { 135: if (c.isInstance(cipherSpec)) 136: return cipherSpec; 137: if (IvParameterSpec.class.isAssignableFrom(c)) 138: { 139: IvParameterSpec result = new IvParameterSpec(cipherSpec.getIV()); 140: return result; 141: } 142: throw new InvalidParameterSpecException(); 143: } 144: 145: protected String engineToString() 146: { 147: return cipherSpec.toString(); 148: } 149: }