bls48286

Documentation

Index

• Constants
• Variables
• func Another(r []*FP48, P1 *ECP8, Q1 *ECP)
• func Another_pc(r []*FP48, T []*FP16, QV *ECP)
• func AuthDecap(config_id int, skR []byte, pkE []byte, pkR []byte, pkS []byte) []byte
• func AuthEncap(config_id int, skE []byte, skS []byte, pkE []byte, pkR []byte, pkS []byte) []byte
• func Comp(a *BIG, b *BIG) int
• func Core_Sign(SIG []byte, M []byte, S []byte) int
• func Core_Verify(SIG []byte, M []byte, W []byte) int
• func Decap(config_id int, skR []byte, pkE []byte, pkR []byte) []byte
• func DeriveKeyPair(config_id int, SK []byte, PK []byte, SEED []byte) bool
• func ECDH_ECIES_DECRYPT(sha int, P1 []byte, P2 []byte, V []byte, C []byte, T []byte, U []byte) []byte
• func ECDH_ECIES_ENCRYPT(sha int, P1 []byte, P2 []byte, RNG *core.RAND, W []byte, M []byte, V []byte, ...) []byte
• func ECDH_ECPSP_DSA(sha int, RNG *core.RAND, S []byte, F []byte, C []byte, D []byte) int
• func ECDH_ECPSVDP_DH(S []byte, WD []byte, Z []byte, typ int) int
• func ECDH_ECPVP_DSA(sha int, W []byte, F []byte, C []byte, D []byte) int
• func ECDH_IN_RANGE(S []byte) bool
• func ECDH_KEY_PAIR_GENERATE(RNG *core.RAND, S []byte, W []byte) int
• func ECDH_PUBLIC_KEY_VALIDATE(W []byte) int
• func Encap(config_id int, skE []byte, pkE []byte, pkR []byte) []byte
• func FP_tpo(i *FP, s *FP) int
• func G1member(P *ECP) bool
• func G2member(P *ECP8) bool
• func GTcyclotomic(m *FP48) bool
• func GTmember(m *FP48) bool
• func Init() int
• func KeyPairGenerate(IKM []byte, S []byte, W []byte) int
• func KeySchedule(config_id int, mode int, Z []byte, info []byte, psk []byte, pskID []byte) ([]byte, []byte, []byte)
• func MPIN_CLIENT_1(CID []byte, rng *core.RAND, X []byte, pin int, TOKEN []byte, SEC []byte, ...) int
• func MPIN_CLIENT_2(X []byte, Y []byte, SEC []byte) int
• func MPIN_ENCODE_TO_CURVE(DST []byte, ID []byte, HCID []byte)
• func MPIN_EXTRACT_PIN(CID []byte, pin int, TOKEN []byte) int
• func MPIN_GET_CLIENT_SECRET(S []byte, IDHTC []byte, CST []byte) int
• func MPIN_GET_SERVER_SECRET(S []byte, SST []byte) int
• func MPIN_HASH_ID(sha int, ID []byte) []byte
• func MPIN_RANDOM_GENERATE(rng *core.RAND, S []byte) int
• func MPIN_SERVER(HID []byte, Y []byte, SST []byte, xID []byte, mSEC []byte) int
• func RFC7748(r *BIG)
• type BIG
  • func FromBytes(b []byte) *BIG
  • func Modadd(a1, b1, m *BIG) *BIG
  • func Modmul(a1, b1, m *BIG) *BIG
  • func Modneg(a1, m *BIG) *BIG
  • func Modsqr(a1, m *BIG) *BIG
  • func NewBIG() *BIG
  • func NewBIGcopy(x *BIG) *BIG
  • func NewBIGdcopy(x *DBIG) *BIG
  • func NewBIGint(x int) *BIG
  • func NewBIGints(x [NLEN]Chunk) *BIG
  • func Random(rng *core.RAND) *BIG
  • func Randomnum(q *BIG, rng *core.RAND) *BIG
  • func Randtrunc(q *BIG, trunc int, rng *core.RAND) *BIG
  • func (r *BIG) Invmodp(p *BIG)
  • func (r *BIG) Jacobi(p *BIG) int
  • func (r *BIG) Minus(x *BIG) *BIG
  • func (r *BIG) Mod(m *BIG)
  • func (r *BIG) Nbits() int
  • func (r *BIG) Plus(x *BIG) *BIG
  • func (r *BIG) Powmod(e1 *BIG, m *BIG) *BIG
  • func (r *BIG) ToBytes(b []byte)
  • func (r *BIG) ToString() string
• type Chunk
• type DBIG
  • func DBIG_fromBytes(b []byte) *DBIG
  • func NewDBIG() *DBIG
  • func NewDBIGcopy(x *DBIG) *DBIG
  • func NewDBIGscopy(x *BIG) *DBIG
  • func (r *DBIG) Mod(m *BIG) *BIG
