ed

package
v0.0.0-...-4c49fd5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 18, 2023 License: GPL-2.0, GPL-3.0 Imports: 9 Imported by: 0

Documentation

Overview

Package ed MPC ed algorithm

Index

Constants

This section is empty.

Variables

View Source 
var A = FieldElement{
	486662, 0, 0, 0, 0, 0, 0, 0, 0, 0,
}

A is a constant in the Montgomery-form of curve25519.

View Source 
var SqrtM1 = FieldElement{
	-32595792, -7943725, 9377950, 3500415, 12389472, -272473, -25146209, -2005654, 326686, 11406482,
}

SqrtM1 is the square-root of -1 in the field.

Functions

func CachedGroupElementCMove 

func CachedGroupElementCMove(t, u *CachedGroupElement, b int32)

CachedGroupElementCMove mov cache group element

func Combine 

func Combine(shares [][32]byte, ids [][32]byte) [32]byte

Combine Calculate the function value of Lagrange polynomial

func Commit 

func Commit(secret [32]byte) ([32]byte, [64]byte, error)

Commit get commitment by secret

func FeAdd 

func FeAdd(dst, a, b *FieldElement)

FeAdd add

func FeCMove 

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

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

Preconditions: b in {0,1}.

func FeCombine 

func FeCombine(h *FieldElement, h0, h1, h2, h3, h4, h5, h6, h7, h8, h9 int64)

FeCombine combine

func FeCopy 

func FeCopy(dst, src *FieldElement)

FeCopy copy

func FeFromBytes 

func FeFromBytes(dst *FieldElement, src *[32]byte)

FeFromBytes from baytes

func FeInvert 

func FeInvert(out, z *FieldElement)

FeInvert invert

func FeIsNegative 

func FeIsNegative(f *FieldElement) byte

FeIsNegative si negative

func FeIsNonZero 

func FeIsNonZero(f *FieldElement) int32

FeIsNonZero is not zero

func FeMul 

func FeMul(h, f, g *FieldElement)

FeMul calculates h = f * g Can overlap h with f or g.

Preconditions: 

|f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.
|g| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.

Postconditions: 

|h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.

Notes on implementation strategy:

Using schoolbook multiplication. Karatsuba would save a little in some cost models.

Most multiplications by 2 and 19 are 32-bit precomputations; cheaper than 64-bit postcomputations.

There is one remaining multiplication by 19 in the carry chain; one *19 precomputation can be merged into this, but the resulting data flow is considerably less clean.

There are 12 carries below. 10 of them are 2-way parallelizable and vectorizable. Can get away with 11 carries, but then data flow is much deeper.

With tighter constraints on inputs, can squeeze carries into int32.

func FeNeg 

func FeNeg(h, f *FieldElement)

FeNeg sets h = -f Preconditions: 

|f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.

Postconditions: 

|h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.

func FeOne 

func FeOne(fe *FieldElement)

FeOne one

func FeSquare 

func FeSquare(h, f *FieldElement)

FeSquare calculates h = f*f. Can overlap h with f.

Preconditions: 

|f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc.

Postconditions: 

|h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.

func FeSquare2 

func FeSquare2(h, f *FieldElement)

FeSquare2 sets h = 2 * f * f Can overlap h with f. Preconditions: 

|f| bounded by 1.65*2^26,1.65*2^25,1.65*2^26,1.65*2^25,etc.

Postconditions: 

|h| bounded by 1.01*2^25,1.01*2^24,1.01*2^25,1.01*2^24,etc.

See fe_mul.c for discussion of implementation strategy.

func FeSub 

func FeSub(dst, a, b *FieldElement)

FeSub sub

func FeToBytes 

func FeToBytes(s *[32]byte, h *FieldElement)

FeToBytes marshals h to s. Preconditions: 

|h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc.

Write p=2^255-19; q=floor(h/p). Basic claim: q = floor(2^(-255)(h + 19 2^(-25)h9 + 2^(-1))).

Proof: 

Have |h|<=p so |q|<=1 so |19^2 2^(-255) q|<1/4.
Also have |h-2^230 h9|<2^230 so |19 2^(-255)(h-2^230 h9)|<1/4.

Write y=2^(-1)-19^2 2^(-255)q-19 2^(-255)(h-2^230 h9).
Then 0<y<1.

Write r=h-pq.
Have 0<=r<=p-1=2^255-20.
Thus 0<=r+19(2^-255)r<r+19(2^-255)2^255<=2^255-1.

Write x=r+19(2^-255)r+y.
Then 0<x<2^255 so floor(2^(-255)x) = 0 so floor(q+2^(-255)x) = q.

Have q+2^(-255)x = 2^(-255)(h + 19 2^(-25) h9 + 2^(-1))
so floor(2^(-255)(h + 19 2^(-25) h9 + 2^(-1))) = q.

func FeZero 

func FeZero(fe *FieldElement)

FeZero zero

func GeAdd 

func GeAdd(C *ExtendedGroupElement, A *ExtendedGroupElement, B *ExtendedGroupElement)

GeAdd point calculate: C = A + B

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 GeScalarMult 

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

GeScalarMult point calculate: h = a * p

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 GetBigIntOrder 

func GetBigIntOrder() *big.Int

