codex-storage/constantine
1
0
Fork 0
mirror of https://github.com/codex-storage/constantine.git synced 2025-01-28 03:26:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

Terminology nres -> mres, montgomeryResidue, montyResidue

Browse Source
This commit is contained in:
Mamy André-Ratsimbazafy 2020-02-15 16:11:17 +01:00
parent d3ad4acb3a
commit e2333dce3c
No known key found for this signature in database
GPG Key ID: 7B88AD1FE79492E1
5 changed files with 22 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
constantine/config/curves_parser.nim
View File

@ -95,7 +95,7 @@ macro declareCurves*(curves: untyped): untyped =
nnkObjConstr.newTree( nnkObjConstr.newTree(
nnkBracketExpr.newTree(Fq, curve), nnkBracketExpr.newTree(Fq, curve),
nnkExprColonExpr.newTree( nnkExprColonExpr.newTree(
ident"nres", ident"mres",
newCall( newCall(
bindSym"fromHex", bindSym"fromHex",
nnkBracketExpr.newTree(bindSym"BigInt", bitSize), nnkBracketExpr.newTree(bindSym"BigInt", bitSize),
@ -151,7 +151,7 @@ macro declareCurves*(curves: untyped): untyped =
# ## P being the prime modulus of the Curve C # ## P being the prime modulus of the Curve C
# ## Internally, data is stored in Montgomery n-residue form # ## Internally, data is stored in Montgomery n-residue form
# ## with the magic constant chosen for convenient division (a power of 2 depending on P bitsize) # ## with the magic constant chosen for convenient division (a power of 2 depending on P bitsize)
# nres*: matchingBigInt(C) # mres*: matchingBigInt(C)
result.add nnkTypeSection.newTree( result.add nnkTypeSection.newTree(
nnkTypeDef.newTree( nnkTypeDef.newTree(
nnkPostfix.newTree(ident"*", Fq), nnkPostfix.newTree(ident"*", Fq),
@ -164,7 +164,7 @@ macro declareCurves*(curves: untyped): untyped =
newEmptyNode(), newEmptyNode(),
nnkRecList.newTree( nnkRecList.newTree(
newIdentDefs( newIdentDefs(
nnkPostfix.newTree(ident"*", ident"nres"), nnkPostfix.newTree(ident"*", ident"mres"),
newCall(matchingBigInt, C) newCall(matchingBigInt, C)
) )
) )

4
constantine/io/io_fields.nim
View File

@ -21,8 +21,8 @@ func fromUint*(dst: var Fq,
src: SomeUnsignedInt) = src: SomeUnsignedInt) =
## Parse a regular unsigned integer ## Parse a regular unsigned integer
## and store it into a BigInt of size `bits` ## and store it into a BigInt of size `bits`
dst.nres.fromRawUint(cast[array[sizeof(src), byte]](src), cpuEndian) dst.mres.fromRawUint(cast[array[sizeof(src), byte]](src), cpuEndian)
dst.nres.unsafeMontgomeryResidue(Fq.C.Mod.nres) dst.mres.unsafeMontyResidue(Fq.C.Mod.mres)
func serializeRawUint*(dst: var openarray[byte], func serializeRawUint*(dst: var openarray[byte],
src: Fq, src: Fq,

12
constantine/math/bigints_checked.nim
View File

@ -111,26 +111,26 @@ func reduce*[aBits, mBits](r: var BigInt[mBits], a: BigInt[aBits], M: BigInt[mBi
# pass a pointer+length to a fixed session of the BSS. # pass a pointer+length to a fixed session of the BSS.
reduce(r.view, a.view, M.view) reduce(r.view, a.view, M.view)
func unsafeMontgomeryResidue*[mBits](nres: var BigInt[mBits], N: BigInt[mBits]) = func unsafeMontyResidue*[mBits](mres: var BigInt[mBits], N: BigInt[mBits]) =
## Convert a BigInt from its natural representation ## Convert a BigInt from its natural representation
## to the Montgomery n-residue form ## to the Montgomery n-residue form
## ##
## `nres` is modified in-place ## `mres` is modified in-place
## ##
## Caller must take care of properly switching between ## Caller must take care of properly switching between
## the natural and montgomery domain. ## the natural and montgomery domain.
## Nesting Montgomery form is possible by applying this function twice. ## Nesting Montgomery form is possible by applying this function twice.
montgomeryResidue(nres.view, N.view) montyResidue(mres.view, N.view)
func unsafeRedc*[mBits](nres: var BigInt[mBits], N: BigInt[mBits], negInvModWord: static BaseType) = func unsafeRedc*[mBits](mres: var BigInt[mBits], N: BigInt[mBits], negInvModWord: static BaseType) =
## Convert a BigInt from its Montgomery n-residue form ## Convert a BigInt from its Montgomery n-residue form
## to the natural representation ## to the natural representation
## ##
## `nres` is modified in-place ## `mres` is modified in-place
## ##
## Caller must take care of properly switching between ## Caller must take care of properly switching between
## the natural and montgomery domain. ## the natural and montgomery domain.
redc(nres.view, N.view, Word(negInvModWord)) redc(mres.view, N.view, Word(negInvModWord))
func montyMul*[mBits](r: var BigInt[mBits], a, b, M: BigInt[mBits], negInvModWord: static BaseType) = func montyMul*[mBits](r: var BigInt[mBits], a, b, M: BigInt[mBits], negInvModWord: static BaseType) =
## Compute r <- a*b (mod M) in the Montgomery domain ## Compute r <- a*b (mod M) in the Montgomery domain

2
constantine/math/bigints_raw.nim
View File

@ -393,7 +393,7 @@ func reduce*(r: BigIntViewMut, a: BigIntViewAny, M: BigIntViewConst) =
# #
# ############################################################ # ############################################################
func montgomeryResidue*(a: BigIntViewMut, N: BigIntViewConst) = func montyResidue*(a: BigIntViewMut, N: BigIntViewConst) =
## Transform a bigint ``a`` from it's natural representation (mod N) ## Transform a bigint ``a`` from it's natural representation (mod N)
## to a the Montgomery n-residue representation ## to a the Montgomery n-residue representation
## ##

20
constantine/math/finite_fields.nim
View File

@ -31,13 +31,13 @@ import
# ## P being the prime modulus of the Curve C # ## P being the prime modulus of the Curve C
# ## Internally, data is stored in Montgomery n-residue form # ## Internally, data is stored in Montgomery n-residue form
# ## with the magic constant chosen for convenient division (a power of 2 depending on P bitsize) # ## with the magic constant chosen for convenient division (a power of 2 depending on P bitsize)
# nres*: matchingBigInt(C) # mres*: matchingBigInt(C)
export Fq # defined in ../config/curves to avoid recursive module dependencies export Fq # defined in ../config/curves to avoid recursive module dependencies
debug: debug:
func `==`*(a, b: Fq): CTBool[Word] = func `==`*(a, b: Fq): CTBool[Word] =
## Returns true if 2 big ints are equal ## Returns true if 2 big ints are equal
a.nres == b.nres a.mres == b.mres
# No exceptions allowed # No exceptions allowed
{.push raises: [].} {.push raises: [].}
@ -51,13 +51,13 @@ debug:
func fromBig*(T: type Fq, src: BigInt): T = func fromBig*(T: type Fq, src: BigInt): T =
## Convert a BigInt to its Montgomery form ## Convert a BigInt to its Montgomery form
result.nres = src result.mres = src
result.nres.unsafeMontgomeryResidue(Fq.C.Mod) result.mres.unsafeMontyResidue(Fq.C.Mod)
func toBig*(src: Fq): auto = func toBig*(src: Fq): auto =
## Convert a finite-field element to a BigInt in natral representation ## Convert a finite-field element to a BigInt in natral representation
result = src.nres result = src.mres
result.unsafeRedC(Fq.C.Mod.nres, Fq.C.Mod.nres.negInvModWord()) result.unsafeRedC(Fq.C.Mod.mres, Fq.C.Mod.mres.negInvModWord())
# ############################################################ # ############################################################
# #
@ -72,7 +72,7 @@ template add(a: var Fq, b: Fq, ctl: CTBool[Word]): CTBool[Word] =
## ##
## a and b MAY be the same buffer ## a and b MAY be the same buffer
## a and b MUST have the same announced bitlength (i.e. `bits` static parameters) ## a and b MUST have the same announced bitlength (i.e. `bits` static parameters)
add(a.nres, b.nres, ctl) add(a.mres, b.mres, ctl)
template sub(a: var Fq, b: Fq, ctl: CTBool[Word]): CTBool[Word] = template sub(a: var Fq, b: Fq, ctl: CTBool[Word]): CTBool[Word] =
## Constant-time big integer in-place optional substraction ## Constant-time big integer in-place optional substraction
@ -81,7 +81,7 @@ template sub(a: var Fq, b: Fq, ctl: CTBool[Word]): CTBool[Word] =
## ##
## a and b MAY be the same buffer ## a and b MAY be the same buffer
## a and b MUST have the same announced bitlength (i.e. `bits` static parameters) ## a and b MUST have the same announced bitlength (i.e. `bits` static parameters)
sub(a.nres, b.nres, ctl) sub(a.mres, b.mres, ctl)
# ############################################################ # ############################################################
# #
@ -114,5 +114,5 @@ func `*`*(a, b: Fq): Fq {.noInit.} =
## It is recommended to assign with {.noInit.} ## It is recommended to assign with {.noInit.}
## as Fq elements are usually large and this ## as Fq elements are usually large and this
## routine will zero init internally the result. ## routine will zero init internally the result.
result.nres.setInternalBitLength() result.mres.setInternalBitLength()
result.nres.montyMul(a.nres, b.nres, Fq.C.Mod.nres, Fq.C.Mod.nres.negInvModWord()) result.mres.montyMul(a.mres, b.mres, Fq.C.Mod.mres, Fq.C.Mod.mres.negInvModWord())