• type ECP
  • func ECP_fromBytes(b []byte) *ECP
  • func ECP_generator() *ECP
  • func ECP_hap2point(h *BIG) *ECP
  • func ECP_map2point(h *FP) *ECP
  • func ECP_mapit(h []byte) *ECP
  • func ECP_muln(n int, X []*ECP, e []*BIG) *ECP
  • func G1mul(P *ECP, e *BIG) *ECP
  • func NewECP() *ECP
  • func NewECPbig(ix *BIG) *ECP
  • func NewECPbigint(ix *BIG, s int) *ECP
  • func NewECPbigs(ix *BIG, iy *BIG) *ECP
  • func (E *ECP) Add(Q *ECP)
  • func (E *ECP) Affine()
  • func (E *ECP) Cfp()
  • func (E *ECP) Copy(P *ECP)
  • func (E *ECP) Equals(Q *ECP) bool
  • func (E *ECP) GetS() int
  • func (E *ECP) GetX() *BIG
  • func (E *ECP) GetY() *BIG
  • func (E *ECP) Is_infinity() bool
  • func (E *ECP) Mul(e *BIG) *ECP
  • func (E *ECP) Mul2(e *BIG, Q *ECP, f *BIG) *ECP
  • func (E *ECP) Neg()
  • func (E *ECP) Sub(Q *ECP)
  • func (E *ECP) ToBytes(b []byte, compress bool)
  • func (E *ECP) ToString() string
• type ECP8
  • func ECP8_fromBytes(b []byte) *ECP8
  • func ECP8_generator() *ECP8
  • func ECP8_hap2point(h *BIG) *ECP8
  • func ECP8_map2point(H *FP8) *ECP8
  • func ECP8_mapit(h []byte) *ECP8
  • func G2mul(P *ECP8, e *BIG) *ECP8
  • func NewECP8() *ECP8
  • func NewECP8fp8(ix *FP8, s int) *ECP8
  • func NewECP8fp8s(ix *FP8, iy *FP8) *ECP8
  • func (E *ECP8) Add(Q *ECP8) int
  • func (E *ECP8) Affine()
  • func (E *ECP8) Cfp()
  • func (E *ECP8) Copy(P *ECP8)
  • func (E *ECP8) Equals(Q *ECP8) bool
  • func (E *ECP8) GetX() *FP8
  • func (E *ECP8) GetY() *FP8
  • func (E *ECP8) Is_infinity() bool
  • func (E *ECP8) Mul(e *BIG) *ECP8
  • func (E *ECP8) Sub(Q *ECP8) int
  • func (E *ECP8) ToBytes(b []byte, compress bool)
  • func (E *ECP8) ToString() string
• type FP
  • func FP_fromBytes(b []byte) *FP
  • func NewFP() *FP
  • func NewFPbig(a *BIG) *FP
  • func NewFPcopy(a *FP) *FP
  • func NewFPint(a int) *FP
  • func NewFPrand(rng *core.RAND) *FP
  • func RHS(x *FP) *FP
  • func (F *FP) Equals(a *FP) bool
  • func (F *FP) ToBytes(b []byte)
  • func (F *FP) ToString() string
• type FP16
  • func FP16_fromBytes(bf []byte) *FP16
  • func NewFP16() *FP16
  • func NewFP16copy(x *FP16) *FP16
  • func NewFP16fp8(c *FP8) *FP16
  • func NewFP16fp8s(c *FP8, d *FP8) *FP16
  • func NewFP16int(a int) *FP16
  • func (F *FP16) Equals(x *FP16) bool
  • func (F *FP16) ToBytes(bf []byte)
• type FP2
  • func ECP8_frob_constants() [3]*FP2
  • func FP2_fromBytes(bf []byte) *FP2
  • func NewFP2() *FP2
  • func NewFP2big(c *BIG) *FP2
  • func NewFP2bigs(c *BIG, d *BIG) *FP2
  • func NewFP2copy(x *FP2) *FP2
  • func NewFP2fp(c *FP) *FP2
  • func NewFP2fps(c *FP, d *FP) *FP2
  • func NewFP2int(a int) *FP2
  • func NewFP2ints(a int, b int) *FP2
  • func NewFP2rand(rng *core.RAND) *FP2
  • func (F *FP2) Equals(x *FP2) bool
  • func (F *FP2) GetA() *BIG
  • func (F *FP2) GetB() *BIG
  • func (F *FP2) ToBytes(bf []byte)
  • func (F *FP2) ToString() string
• type FP4
  • func FP4_fromBytes(bf []byte) *FP4
  • func NewFP4() *FP4
  • func NewFP4copy(x *FP4) *FP4
  • func NewFP4fp(c *FP) *FP4
  • func NewFP4fp2(c *FP2) *FP4
  • func NewFP4fp2s(c *FP2, d *FP2) *FP4
  • func NewFP4int(a int) *FP4
  • func NewFP4ints(a int, b int) *FP4
  • func NewFP4rand(rng *core.RAND) *FP4
  • func (F *FP4) Equals(x *FP4) bool
  • func (F *FP4) ToBytes(bf []byte)
