module

Noble::Ed25519

Constants

BigInt256 = BigInt.new(255)
CURVE_ORDER = (Two ** (BigInt.new(252))) + (BigInt.new("27742317777372353535851937790883648493"))
D_MINUS_ONE_SQ = BigInt.new("40440834346308536858101042469323190826248399146238708352240133220865137265952")

(d-1)²

Hexes = (0..255).each.with_index.map do |v, i| (i.to_s(16)).rjust(2, '0') end.to_a

Convert between types

INVSQRT_A_MINUS_D = BigInt.new("54469307008909316920995813868745141605393597292927456921205312896311721017578")

1 / √(a-d)

MAX_256B = Noble::Ed25519::Two ** (BigInt.new(256))
One = BigInt.new(1)
ONE_MINUS_D_SQ = BigInt.new("1159843021668779879193775521855586647937357759715417654439879720876111806838")

1-d²

PointPrecomputes = Hash(Point, Array(ExtendedPoint)).new()

Stores precomputed values for points.

SQRT_AD_MINUS_ONE = BigInt.new("25063068953384623474111414158702152701244531502492656460079210482610430750235")

√(ad - 1)

SQRT_D = BigInt.new("6853475219497561581579357271197624642482790079785650197046958215289687604742")

√d aka sqrt(-486664)

SQRT_M1 = BigInt.new("19681161376707505956807079304988542015446066515923890162744021073123829784752")

√(-1) aka √(a) aka 2^((p-1)/4)

Two = BigInt.new(2)
Zero = BigInt.new(0)

Class methods

normalizeScalar(num : Int, max : BigInt, strict = true) : BigInt

** Checks for num to be in range: For strict == true: 0 < num < max. For strict == false: 0 <= num < max. Converts non-float safe numbers to BigInts. /

Source

Instance methods

adjustBytes25519(bytes : Bytes) : Bytes
Source
bytes255ToNumberLE(bytes : Bytes) : BigInt
Source
bytesToHex(uint8a : Bytes) : String
Source
bytesToNumberLE(uint8a : Bytes) : BigInt

Little Endian

Source
concatBytes(*arrays) : Bytes
Source
cswap(swap : BigInt, x_2 : BigInt, x_3 : BigInt) : Tuple(BigInt, BigInt)

cswap from RFC7748

Source
decodeScalar25519(n : Hex) : BigInt
Source
decodeUCoordinate(uEnc : Hex) : BigInt
Source
edIsNegative(num : BigInt)

Little-endian check for first LE bit (last BE bit)

Source
encodeUCoordinate(u : BigInt) : Bytes
Source
ensureBytes(hex : Hex, expectedLength : Int32 | Nil = nil) : Bytes
Source
equalBytes(b1 : Bytes, b2 : Bytes)
Source
getExtendedPublicKey(key : PrivKey)

Private convenience method RFC8032 5.1.5

Source
getPublicKey(privateKey : PrivKey) : Bytes

** Calculates ed25519 public key.

  1. private key is hashed with sha512, then first 32 bytes are taken from the hash
  2. 3 least significant bits of the first byte are cleared RFC8032 5.1.5 /
Source
getSharedSecret(privateKey : PrivKey, publicKey : Hex) : Bytes

** Calculates X25519 DH shared secret from ed25519 private & public keys. Curve25519 used in X25519 consumes private keys as-is, while ed25519 hashes them with sha512. Which means we will need to normalize ed25519 seeds to "hashed repr". @param privateKey ed25519 private key @param publicKey ed25519 public key @returns X25519 shared key /

Source
hexToBytes(hex : String) : Bytes

Caching slows it down 2-3x

Source
invert(number : BigInt, modulo : BigInt = Curve::P) : BigInt

Note: this egcd-based invert is 50% faster than powMod-based one. Inverses number over modulo

Source
invertBatch(nums : Array(BigInt), p : BigInt = Curve::P) : Array(BigInt)

** Takes a list of numbers, efficiently inverts all of them. @param nums list of BigInts @param p modulo @returns list of inverted BigInts @example Noble::Ed25519.invertBatch([1n, 2n, 4n], 21n)

=> [1n, 11n, 16n]

/

Source
invertSqrt(number : BigInt)

Calculates 1/√(number)

Source
mod(a : BigInt, b : BigInt = Curve::P) : BigInt
Source
montgomeryLadder(pointU : BigInt, scalar : BigInt) : BigInt

x25519 from 4 **

@param pointU u coordinate (x) on Montgomery Curve 25519 @param scalar by which the point would be multiplied @returns new Point on Montgomery curve /

Source
numberTo32BytesBE(num : BigInt) : Bytes
Source
numberTo32BytesLE(num : BigInt) : Bytes
Source
pow2(x : BigInt, power : BigInt) : BigInt

Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)

Source
pow_2_252_3(x : BigInt)

Power to (p-5)/8 aka x^(2^252-3) Used to calculate y - the square root of y². Exponentiates it to very big number. We are unwrapping the loop because it's 2x faster. (2n**252n-3n).toString(2) would produce bits [250x 1, 0, 1] We are multiplying it bit-by-bit

Source
sha512ModqLE(*args) : BigInt

Little-endian SHA512 with modulo n

Source
sign(message : Hex, privateKey : Hex) : Bytes

** Signs message with privateKey. RFC8032 5.1.6 /

Source
uvRatio(u : BigInt, v : BigInt) : NamedTuple(isValid: Bool, value: BigInt)

Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3. Constant-time prettier-ignore

Source
verify(sig : SigType, message : Hex, publicKey : PubKey) : Bool

** Verifies ed25519 signature against message and public key. An extended group equation is checked. RFC8032 5.1.7 Compliant with ZIP215: 0 <= sig.R/publicKey < 2**256 (can be >= curve.P) 0 <= sig.s < l Not compliant with RFC8032: it's not possible to comply to both ZIP & RFC at the same time. /

Source

Nested types