org.bcos.web3j.crypto.sm2.util.BigIntegers Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of web3sdk Show documentation
fisco-bcos web3sdk
There is a newer version: 2.6.6
package org.bcos.web3j.crypto.sm2.util;

import java.math.BigInteger;
import java.security.SecureRandom;

/**
 * BigInteger utilities.
 */
public final class BigIntegers {
	private static final int MAX_ITERATIONS = 1000;
	private static final BigInteger ZERO = BigInteger.valueOf(0);

	/**
	 * Return the passed in value as an unsigned byte array.
	 * 
	 * @param value
	 *            value to be converted.
	 * @return a byte array without a leading zero byte if present in the signed
	 *         encoding.
	 */
	public static byte[] asUnsignedByteArray(BigInteger value) {
		byte[] bytes = value.toByteArray();

		if (bytes[0] == 0) {
			byte[] tmp = new byte[bytes.length - 1];

			System.arraycopy(bytes, 1, tmp, 0, tmp.length);

			return tmp;
		}

		return bytes;
	}

	/**
	 * Return the passed in value as an unsigned byte array.
	 *
	 * @param value
	 *            value to be converted.
	 * @return a byte array without a leading zero byte if present in the signed
	 *         encoding.
	 */
	public static byte[] asUnsignedByteArray(int length, BigInteger value) {
		byte[] bytes = value.toByteArray();
		if (bytes.length == length) {
			return bytes;
		}

		int start = bytes[0] == 0 ? 1 : 0;
		int count = bytes.length - start;

		if (count > length) {
			throw new IllegalArgumentException(
					"standard length exceeded for value");
		}

		byte[] tmp = new byte[length];
		System.arraycopy(bytes, start, tmp, tmp.length - count, count);
		return tmp;
	}

	/**
	 * Return a random BigInteger not less than 'min' and not greater than 'max'
	 * 
	 * @param min
	 *            the least value that may be generated
	 * @param max
	 *            the greatest value that may be generated
	 * @param random
	 *            the source of randomness
	 * @return a random BigInteger value in the range [min,max]
	 */
	public static BigInteger createRandomInRange(BigInteger min,
			BigInteger max, SecureRandom random) {
		int cmp = min.compareTo(max);
		if (cmp >= 0) {
			if (cmp > 0) {
				throw new IllegalArgumentException(
						"'min' may not be greater than 'max'");
			}

			return min;
		}

		if (min.bitLength() > max.bitLength() / 2) {
			return createRandomInRange(ZERO, max.subtract(min), random)
					.add(min);
		}

		for (int i = 0; i < MAX_ITERATIONS; ++i) {
			BigInteger x = new BigInteger(max.bitLength(), random);
			if (x.compareTo(min) >= 0 && x.compareTo(max) <= 0) {
				return x;
			}
		}

		// fall back to a faster (restricted) method
		return new BigInteger(max.subtract(min).bitLength() - 1, random)
				.add(min);
	}

	public static BigInteger fromUnsignedByteArray(byte[] buf) {
		return new BigInteger(1, buf);
	}

	public static BigInteger fromUnsignedByteArray(byte[] buf, int off,
			int length) {
		byte[] mag = buf;
		if (off != 0 || length != buf.length) {
			mag = new byte[length];
			System.arraycopy(buf, off, mag, 0, length);
		}
		return new BigInteger(1, mag);
	}
}