• type FP48
  • func Ate(P1 *ECP8, Q1 *ECP) *FP48
  • func Ate2(P1 *ECP8, Q1 *ECP, R1 *ECP8, S1 *ECP) *FP48
  • func FP48_fromBytes(w []byte) *FP48
  • func Fexp(m *FP48) *FP48
  • func GTpow(d *FP48, e *BIG) *FP48
  • func Initmp() []*FP48
  • func Miller(r []*FP48) *FP48
  • func NewFP48() *FP48
  • func NewFP48copy(x *FP48) *FP48
  • func NewFP48fp16(d *FP16) *FP48
  • func NewFP48fp16s(d *FP16, e *FP16, f *FP16) *FP48
  • func NewFP48int(d int) *FP48
  • func (F *FP48) Copy(x *FP48)
  • func (F *FP48) Equals(x *FP48) bool
  • func (F *FP48) Inverse()
  • func (F *FP48) Isunity() bool
  • func (F *FP48) Mul(y *FP48)
  • func (F *FP48) Pow(e *BIG) *FP48
  • func (F *FP48) ToBytes(w []byte)
  • func (F *FP48) ToString() string
• type FP8
  • func FP8_fromBytes(bf []byte) *FP8
  • func NewFP8() *FP8
  • func NewFP8copy(x *FP8) *FP8
  • func NewFP8fp(c *FP) *FP8
  • func NewFP8fp4(c *FP4) *FP8
  • func NewFP8fp4s(c *FP4, d *FP4) *FP8
  • func NewFP8int(a int) *FP8
  • func NewFP8ints(a int, b int) *FP8
  • func NewFP8rand(rng *core.RAND) *FP8
  • func RHS8(x *FP8) *FP8
  • func (F *FP8) Equals(x *FP8) bool
  • func (F *FP8) ToBytes(bf []byte)

Constants

const AESKEY int = 16

const ALLOW_ALT_COMPRESS bool = false

const ATE_BITS int = 17

const BAD_PARAMS int = -11

const BAD_PIN int = -19

const BASEBITS uint = 60

const BFS int = int(MODBYTES)

const BGS int = int(MODBYTES)

const BIGBITS int = int(MODBYTES * 8)

const BIG_ENDIAN_SIGN bool = false

const BLS12 int = 2

const BLS24 int = 3

const BLS48 int = 4

const BLS_FAIL int = -1

const BLS_OK int = 0

const BN int = 1

const CHUNK int = 64 /* Set word size */

const CURVETYPE int = WEIERSTRASS

const CURVE_A int = 0

const CURVE_B_I int = 10

const CURVE_Cof_I int = 62958

*** rom curve parameters ***** Ate Bits= 17 G2 Table size= 20

const CURVE_PAIRING_TYPE int = BLS48

const DNLEN int = 2 * NLEN

const D_TYPE int = 0

Pairing Twist type

const EDWARDS int = 1

const EFS int = int(MODBYTES)

const INVALID int = -4

const EGS int = int(MODBYTES)

const ERROR int = -3

const FEXCESS int32 = ((int32(1) << 14) - 1)

const FP_DENSE int = 5

const FP_ONE int = 1

const FP_SPARSE int = 4

const FP_SPARSER int = 3

const FP_SPARSEST int = 2

const FP_ZERO int = 0

Sparsity

const G2_TABLE int = 20

const GENERALISED_MERSENNE int = 3

const HASH_TYPE int = 32

const HBITS uint = (BASEBITS / 2)

const HTC_ISO int = 0

const HTC_ISO_G2 int = 0

const INVALID_POINT int = -14

const INVALID_PUBLIC_KEY int = -2

const MAXPIN int32 = 10000 /* PIN less than this */

const MFS int = int(MODBYTES)

const MGS int = int(MODBYTES)

const MODBITS uint = 286 /* Number of bits in Modulus */

Modulus details

const MODBYTES uint = 36

BIG length in bytes and number base

const MODTYPE int = NOT_SPECIAL //NOT_SPECIAL

const MONTGOMERY int = 2

const MONTGOMERY_FRIENDLY int = 2

const M_TYPE int = 1

const NEGATIVEX int = 1

const NEGATOWER int = 0

const NEXCESS int = (1 << (uint(CHUNK) - BASEBITS - 1))

const NLEN int = int((1 + ((8*MODBYTES - 1) / BASEBITS)))

BIG lengths and Masks

const NOT int = 0

Pairing Friendly?

const NOT_SPECIAL int = 0

Modulus types

const PBLEN int32 = 14 /* Number of bits in PIN */

const PM1D2 uint = 1 /* Modulus mod 8 */

const POSITIVEX int = 0

Pairing x parameter sign

const POSITOWER int = 1

const PSEUDO_MERSENNE int = 1

const QNRI int = 0 // Fp2 QNR

const RIADZ int = 1 /* hash-to-point Z */

const RIADZG2A int = 1 /* G2 hash-to-point Z */

const RIADZG2B int = 0 /* G2 hash-to-point Z */

const SEXTIC_TWIST int = M_TYPE

const SIGN_OF_X int = POSITIVEX

const TBITS uint = MODBITS % BASEBITS // Number of active bits in top word

const TOWER int = NEGATOWER // Tower type

const USE_GLV bool = true

const USE_GS_G2 bool = true

const USE_GS_GT bool = true

const WEIERSTRASS int = 0

Curve types

const WRONG_ORDER int = -18

Variables

var CRu = [...]Chunk{0x5A6539603773F7B, 0x24CEA2CA30AEE39, 0x1F28B5A98667A6F, 0xD810619F5566B10, 0x297243C332B8}

var CURVE_B = [...]Chunk{0xA, 0x0, 0x0, 0x0, 0x0}

