http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/CryptoOutputStream.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/CryptoOutputStream.java b/src/main/java/org/apache/commons/crypto/stream/CryptoOutputStream.java deleted file mode 100644 index 3d3ac8d..0000000 --- a/src/main/java/org/apache/commons/crypto/stream/CryptoOutputStream.java +++ /dev/null @@ -1,283 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package org.apache.commons.crypto.stream; - -import java.io.IOException; -import java.io.OutputStream; -import java.nio.ByteBuffer; -import java.nio.channels.WritableByteChannel; -import java.security.InvalidAlgorithmParameterException; -import java.security.InvalidKeyException; -import java.util.Properties; - -import javax.crypto.BadPaddingException; -import javax.crypto.IllegalBlockSizeException; -import javax.crypto.ShortBufferException; - -import org.apache.commons.crypto.cipher.Cipher; -import org.apache.commons.crypto.cipher.CipherTransformation; -import org.apache.commons.crypto.stream.output.ChannelOutput; -import org.apache.commons.crypto.stream.output.Output; -import org.apache.commons.crypto.stream.output.StreamOutput; -import org.apache.commons.crypto.utils.Utils; - -/** - * CryptoOutputStream encrypts data and writes to the under layer output. It supports - * any mode of operations such as AES CBC/CTR/GCM mode in concept. It is not thread-safe. - */ - -public class CryptoOutputStream extends OutputStream implements - WritableByteChannel { - private final byte[] oneByteBuf = new byte[1]; - - protected Output output; - protected final Cipher cipher; - protected final int bufferSize; - - protected final byte[] key; - protected final byte[] initIV; - protected byte[] iv; - - protected boolean closed; - - /** - * Input data buffer. The data starts at inBuffer.position() and ends at - * inBuffer.limit(). - */ - protected ByteBuffer inBuffer; - - /** - * Encrypted data buffer. The data starts at outBuffer.position() and ends at - * outBuffer.limit(); - */ - protected ByteBuffer outBuffer; - - public CryptoOutputStream(CipherTransformation transformation, - Properties props, OutputStream out, byte[] key, byte[] iv) - throws IOException { - this(out, Utils.getCipherInstance(transformation, props), - Utils.getBufferSize(props), key, iv); - } - - public CryptoOutputStream(CipherTransformation transformation, - Properties props, WritableByteChannel out, byte[] key, byte[] iv) - throws IOException { - this(out, Utils.getCipherInstance(transformation, props), - Utils.getBufferSize(props), key, iv); - } - - public CryptoOutputStream(OutputStream out, Cipher cipher, - int bufferSize, byte[] key, byte[] iv) throws IOException { - this(new StreamOutput(out, bufferSize), cipher, bufferSize, key, iv); - } - - public CryptoOutputStream(WritableByteChannel channel, Cipher cipher, - int bufferSize, byte[] key, byte[] iv) throws IOException { - this(new ChannelOutput(channel), cipher, bufferSize, key, iv); - } - - protected CryptoOutputStream(Output output, Cipher cipher, - int bufferSize, byte[] key, byte[] iv) - throws IOException { - - this.output = output; - this.bufferSize = Utils.checkBufferSize(cipher, bufferSize); - this.cipher = cipher; - this.key = key.clone(); - this.initIV = iv.clone(); - this.iv = iv.clone(); - inBuffer = ByteBuffer.allocateDirect(this.bufferSize); - outBuffer = ByteBuffer.allocateDirect(this.bufferSize + - cipher.getTransformation().getAlgorithmBlockSize()); - - initCipher(); - } - - @Override - public void write(int b) throws IOException { - oneByteBuf[0] = (byte)(b & 0xff); - write(oneByteBuf, 0, oneByteBuf.length); - } - - /** - * Encryption is buffer based. - * If there is enough room in {@link #inBuffer}, then write to this buffer. - * If {@link #inBuffer} is full, then do encryption and write data to the - * underlying stream. - * @param b the data. - * @param off the start offset in the data. - * @param len the number of bytes to write. - * @throws IOException - */ - public void write(byte[] b, int off, int len) throws IOException { - checkStream(); - if (b == null) { - throw new NullPointerException(); - } else if (off < 0 || len < 0 || off > b.length || - len > b.length - off) { - throw new IndexOutOfBoundsException(); - } - - while (len > 0) { - final int remaining = inBuffer.remaining(); - if (len < remaining) { - inBuffer.put(b, off, len); - len = 0; - } else { - inBuffer.put(b, off, remaining); - off += remaining; - len -= remaining; - encrypt(); - } - } - } - - /** - * To flush, we need to encrypt the data in the buffer and write to the - * underlying stream, then do the flush. - */ - @Override - public void flush() throws IOException { - checkStream(); - encrypt(); - output.flush(); - super.flush(); - } - - @Override - public void close() throws IOException { - if (closed) { - return; - } - - try { - encryptFinal(); - output.close(); - freeBuffers(); - cipher.close(); - super.close(); - } finally { - closed = true; - } - } - - @Override - public boolean isOpen() { - return !closed; - } - - @Override - public int write(ByteBuffer src) throws IOException { - checkStream(); - final int len = src.remaining(); - int remaining = len; - while (remaining > 0) { - final int space = inBuffer.remaining(); - if (remaining < space) { - inBuffer.put(src); - remaining = 0; - } else { - // to void copy twice, we set the limit to copy directly - final int oldLimit = src.limit(); - final int newLimit = src.position() + space; - src.limit(newLimit); - - inBuffer.put(src); - - // restore the old limit - src.limit(oldLimit); - - remaining -= space; - encrypt(); - } - } - - return len; - } - - /** Initialize the cipher. */ - protected void initCipher() - throws IOException { - try { - cipher.init(Cipher.ENCRYPT_MODE, key, iv); - } catch (InvalidKeyException e) { - throw new IOException(e); - } catch(InvalidAlgorithmParameterException e) { - throw new IOException(e); - } - } - - /** - * Do the encryption, input is {@link #inBuffer} and output is - * {@link #outBuffer}. - */ - protected void encrypt() throws IOException { - - inBuffer.flip(); - outBuffer.clear(); - - try { - cipher.update(inBuffer, outBuffer); - } catch (ShortBufferException e) { - throw new IOException(e); - } - - inBuffer.clear(); - outBuffer.flip(); - - // write to output - output.write(outBuffer); - } - - /** - * Do final encryption of the last data - */ - protected void encryptFinal() throws IOException { - inBuffer.flip(); - outBuffer.clear(); - - try { - cipher.doFinal(inBuffer, outBuffer); - } catch (ShortBufferException e) { - throw new IOException(e); - } catch (IllegalBlockSizeException e) { - throw new IOException(e); - } catch( BadPaddingException e) { - throw new IOException(e); - } - - inBuffer.clear(); - outBuffer.flip(); - - // write to output - output.write(outBuffer); - } - - protected void checkStream() throws IOException { - if (closed) { - throw new IOException("Stream closed"); - } - } - - /** Forcibly free the direct buffers. */ - protected void freeBuffers() { - Utils.freeDirectBuffer(inBuffer); - Utils.freeDirectBuffer(outBuffer); - } -}
http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/PositionedCipherInputStream.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/PositionedCipherInputStream.java b/src/main/java/org/apache/commons/crypto/stream/PositionedCipherInputStream.java new file mode 100644 index 0000000..c6a4169 --- /dev/null +++ b/src/main/java/org/apache/commons/crypto/stream/PositionedCipherInputStream.java @@ -0,0 +1,311 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.crypto.stream; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.security.GeneralSecurityException; +import java.security.InvalidAlgorithmParameterException; +import java.security.InvalidKeyException; +import java.util.Properties; +import java.util.Queue; +import java.util.concurrent.ConcurrentLinkedQueue; + +import javax.crypto.BadPaddingException; +import javax.crypto.IllegalBlockSizeException; +import javax.crypto.ShortBufferException; + +import org.apache.commons.crypto.cipher.Cipher; +import org.apache.commons.crypto.cipher.CipherFactory; +import org.apache.commons.crypto.stream.input.Input; +import org.apache.commons.crypto.utils.IOUtils; +import org.apache.commons.crypto.utils.Utils; + +import static org.apache.commons.crypto.cipher.CipherTransformation.AES_CTR_NOPADDING; + +/** + * PositionedCipherInputStream provides the capability to decrypt the stream starting + * at random position as well as provides the foundation for positioned read for + * decrypting. This needs a stream cipher mode such as AES CTR mode. + */ +public class PositionedCipherInputStream extends CTRCipherInputStream { + + /** + * DirectBuffer pool + */ + private final Queue<ByteBuffer> bufferPool = new + ConcurrentLinkedQueue<ByteBuffer>(); + + /** + * Cipher pool + */ + private final Queue<CipherState> cipherPool = new + ConcurrentLinkedQueue<CipherState>(); + + public PositionedCipherInputStream(Properties props, Input in, + byte[] key, byte[] iv, long streamOffset) throws IOException { + this(in, Utils.getCipherInstance(AES_CTR_NOPADDING, props), + Utils.getBufferSize(props), key, iv, streamOffset); + } + + public PositionedCipherInputStream( + Input input, + Cipher cipher, + int bufferSize, + byte[] key, + byte[] iv, + long streamOffset) throws IOException { + super(input, cipher, bufferSize, key, iv, streamOffset); + } + + /** + * Read upto the specified number of bytes from a given position + * within a stream and return the number of bytes read. This does not + * change the current offset of the stream, and is thread-safe. + */ + public int read(long position, byte[] buffer, int offset, int length) + throws IOException { + checkStream(); + final int n = input.read(position, buffer, offset, length); + if (n > 0) { + // This operation does not change the current offset of the file + decrypt(position, buffer, offset, n); + } + return n; + } + + /** + * Read the specified number of bytes from a given position within a stream. + * This does not change the current offset of the stream and is thread-safe. + */ + public void readFully(long position, byte[] buffer, int offset, int length) + throws IOException { + checkStream(); + IOUtils.readFully(input, position, buffer, offset, length); + if (length > 0) { + // This operation does not change the current offset of the file + decrypt(position, buffer, offset, length); + } + } + + public void readFully(long position, byte[] buffer) throws IOException { + readFully(position, buffer, 0, buffer.length); + } + + /** + * Decrypt length bytes in buffer starting at offset. Output is also put + * into buffer starting at offset. It is thread-safe. + */ + protected void decrypt(long position, byte[] buffer, int offset, int length) + throws IOException { + ByteBuffer inBuffer = getBuffer(); + ByteBuffer outBuffer = getBuffer(); + CipherState state = null; + try { + state = getCipherState(); + byte[] iv = getInitIV().clone(); + resetCipher(state, position, iv); + byte padding = getPadding(position); + inBuffer.position(padding); // Set proper position for input data. + + int n = 0; + while (n < length) { + int toDecrypt = Math.min(length - n, inBuffer.remaining()); + inBuffer.put(buffer, offset + n, toDecrypt); + + // Do decryption + decrypt(state, inBuffer, outBuffer, padding); + + outBuffer.get(buffer, offset + n, toDecrypt); + n += toDecrypt; + padding = postDecryption(state, inBuffer, position + n, iv); + } + } finally { + returnBuffer(inBuffer); + returnBuffer(outBuffer); + returnCipherState(state); + } + } + + /** + * Do the decryption using inBuffer as input and outBuffer as output. + * Upon return, inBuffer is cleared; the decrypted data starts at + * outBuffer.position() and ends at outBuffer.limit(); + */ + private void decrypt(CipherState state, ByteBuffer inBuffer, + ByteBuffer outBuffer, byte padding) throws IOException { + Utils.checkState(inBuffer.position() >= padding); + if(inBuffer.position() == padding) { + // There is no real data in inBuffer. + return; + } + inBuffer.flip(); + outBuffer.clear(); + decryptBuffer(state, inBuffer, outBuffer); + inBuffer.clear(); + outBuffer.flip(); + if (padding > 0) { + /* + * The plain text and cipher text have a 1:1 mapping, they start at the + * same position. + */ + outBuffer.position(padding); + } + } + + private void decryptBuffer(CipherState state, ByteBuffer inBuffer, ByteBuffer outBuffer) + throws IOException { + int inputSize = inBuffer.remaining(); + try { + int n = state.getCipher().update(inBuffer, outBuffer); + if (n < inputSize) { + /** + * Typically code will not get here. Cipher#update will consume all + * input data and put result in outBuffer. + * Cipher#doFinal will reset the cipher context. + */ + state.getCipher().doFinal(inBuffer, outBuffer); + state.reset(true); + } + } catch (ShortBufferException e) { + throw new IOException(e); + } catch (IllegalBlockSizeException e) { + throw new IOException(e); + } catch (BadPaddingException e) { + throw new IOException(e); + } + } + + /** + * This method is executed immediately after decryption. Check whether + * cipher should be updated and recalculate padding if needed. + */ + private byte postDecryption(CipherState state, ByteBuffer inBuffer, + long position, byte[] iv) throws IOException { + byte padding = 0; + if (state.isReset()) { + /* + * This code is generally not executed since the cipher usually + * maintains cipher context (e.g. the counter) internally. However, + * some implementations can't maintain context so a re-init is necessary + * after each decryption call. + */ + resetCipher(state, position, iv); + padding = getPadding(position); + inBuffer.position(padding); + } + return padding; + } + + /** Calculate the counter and iv, reset the cipher. */ + private void resetCipher(CipherState state, long position, byte[] iv) + throws IOException { + final long counter = getCounter(position); + Utils.calculateIV(getInitIV(), counter, iv); + try { + state.getCipher().init(Cipher.DECRYPT_MODE, getKey(), iv); + } catch (InvalidKeyException e) { + throw new IOException(e); + } catch (InvalidAlgorithmParameterException e) { + throw new IOException(e); + } + state.reset(false); + } + + /** Get Cipher from pool */ + private CipherState getCipherState() throws IOException { + CipherState state = cipherPool.poll(); + if (state == null) { + Cipher cipher; + try { + cipher = CipherFactory.getInstance(getCipher().getTransformation(), + getCipher().getProperties()); + } catch (GeneralSecurityException e) { + throw new IOException(e); + } + state = new CipherState(cipher); + } + + return state; + } + + /** Return Cipher to pool */ + private void returnCipherState(CipherState state) { + if (state != null) { + cipherPool.add(state); + } + } + + /** Get direct buffer from pool */ + private ByteBuffer getBuffer() { + ByteBuffer buffer = bufferPool.poll(); + if (buffer == null) { + buffer = ByteBuffer.allocateDirect(getBufferSize()); + } + + return buffer; + } + + /** Return direct buffer to pool */ + private void returnBuffer(ByteBuffer buf) { + if (buf != null) { + buf.clear(); + bufferPool.add(buf); + } + } + + @Override + public void close() throws IOException { + if (!isOpen()) { + return; + } + + cleanBufferPool(); + super.close(); + } + + /** Clean direct buffer pool */ + private void cleanBufferPool() { + ByteBuffer buf; + while ((buf = bufferPool.poll()) != null) { + Utils.freeDirectBuffer(buf); + } + } + + private class CipherState { + private Cipher cipher; + private boolean reset; + + public CipherState(Cipher cipher) { + this.cipher = cipher; + this.reset = false; + } + + public Cipher getCipher() { + return cipher; + } + + public boolean isReset() { + return reset; + } + + public void reset(boolean reset) { + this.reset = reset; + } + } +} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java b/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java deleted file mode 100644 index 160f6ee..0000000 --- a/src/main/java/org/apache/commons/crypto/stream/PositionedCryptoInputStream.java +++ /dev/null @@ -1,311 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.crypto.stream; - -import java.io.IOException; -import java.nio.ByteBuffer; -import java.security.GeneralSecurityException; -import java.security.InvalidAlgorithmParameterException; -import java.security.InvalidKeyException; -import java.util.Properties; -import java.util.Queue; -import java.util.concurrent.ConcurrentLinkedQueue; - -import javax.crypto.BadPaddingException; -import javax.crypto.IllegalBlockSizeException; -import javax.crypto.ShortBufferException; - -import org.apache.commons.crypto.cipher.Cipher; -import org.apache.commons.crypto.cipher.CipherFactory; -import org.apache.commons.crypto.stream.input.Input; -import org.apache.commons.crypto.utils.IOUtils; -import org.apache.commons.crypto.utils.Utils; - -import static org.apache.commons.crypto.cipher.CipherTransformation.AES_CTR_NOPADDING; - -/** - * PositionedCryptoInputStream provides the capability to decrypt the stream starting - * at random position as well as provides the foundation for positioned read for - * decrypting. This needs a stream cipher mode such as AES CTR mode. - */ -public class PositionedCryptoInputStream extends CTRCryptoInputStream { - - /** - * DirectBuffer pool - */ - private final Queue<ByteBuffer> bufferPool = new - ConcurrentLinkedQueue<ByteBuffer>(); - - /** - * Cipher pool - */ - private final Queue<CipherState> cipherPool = new - ConcurrentLinkedQueue<CipherState>(); - - public PositionedCryptoInputStream(Properties props, Input in, - byte[] key, byte[] iv, long streamOffset) throws IOException { - this(in, Utils.getCipherInstance(AES_CTR_NOPADDING, props), - Utils.getBufferSize(props), key, iv, streamOffset); - } - - public PositionedCryptoInputStream( - Input input, - Cipher cipher, - int bufferSize, - byte[] key, - byte[] iv, - long streamOffset) throws IOException { - super(input, cipher, bufferSize, key, iv, streamOffset); - } - - /** - * Read upto the specified number of bytes from a given position - * within a stream and return the number of bytes read. This does not - * change the current offset of the stream, and is thread-safe. - */ - public int read(long position, byte[] buffer, int offset, int length) - throws IOException { - checkStream(); - final int n = input.read(position, buffer, offset, length); - if (n > 0) { - // This operation does not change the current offset of the file - decrypt(position, buffer, offset, n); - } - return n; - } - - /** - * Read the specified number of bytes from a given position within a stream. - * This does not change the current offset of the stream and is thread-safe. - */ - public void readFully(long position, byte[] buffer, int offset, int length) - throws IOException { - checkStream(); - IOUtils.readFully(input, position, buffer, offset, length); - if (length > 0) { - // This operation does not change the current offset of the file - decrypt(position, buffer, offset, length); - } - } - - public void readFully(long position, byte[] buffer) throws IOException { - readFully(position, buffer, 0, buffer.length); - } - - /** - * Decrypt length bytes in buffer starting at offset. Output is also put - * into buffer starting at offset. It is thread-safe. - */ - protected void decrypt(long position, byte[] buffer, int offset, int length) - throws IOException { - ByteBuffer inBuffer = getBuffer(); - ByteBuffer outBuffer = getBuffer(); - CipherState state = null; - try { - state = getCipherState(); - byte[] iv = getInitIV().clone(); - resetCipher(state, position, iv); - byte padding = getPadding(position); - inBuffer.position(padding); // Set proper position for input data. - - int n = 0; - while (n < length) { - int toDecrypt = Math.min(length - n, inBuffer.remaining()); - inBuffer.put(buffer, offset + n, toDecrypt); - - // Do decryption - decrypt(state, inBuffer, outBuffer, padding); - - outBuffer.get(buffer, offset + n, toDecrypt); - n += toDecrypt; - padding = postDecryption(state, inBuffer, position + n, iv); - } - } finally { - returnBuffer(inBuffer); - returnBuffer(outBuffer); - returnCipherState(state); - } - } - - /** - * Do the decryption using inBuffer as input and outBuffer as output. - * Upon return, inBuffer is cleared; the decrypted data starts at - * outBuffer.position() and ends at outBuffer.limit(); - */ - private void decrypt(CipherState state, ByteBuffer inBuffer, - ByteBuffer outBuffer, byte padding) throws IOException { - Utils.checkState(inBuffer.position() >= padding); - if(inBuffer.position() == padding) { - // There is no real data in inBuffer. - return; - } - inBuffer.flip(); - outBuffer.clear(); - decryptBuffer(state, inBuffer, outBuffer); - inBuffer.clear(); - outBuffer.flip(); - if (padding > 0) { - /* - * The plain text and cipher text have a 1:1 mapping, they start at the - * same position. - */ - outBuffer.position(padding); - } - } - - private void decryptBuffer(CipherState state, ByteBuffer inBuffer, ByteBuffer outBuffer) - throws IOException { - int inputSize = inBuffer.remaining(); - try { - int n = state.getCipher().update(inBuffer, outBuffer); - if (n < inputSize) { - /** - * Typically code will not get here. Cipher#update will consume all - * input data and put result in outBuffer. - * Cipher#doFinal will reset the cipher context. - */ - state.getCipher().doFinal(inBuffer, outBuffer); - state.reset(true); - } - } catch (ShortBufferException e) { - throw new IOException(e); - } catch (IllegalBlockSizeException e) { - throw new IOException(e); - } catch (BadPaddingException e) { - throw new IOException(e); - } - } - - /** - * This method is executed immediately after decryption. Check whether - * cipher should be updated and recalculate padding if needed. - */ - private byte postDecryption(CipherState state, ByteBuffer inBuffer, - long position, byte[] iv) throws IOException { - byte padding = 0; - if (state.isReset()) { - /* - * This code is generally not executed since the cipher usually - * maintains cipher context (e.g. the counter) internally. However, - * some implementations can't maintain context so a re-init is necessary - * after each decryption call. - */ - resetCipher(state, position, iv); - padding = getPadding(position); - inBuffer.position(padding); - } - return padding; - } - - /** Calculate the counter and iv, reset the cipher. */ - private void resetCipher(CipherState state, long position, byte[] iv) - throws IOException { - final long counter = getCounter(position); - Utils.calculateIV(getInitIV(), counter, iv); - try { - state.getCipher().init(Cipher.DECRYPT_MODE, getKey(), iv); - } catch (InvalidKeyException e) { - throw new IOException(e); - } catch (InvalidAlgorithmParameterException e) { - throw new IOException(e); - } - state.reset(false); - } - - /** Get Cipher from pool */ - private CipherState getCipherState() throws IOException { - CipherState state = cipherPool.poll(); - if (state == null) { - Cipher cipher; - try { - cipher = CipherFactory.getInstance(getCipher().getTransformation(), - getCipher().getProperties()); - } catch (GeneralSecurityException e) { - throw new IOException(e); - } - state = new CipherState(cipher); - } - - return state; - } - - /** Return Cipher to pool */ - private void returnCipherState(CipherState state) { - if (state != null) { - cipherPool.add(state); - } - } - - /** Get direct buffer from pool */ - private ByteBuffer getBuffer() { - ByteBuffer buffer = bufferPool.poll(); - if (buffer == null) { - buffer = ByteBuffer.allocateDirect(getBufferSize()); - } - - return buffer; - } - - /** Return direct buffer to pool */ - private void returnBuffer(ByteBuffer buf) { - if (buf != null) { - buf.clear(); - bufferPool.add(buf); - } - } - - @Override - public void close() throws IOException { - if (!isOpen()) { - return; - } - - cleanBufferPool(); - super.close(); - } - - /** Clean direct buffer pool */ - private void cleanBufferPool() { - ByteBuffer buf; - while ((buf = bufferPool.poll()) != null) { - Utils.freeDirectBuffer(buf); - } - } - - private class CipherState { - private Cipher cipher; - private boolean reset; - - public CipherState(Cipher cipher) { - this.cipher = cipher; - this.reset = false; - } - - public Cipher getCipher() { - return cipher; - } - - public boolean isReset() { - return reset; - } - - public void reset(boolean reset) { - this.reset = reset; - } - } -} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java b/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java index ee24a0c..9aff624 100644 --- a/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java +++ b/src/main/java/org/apache/commons/crypto/stream/input/ChannelInput.java @@ -23,7 +23,7 @@ import java.nio.channels.ReadableByteChannel; /** * The ChannelInput class takes a <code>ReadableByteChannel</code> object and - * wraps it as <code>Input</code> object acceptable by <code>CryptoInputStream</code>. + * wraps it as <code>Input</code> object acceptable by <code>CipherInputStream</code>. */ public class ChannelInput implements Input { private static final int SKIP_BUFFER_SIZE = 2048; http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/input/Input.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/input/Input.java b/src/main/java/org/apache/commons/crypto/stream/input/Input.java index a63c6ca..2971edb 100644 --- a/src/main/java/org/apache/commons/crypto/stream/input/Input.java +++ b/src/main/java/org/apache/commons/crypto/stream/input/Input.java @@ -21,7 +21,7 @@ import java.io.IOException; import java.nio.ByteBuffer; /** - * The Input interface abstract the input source of <code>CryptoInputStream</code> so that + * The Input interface abstract the input source of <code>CipherInputStream</code> so that * different implementation of input can be used. The implementation Input interface will usually * wraps an input mechanism such as <code>InputStream</code> or <code>ReadableByteChannel</code>. */ http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java b/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java index ac3739b..c7e6771 100644 --- a/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java +++ b/src/main/java/org/apache/commons/crypto/stream/input/StreamInput.java @@ -23,7 +23,7 @@ import java.nio.ByteBuffer; /** * The StreamInput class takes a <code>InputStream</code> object and - * wraps it as <code>Input</code> object acceptable by <code>CryptoInputStream</code>. + * wraps it as <code>Input</code> object acceptable by <code>CipherInputStream</code>. */ public class StreamInput implements Input { private byte[] buf; http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java b/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java index bae82a8..0a60217 100644 --- a/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java +++ b/src/main/java/org/apache/commons/crypto/stream/output/ChannelOutput.java @@ -23,7 +23,7 @@ import java.nio.channels.WritableByteChannel; /** * The ChannelOutput class takes a <code>WritableByteChannel</code> object and wraps it as - * <code>Output</code> object acceptable by <code>CryptoOutputStream</code> as the output target. + * <code>Output</code> object acceptable by <code>CipherOutputStream</code> as the output target. */ public class ChannelOutput implements Output { http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/output/Output.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/output/Output.java b/src/main/java/org/apache/commons/crypto/stream/output/Output.java index 903fcea..c57a89e 100644 --- a/src/main/java/org/apache/commons/crypto/stream/output/Output.java +++ b/src/main/java/org/apache/commons/crypto/stream/output/Output.java @@ -21,7 +21,7 @@ import java.io.IOException; import java.nio.ByteBuffer; /** - * The Output interface abstract the output target of <code>CryptoOutputStream</code> so that + * The Output interface abstract the output target of <code>CipherOutputStream</code> so that * different implementation of output can be used. The implementation Output interface will usually * wraps an output mechanism such as <code>OutputStream</code> or <code>WritableByteChannel</code>. */ http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java ---------------------------------------------------------------------- diff --git a/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java b/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java index beead7f..ad067be 100644 --- a/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java +++ b/src/main/java/org/apache/commons/crypto/stream/output/StreamOutput.java @@ -23,7 +23,7 @@ import java.nio.ByteBuffer; /** * The StreamOutput class takes a <code>OutputStream</code> object and wraps it as - * <code>Output</code> object acceptable by <code>CryptoOutputStream</code> as the output target. + * <code>Output</code> object acceptable by <code>CipherOutputStream</code> as the output target. */ public class StreamOutput implements Output { private byte[] buf; http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/AbstractCipherStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/AbstractCipherStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/AbstractCipherStreamTest.java new file mode 100644 index 0000000..6e2d864 --- /dev/null +++ b/src/test/java/org/apache/commons/crypto/stream/AbstractCipherStreamTest.java @@ -0,0 +1,456 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.crypto.stream; + +import java.io.BufferedInputStream; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.DataInputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.nio.ByteBuffer; +import java.nio.channels.Channels; +import java.nio.channels.ReadableByteChannel; +import java.security.SecureRandom; +import java.util.Properties; +import java.util.Random; + +import org.apache.commons.crypto.cipher.Cipher; +import org.apache.commons.crypto.cipher.CipherTransformation; +import org.apache.commons.crypto.cipher.JceCipher; +import org.apache.commons.crypto.cipher.Openssl; +import org.apache.commons.crypto.cipher.OpensslCipher; +import org.apache.commons.crypto.utils.ReflectionUtils; +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.junit.Assert; +import org.junit.Before; +import org.junit.Test; + +public abstract class AbstractCipherStreamTest { + private static final Log LOG= LogFactory.getLog(AbstractCipherStreamTest.class); + + private final int dataLen = 20000; + private byte[] data = new byte[dataLen]; + private byte[] encData; + private Properties props = new Properties(); + protected byte[] key = new byte[16]; + private byte[] iv = new byte[16]; + private int count = 10000; + protected static int defaultBufferSize = 8192; + protected static int smallBufferSize = 1024; + + private final String jceCipherClass = JceCipher.class.getName(); + private final String opensslCipherClass = OpensslCipher.class.getName(); + protected CipherTransformation transformation; + + public abstract void setUp() throws IOException; + + @Before + public void before() throws IOException { + Random random = new SecureRandom(); + random.nextBytes(data); + random.nextBytes(key); + random.nextBytes(iv); + setUp(); + prepareData(); + } + + /** Test skip. */ + @Test(timeout=120000) + public void testSkip() throws Exception { + doSkipTest(jceCipherClass, false); + doSkipTest(opensslCipherClass, false); + + doSkipTest(jceCipherClass, true); + doSkipTest(opensslCipherClass, true); + } + + /** Test byte buffer read with different buffer size. */ + @Test(timeout=120000) + public void testByteBufferRead() throws Exception { + doByteBufferRead(jceCipherClass, false); + doByteBufferRead(opensslCipherClass, false); + + doByteBufferRead(jceCipherClass, true); + doByteBufferRead(opensslCipherClass, true); + } + + /** Test byte buffer write. */ + @Test(timeout=120000) + public void testByteBufferWrite() throws Exception { + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + doByteBufferWrite(jceCipherClass, baos, false); + doByteBufferWrite(opensslCipherClass, baos, false); + + doByteBufferWrite(jceCipherClass, baos, true); + doByteBufferWrite(opensslCipherClass, baos, true); + } + + private void doSkipTest(String cipherClass, boolean withChannel) throws IOException { + InputStream in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), defaultBufferSize, iv, withChannel); + byte[] result = new byte[dataLen]; + int n1 = readAll(in, result, 0, dataLen / 3); + + long skipped = in.skip(dataLen / 3); + int n2 = readAll(in, result, 0, dataLen); + + Assert.assertEquals(dataLen, n1 + skipped + n2); + byte[] readData = new byte[n2]; + System.arraycopy(result, 0, readData, 0, n2); + byte[] expectedData = new byte[n2]; + System.arraycopy(data, dataLen - n2, expectedData, 0, n2); + Assert.assertArrayEquals(readData, expectedData); + + try { + skipped = in.skip(-3); + Assert.fail("Skip Negative length should fail."); + } catch (IllegalArgumentException e) { + Assert.assertTrue(e.getMessage().contains("Negative skip length")); + } + + // Skip after EOF + skipped = in.skip(3); + Assert.assertEquals(skipped, 0); + + in.close(); + } + + private void doByteBufferRead(String cipherClass, boolean withChannel) throws Exception { + // Default buffer size, initial buffer position is 0 + InputStream in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), defaultBufferSize, iv, withChannel); + ByteBuffer buf = ByteBuffer.allocate(dataLen + 100); + byteBufferReadCheck(in, buf, 0); + in.close(); + + // Default buffer size, initial buffer position is not 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), defaultBufferSize, iv, withChannel); + buf.clear(); + byteBufferReadCheck(in, buf, 11); + in.close(); + + // Small buffer size, initial buffer position is 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), smallBufferSize, iv, withChannel); + buf.clear(); + byteBufferReadCheck(in, buf, 0); + in.close(); + + // Small buffer size, initial buffer position is not 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), smallBufferSize, iv, withChannel); + buf.clear(); + byteBufferReadCheck(in, buf, 11); + in.close(); + + // Direct buffer, default buffer size, initial buffer position is 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), defaultBufferSize, iv, withChannel); + buf = ByteBuffer.allocateDirect(dataLen + 100); + byteBufferReadCheck(in, buf, 0); + in.close(); + + // Direct buffer, default buffer size, initial buffer position is not 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), defaultBufferSize, iv, withChannel); + buf.clear(); + byteBufferReadCheck(in, buf, 11); + in.close(); + + // Direct buffer, small buffer size, initial buffer position is 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), smallBufferSize, iv, withChannel); + buf.clear(); + byteBufferReadCheck(in, buf, 0); + in.close(); + + // Direct buffer, small buffer size, initial buffer position is not 0 + in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), smallBufferSize, iv, withChannel); + buf.clear(); + byteBufferReadCheck(in, buf, 11); + in.close(); + } + + private void doByteBufferWrite(String cipherClass, ByteArrayOutputStream baos, + boolean withChannel) + throws Exception { + baos.reset(); + CipherOutputStream out = + getCipherOutputStream(baos, getCipher(cipherClass), defaultBufferSize, + iv, withChannel); + ByteBuffer buf = ByteBuffer.allocateDirect(dataLen / 2); + buf.put(data, 0, dataLen / 2); + buf.flip(); + int n1 = out.write(buf); + + buf.clear(); + buf.put(data, n1, dataLen / 3); + buf.flip(); + int n2 = out.write(buf); + + buf.clear(); + buf.put(data, n1 + n2, dataLen - n1 - n2); + buf.flip(); + int n3 = out.write(buf); + + Assert.assertEquals(dataLen, n1 + n2 + n3); + + out.flush(); + + InputStream in = getCipherInputStream(new ByteArrayInputStream(encData), + getCipher(cipherClass), defaultBufferSize, iv, withChannel); + buf = ByteBuffer.allocate(dataLen + 100); + byteBufferReadCheck(in, buf, 0); + in.close(); + } + + private void byteBufferReadCheck(InputStream in, ByteBuffer buf, + int bufPos) throws Exception { + buf.position(bufPos); + int n = ((ReadableByteChannel) in).read(buf); + Assert.assertEquals(bufPos + n, buf.position()); + byte[] readData = new byte[n]; + buf.rewind(); + buf.position(bufPos); + buf.get(readData); + byte[] expectedData = new byte[n]; + System.arraycopy(data, 0, expectedData, 0, n); + Assert.assertArrayEquals(readData, expectedData); + } + + private void prepareData() throws IOException { + Cipher cipher = null; + try { + cipher = (Cipher)ReflectionUtils.newInstance( + ReflectionUtils.getClassByName(jceCipherClass), props, transformation); + } catch (ClassNotFoundException cnfe) { + throw new IOException("Illegal crypto cipher!"); + } + + ByteArrayOutputStream baos = new ByteArrayOutputStream(); + OutputStream out = new CipherOutputStream(baos, cipher, defaultBufferSize, key, iv); + out.write(data); + out.flush(); + out.close(); + encData = baos.toByteArray(); + } + + protected CipherInputStream getCipherInputStream(ByteArrayInputStream bais, + Cipher cipher, + int bufferSize, byte[] iv, + boolean withChannel) throws + IOException { + if (withChannel) { + return new CipherInputStream(Channels.newChannel(bais), cipher, + bufferSize, key, iv); + } else { + return new CipherInputStream(bais, cipher, bufferSize, key, iv); + } + } + + protected CipherOutputStream getCipherOutputStream(ByteArrayOutputStream baos, + Cipher cipher, + int bufferSize, byte[] iv, + boolean withChannel) throws + IOException { + if (withChannel) { + return new CipherOutputStream(Channels.newChannel(baos), cipher, + bufferSize, key, iv); + } else { + return new CipherOutputStream(baos, cipher, bufferSize, key, iv); + } + } + + private int readAll(InputStream in, byte[] b, int offset, int len) + throws IOException { + int n = 0; + int total = 0; + while (n != -1) { + total += n; + if (total >= len) { + break; + } + n = in.read(b, offset + total, len - total); + } + + return total; + } + + protected Cipher getCipher(String cipherClass) throws IOException { + try { + return (Cipher)ReflectionUtils.newInstance( + ReflectionUtils.getClassByName(cipherClass), props, transformation); + } catch (ClassNotFoundException cnfe) { + throw new IOException("Illegal crypto cipher!"); + } + } + + @Test + public void testReadWrite() throws Exception { + Assert.assertEquals(null, Openssl.getLoadingFailureReason()); + doReadWriteTest(0, jceCipherClass, jceCipherClass, iv); + doReadWriteTest(0, opensslCipherClass, opensslCipherClass, iv); + doReadWriteTest(count, jceCipherClass, jceCipherClass, iv); + doReadWriteTest(count, opensslCipherClass, opensslCipherClass, iv); + doReadWriteTest(count, jceCipherClass, opensslCipherClass, iv); + doReadWriteTest(count, opensslCipherClass, jceCipherClass, iv); + // Overflow test, IV: xx xx xx xx xx xx xx xx ff ff ff ff ff ff ff ff + for(int i = 0; i < 8; i++) { + iv[8 + i] = (byte) 0xff; + } + doReadWriteTest(count, jceCipherClass, jceCipherClass, iv); + doReadWriteTest(count, opensslCipherClass, opensslCipherClass, iv); + doReadWriteTest(count, jceCipherClass, opensslCipherClass, iv); + doReadWriteTest(count, opensslCipherClass, jceCipherClass, iv); + } + + private void doReadWriteTest(int count, String encCipherClass, + String decCipherClass, byte[] iv) throws IOException { + doReadWriteTestForInputStream(count, encCipherClass, decCipherClass, iv); + doReadWriteTestForReadableByteChannel(count, encCipherClass, decCipherClass, + iv); + } + + private void doReadWriteTestForInputStream(int count, String encCipherClass, + String decCipherClass, byte[] iv) throws IOException { + Cipher encCipher = getCipher(encCipherClass); + LOG.debug("Created a cipher object of type: " + encCipherClass); + + // Generate data + SecureRandom random = new SecureRandom(); + byte[] originalData = new byte[count]; + byte[] decryptedData = new byte[count]; + random.nextBytes(originalData); + LOG.debug("Generated " + count + " records"); + + // Encrypt data + ByteArrayOutputStream encryptedData = new ByteArrayOutputStream(); + CipherOutputStream out = + getCipherOutputStream(encryptedData, encCipher, defaultBufferSize, iv, + false); + out.write(originalData, 0, originalData.length); + out.flush(); + out.close(); + LOG.debug("Finished encrypting data"); + + Cipher decCipher = getCipher(decCipherClass); + LOG.debug("Created a cipher object of type: " + decCipherClass); + + // Decrypt data + CipherInputStream in = getCipherInputStream( + new ByteArrayInputStream(encryptedData.toByteArray()), decCipher, + defaultBufferSize, iv, false); + + // Check + int remainingToRead = count; + int offset = 0; + while (remainingToRead > 0) { + int n = in.read(decryptedData, offset, decryptedData.length - offset); + if (n >=0) { + remainingToRead -= n; + offset += n; + } + } + + Assert.assertArrayEquals("originalData and decryptedData not equal", + originalData, decryptedData); + + // Decrypt data byte-at-a-time + in = getCipherInputStream( + new ByteArrayInputStream(encryptedData.toByteArray()), decCipher, + defaultBufferSize, iv, false); + + // Check + DataInputStream originalIn = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(originalData))); + int expected; + do { + expected = originalIn.read(); + Assert.assertEquals("Decrypted stream read by byte does not match", + expected, in.read()); + } while (expected != -1); + + LOG.debug("SUCCESS! Completed checking " + count + " records"); + } + + private void doReadWriteTestForReadableByteChannel(int count, + String encCipherClass, + String decCipherClass, + byte[] iv) throws IOException { + Cipher encCipher = getCipher(encCipherClass); + LOG.debug("Created a cipher object of type: " + encCipherClass); + + // Generate data + SecureRandom random = new SecureRandom(); + byte[] originalData = new byte[count]; + byte[] decryptedData = new byte[count]; + random.nextBytes(originalData); + LOG.debug("Generated " + count + " records"); + + // Encrypt data + ByteArrayOutputStream encryptedData = new ByteArrayOutputStream(); + CipherOutputStream out = + getCipherOutputStream(encryptedData, encCipher, defaultBufferSize, iv, + true); + out.write(originalData, 0, originalData.length); + out.flush(); + out.close(); + LOG.debug("Finished encrypting data"); + + Cipher decCipher = getCipher(decCipherClass); + LOG.debug("Created a cipher object of type: " + decCipherClass); + + // Decrypt data + CipherInputStream in = getCipherInputStream( + new ByteArrayInputStream(encryptedData.toByteArray()), decCipher, + defaultBufferSize, iv, true); + + // Check + int remainingToRead = count; + int offset = 0; + while (remainingToRead > 0) { + int n = in.read(decryptedData, offset, decryptedData.length - offset); + if (n >=0) { + remainingToRead -= n; + offset += n; + } + } + + Assert.assertArrayEquals("originalData and decryptedData not equal", + originalData, decryptedData); + + // Decrypt data byte-at-a-time + in = getCipherInputStream(new ByteArrayInputStream( + encryptedData.toByteArray()),decCipher,defaultBufferSize,iv,true); + + // Check + DataInputStream originalIn = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(originalData))); + int expected; + do { + expected = originalIn.read(); + Assert.assertEquals("Decrypted stream read by byte does not match", + expected, in.read()); + } while (expected != -1); + + LOG.debug("SUCCESS! Completed checking " + count + " records"); + } +} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/AbstractCryptoStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/AbstractCryptoStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/AbstractCryptoStreamTest.java deleted file mode 100644 index fe73f00..0000000 --- a/src/test/java/org/apache/commons/crypto/stream/AbstractCryptoStreamTest.java +++ /dev/null @@ -1,456 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.crypto.stream; - -import java.io.BufferedInputStream; -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.DataInputStream; -import java.io.IOException; -import java.io.InputStream; -import java.io.OutputStream; -import java.nio.ByteBuffer; -import java.nio.channels.Channels; -import java.nio.channels.ReadableByteChannel; -import java.security.SecureRandom; -import java.util.Properties; -import java.util.Random; - -import org.apache.commons.crypto.cipher.Cipher; -import org.apache.commons.crypto.cipher.CipherTransformation; -import org.apache.commons.crypto.cipher.JceCipher; -import org.apache.commons.crypto.cipher.Openssl; -import org.apache.commons.crypto.cipher.OpensslCipher; -import org.apache.commons.crypto.utils.ReflectionUtils; -import org.apache.commons.logging.Log; -import org.apache.commons.logging.LogFactory; -import org.junit.Assert; -import org.junit.Before; -import org.junit.Test; - -public abstract class AbstractCryptoStreamTest { - private static final Log LOG= LogFactory.getLog(AbstractCryptoStreamTest.class); - - private final int dataLen = 20000; - private byte[] data = new byte[dataLen]; - private byte[] encData; - private Properties props = new Properties(); - protected byte[] key = new byte[16]; - private byte[] iv = new byte[16]; - private int count = 10000; - protected static int defaultBufferSize = 8192; - protected static int smallBufferSize = 1024; - - private final String jceCipherClass = JceCipher.class.getName(); - private final String opensslCipherClass = OpensslCipher.class.getName(); - protected CipherTransformation transformation; - - public abstract void setUp() throws IOException; - - @Before - public void before() throws IOException { - Random random = new SecureRandom(); - random.nextBytes(data); - random.nextBytes(key); - random.nextBytes(iv); - setUp(); - prepareData(); - } - - /** Test skip. */ - @Test(timeout=120000) - public void testSkip() throws Exception { - doSkipTest(jceCipherClass, false); - doSkipTest(opensslCipherClass, false); - - doSkipTest(jceCipherClass, true); - doSkipTest(opensslCipherClass, true); - } - - /** Test byte buffer read with different buffer size. */ - @Test(timeout=120000) - public void testByteBufferRead() throws Exception { - doByteBufferRead(jceCipherClass, false); - doByteBufferRead(opensslCipherClass, false); - - doByteBufferRead(jceCipherClass, true); - doByteBufferRead(opensslCipherClass, true); - } - - /** Test byte buffer write. */ - @Test(timeout=120000) - public void testByteBufferWrite() throws Exception { - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - doByteBufferWrite(jceCipherClass, baos, false); - doByteBufferWrite(opensslCipherClass, baos, false); - - doByteBufferWrite(jceCipherClass, baos, true); - doByteBufferWrite(opensslCipherClass, baos, true); - } - - private void doSkipTest(String cipherClass, boolean withChannel) throws IOException { - InputStream in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), defaultBufferSize, iv, withChannel); - byte[] result = new byte[dataLen]; - int n1 = readAll(in, result, 0, dataLen / 3); - - long skipped = in.skip(dataLen / 3); - int n2 = readAll(in, result, 0, dataLen); - - Assert.assertEquals(dataLen, n1 + skipped + n2); - byte[] readData = new byte[n2]; - System.arraycopy(result, 0, readData, 0, n2); - byte[] expectedData = new byte[n2]; - System.arraycopy(data, dataLen - n2, expectedData, 0, n2); - Assert.assertArrayEquals(readData, expectedData); - - try { - skipped = in.skip(-3); - Assert.fail("Skip Negative length should fail."); - } catch (IllegalArgumentException e) { - Assert.assertTrue(e.getMessage().contains("Negative skip length")); - } - - // Skip after EOF - skipped = in.skip(3); - Assert.assertEquals(skipped, 0); - - in.close(); - } - - private void doByteBufferRead(String cipherClass, boolean withChannel) throws Exception { - // Default buffer size, initial buffer position is 0 - InputStream in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), defaultBufferSize, iv, withChannel); - ByteBuffer buf = ByteBuffer.allocate(dataLen + 100); - byteBufferReadCheck(in, buf, 0); - in.close(); - - // Default buffer size, initial buffer position is not 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), defaultBufferSize, iv, withChannel); - buf.clear(); - byteBufferReadCheck(in, buf, 11); - in.close(); - - // Small buffer size, initial buffer position is 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), smallBufferSize, iv, withChannel); - buf.clear(); - byteBufferReadCheck(in, buf, 0); - in.close(); - - // Small buffer size, initial buffer position is not 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), smallBufferSize, iv, withChannel); - buf.clear(); - byteBufferReadCheck(in, buf, 11); - in.close(); - - // Direct buffer, default buffer size, initial buffer position is 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), defaultBufferSize, iv, withChannel); - buf = ByteBuffer.allocateDirect(dataLen + 100); - byteBufferReadCheck(in, buf, 0); - in.close(); - - // Direct buffer, default buffer size, initial buffer position is not 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), defaultBufferSize, iv, withChannel); - buf.clear(); - byteBufferReadCheck(in, buf, 11); - in.close(); - - // Direct buffer, small buffer size, initial buffer position is 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), smallBufferSize, iv, withChannel); - buf.clear(); - byteBufferReadCheck(in, buf, 0); - in.close(); - - // Direct buffer, small buffer size, initial buffer position is not 0 - in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), smallBufferSize, iv, withChannel); - buf.clear(); - byteBufferReadCheck(in, buf, 11); - in.close(); - } - - private void doByteBufferWrite(String cipherClass, ByteArrayOutputStream baos, - boolean withChannel) - throws Exception { - baos.reset(); - CryptoOutputStream out = - getCryptoOutputStream(baos, getCipher(cipherClass), defaultBufferSize, - iv, withChannel); - ByteBuffer buf = ByteBuffer.allocateDirect(dataLen / 2); - buf.put(data, 0, dataLen / 2); - buf.flip(); - int n1 = out.write(buf); - - buf.clear(); - buf.put(data, n1, dataLen / 3); - buf.flip(); - int n2 = out.write(buf); - - buf.clear(); - buf.put(data, n1 + n2, dataLen - n1 - n2); - buf.flip(); - int n3 = out.write(buf); - - Assert.assertEquals(dataLen, n1 + n2 + n3); - - out.flush(); - - InputStream in = getCryptoInputStream(new ByteArrayInputStream(encData), - getCipher(cipherClass), defaultBufferSize, iv, withChannel); - buf = ByteBuffer.allocate(dataLen + 100); - byteBufferReadCheck(in, buf, 0); - in.close(); - } - - private void byteBufferReadCheck(InputStream in, ByteBuffer buf, - int bufPos) throws Exception { - buf.position(bufPos); - int n = ((ReadableByteChannel) in).read(buf); - Assert.assertEquals(bufPos + n, buf.position()); - byte[] readData = new byte[n]; - buf.rewind(); - buf.position(bufPos); - buf.get(readData); - byte[] expectedData = new byte[n]; - System.arraycopy(data, 0, expectedData, 0, n); - Assert.assertArrayEquals(readData, expectedData); - } - - private void prepareData() throws IOException { - Cipher cipher = null; - try { - cipher = (Cipher)ReflectionUtils.newInstance( - ReflectionUtils.getClassByName(jceCipherClass), props, transformation); - } catch (ClassNotFoundException cnfe) { - throw new IOException("Illegal crypto cipher!"); - } - - ByteArrayOutputStream baos = new ByteArrayOutputStream(); - OutputStream out = new CryptoOutputStream(baos, cipher, defaultBufferSize, key, iv); - out.write(data); - out.flush(); - out.close(); - encData = baos.toByteArray(); - } - - protected CryptoInputStream getCryptoInputStream(ByteArrayInputStream bais, - Cipher cipher, - int bufferSize, byte[] iv, - boolean withChannel) throws - IOException { - if (withChannel) { - return new CryptoInputStream(Channels.newChannel(bais), cipher, - bufferSize, key, iv); - } else { - return new CryptoInputStream(bais, cipher, bufferSize, key, iv); - } - } - - protected CryptoOutputStream getCryptoOutputStream(ByteArrayOutputStream baos, - Cipher cipher, - int bufferSize, byte[] iv, - boolean withChannel) throws - IOException { - if (withChannel) { - return new CryptoOutputStream(Channels.newChannel(baos), cipher, - bufferSize, key, iv); - } else { - return new CryptoOutputStream(baos, cipher, bufferSize, key, iv); - } - } - - private int readAll(InputStream in, byte[] b, int offset, int len) - throws IOException { - int n = 0; - int total = 0; - while (n != -1) { - total += n; - if (total >= len) { - break; - } - n = in.read(b, offset + total, len - total); - } - - return total; - } - - protected Cipher getCipher(String cipherClass) throws IOException { - try { - return (Cipher)ReflectionUtils.newInstance( - ReflectionUtils.getClassByName(cipherClass), props, transformation); - } catch (ClassNotFoundException cnfe) { - throw new IOException("Illegal crypto cipher!"); - } - } - - @Test - public void testReadWrite() throws Exception { - Assert.assertEquals(null, Openssl.getLoadingFailureReason()); - doReadWriteTest(0, jceCipherClass, jceCipherClass, iv); - doReadWriteTest(0, opensslCipherClass, opensslCipherClass, iv); - doReadWriteTest(count, jceCipherClass, jceCipherClass, iv); - doReadWriteTest(count, opensslCipherClass, opensslCipherClass, iv); - doReadWriteTest(count, jceCipherClass, opensslCipherClass, iv); - doReadWriteTest(count, opensslCipherClass, jceCipherClass, iv); - // Overflow test, IV: xx xx xx xx xx xx xx xx ff ff ff ff ff ff ff ff - for(int i = 0; i < 8; i++) { - iv[8 + i] = (byte) 0xff; - } - doReadWriteTest(count, jceCipherClass, jceCipherClass, iv); - doReadWriteTest(count, opensslCipherClass, opensslCipherClass, iv); - doReadWriteTest(count, jceCipherClass, opensslCipherClass, iv); - doReadWriteTest(count, opensslCipherClass, jceCipherClass, iv); - } - - private void doReadWriteTest(int count, String encCipherClass, - String decCipherClass, byte[] iv) throws IOException { - doReadWriteTestForInputStream(count, encCipherClass, decCipherClass, iv); - doReadWriteTestForReadableByteChannel(count, encCipherClass, decCipherClass, - iv); - } - - private void doReadWriteTestForInputStream(int count, String encCipherClass, - String decCipherClass, byte[] iv) throws IOException { - Cipher encCipher = getCipher(encCipherClass); - LOG.debug("Created a cipher object of type: " + encCipherClass); - - // Generate data - SecureRandom random = new SecureRandom(); - byte[] originalData = new byte[count]; - byte[] decryptedData = new byte[count]; - random.nextBytes(originalData); - LOG.debug("Generated " + count + " records"); - - // Encrypt data - ByteArrayOutputStream encryptedData = new ByteArrayOutputStream(); - CryptoOutputStream out = - getCryptoOutputStream(encryptedData, encCipher, defaultBufferSize, iv, - false); - out.write(originalData, 0, originalData.length); - out.flush(); - out.close(); - LOG.debug("Finished encrypting data"); - - Cipher decCipher = getCipher(decCipherClass); - LOG.debug("Created a cipher object of type: " + decCipherClass); - - // Decrypt data - CryptoInputStream in = getCryptoInputStream( - new ByteArrayInputStream(encryptedData.toByteArray()), decCipher, - defaultBufferSize, iv, false); - - // Check - int remainingToRead = count; - int offset = 0; - while (remainingToRead > 0) { - int n = in.read(decryptedData, offset, decryptedData.length - offset); - if (n >=0) { - remainingToRead -= n; - offset += n; - } - } - - Assert.assertArrayEquals("originalData and decryptedData not equal", - originalData, decryptedData); - - // Decrypt data byte-at-a-time - in = getCryptoInputStream( - new ByteArrayInputStream(encryptedData.toByteArray()), decCipher, - defaultBufferSize, iv, false); - - // Check - DataInputStream originalIn = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(originalData))); - int expected; - do { - expected = originalIn.read(); - Assert.assertEquals("Decrypted stream read by byte does not match", - expected, in.read()); - } while (expected != -1); - - LOG.debug("SUCCESS! Completed checking " + count + " records"); - } - - private void doReadWriteTestForReadableByteChannel(int count, - String encCipherClass, - String decCipherClass, - byte[] iv) throws IOException { - Cipher encCipher = getCipher(encCipherClass); - LOG.debug("Created a cipher object of type: " + encCipherClass); - - // Generate data - SecureRandom random = new SecureRandom(); - byte[] originalData = new byte[count]; - byte[] decryptedData = new byte[count]; - random.nextBytes(originalData); - LOG.debug("Generated " + count + " records"); - - // Encrypt data - ByteArrayOutputStream encryptedData = new ByteArrayOutputStream(); - CryptoOutputStream out = - getCryptoOutputStream(encryptedData, encCipher, defaultBufferSize, iv, - true); - out.write(originalData, 0, originalData.length); - out.flush(); - out.close(); - LOG.debug("Finished encrypting data"); - - Cipher decCipher = getCipher(decCipherClass); - LOG.debug("Created a cipher object of type: " + decCipherClass); - - // Decrypt data - CryptoInputStream in = getCryptoInputStream( - new ByteArrayInputStream(encryptedData.toByteArray()), decCipher, - defaultBufferSize, iv, true); - - // Check - int remainingToRead = count; - int offset = 0; - while (remainingToRead > 0) { - int n = in.read(decryptedData, offset, decryptedData.length - offset); - if (n >=0) { - remainingToRead -= n; - offset += n; - } - } - - Assert.assertArrayEquals("originalData and decryptedData not equal", - originalData, decryptedData); - - // Decrypt data byte-at-a-time - in = getCryptoInputStream(new ByteArrayInputStream( - encryptedData.toByteArray()),decCipher,defaultBufferSize,iv,true); - - // Check - DataInputStream originalIn = new DataInputStream(new BufferedInputStream(new ByteArrayInputStream(originalData))); - int expected; - do { - expected = originalIn.read(); - Assert.assertEquals("Decrypted stream read by byte does not match", - expected, in.read()); - } while (expected != -1); - - LOG.debug("SUCCESS! Completed checking " + count + " records"); - } -} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCipherStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCipherStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCipherStreamTest.java new file mode 100644 index 0000000..c8717ff --- /dev/null +++ b/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCipherStreamTest.java @@ -0,0 +1,31 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.crypto.stream; + +import java.io.IOException; + +import org.apache.commons.crypto.cipher.CipherTransformation; + +public class CBCNoPaddingCipherStreamTest extends AbstractCipherStreamTest { + + public void setUp() throws IOException { + transformation = CipherTransformation + .AES_CBC_NOPADDING; + } + +} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCryptoStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCryptoStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCryptoStreamTest.java deleted file mode 100644 index 743a3ac..0000000 --- a/src/test/java/org/apache/commons/crypto/stream/CBCNoPaddingCryptoStreamTest.java +++ /dev/null @@ -1,31 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.crypto.stream; - -import java.io.IOException; - -import org.apache.commons.crypto.cipher.CipherTransformation; - -public class CBCNoPaddingCryptoStreamTest extends AbstractCryptoStreamTest { - - public void setUp() throws IOException { - transformation = CipherTransformation - .AES_CBC_NOPADDING; - } - -} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCipherStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCipherStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCipherStreamTest.java new file mode 100644 index 0000000..ff34bc9 --- /dev/null +++ b/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCipherStreamTest.java @@ -0,0 +1,30 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.crypto.stream; + +import java.io.IOException; + +import org.apache.commons.crypto.cipher.CipherTransformation; + +public class CBCPKCS5PaddingCipherStreamTest extends AbstractCipherStreamTest { + + public void setUp() throws IOException { + transformation = CipherTransformation + .AES_CBC_PKCS5PADDING; + } +} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCryptoStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCryptoStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCryptoStreamTest.java deleted file mode 100644 index cb65dac..0000000 --- a/src/test/java/org/apache/commons/crypto/stream/CBCPKCS5PaddingCryptoStreamTest.java +++ /dev/null @@ -1,30 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.crypto.stream; - -import java.io.IOException; - -import org.apache.commons.crypto.cipher.CipherTransformation; - -public class CBCPKCS5PaddingCryptoStreamTest extends AbstractCryptoStreamTest { - - public void setUp() throws IOException { - transformation = CipherTransformation - .AES_CBC_PKCS5PADDING; - } -} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CTRCipherStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CTRCipherStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CTRCipherStreamTest.java new file mode 100644 index 0000000..f5e85ff --- /dev/null +++ b/src/test/java/org/apache/commons/crypto/stream/CTRCipherStreamTest.java @@ -0,0 +1,58 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.crypto.stream; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.nio.channels.Channels; + +import org.apache.commons.crypto.cipher.Cipher; +import org.apache.commons.crypto.cipher.CipherTransformation; + +public class CTRCipherStreamTest extends AbstractCipherStreamTest { + + public void setUp() throws IOException { + transformation = CipherTransformation + .AES_CTR_NOPADDING; + } + + @Override + protected CTRCipherInputStream getCipherInputStream + (ByteArrayInputStream bais, Cipher cipher, int + bufferSize,byte[] iv, boolean withChannel) + throws IOException { + if (withChannel) { + return new CTRCipherInputStream(Channels.newChannel(bais), cipher, + bufferSize, key, iv); + } else { + return new CTRCipherInputStream(bais, cipher, bufferSize, key, iv); + } + } + + @Override + protected CTRCipherOutputStream getCipherOutputStream(ByteArrayOutputStream baos, Cipher cipher, int + bufferSize, byte[] iv, boolean withChannel) + throws IOException { + if (withChannel) { + return new CTRCipherOutputStream(Channels.newChannel(baos), cipher, bufferSize, key, iv); + } else { + return new CTRCipherOutputStream(baos, cipher, bufferSize, key, iv); + } + } +} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CTRCryptoStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CTRCryptoStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CTRCryptoStreamTest.java deleted file mode 100644 index 1a50382..0000000 --- a/src/test/java/org/apache/commons/crypto/stream/CTRCryptoStreamTest.java +++ /dev/null @@ -1,58 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.crypto.stream; - -import java.io.ByteArrayInputStream; -import java.io.ByteArrayOutputStream; -import java.io.IOException; -import java.nio.channels.Channels; - -import org.apache.commons.crypto.cipher.Cipher; -import org.apache.commons.crypto.cipher.CipherTransformation; - -public class CTRCryptoStreamTest extends AbstractCryptoStreamTest { - - public void setUp() throws IOException { - transformation = CipherTransformation - .AES_CTR_NOPADDING; - } - - @Override - protected CTRCryptoInputStream getCryptoInputStream - (ByteArrayInputStream bais, Cipher cipher, int - bufferSize,byte[] iv, boolean withChannel) - throws IOException { - if (withChannel) { - return new CTRCryptoInputStream(Channels.newChannel(bais), cipher, - bufferSize, key, iv); - } else { - return new CTRCryptoInputStream(bais, cipher, bufferSize, key, iv); - } - } - - @Override - protected CTRCryptoOutputStream getCryptoOutputStream(ByteArrayOutputStream baos,Cipher cipher, int - bufferSize, byte[] iv, boolean withChannel) - throws IOException { - if (withChannel) { - return new CTRCryptoOutputStream(Channels.newChannel(baos), cipher, bufferSize, key, iv); - } else { - return new CTRCryptoOutputStream(baos, cipher, bufferSize, key, iv); - } - } -} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCipherStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCipherStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCipherStreamTest.java new file mode 100644 index 0000000..b59761d --- /dev/null +++ b/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCipherStreamTest.java @@ -0,0 +1,31 @@ +/** + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.apache.commons.crypto.stream; + +import java.io.IOException; + +import org.apache.commons.crypto.cipher.CipherTransformation; + +public class CTRNoPaddingCipherStreamTest extends AbstractCipherStreamTest { + + public void setUp() throws IOException { + transformation = CipherTransformation + .AES_CTR_NOPADDING; + } + +} http://git-wip-us.apache.org/repos/asf/commons-crypto/blob/ad81d236/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCryptoStreamTest.java ---------------------------------------------------------------------- diff --git a/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCryptoStreamTest.java b/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCryptoStreamTest.java deleted file mode 100644 index 1bbf600..0000000 --- a/src/test/java/org/apache/commons/crypto/stream/CTRNoPaddingCryptoStreamTest.java +++ /dev/null @@ -1,31 +0,0 @@ -/** - * Licensed to the Apache Software Foundation (ASF) under one - * or more contributor license agreements. See the NOTICE file - * distributed with this work for additional information - * regarding copyright ownership. The ASF licenses this file - * to you under the Apache License, Version 2.0 (the - * "License"); you may not use this file except in compliance - * with the License. You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package org.apache.commons.crypto.stream; - -import java.io.IOException; - -import org.apache.commons.crypto.cipher.CipherTransformation; - -public class CTRNoPaddingCryptoStreamTest extends AbstractCryptoStreamTest { - - public void setUp() throws IOException { - transformation = CipherTransformation - .AES_CTR_NOPADDING; - } - -}