GetBigIntOrder get Order of edwards25519 order [4]uint64 {0x1000000000000000, 0x0000000000000000, 0x14def9dea2f79cd6, 0x5812631a5cf5d3ed} = 2^252+27742317777372353535851937790883648493

func GetBytesOrder 

func GetBytesOrder() [32]byte

GetBytesOrder get bytes order

func PreComputedGroupElementCMove 

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

PreComputedGroupElementCMove pre move computed group element

func Prove 

func Prove(sk [32]byte) ([64]byte, error)

Prove Generate SK zero knowledge proof data

func Prove2 

func Prove2(sk [32]byte, pk [32]byte) ([64]byte, error)

Prove2 Generate SK zero knowledge proof data,include pk

func ScAdd 

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

ScAdd c = a + b

func ScMinimal 

func ScMinimal(scalar *[32]byte) bool

ScMinimal returns true if the given scalar is less than the order of the curve.

func ScModInverse 

func ScModInverse(a, order [32]byte) [32]byte

ScModInverse mod inverse

func ScMul 

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

ScMul c = a * b

func ScMulAdd 

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

ScMulAdd The scalars are GF(2^252 + 27742317777372353535851937790883648493). 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 ScMulSub 

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

ScMulSub s = ab - c

func ScReduce 

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

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

func ScReverse 

func ScReverse(s *[32]byte)

ScReverse little endian -> big endian or big endian -> little endian

func ScSub 

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

ScSub c = a - b, can not calculate a < b

func Verify 

func Verify(C [32]byte, D [64]byte) bool

Verify Verify commitment data

func VerifyVss 

func VerifyVss(share [32]byte, id [32]byte, cfsBBytes [][32]byte) bool

VerifyVss verify secret sharing value

func VerifyZk 

func VerifyZk(signature [64]byte, pk [32]byte) bool

VerifyZk verify SK zero knowledge proof data

func VerifyZk2 

func VerifyZk2(signature [64]byte, pk [32]byte) bool

VerifyZk2 verify SK zero knowledge proof data,include pk

func Vss 

func Vss(secret [32]byte, ids [][32]byte, t int, n int) ([][32]byte, [][32]byte, [][32]byte, error)

Vss Calculate secret sharing value

func Vss2 

func Vss2(secret [32]byte, t int, n int, uids map[string][32]byte) ([][32]byte, [][32]byte, map[string][32]byte, error)

Vss2 Calculate secret sharing value

Types

type CachedGroupElement 

type CachedGroupElement struct {
	Z, T2d FieldElement
	// contains filtered or unexported fields
}

CachedGroupElement cache group element

func (*CachedGroupElement) Zero 

func (q *CachedGroupElement) Zero()

Zero zero

type CompletedGroupElement 

type CompletedGroupElement struct {
	X, Y, Z, T FieldElement
}

CompletedGroupElement computed group element

func (*CompletedGroupElement) ToExtended 

func (p *CompletedGroupElement) ToExtended(r *ExtendedGroupElement)

ToExtended to extended

func (*CompletedGroupElement) ToProjective 

func (p *CompletedGroupElement) ToProjective(r *ProjectiveGroupElement)

ToProjective to projective

type ExtendedGroupElement 

type ExtendedGroupElement struct {
	X, Y, Z, T FieldElement
}

ExtendedGroupElement extended group element

func (*ExtendedGroupElement) Double 

func (p *ExtendedGroupElement) Double(r *CompletedGroupElement)

Double Double

func (*ExtendedGroupElement) FromBytes 

func (p *ExtendedGroupElement) FromBytes(s *[32]byte) bool

FromBytes from bytes

func (*ExtendedGroupElement) ToBytes 

func (p *ExtendedGroupElement) ToBytes(s *[32]byte)

ToBytes to bytes

func (*ExtendedGroupElement) ToCached 

func (p *ExtendedGroupElement) ToCached(r *CachedGroupElement)

ToCached to cache

func (*ExtendedGroupElement) ToProjective 

func (p *ExtendedGroupElement) ToProjective(r *ProjectiveGroupElement)

ToProjective to projective

func (*ExtendedGroupElement) Zero 

func (p *ExtendedGroupElement) Zero()

Zero zero

type FieldElement 

type FieldElement [10]int32

FieldElement represents an element of the field GF(2^255 - 19). An element t, entries t[0]...t[9], represents the integer t[0]+2^26 t[1]+2^51 t[2]+2^77 t[3]+2^102 t[4]+...+2^230 t[9]. Bounds on each t[i] vary depending on context.

type PreComputedGroupElement 

type PreComputedGroupElement struct {
	// contains filtered or unexported fields
}

PreComputedGroupElement pre-computed group element

func (*PreComputedGroupElement) Zero 

func (p *PreComputedGroupElement) Zero()

Zero zero

type ProjectiveGroupElement 

type ProjectiveGroupElement struct {
	X, Y, Z FieldElement
}

ProjectiveGroupElement projective group element

func (*ProjectiveGroupElement) Double 

func (p *ProjectiveGroupElement) Double(r *CompletedGroupElement)

Double Double

func (*ProjectiveGroupElement) ToBytes 

func (p *ProjectiveGroupElement) ToBytes(s *[32]byte)

ToBytes to bytes

func (*ProjectiveGroupElement) Zero 

func (p *ProjectiveGroupElement) Zero()

Zero zero

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.