var CURVE_Bnx = [...]Chunk{0xF5EF, 0x0, 0x0, 0x0, 0x0}

var CURVE_Cof = [...]Chunk{0xF5EE, 0x0, 0x0, 0x0, 0x0}

var CURVE_Gx = [...]Chunk{0xC897EA3095D59E0, 0xDD97475CEFBA15D, 0x544741A4E84D19, 0xDB88FB476C0F04C, 0x6972433D120}

var CURVE_Gy = [...]Chunk{0xEEF69F970ABEB43, 0x237CE6B580E3E2E, 0x3308DEE53B0AC1F, 0x6E2D78897F979AA, 0x2038E40A1E65}

var CURVE_HTPC = [...]Chunk{0x1, 0x0, 0x0, 0x0, 0x0}

var CURVE_Order = [...]Chunk{0xFC411B2FD612C81, 0x98F28822F29701F, 0xB262A94FBE4FE22, 0x9EB01535FC9EDE6, 0x86BC}

var CURVE_Pxaaa = [...]Chunk{0x8416349856106B5, 0xCC3B1CECC4CC0FE, 0xA952DACAFD9F51A, 0x71D2A27B04CAEB7, 0x22ACFD40531C}

var CURVE_Pxaab = [...]Chunk{0xDECD1BD896D1A55, 0x427718553891DA9, 0xC8A32592FEF56B9, 0x85A58D250C873E4, 0x18DBB9996B5C}

var CURVE_Pxaba = [...]Chunk{0x8811A3A67D7A35E, 0x9FAF4E8CC58A603, 0xC19A506B52AF41C, 0x7C317AE2BDE1D4D, 0xA8292D5DE0A}

var CURVE_Pxabb = [...]Chunk{0x28E8520C2F023E8, 0xF191B5CF33D2D0A, 0xE725CF5DFB62D89, 0x94CD8BBB1F92E81, 0x202BE0D55FAC}

var CURVE_Pxbaa = [...]Chunk{0x8B98D5B8F14CB9B, 0x1A17D62FE2554D8, 0xC71EF6D551B96A2, 0xF76284B52259647, 0x17527369A1E3}

var CURVE_Pxbab = [...]Chunk{0xBF6B286CB60DD54, 0xB8532B9371A2443, 0x638D54D7E6BE9C0, 0x59F346C42D3760D, 0x1101EA485E9D}

var CURVE_Pxbba = [...]Chunk{0x20A5B0AB9D776DA, 0xA657276121135FA, 0xDE41458BE4ADABA, 0xE41FCEF60E4AAD4, 0xF606FCE261F}

var CURVE_Pxbbb = [...]Chunk{0xF3FE23828B50A8E, 0x77554EF2609CEB5, 0x72CE1923A1EC9A5, 0x19566C5168C0002, 0x1F0B30E6920D}

var CURVE_Pyaaa = [...]Chunk{0x26CD5FD67E988BE, 0x1FE5EF8E978BCEE, 0x39B2544F14E8B3, 0xCD557C7F38694FF, 0x21F0F8CDA962}

var CURVE_Pyaab = [...]Chunk{0x778566D0DF11B92, 0x83331801EBC5E08, 0xB840129F0DB40CB, 0xD7A943A25E15861, 0xE01C1FEC6FE}

var CURVE_Pyaba = [...]Chunk{0x47CFA67ABFDD06A, 0x4BCDAB08CFE5925, 0x55AE0A98D2EB8E6, 0xBEA2D9EBB35EFF2, 0x12C0FFB8C3D6}

var CURVE_Pyabb = [...]Chunk{0xB3DDFD3788A47F4, 0x195F9A36106B328, 0x4B28538511F157D, 0xFF3A1DDBDD352B3, 0x156831E55BDF}

var CURVE_Pybaa = [...]Chunk{0xB6EDB7345E39E77, 0x4C8190FF9538C4C, 0xF647CDEF2511932, 0x84EB4F5EF4193ED, 0x738E40AA018}

var CURVE_Pybab = [...]Chunk{0x3282814364975C6, 0xBE24AD9CA88C0B0, 0x1969B0DAE613723, 0x24391C50369BE1A, 0x13658766896E}

var CURVE_Pybba = [...]Chunk{0xBD339ABC1BF2D7C, 0xB713EF1B3AA2440, 0x6145A099D3837F1, 0xC9C5EE34A88F81B, 0x1FB0A8375143}

var CURVE_Pybbb = [...]Chunk{0xAA9A0D1E51130A6, 0xEB9E708362553DA, 0xEDA47676A7C687E, 0x9E9A1777B2D6330, 0x193F378DC6AC}

var Fra = [...]Chunk{0xEA8695F3FC90183, 0xC556BED1BD3E936, 0xD903EF0268F09A7, 0x114E8AEC2FE0043, 0xD9417EC522C}

var Frb = [...]Chunk{0xFCC9959E0D332D8, 0x30EB0580D0F69A2, 0xEFC3F2A99B90003, 0xC66195305165A42, 0x1BDEAD459A4F}

var G2_TAB []*FP16

var Modulus = [...]Chunk{0xE7502B9209C345B, 0xF641C4528E352D9, 0xC8C7E1AC04809AA, 0xD7B0201C8145A86, 0x2972C531EC7B}

Base bits= 60

