1 /* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 /** 19 * @author Boris V. Kuznetsov 20 * @version $Revision$ 21 */ 22 23 package org.apache.harmony.crypto.internal; 24 25 import java.nio.ByteBuffer; 26 import java.security.AlgorithmParameters; 27 import java.security.InvalidAlgorithmParameterException; 28 import java.security.InvalidKeyException; 29 import java.security.Key; 30 import java.security.NoSuchAlgorithmException; 31 import java.security.SecureRandom; 32 import java.security.spec.AlgorithmParameterSpec; 33 import javax.crypto.BadPaddingException; 34 import javax.crypto.CipherSpi; 35 import javax.crypto.IllegalBlockSizeException; 36 import javax.crypto.NoSuchPaddingException; 37 import javax.crypto.ShortBufferException; 38 39 /** 40 * CipherSpi implementation for javax.crypto.NullCipher 41 * 42 */ 43 public class NullCipherSpi extends CipherSpi { 44 45 @Override 46 public void engineSetMode(String arg0) throws NoSuchAlgorithmException { 47 // Do nothing 48 } 49 50 @Override 51 public void engineSetPadding(String arg0) throws NoSuchPaddingException { 52 // Do nothing 53 } 54 55 @Override 56 public int engineGetBlockSize() { 57 return 1; 58 } 59 60 @Override 61 public int engineGetOutputSize(int inputLen) { 62 return inputLen; 63 } 64 65 @Override 66 public byte[] engineGetIV() { 67 return new byte[8]; // compatible with RI 68 } 69 70 @Override 71 public AlgorithmParameters engineGetParameters() { 72 return null; 73 } 74 75 @Override 76 public void engineInit(int opmode, Key key, SecureRandom random) 77 throws InvalidKeyException { 78 // Do nothing 79 } 80 81 @Override 82 public void engineInit(int opmode, Key key, AlgorithmParameterSpec params, 83 SecureRandom random) throws InvalidKeyException, 84 InvalidAlgorithmParameterException { 85 // Do nothing 86 } 87 88 @Override 89 public void engineInit(int opmode, Key key, AlgorithmParameters params, 90 SecureRandom random) throws InvalidKeyException, 91 InvalidAlgorithmParameterException { 92 // Do nothing 93 } 94 95 @Override 96 public byte[] engineUpdate(byte[] input, int inputOffset, int inputLen) { 97 if (input == null) { 98 return null; 99 } 100 byte[] result = new byte[inputLen]; 101 System.arraycopy(input, inputOffset, result, 0, inputLen); 102 return result; 103 } 104 105 @Override 106 public int engineUpdate(byte[] input, int inputOffset, int inputLen, 107 byte[] output, int outputOffset) throws ShortBufferException { 108 if (input == null) { 109 return 0; 110 } 111 System.arraycopy(input, inputOffset, output, outputOffset, inputLen); 112 return inputLen; 113 } 114 115 @Override 116 public int engineUpdate(ByteBuffer input, ByteBuffer output) 117 throws ShortBufferException { 118 if (input == null) { 119 throw new NullPointerException("input == null"); 120 } else if (output == null) { 121 throw new NullPointerException("output == null"); 122 } 123 int result = input.limit() - input.position(); 124 try { 125 output.put(input); 126 } catch (java.nio.BufferOverflowException e) { 127 throw new ShortBufferException("output buffer too small"); 128 } 129 return result; 130 } 131 132 @Override 133 public byte[] engineDoFinal(byte[] input, int inputOffset, int inputLen) 134 throws IllegalBlockSizeException, BadPaddingException { 135 if (input == null) { 136 return null; 137 } 138 return engineUpdate(input, inputOffset, inputLen); 139 } 140 141 @Override 142 public int engineDoFinal(byte[] input, int inputOffset, int inputLen, 143 byte[] output, int outputOffset) throws ShortBufferException, 144 IllegalBlockSizeException, BadPaddingException { 145 int result = engineUpdate(input, inputOffset, inputLen, output, 146 outputOffset); 147 return result; 148 } 149 150 @Override 151 public int engineDoFinal(ByteBuffer input, ByteBuffer output) 152 throws ShortBufferException, IllegalBlockSizeException, 153 BadPaddingException { 154 return engineUpdate(input, output); 155 } 156 157 @Override 158 public byte[] engineWrap(Key key) throws IllegalBlockSizeException, InvalidKeyException { 159 throw new UnsupportedOperationException(); 160 } 161 162 @Override 163 public Key engineUnwrap(byte[] wrappedKey, String wrappedKeyAlgorithm, 164 int wrappedKeyType) throws InvalidKeyException, 165 NoSuchAlgorithmException { 166 throw new UnsupportedOperationException(); 167 } 168 169 @Override 170 public int engineGetKeySize(Key key) throws InvalidKeyException { 171 throw new UnsupportedOperationException(); 172 } 173 } 174
