Package com.amazonaws.encryptionsdk.internal

Class Utils

java.lang.Object

com.amazonaws.encryptionsdk.internal.Utils

public final class Utils
extends Object

Internal utility methods.

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	Utils.ComparingByteArrays	Comparator that performs a lexicographical comparison of byte arrays, treating them as unsigned.
static class	Utils.ComparingByteBuffers

Method Summary

Modifier and Type	Method	Description
static boolean	arrayPrefixEquals(byte[] a, byte[] b, int length)	Returns true if the prefix of the given length for the input arrays are equal.
static <T> T	assertNonNull(T object, String paramName)	Throws NullPointerException with message paramName if object is null.
static byte[]	bigIntegerToByteArray(BigInteger bigInteger, int length)	Removes the leading zero sign byte from the byte array representation of a BigInteger (if present) and left pads with zeroes to produce a byte array of the given length.
static ByteBuffer	clear(ByteBuffer buff)	Equivalent to calling ByteBuffer.clear() but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.
static int	compareObjectIdentity(Object a, Object b)	Provides an arbitrary but consistent total ordering over all objects.
static byte[]	decodeBase64String(String encoded)	Takes a Base64-encoded String, decodes it, and returns contents as a byte array.
static String	encodeBase64String(byte[] data)	Takes data in a byte array, encodes them in Base64, and returns the result as a String.
static ByteBuffer	flip(ByteBuffer buff)	Equivalent to calling ByteBuffer.flip() but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.
static SecureRandom	getSecureRandom()
static ByteBuffer	limit(ByteBuffer buff, int newLimit)	Equivalent to calling ByteBuffer.limit(int) but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.
static ByteBuffer	position(ByteBuffer buff, int newPosition)	Equivalent to calling ByteBuffer.position(int) but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.
static long	saturatingAdd(long a, long b)
static byte[]	truncate(byte[] arr, int len)	Returns a possibly truncated version of arr which is guaranteed to be exactly len elements long.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

compareObjectIdentity

public static int compareObjectIdentity(Object a,
                                        Object b)

Provides an arbitrary but consistent total ordering over all objects. This comparison function will return 0 if and only if a == b, and otherwise will return arbitrarily either -1 or 1, but will do so in a way that results in a consistent total order.

Parameters:

a -

b -

Returns:

-1 or 1 (consistently) if a != b; 0 if a == b.

saturatingAdd

public static long saturatingAdd(long a,
                                 long b)

assertNonNull

public static <T> T assertNonNull(T object,
                                  String paramName)
                           throws NullPointerException

Throws NullPointerException with message paramName if object is null.

Parameters:

object - value to be null-checked

paramName - message for the potential NullPointerException

Returns:

object

Throws:

NullPointerException - if object is null

truncate

public static byte[] truncate(byte[] arr,
                              int len)
                       throws IllegalArgumentException

Returns a possibly truncated version of arr which is guaranteed to be exactly len elements long. If arr is already exactly len elements long, then arr is returned without copy or modification. If arr is longer than len, then a truncated copy is returned. If arr is shorter than len then this throws an IllegalArgumentException.

Throws:

IllegalArgumentException

getSecureRandom

public static SecureRandom getSecureRandom()

flip

public static ByteBuffer flip(ByteBuffer buff)

Equivalent to calling ByteBuffer.flip() but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.

clear

public static ByteBuffer clear(ByteBuffer buff)

Equivalent to calling ByteBuffer.clear() but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.

position

public static ByteBuffer position(ByteBuffer buff,
                                  int newPosition)

Equivalent to calling ByteBuffer.position(int) but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.

limit

public static ByteBuffer limit(ByteBuffer buff,
                               int newLimit)

Equivalent to calling ByteBuffer.limit(int) but in a manner which is safe when compiled on Java 9 or newer but used on Java 8 or older.

decodeBase64String

public static byte[] decodeBase64String(String encoded)

Takes a Base64-encoded String, decodes it, and returns contents as a byte array.

Parameters:

encoded - Base64 encoded String

Returns:

decoded data as a byte array

encodeBase64String

public static String encodeBase64String(byte[] data)

Takes data in a byte array, encodes them in Base64, and returns the result as a String.

Parameters:

data - The data to encode.

Returns:

Base64 string that encodes the data.

bigIntegerToByteArray

public static byte[] bigIntegerToByteArray(BigInteger bigInteger,
                                           int length)

Removes the leading zero sign byte from the byte array representation of a BigInteger (if present) and left pads with zeroes to produce a byte array of the given length.

Parameters:

bigInteger - The BigInteger to convert to a byte array

length - The length of the byte array, must be at least as long as the BigInteger byte array without the sign byte

Returns:

The byte array

arrayPrefixEquals

public static boolean arrayPrefixEquals(byte[] a,
                                        byte[] b,
                                        int length)

Returns true if the prefix of the given length for the input arrays are equal. This method will return as soon as the first difference is found, and is thus not constant-time.

Parameters:

a - The first array.

b - The second array.

length - The length of the prefix to compare.

Returns:

True if the prefixes are equal, false otherwise.