var R2modp = [...]Chunk{0x61F9539D245AF2C, 0xA1991A6E51410D8, 0x1603A99FC661885, 0xC8A2CE485CD7822, 0xD54A6F0B25E}

var ROI = [...]Chunk{0xE7502B9209C345A, 0xF641C4528E352D9, 0xC8C7E1AC04809AA, 0xD7B0201C8145A86, 0x2972C531EC7B}

var SQRTm3 = [...]Chunk{0xCD7A472E6524A9C, 0x535B8141D328998, 0x758989A7084EB33, 0xD870A3222987B99, 0x2971C25478F5}

var TWK = [...]Chunk{0xA7D9735C3D05DCC, 0x1997054542A70B9, 0xBCCBD14CBAA2C6A, 0x33519F37367221F, 0x1D20EDEF448A}

Functions

func Another

func Another(r []*FP48, P1 *ECP8, Q1 *ECP)

Accumulate another set of line functions for n-pairing

func Another_pc

func Another_pc(r []*FP48, T []*FP16, QV *ECP)

func AuthDecap

func AuthDecap(config_id int, skR []byte, pkE []byte, pkR []byte, pkS []byte) []byte

func AuthEncap

func AuthEncap(config_id int, skE []byte, skS []byte, pkE []byte, pkR []byte, pkS []byte) []byte

func Comp

func Comp(a *BIG, b *BIG) int

Compare a and b, return 0 if a==b, -1 if a<b, +1 if a>b. Inputs must be normalised

func Core_Sign

func Core_Sign(SIG []byte, M []byte, S []byte) int

Sign message m using private key S to produce signature SIG

func Core_Verify

func Core_Verify(SIG []byte, M []byte, W []byte) int

func Decap

func Decap(config_id int, skR []byte, pkE []byte, pkR []byte) []byte

func DeriveKeyPair

func DeriveKeyPair(config_id int, SK []byte, PK []byte, SEED []byte) bool

func ECDH_ECIES_DECRYPT

func ECDH_ECIES_DECRYPT(sha int, P1 []byte, P2 []byte, V []byte, C []byte, T []byte, U []byte) []byte

IEEE1363 ECIES decryption. Decryption of ciphertext V,C,T using private key U outputs plaintext M

func ECDH_ECIES_ENCRYPT

func ECDH_ECIES_ENCRYPT(sha int, P1 []byte, P2 []byte, RNG *core.RAND, W []byte, M []byte, V []byte, T []byte) []byte

IEEE1363 ECIES encryption. Encryption of plaintext M uses public key W and produces ciphertext V,C,T

func ECDH_ECPSP_DSA

func ECDH_ECPSP_DSA(sha int, RNG *core.RAND, S []byte, F []byte, C []byte, D []byte) int

IEEE ECDSA Signature, C and D are signature on F using private key S

func ECDH_ECPSVDP_DH

func ECDH_ECPSVDP_DH(S []byte, WD []byte, Z []byte, typ int) int

IEEE-1363 Diffie-Hellman online calculation Z=S.WD

type = 0 is just x coordinate output type = 1 for standard compressed output type = 2 for standard uncompress output 04|x|y

func ECDH_ECPVP_DSA

func ECDH_ECPVP_DSA(sha int, W []byte, F []byte, C []byte, D []byte) int

IEEE1363 ECDSA Signature Verification. Signature C and D on F is verified using public key W

func ECDH_IN_RANGE

func ECDH_IN_RANGE(S []byte) bool

return true if S is in ranger 0 < S < order , else return false

func ECDH_KEY_PAIR_GENERATE

func ECDH_KEY_PAIR_GENERATE(RNG *core.RAND, S []byte, W []byte) int

Calculate a public/private EC GF(p) key pair W,S where W=S.G mod EC(p), * where S is the secret key and W is the public key * and G is fixed generator. * If RNG is NULL then the private key is provided externally in S * otherwise it is generated randomly internally

func ECDH_PUBLIC_KEY_VALIDATE

func ECDH_PUBLIC_KEY_VALIDATE(W []byte) int

validate public key

func Encap

func Encap(config_id int, skE []byte, pkE []byte, pkR []byte) []byte

func FP_tpo

func FP_tpo(i *FP, s *FP) int

Two for the price of one - See Hamburg https://eprint.iacr.org/2012/309.pdf Calculate inverse of i and square root of s, return QR

func G1member

func G1member(P *ECP) bool

test G1 group membership

func G2member

func G2member(P *ECP8) bool

test G2 group membership

func GTcyclotomic

func GTcyclotomic(m *FP48) bool

Check that m is in cyclotomic sub-group Check that m!=1, conj(m)*m==1, and m.m^{p^16}=m^{p^8}

func GTmember

func GTmember(m *FP48) bool

test for full GT membership

func Init

func Init() int

func KeyPairGenerate

func KeyPairGenerate(IKM []byte, S []byte, W []byte) int

generate key pair, private key S, public key W

func KeySchedule

func KeySchedule(config_id int, mode int, Z []byte, info []byte, psk []byte, pskID []byte) ([]byte, []byte, []byte)

func MPIN_CLIENT_1

func MPIN_CLIENT_1(CID []byte, rng *core.RAND, X []byte, pin int, TOKEN []byte, SEC []byte, xID []byte) int

