com.tencent.kona.sun.security.util.math.intpoly

Class IntegerPolynomial

java.lang.Object

com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial

All Implemented Interfaces:

IntegerFieldModuloP

Direct Known Subclasses:

Curve25519OrderField, Curve448OrderField, IntegerPolynomial25519, IntegerPolynomial448, IntegerPolynomialModBinP, IntegerPolynomialP256, IntegerPolynomialP384, IntegerPolynomialP521, IntegerPolynomialSM2, P256OrderField, P384OrderField, P521OrderField, SM2OrderField

public abstract class IntegerPolynomial
extends java.lang.Object
implements IntegerFieldModuloP

A large number polynomial representation using sparse limbs of signed long (64-bit) values. Limb values will always fit within a long, so inputs to multiplication must be less than 32 bits. The following element operations are branch-free for all subclasses: fixed mutable add additiveInverse multiply square subtract conditionalSwapWith setValue (may branch on high-order byte parameter only) setSum setDifference setProduct setSquare addModPowerTwo asByteArray All other operations may branch in some subclasses.

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	IntegerPolynomial.MutableElement

Field Summary

Fields

Modifier and Type	Field and Description
protected int	bitsPerLimb
protected int	numLimbs
protected static java.math.BigInteger	TWO

Method Summary

Modifier and Type	Method and Description
protected void	addLimbs(long[] a, long[] b, long[] dst) Add two IntegerPolynomial representations (a and b) and store the result in an IntegerPolynomialRepresentation (dst).
protected void	addLimbsModPowerTwo(long[] limbs, long[] other, byte[] result) Add the reduced number corresponding to limbs and other, and store the low-order bytes of the sum in result.
protected void	carry(long[] limbs)
protected void	carry(long[] limbs, int start, int end)
protected long	carryOut(long[] limbs, int index) Carry out of the specified position and return the carry value.
protected long	carryValue(long x)
protected static void	conditionalAssign(int set, long[] a, long[] b) Branch-free conditional assignment of b to a.
protected static void	conditionalSwap(int swap, long[] a, long[] b) Branch-free conditional swap of a and b.
protected void	decode(long[] v, byte[] dst, int offset, int length) Decode the value in v and store it in dst.
protected void	encode(byte[] v, int offset, int length, byte highByte, long[] result)
protected void	encode(java.nio.ByteBuffer buf, int length, byte highByte, long[] result) This version of encode takes a ByteBuffer that is properly ordered, and may extract larger values (e.g.
protected void	encodeSmall(java.nio.ByteBuffer buf, int length, byte highByte, long[] result)
protected java.math.BigInteger	evaluate(long[] limbs)
protected abstract void	finalCarryReduceLast(long[] limbs) Carry out of the last limb and reduce back in.
protected void	finalReduce(long[] limbs) Convert reduced limbs into a number between 0 and MODULUS-1.
com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement	get0() Get the additive identity element 0
com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement	get1() Get the multiplicative identity element 1
com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement	getElement(java.math.BigInteger v) Get the field element equivalent to the supplied BigInteger value.
com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement	getElement(byte[] v, int offset, int length, byte highByte) Get a field element from a little-endian unsigned integer stored at the specified position in an array.
int	getMaxAdds()
protected int	getNumLimbs()
java.math.BigInteger	getSize() Get the size of the field as a BigInteger.
SmallValue	getSmallValue(int value) Get a "small" value according to this implementation.
protected void	limbsToByteArray(long[] limbs, byte[] result) Stores the reduced, little-endian value of limbs in result.
protected abstract void	mult(long[] a, long[] b, long[] r) Multiply two IntegerPolynomial representations (a and b) and store the result in an IntegerPolynomial representation (r).
protected void	multByInt(long[] a, long b) Multiply an IntegerPolynomial representation (a) with a long (b) and store the result in an IntegerPolynomial representation in a.
protected void	postEncodeCarry(long[] v)
protected abstract void	reduce(long[] a) Reduce an IntegerPolynomial representation (a) and store the result in a.
protected abstract void	reduceIn(long[] c, long v, int i)
protected void	setLimbsValuePositive(java.math.BigInteger v, long[] limbs)
protected abstract void	square(long[] a, long[] r) Multiply an IntegerPolynomial representation (a) with itself and store the result in an IntegerPolynomialRepresentation (r).

Methods inherited from class java.lang.Object

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

Methods inherited from interface com.tencent.kona.sun.security.util.math.IntegerFieldModuloP

getElement

Field Detail

TWO

protected static final java.math.BigInteger TWO

numLimbs

protected final int numLimbs

bitsPerLimb

protected final int bitsPerLimb

Method Detail

reduce

protected abstract void reduce(long[] a)

Reduce an IntegerPolynomial representation (a) and store the result in a. Requires that a.length == numLimbs.

multByInt

protected void multByInt(long[] a,
                         long b)

Multiply an IntegerPolynomial representation (a) with a long (b) and store the result in an IntegerPolynomial representation in a. Requires that a.length == numLimbs.

mult

protected abstract void mult(long[] a,
                             long[] b,
                             long[] r)

Multiply two IntegerPolynomial representations (a and b) and store the result in an IntegerPolynomial representation (r). Requires that a.length == b.length == r.length == numLimbs. It is allowed for a and r to be the same array.

square

protected abstract void square(long[] a,
                               long[] r)

Multiply an IntegerPolynomial representation (a) with itself and store the result in an IntegerPolynomialRepresentation (r). Requires that a.length == r.length == numLimbs. It is allowed for a and r to be the same array.

getNumLimbs

protected int getNumLimbs()

getMaxAdds

public int getMaxAdds()

getSize

public java.math.BigInteger getSize()

Description copied from interface: IntegerFieldModuloP

Get the size of the field as a BigInteger. This size is equal to the prime modulus used to construct the field.

Specified by:

getSize in interface IntegerFieldModuloP

Returns:

the size of the field.

get0

public com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement get0()

Description copied from interface: IntegerFieldModuloP

Get the additive identity element 0

Specified by:

get0 in interface IntegerFieldModuloP

Returns:

the additive identity element

get1

public com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement get1()

Description copied from interface: IntegerFieldModuloP

Get the multiplicative identity element 1

Specified by:

get1 in interface IntegerFieldModuloP

Returns:

the multiplicative identity element

getElement

public com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement getElement(java.math.BigInteger v)

Description copied from interface: IntegerFieldModuloP

Get the field element equivalent to the supplied BigInteger value. The supplied value may be negative or larger than the modulus that defines the field.

Specified by:

getElement in interface IntegerFieldModuloP

Parameters:

v - a BigInteger value

Returns:

the field element corresponding to v

getSmallValue

public SmallValue getSmallValue(int value)

Description copied from interface: IntegerFieldModuloP

Get a "small" value according to this implementation. This value may be used in optimized forms of some operations to avoid unnecessary calculations. For example, multiplication is much faster when it is known that one of the numbers fits within a single limb. The definition of "small", and the range of accepted values, is implementation-specific.

Specified by:

getSmallValue in interface IntegerFieldModuloP

Parameters:

value - the small integer value

reduceIn

protected abstract void reduceIn(long[] c,
                                 long v,
                                 int i)

encode

protected void encode(java.nio.ByteBuffer buf,
                      int length,
                      byte highByte,
                      long[] result)

This version of encode takes a ByteBuffer that is properly ordered, and may extract larger values (e.g. long) from the ByteBuffer for better performance. The implementation below only extracts bytes from the buffer, but this method may be overridden in field-specific implementations.

encodeSmall

protected void encodeSmall(java.nio.ByteBuffer buf,
                           int length,
                           byte highByte,
                           long[] result)

encode

protected void encode(byte[] v,
                      int offset,
                      int length,
                      byte highByte,
                      long[] result)

postEncodeCarry

protected void postEncodeCarry(long[] v)

getElement

public com.tencent.kona.sun.security.util.math.intpoly.IntegerPolynomial.ImmutableElement getElement(byte[] v,
                                                                                                     int offset,
                                                                                                     int length,
                                                                                                     byte highByte)

Description copied from interface: IntegerFieldModuloP

Get a field element from a little-endian unsigned integer stored at the specified position in an array. The supplied value may be larger than the modulus that defines the field. This method also takes a byte which is interpreted as an additional high-order byte of the number. The array will not be modified.

Specified by:

getElement in interface IntegerFieldModuloP

Parameters:

v - an array containing a little-endian unsigned integer

offset - the starting position of the integer

length - the number of bytes to read

highByte - the high-order byte of the number

Returns:

the field element corresponding to the bytes at the specified position

evaluate

protected java.math.BigInteger evaluate(long[] limbs)

carryValue

protected long carryValue(long x)

carry

protected void carry(long[] limbs,
                     int start,
                     int end)

carry

protected void carry(long[] limbs)

carryOut

protected long carryOut(long[] limbs,
                        int index)

Carry out of the specified position and return the carry value.

setLimbsValuePositive

protected void setLimbsValuePositive(java.math.BigInteger v,
                                     long[] limbs)

finalCarryReduceLast

protected abstract void finalCarryReduceLast(long[] limbs)

Carry out of the last limb and reduce back in. This method will be called as part of the "finalReduce" operation that puts the representation into a fully-reduced form. It is representation- specific, because representations have different amounts of empty space in the high-order limb. Requires that limbs.length=numLimbs.

finalReduce

protected void finalReduce(long[] limbs)

Convert reduced limbs into a number between 0 and MODULUS-1. Requires that limbs.length == numLimbs. This method only works if the modulus has at most three terms.

decode

protected void decode(long[] v,
                      byte[] dst,
                      int offset,
                      int length)

Decode the value in v and store it in dst. Requires that v is final reduced. I.e. all limbs in [0, 2^bitsPerLimb) and value in [0, modulus).

addLimbs

protected void addLimbs(long[] a,
                        long[] b,
                        long[] dst)

Add two IntegerPolynomial representations (a and b) and store the result in an IntegerPolynomialRepresentation (dst). Requires that a.length == b.length == dst.length. It is allowed for a and dst to be the same array.

conditionalAssign

protected static void conditionalAssign(int set,
                                        long[] a,
                                        long[] b)

Branch-free conditional assignment of b to a. Requires that set is 0 or 1, and that a.length == b.length. If set==0, then the values of a and b will be unchanged. If set==1, then the values of b will be assigned to a. The behavior is undefined if swap has any value other than 0 or 1.

conditionalSwap

protected static void conditionalSwap(int swap,
                                      long[] a,
                                      long[] b)

Branch-free conditional swap of a and b. Requires that swap is 0 or 1, and that a.length == b.length. If swap==0, then the values of a and b will be unchanged. If swap==1, then the values of a and b will be swapped. The behavior is undefined if swap has any value other than 0 or 1.

limbsToByteArray

protected void limbsToByteArray(long[] limbs,
                                byte[] result)

Stores the reduced, little-endian value of limbs in result.

addLimbsModPowerTwo

protected void addLimbsModPowerTwo(long[] limbs,
                                   long[] other,
                                   byte[] result)

Add the reduced number corresponding to limbs and other, and store the low-order bytes of the sum in result. Requires that limbs.length==other.length. The result array may have any length.