ffrs.GF256¶

class ffrs.GF256¶

Finite-field operations optimized for \(GF(2^8)\)

Methods

`GF256.__init__`	Instantiate type for operations over \(GF(p^n)/P\)
`GF256.add`	Addition: \(\text{lhs} + \text{rhs}\)
`GF256.div`	Division: \(\frac{\text{num}}{\text{den}}\)
`GF256.exp`	Exponential function: \(a^{\text{value}}\)
`GF256.inv`	Reciprocal: \(\frac{1}{\text{value}}\)
`GF256.log`	Logarithm: \(\log_a (\text{value})\)
`GF256.mul`	Multiplication: \(\text{lhs} \times \text{rhs}\)
`GF256.mul8`	Multiply 8 values in a single operation
`GF256.poly_add`	Add polynomials
`GF256.poly_divmod`	Polynomial quotient and remainder
`GF256.poly_eval`	Evaluate polynomial at `x`
`GF256.poly_eval8`	Evaluate polynomial at 8 points on a single operation
`GF256.poly_mod`	Polynomial remainder
`GF256.poly_mod_x_n`	Shifted polynomial remainder
`GF256.poly_mul`	Multiply polynomials
`GF256.poly_sub`	Subtract polynomials
`GF256.pow`	Power: \(\text{base}^\text{exponent}\)
`GF256.sub`	Subtraction: \(\text{lhs} - \text{rhs}\)

Attributes

`GF256.field_elements`	Always 256
`GF256.poly1`	Masked irreducible polynomial, excluding MSb
`GF256.power`	Always 8
`GF256.prime`	Always 2
`GF256.primitive`	Primitive value used to generate the field

__init__(self: libffrs.GF256, primitive: SupportsInt | SupportsIndex = 2, poly1: SupportsInt | SupportsIndex = 285) → None¶

Instantiate type for operations over \(GF(p^n)/P\)

Parameters:

add(self: libffrs.GF256, lhs: SupportsInt | SupportsIndex, rhs: SupportsInt | SupportsIndex) → int¶: Addition: \(\text{lhs} + \text{rhs}\)

div(self: libffrs.GF256, num: SupportsInt | SupportsIndex, den: SupportsInt | SupportsIndex) → int¶: Division: \(\frac{\text{num}}{\text{den}}\)

exp(self: libffrs.GF256, value: SupportsInt | SupportsIndex) → int¶: Exponential function: \(a^{\text{value}}\)

inv(self: libffrs.GF256, value: SupportsInt | SupportsIndex) → int¶: Reciprocal: \(\frac{1}{\text{value}}\)

log(self: libffrs.GF256, value: SupportsInt | SupportsIndex) → int¶: Logarithm: \(\log_a (\text{value})\)

mul(self: libffrs.GF256, lhs: SupportsInt | SupportsIndex, rhs: SupportsInt | SupportsIndex) → int¶: Multiplication: \(\text{lhs} \times \text{rhs}\)

mul8(self: libffrs.GF256, a: collections.abc.Buffer, b: collections.abc.Buffer) → bytearray¶: Multiply 8 values in a single operation

poly_add(self: libffrs.GF256, p1: collections.abc.Buffer, p2: collections.abc.Buffer) → bytearray¶: Add polynomials

poly_divmod(self: libffrs.GF256, p1: collections.abc.Buffer, p2: collections.abc.Buffer) → tuple¶

Polynomial quotient and remainder

poly_eval(self: libffrs.GF256, poly: collections.abc.Buffer, x: SupportsInt | SupportsIndex) → int¶: Evaluate polynomial at x

poly_eval8(self: libffrs.GF256, poly: collections.abc.Buffer, xs: collections.abc.Buffer) → bytearray¶: Evaluate polynomial at 8 points on a single operation

poly_mod(self: libffrs.GF256, p1: collections.abc.Buffer, p2: collections.abc.Buffer) → bytearray¶: Polynomial remainder

poly_mod_x_n(self: libffrs.GF256, p1: collections.abc.Buffer, p2: collections.abc.Buffer) → bytearray¶

Shifted polynomial remainder

\(P \times X^n \mod (X^n + p_2)\) where n = len(p2)

poly_mul(self: libffrs.GF256, p1: collections.abc.Buffer, p2: collections.abc.Buffer) → bytearray¶: Multiply polynomials

poly_sub(self: libffrs.GF256, p1: collections.abc.Buffer, p2: collections.abc.Buffer) → bytearray¶: Subtract polynomials

pow(self: libffrs.GF256, base: SupportsInt | SupportsIndex, exponent: SupportsInt | SupportsIndex) → int¶: Power: \(\text{base}^\text{exponent}\)

sub(self: libffrs.GF256, lhs: SupportsInt | SupportsIndex, rhs: SupportsInt | SupportsIndex) → int¶: Subtraction: \(\text{lhs} - \text{rhs}\)