edwards25519

func FeAdd ¶

func FeAdd(out, a, b *FieldElement)

FeAdd sets out = a + b. Long sequences of additions without reduction that let coefficients grow larger than 54 bits would be a problem. Paper cautions: "do not have such sequences of additions".

func FeCMove ¶

func FeCMove(f, g *FieldElement, b int32)

Replace (f,g) with (g,g) if b == 1; replace (f,g) with (f,g) if b == 0.

Preconditions: b in {0,1}.

func FeCopy ¶

func FeCopy(dst, src *FieldElement)

func FeFromBytes ¶

func FeFromBytes(v *FieldElement, x *[32]byte)

func FeInvert ¶

func FeInvert(out, z *FieldElement)

func FeIsNegative ¶

func FeIsNegative(f *FieldElement) byte

func FeIsNonZero ¶

func FeIsNonZero(f *FieldElement) int32

func FeMul ¶

func FeMul(out, a, b *FieldElement)

FeMul calculates out = a * b.

func FeNeg ¶

func FeNeg(out, a *FieldElement)

FeNeg sets out = -a

func FeOne ¶

func FeOne(fe *FieldElement)

func FeSquare ¶

func FeSquare(out, a *FieldElement)

FeSquare calculates out = a * a.

func FeSquare2 ¶

func FeSquare2(out, a *FieldElement)

FeSquare2 calculates out = 2 * a * a.

func FeSub ¶

func FeSub(out, a, b *FieldElement)

FeSub sets out = a - b

func FeToBytes ¶

func FeToBytes(r *[32]byte, v *FieldElement)

func FeZero ¶

func FeZero(fe *FieldElement)

func GeDoubleScalarMultVartime ¶

func GeDoubleScalarMultVartime(r *ProjectiveGroupElement, a *[32]byte, A *ExtendedGroupElement, b *[32]byte)

GeDoubleScalarMultVartime sets r = a*A + b*B where a = a[0]+256*a[1]+...+256^31 a[31]. and b = b[0]+256*b[1]+...+256^31 b[31]. B is the Ed25519 base point (x,4/5) with x positive.

func GeScalarMultBase ¶

func GeScalarMultBase(h *ExtendedGroupElement, a *[32]byte)

GeScalarMultBase computes h = a*B, where

a = a[0]+256*a[1]+...+256^31 a[31]
B is the Ed25519 base point (x,4/5) with x positive.

Preconditions:

a[31] <= 127

func PreComputedGroupElementCMove ¶

func PreComputedGroupElementCMove(t, u *PreComputedGroupElement, b int32)

func ScMulAdd ¶

func ScMulAdd(s, a, b, c *[32]byte)

Input:

a[0]+256*a[1]+...+256^31*a[31] = a
b[0]+256*b[1]+...+256^31*b[31] = b
c[0]+256*c[1]+...+256^31*c[31] = c

Output:

s[0]+256*s[1]+...+256^31*s[31] = (ab+c) mod l
where l = 2^252 + 27742317777372353535851937790883648493.

func ScReduce ¶

func ScReduce(out *[32]byte, s *[64]byte)

Input:

s[0]+256*s[1]+...+256^63*s[63] = s

Output:

s[0]+256*s[1]+...+256^31*s[31] = s mod l
where l = 2^252 + 27742317777372353535851937790883648493.