Implement step 1 on client side of MPin protocol

func MPIN_CLIENT_2

func MPIN_CLIENT_2(X []byte, Y []byte, SEC []byte) int

Implement step 2 on client side of MPin protocol

func MPIN_ENCODE_TO_CURVE

func MPIN_ENCODE_TO_CURVE(DST []byte, ID []byte, HCID []byte)

func MPIN_EXTRACT_PIN

func MPIN_EXTRACT_PIN(CID []byte, pin int, TOKEN []byte) int

func MPIN_GET_CLIENT_SECRET

func MPIN_GET_CLIENT_SECRET(S []byte, IDHTC []byte, CST []byte) int

func MPIN_GET_SERVER_SECRET

func MPIN_GET_SERVER_SECRET(S []byte, SST []byte) int

Extract Server Secret SST=S*Q where Q is fixed generator in G2 and S is master secret

func MPIN_HASH_ID

func MPIN_HASH_ID(sha int, ID []byte) []byte

func MPIN_RANDOM_GENERATE

func MPIN_RANDOM_GENERATE(rng *core.RAND, S []byte) int

create random secret S

func MPIN_SERVER

func MPIN_SERVER(HID []byte, Y []byte, SST []byte, xID []byte, mSEC []byte) int

Implement step 2 of MPin protocol on server side

func RFC7748

func RFC7748(r *BIG)

Transform a point multiplier to RFC7748 form

Types

type BIG

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

func FromBytes

func FromBytes(b []byte) *BIG

func Modadd

func Modadd(a1, b1, m *BIG) *BIG

return a+b mod m

func Modmul

func Modmul(a1, b1, m *BIG) *BIG

return a*b mod m

func Modneg

func Modneg(a1, m *BIG) *BIG

return -a mod m

func Modsqr

func Modsqr(a1, m *BIG) *BIG

return a^2 mod m

func NewBIG

func NewBIG() *BIG

func NewBIGcopy

func NewBIGcopy(x *BIG) *BIG

func NewBIGdcopy

func NewBIGdcopy(x *DBIG) *BIG

func NewBIGint

func NewBIGint(x int) *BIG

func NewBIGints

func NewBIGints(x [NLEN]Chunk) *BIG

func Random

func Random(rng *core.RAND) *BIG

get 8*MODBYTES size random number

func Randomnum

func Randomnum(q *BIG, rng *core.RAND) *BIG

Create random BIG in portable way, one bit at a time

func Randtrunc

func Randtrunc(q *BIG, trunc int, rng *core.RAND) *BIG

func (*BIG) Invmodp

func (r *BIG) Invmodp(p *BIG)

this=1/this mod p. Binary method

func (*BIG) Jacobi

func (r *BIG) Jacobi(p *BIG) int

Jacobi Symbol (this/p). Returns 0, 1 or -1

func (*BIG) Minus

func (r *BIG) Minus(x *BIG) *BIG

return this-x

func (*BIG) Mod

func (r *BIG) Mod(m *BIG)

reduce this mod m

func (*BIG) Nbits

func (r *BIG) Nbits() int

func (*BIG) Plus

func (r *BIG) Plus(x *BIG) *BIG

return this+x

func (*BIG) Powmod

func (r *BIG) Powmod(e1 *BIG, m *BIG) *BIG

return this^e mod m

func (*BIG) ToBytes

func (r *BIG) ToBytes(b []byte)

func (*BIG) ToString

func (r *BIG) ToString() string

Convert to Hex String

type Chunk

type Chunk int64

const BMASK Chunk = ((Chunk(1) << BASEBITS) - 1)

const HMASK Chunk = ((Chunk(1) << HBITS) - 1)

const MConst Chunk = 0x227E5D8F6EA242D

const OMASK Chunk = ((Chunk(-1)) << (MODBITS % BASEBITS))

Modulus Masks

const TMASK Chunk = (Chunk(1) << TBITS) - 1

type DBIG

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

func DBIG_fromBytes

func DBIG_fromBytes(b []byte) *DBIG

convert from byte array to BIG

func NewDBIG

func NewDBIG() *DBIG

func NewDBIGcopy

func NewDBIGcopy(x *DBIG) *DBIG

func NewDBIGscopy

func NewDBIGscopy(x *BIG) *DBIG

func (*DBIG) Mod

func (r *DBIG) Mod(m *BIG) *BIG

reduces this DBIG mod a BIG, and returns the BIG

type ECP

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

func ECP_fromBytes

func ECP_fromBytes(b []byte) *ECP

convert from byte array to point

func ECP_generator

func ECP_generator() *ECP

func ECP_hap2point

func ECP_hap2point(h *BIG) *ECP

Hunt and Peck a BIG to a curve point

func ECP_map2point

func ECP_map2point(h *FP) *ECP

Constant time Map to Point

func ECP_mapit

func ECP_mapit(h []byte) *ECP

func ECP_muln

func ECP_muln(n int, X []*ECP, e []*BIG) *ECP

Generic multi-multiplication, fixed 4-bit window, P=Sigma e_i*X_i

func G1mul

func G1mul(P *ECP, e *BIG) *ECP

Multiply P by e in group G1

func NewECP

func NewECP() *ECP

Constructors

func NewECPbig

