Package com.amazonaws.encryptionsdk.internal

Class Utils

java.lang.Object
com.amazonaws.encryptionsdk.internal.Utils
public final class Utils extends Object
Internal utility methods.

  • Method Details

    • 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.