http://commons.apache.org/proper/commons-crypto/: Apache Commons Crypto is a cryptographic library optimized with AES-NI (Advanced Encryption Standard New Instructions). It provides Java API for both cipher level and Java stream level. Developers can use it to implement high performance AES encryption/decryption with the minimum code and effort. Please note that Crypto doesn't implement the cryptographic algorithm such as AES directly. It wraps to Openssl or JCE which implement the algorithms. Features -------- 1. Cipher API for low level cryptographic operations. 2. Java stream API (CryptoInputStream/CryptoOutputStream) for high level stream encyrption/decryption. 3. Both optimized with high performance AES encryption/decryption. (1400 MB/s - 1700 MB/s throughput in modern Xeon processors). 4. JNI-based implementation to achieve comparable performance to the native C++ version based on OpenSsl. 5. Portable across various operating systems (currently only Linux/MacOSX/Windows); Apache Commons Crypto loads the library according to your machine environment (it checks system properties, `os.name` and `os.arch`). 6. Simple usage. Add the commons-crypto-(version).jar file to your classpath. Export restrictions ------------------- This distribution includes cryptographic software. The country in which you currently reside may have restrictions on the import, possession, use, and/or re-export to another country, of encryption software. BEFORE using any encryption software, please check your country's laws, regulations and policies concerning the import, possession, or use, and re-export of encryption software, to see if this is permitted. See <http://www.wassenaar.org/> for more information. The U.S. Government Department of Commerce, Bureau of Industry and Security (BIS), has classified this software as Export Commodity Control Number (ECCN) 5D002.C.1, which includes information security software using or performing cryptographic functions with asymmetric algorithms. The form and manner of this Apache Software Foundation distribution makes it eligible for export under the License Exception ENC Technology Software Unrestricted (TSU) exception (see the BIS Export Administration Regulations, Section 740.13) for both object code and source code. The following provides more details on the included cryptographic software: * Commons Crypto use [Java Cryptography Extension](http://docs.oracle.com/javase/8/docs/technotes/guides/security/crypto/CryptoSpec.html) provided by Java * Commons Crypto link to and use [OpenSSL](https://www.openssl.org/) ciphers (The Apache Software Foundation)
  • Colin Ma
  • Xianda Ke
  • Ke Jia
  • George Kankava
  • Aaron T Myers
  • Andrew Wang
  • Chris Nauroth
  • Colin P. McCabe
  • Dapeng Sun
  • Dian Fu
  • Dong Chen
  • Ferdinand Xu
  • Haifeng Chen
  • Marcelo Vanzin
  • Uma Maheswara Rao G
  • Yi Liu 
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.

/**
 * 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.input;

import java.io.IOException;
import java.nio.ByteBuffer;


The Input interface abstract the input source of
CryptoInputStream so that different implementation of input can
be used. The implementation Input interface will usually wraps an input
mechanism such as InputStream or
ReadableByteChannel.

/**
 * The Input interface abstract the input source of
 * <code>CryptoInputStream</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>.
 */