func NewECPbig(ix *BIG) *ECP

set from x - calculate y from curve equation

func NewECPbigint

func NewECPbigint(ix *BIG, s int) *ECP

set (x,y) from BIG and a bit

func NewECPbigs

func NewECPbigs(ix *BIG, iy *BIG) *ECP

set (x,y) from two BIGs

func (*ECP) Add

func (E *ECP) Add(Q *ECP)

this+=Q

func (*ECP) Affine

func (E *ECP) Affine()

set to affine - from (x,y,z) to (x,y)

func (*ECP) Cfp

func (E *ECP) Cfp()

func (*ECP) Copy

func (E *ECP) Copy(P *ECP)

this=P

func (*ECP) Equals

func (E *ECP) Equals(Q *ECP) bool

Test P == Q

func (*ECP) GetS

func (E *ECP) GetS() int

get sign of Y

func (*ECP) GetX

func (E *ECP) GetX() *BIG

extract x as a BIG

func (*ECP) GetY

func (E *ECP) GetY() *BIG

extract y as a BIG

func (*ECP) Is_infinity

func (E *ECP) Is_infinity() bool

test for O point-at-infinity

func (*ECP) Mul

func (E *ECP) Mul(e *BIG) *ECP

Public version

func (*ECP) Mul2

func (E *ECP) Mul2(e *BIG, Q *ECP, f *BIG) *ECP

func (*ECP) Neg

func (E *ECP) Neg()

this=-this

func (*ECP) Sub

func (E *ECP) Sub(Q *ECP)

this-=Q

func (*ECP) ToBytes

func (E *ECP) ToBytes(b []byte, compress bool)

convert to byte array

func (*ECP) ToString

func (E *ECP) ToString() string

convert to hex string

type ECP8

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

func ECP8_fromBytes

func ECP8_fromBytes(b []byte) *ECP8

convert from byte array to point

func ECP8_generator

func ECP8_generator() *ECP8

func ECP8_hap2point

func ECP8_hap2point(h *BIG) *ECP8

func ECP8_map2point

func ECP8_map2point(H *FP8) *ECP8

Deterministic mapping of Fp to point on curve

func ECP8_mapit

func ECP8_mapit(h []byte) *ECP8

Map octet string to curve point

func G2mul

func G2mul(P *ECP8, e *BIG) *ECP8

Multiply P by e in group G2

func NewECP8

func NewECP8() *ECP8

func NewECP8fp8

func NewECP8fp8(ix *FP8, s int) *ECP8

construct this from x - but set to O if not on curve

func NewECP8fp8s

func NewECP8fp8s(ix *FP8, iy *FP8) *ECP8

construct this from (x,y) - but set to O if not on curve

func (*ECP8) Add

func (E *ECP8) Add(Q *ECP8) int

this+=Q - return 0 for add, 1 for double, -1 for O

func (*ECP8) Affine

func (E *ECP8) Affine()

set to Affine - (x,y,z) to (x,y)

func (*ECP8) Cfp

func (E *ECP8) Cfp()

needed for SOK

func (*ECP8) Copy

func (E *ECP8) Copy(P *ECP8)

copy this=P

func (*ECP8) Equals

func (E *ECP8) Equals(Q *ECP8) bool

Test if P == Q

func (*ECP8) GetX

func (E *ECP8) GetX() *FP8

extract affine x as FP2

func (*ECP8) GetY

func (E *ECP8) GetY() *FP8

extract affine y as FP2

func (*ECP8) Is_infinity

func (E *ECP8) Is_infinity() bool

Test this=O?

func (*ECP8) Mul

func (E *ECP8) Mul(e *BIG) *ECP8

Public version

func (*ECP8) Sub

func (E *ECP8) Sub(Q *ECP8) int

set this-=Q

func (*ECP8) ToBytes

func (E *ECP8) ToBytes(b []byte, compress bool)

convert to byte array

func (*ECP8) ToString

func (E *ECP8) ToString() string

convert this to hex string

type FP

type FP struct {
	XES int32
	// contains filtered or unexported fields
}

func FP_fromBytes

func FP_fromBytes(b []byte) *FP

func NewFP

func NewFP() *FP

func NewFPbig

func NewFPbig(a *BIG) *FP

func NewFPcopy

func NewFPcopy(a *FP) *FP

func NewFPint

func NewFPint(a int) *FP

func NewFPrand

func NewFPrand(rng *core.RAND) *FP

func RHS

func RHS(x *FP) *FP

Calculate RHS of curve equation

func (*FP) Equals

func (F *FP) Equals(a *FP) bool

return TRUE if this==a

func (*FP) ToBytes

func (F *FP) ToBytes(b []byte)

func (*FP) ToString

func (F *FP) ToString() string

type FP16

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

func FP16_fromBytes

func FP16_fromBytes(bf []byte) *FP16

func NewFP16

func NewFP16() *FP16

func NewFP16copy

func NewFP16copy(x *FP16) *FP16

func NewFP16fp8

func NewFP16fp8(c *FP8) *FP16

func NewFP16fp8s

func NewFP16fp8s(c *FP8, d *FP8) *FP16

func NewFP16int

func NewFP16int(a int) *FP16

Constructors

func (*FP16) Equals

func (F *FP16) Equals(x *FP16) bool

