| Frames | No Frames |
1: /* BlockCipherParameters.java -- 2: Copyright (C) 2002, 2003, 2006, 2010 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 = Configuration.DEBUG ? 63: Logger.getLogger(BlockCipherParameters.class.getName()) : null; 64: /** The underlying block cipher specification. */ 65: protected BlockCipherParameterSpec cipherSpec; 66: private static final String DEFAULT_FORMAT = "ASN.1"; 67: 68: /** 69: * Return these parameters encoded in ASN.1 (DER). 70: * <p> 71: * For GNU block ciphers we will define these parameters as 72: * <pre> 73: * BlockCipherParameters ::= SEQUENCE { 74: * blockSize INTEGER, 75: * keySize INTEGER, 76: * initializationVector OCTET STRING OPTIONAL } 77: * </pre> 78: * 79: * @return The parameters, encoded an an ASN.1 DER sequence. 80: * @throws java.io.IOException If encoding these parameters fails. 81: */ 82: protected byte[] engineGetEncoded() throws IOException 83: { 84: return engineGetEncoded(DEFAULT_FORMAT); 85: } 86: 87: protected byte[] engineGetEncoded(String format) throws IOException 88: { 89: if (! format.equalsIgnoreCase(DEFAULT_FORMAT) 90: && ! format.equalsIgnoreCase("asn1")) 91: throw new IOException("unknown format \"" + format + "\""); 92: DERWriter writer = new DERWriter(); 93: int cipherBlockSize = cipherSpec.getBlockSize(); 94: int cipherKeySize = cipherSpec.getKeySize(); 95: byte[] iv = cipherSpec.getIV(); 96: return writer.joinarrays( 97: writer.writeBigInteger(BigInteger.valueOf(cipherBlockSize)), 98: writer.writeBigInteger(BigInteger.valueOf(cipherKeySize)), 99: (iv != null) ? writer.writeBigInteger(new BigInteger(iv)) 100: : new byte[0]); 101: } 102: 103: protected void engineInit(AlgorithmParameterSpec spec) 104: throws InvalidParameterSpecException 105: { 106: if (spec instanceof BlockCipherParameterSpec) 107: cipherSpec = (BlockCipherParameterSpec) spec; 108: else 109: throw new InvalidParameterSpecException(); 110: } 111: 112: protected void engineInit(byte[] encoded, String format) throws IOException 113: { 114: if (! format.equalsIgnoreCase(DEFAULT_FORMAT) 115: && ! format.equalsIgnoreCase("ASN1")) 116: throw new IOException("invalid format: only accepts ASN.1"); 117: engineInit(encoded); 118: } 119: 120: protected void engineInit(byte[] encoded) throws IOException 121: { 122: DERReader reader = new DERReader(encoded); 123: int bs = reader.getBigInteger().intValue(); 124: int ks = reader.getBigInteger().intValue(); 125: byte[] iv = null; 126: if (reader.hasMorePrimitives()) 127: iv = reader.getBigInteger().toByteArray(); 128: cipherSpec = new BlockCipherParameterSpec(iv, bs, ks); 129: if (Configuration.DEBUG) 130: log.fine("cipherSpec: " + cipherSpec); 131: } 132: 133: protected AlgorithmParameterSpec engineGetParameterSpec(Class c) 134: throws InvalidParameterSpecException 135: { 136: if (c.isInstance(cipherSpec)) 137: return cipherSpec; 138: if (IvParameterSpec.class.isAssignableFrom(c)) 139: { 140: IvParameterSpec result = new IvParameterSpec(cipherSpec.getIV()); 141: return result; 142: } 143: throw new InvalidParameterSpecException(); 144: } 145: 146: protected String engineToString() 147: { 148: return cipherSpec.toString(); 149: } 150: }