public interface Input {
    
Reads a sequence of bytes from input into the given buffer.


An attempt is made to read up to r bytes from the input, where
r is the number of bytes remaining in the buffer, that is,
dst.remaining(), at the moment this method is invoked.


Suppose that a byte sequence of length n is read, where 0
 <= n <= r.
This byte sequence will be transferred into the buffer so that the first
byte in the sequence is at index p and the last byte is at index
p + n - 1,
where p is the buffer's position at the moment this method is
invoked. Upon return the buffer's position will be equal to
p + n; its limit will not have changed.

Params:
  • dst – The buffer into which bytes are to be transferred.
Throws:
Returns:the total number of bytes read into the buffer, or
        -1 if there is no more data because the end of the
        stream has been reached.
/**
     * Reads a sequence of bytes from input into the given buffer.
     *
     * <p>
     * An attempt is made to read up to <i>r</i> bytes from the input, where
     * <i>r</i> is the number of bytes remaining in the buffer, that is,
     * <tt>dst.remaining()</tt>, at the moment this method is invoked.
     *
     * <p>
     * Suppose that a byte sequence of length <i>n</i> is read, where <tt>0</tt>
     * &nbsp;<tt>&lt;=</tt>&nbsp;<i>n</i>&nbsp;<tt>&lt;=</tt>&nbsp;<i>r</i>.
     * This byte sequence will be transferred into the buffer so that the first
     * byte in the sequence is at index <i>p</i> and the last byte is at index
     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>&nbsp;<tt>-</tt>&nbsp;<tt>1</tt>,
     * where <i>p</i> is the buffer's position at the moment this method is
     * invoked. Upon return the buffer's position will be equal to
     * <i>p</i>&nbsp;<tt>+</tt>&nbsp;<i>n</i>; its limit will not have changed.
     *
     * @param dst The buffer into which bytes are to be transferred.
     * @return the total number of bytes read into the buffer, or
     *         <code>-1</code> if there is no more data because the end of the
     *         stream has been reached.
     * @throws IOException If some other I/O error occurs.
     */
    int read(ByteBuffer dst) throws IOException;

    
Skips over and discards n bytes of data from this input The
skip method may, for a variety of reasons, end up skipping
over some smaller number of bytes, possibly 0. This may
result from any of a number of conditions; reaching end of file before
n bytes have been skipped is only one possibility. The
actual number of bytes skipped is returned. If n is
negative, no bytes are skipped.


The skip method of this class creates a byte array and then
repeatedly reads into it until n bytes have been read or the
end of the stream has been reached. Subclasses are encouraged to provide
a more efficient implementation of this method. For instance, the
implementation may depend on the ability to seek.

Params:
  • n – the number of bytes to be skipped.
Throws:
  • IOException – if the stream does not support seek, or if some
           other I/O error occurs.
Returns:the actual number of bytes skipped.
/**
     * Skips over and discards <code>n</code> bytes of data from this input The
     * <code>skip</code> method may, for a variety of reasons, end up skipping
     * over some smaller number of bytes, possibly <code>0</code>. This may
     * result from any of a number of conditions; reaching end of file before
     * <code>n</code> bytes have been skipped is only one possibility. The
     * actual number of bytes skipped is returned. If <code>n</code> is
     * negative, no bytes are skipped.
     *
     * <p>
     * The <code>skip</code> method of this class creates a byte array and then
     * repeatedly reads into it until <code>n</code> bytes have been read or the
     * end of the stream has been reached. Subclasses are encouraged to provide
     * a more efficient implementation of this method. For instance, the
     * implementation may depend on the ability to seek.
     *
     * @param n the number of bytes to be skipped.
     * @return the actual number of bytes skipped.
     * @throws IOException if the stream does not support seek, or if some
     *            other I/O error occurs.
     */
    long skip(long n) throws IOException;

    
Returns an estimate of the number of bytes that can be read (or skipped
over) from this input without blocking by the next invocation of a method
for this input stream. The next invocation might be the same thread or
another thread. A single read or skip of this many bytes will not block,
but may read or skip fewer bytes.


It is never correct to use the return value of this method to allocate a
buffer intended to hold all data in this stream.

Throws:
Returns:an estimate of the number of bytes that can be read (or skipped over) from this input stream without blocking or 0 when it reaches the end of the input stream.
/**
     * Returns an estimate of the number of bytes that can be read (or skipped
     * over) from this input without blocking by the next invocation of a method
     * for this input stream. The next invocation might be the same thread or
     * another thread. A single read or skip of this many bytes will not block,
     * but may read or skip fewer bytes.
     *
     * <p>
     * It is never correct to use the return value of this method to allocate a
     * buffer intended to hold all data in this stream.
     *
     * @return an estimate of the number of bytes that can be read (or skipped
     *         over) from this input stream without blocking or {@code 0} when
     *         it reaches the end of the input stream.
     * @throws IOException if an I/O error occurs.
     */
    int available() throws IOException;

    
Reads up to 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.
An implementation may not support positioned read. If the implementation
doesn't support positioned read, it throws UnsupportedOperationException.

Params:
  • position – the given position within a stream.
  • buffer – the buffer into which the data is read.
  • offset – the start offset in array buffer.
  • length – the maximum number of bytes to read.
Throws:
Returns:the total number of bytes read into the buffer, or
        -1 if there is no more data because the end of the
        stream has been reached.
/**
     * Reads up to 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.
     *
     * An implementation may not support positioned read. If the implementation
     * doesn't support positioned read, it throws UnsupportedOperationException.
     *
     * @param position the given position within a stream.
     * @param buffer the buffer into which the data is read.
     * @param offset the start offset in array buffer.
     * @param length the maximum number of bytes to read.
     * @return the total number of bytes read into the buffer, or
     *         <code>-1</code> if there is no more data because the end of the
     *         stream has been reached.
     * @throws IOException if an I/O error occurs.
     */
    int read(long position, byte[] buffer, int offset, int length)
            throws IOException;

    
Seeks to the given offset from the start of the stream. The next read()
will be from that location.
An implementation may not support seek. If the implementation doesn't
support seek, it throws UnsupportedOperationException.

Params:
  • position – the offset from the start of the stream.
Throws:
/**
     * Seeks to the given offset from the start of the stream. The next read()
     * will be from that location.
     *
     * An implementation may not support seek. If the implementation doesn't
     * support seek, it throws UnsupportedOperationException.
     *
     * @param position the offset from the start of the stream.
     * @throws IOException if an I/O error occurs.
     */
    void seek(long position) throws IOException;

    
Closes this input and releases any system resources associated with the
under layer input.

Throws:
  • IOException – if an I/O error occurs.
/**
     * Closes this input and releases any system resources associated with the
     * under layer input.
     *
     * @throws IOException if an I/O error occurs.
     */
    void close() throws IOException;
}