test this=x?

func (*FP16) ToBytes

func (F *FP16) ToBytes(bf []byte)

type FP2

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

func ECP8_frob_constants

func ECP8_frob_constants() [3]*FP2

func FP2_fromBytes

func FP2_fromBytes(bf []byte) *FP2

func NewFP2

func NewFP2() *FP2

func NewFP2big

func NewFP2big(c *BIG) *FP2

func NewFP2bigs

func NewFP2bigs(c *BIG, d *BIG) *FP2

func NewFP2copy

func NewFP2copy(x *FP2) *FP2

func NewFP2fp

func NewFP2fp(c *FP) *FP2

func NewFP2fps

func NewFP2fps(c *FP, d *FP) *FP2

func NewFP2int

func NewFP2int(a int) *FP2

Constructors

func NewFP2ints

func NewFP2ints(a int, b int) *FP2

func NewFP2rand

func NewFP2rand(rng *core.RAND) *FP2

func (*FP2) Equals

func (F *FP2) Equals(x *FP2) bool

test this=x

func (*FP2) GetA

func (F *FP2) GetA() *BIG

extract a

func (*FP2) GetB

func (F *FP2) GetB() *BIG

extract b

func (*FP2) ToBytes

func (F *FP2) ToBytes(bf []byte)

func (*FP2) ToString

func (F *FP2) ToString() string

output to hex string

type FP4

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

func FP4_fromBytes

func FP4_fromBytes(bf []byte) *FP4

func NewFP4

func NewFP4() *FP4

func NewFP4copy

func NewFP4copy(x *FP4) *FP4

func NewFP4fp

func NewFP4fp(c *FP) *FP4

func NewFP4fp2

func NewFP4fp2(c *FP2) *FP4

func NewFP4fp2s

func NewFP4fp2s(c *FP2, d *FP2) *FP4

func NewFP4int

func NewFP4int(a int) *FP4

Constructors

func NewFP4ints

func NewFP4ints(a int, b int) *FP4

Constructors

func NewFP4rand

func NewFP4rand(rng *core.RAND) *FP4

func (*FP4) Equals

func (F *FP4) Equals(x *FP4) bool

test this=x?

func (*FP4) ToBytes

func (F *FP4) ToBytes(bf []byte)

type FP48

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

func Ate

func Ate(P1 *ECP8, Q1 *ECP) *FP48

Optimal R-ate pairing

func Ate2

func Ate2(P1 *ECP8, Q1 *ECP, R1 *ECP8, S1 *ECP) *FP48

Optimal R-ate double pairing e(P,Q).e(R,S)

func FP48_fromBytes

func FP48_fromBytes(w []byte) *FP48

convert from byte array to FP48

func Fexp

func Fexp(m *FP48) *FP48

final exponentiation - keep separate for multi-pairings and to avoid thrashing stack

func GTpow

func GTpow(d *FP48, e *BIG) *FP48

f=f^e Note that this method requires a lot of RAM!

func Initmp

func Initmp() []*FP48

prepare for multi-pairing

func Miller

func Miller(r []*FP48) *FP48

basic Miller loop

func NewFP48

func NewFP48() *FP48

func NewFP48copy

func NewFP48copy(x *FP48) *FP48

func NewFP48fp16

func NewFP48fp16(d *FP16) *FP48

Constructors

func NewFP48fp16s

func NewFP48fp16s(d *FP16, e *FP16, f *FP16) *FP48

func NewFP48int

func NewFP48int(d int) *FP48

func (*FP48) Copy

func (F *FP48) Copy(x *FP48)

copy this=x

func (*FP48) Equals

func (F *FP48) Equals(x *FP48) bool

return 1 if x==y, else 0

func (*FP48) Inverse

func (F *FP48) Inverse()

this=1/this

func (*FP48) Isunity

func (F *FP48) Isunity() bool

test x==1 ?

func (*FP48) Mul

func (F *FP48) Mul(y *FP48)

FP48 full multiplication this=this*y

func (*FP48) Pow

func (F *FP48) Pow(e *BIG) *FP48

this=this^e

func (*FP48) ToBytes

func (F *FP48) ToBytes(w []byte)

convert this to byte array

func (*FP48) ToString

func (F *FP48) ToString() string

convert to hex string

type FP8

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

func FP8_fromBytes

func FP8_fromBytes(bf []byte) *FP8

func NewFP8

func NewFP8() *FP8

func NewFP8copy

func NewFP8copy(x *FP8) *FP8

func NewFP8fp

func NewFP8fp(c *FP) *FP8

func NewFP8fp4

func NewFP8fp4(c *FP4) *FP8

func NewFP8fp4s

func NewFP8fp4s(c *FP4, d *FP4) *FP8

func NewFP8int

func NewFP8int(a int) *FP8

Constructors

func NewFP8ints

func NewFP8ints(a int, b int) *FP8

Constructors

func NewFP8rand

func NewFP8rand(rng *core.RAND) *FP8

func RHS8

func RHS8(x *FP8) *FP8

Calculate RHS of twisted curve equation x^3+B/i

func (*FP8) Equals

func (F *FP8) Equals(x *FP8) bool

test this=x?

func (*FP8) ToBytes

func (F *FP8) ToBytes(bf []byte)