diff --git a/integration-tests/auth_utils.go b/integration-tests/auth_utils.go index 568f0c56..bf52d1b3 100644 --- a/integration-tests/auth_utils.go +++ b/integration-tests/auth_utils.go @@ -8,37 +8,40 @@ import ( "net/http" "code.miracl.com/maas/maas/src/lib/gomiracl" - "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" - "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" + "code.miracl.com/maas/maas/src/lib/gomiracl/curve" + "code.miracl.com/maas/maas/src/lib/gomiracl/mpin" ) var errAuthenticate = errors.New("error making the authenticate request") -func authenticate(httpClient *http.Client, identity identity, pin int, code string) error { - // Get pass1 proof from the token and pin (this is the U param in /pass1). - rand := bindings.NewRand([]byte{}) - X := make([]byte, 32) - proof := make([]byte, 65) +func authenticate(httpClient *http.Client, identity *identity, pin int, code string) error { + token := mpin.NewClientToken(identity.Token, curve.BN254CX) - xR, S, U, _, err := wrap.Client1BN254CX(int(gomiracl.SHA256), 0, identity.MPinID, rand, X, pin, identity.Token, proof) + // Client Pass 1. + pass1Proof, err := token.Pass1(identity.dvsMPinID(), pin, gomiracl.SHA256, newRand()) if err != nil { return fmt.Errorf("error getting client 1: %w", err) } - // Call to /rps/v2/pass1 endpoint. - p1Response, err := pass1Request(httpClient, identity, U, "oidc") + // Call to /rps/v2/pass1 endpoint for Server Pass 1. + p1Response, err := pass1Request(httpClient, identity.MPinID, identity.PublicKey, pass1Proof.U, pass1Proof.UT, identity.DTAs, "jwt") if err != nil { return fmt.Errorf("error making the pass 1 request: %w", err) } - // Get V (used in /pass2) param using Y param from the pass1 response. - V, err := wrap.Client2BN254CX(xR, hex2bytes(p1Response.Y), S) + y, err := hex.DecodeString(p1Response.Y) + if err != nil { + return fmt.Errorf("error decoding pass1 response: %w", err) + } + + // Client Pass 2. + pass2Proof, err := token.Pass2(pass1Proof.X, y, pass1Proof.SEC) if err != nil { return fmt.Errorf("error getting client 2: %w", err) } - // Call to /rps/v2/pass2 endpoint. - p2Response, err := pass2Request(httpClient, identity, V, code) + // Call to /rps/v2/pass2 endpoint for Server Pass 2. + p2Response, err := pass2Request(httpClient, identity.MPinID, pass2Proof.V, code) if err != nil { return fmt.Errorf("error making the pass 2 request: %w", err) } @@ -56,23 +59,29 @@ func authenticate(httpClient *http.Client, identity identity, pin int, code stri return nil } -func pass1Request(httpClient *http.Client, identity identity, proof []byte, scope ...string) (p1Response *pass1Response, err error) { - payload := struct { - U string `json:"U"` - MPinID string `json:"mpin_id"` - DTAs string `json:"dtas"` - Scope []string `json:"scope"` +func pass1Request(httpClient *http.Client, mpinID, pubKey, u, ut []byte, dtas string, scope ...string) (p1Response *pass1Response, err error) { + payload := &struct { + DTAs string `json:"dtas"` + MPinID string `json:"mpin_id"` + Pass int `json:"pass"` + PublicKey string `json:"publicKey"` + Scope []string `json:"scope"` + U string `json:"U"` + UT string `json:"UT"` }{ - hex.EncodeToString(proof), - hex.EncodeToString(identity.MPinID), - identity.DTAs, - scope, + DTAs: dtas, + MPinID: hex.EncodeToString(mpinID), + Pass: 1, + PublicKey: hex.EncodeToString(pubKey), + Scope: scope, + U: hex.EncodeToString(u), + UT: hex.EncodeToString(ut), } resp, err := makeRequest( httpClient, options.projectDomain+"/rps/v2/pass1", - "POST", + http.MethodPost, payload, ) if err != nil { @@ -86,21 +95,21 @@ func pass1Request(httpClient *http.Client, identity identity, proof []byte, scop return p1Response, nil } -func pass2Request(httpClient *http.Client, identity identity, proof []byte, wid string) (p2Response *pass2Response, err error) { - payload := struct { +func pass2Request(httpClient *http.Client, mpinID, proof []byte, wid string) (p2Response *pass2Response, err error) { + payload := &struct { + MPinID string `json:"mpin_id"` V string `json:"V"` WID string `json:"WID"` - MPinID string `json:"mpin_id"` }{ - hex.EncodeToString(proof), - wid, - hex.EncodeToString(identity.MPinID), + MPinID: hex.EncodeToString(mpinID), + V: hex.EncodeToString(proof), + WID: wid, } resp, err := makeRequest( httpClient, options.projectDomain+"/rps/v2/pass2", - "POST", + http.MethodPost, payload, ) if err != nil { @@ -124,7 +133,7 @@ func authenticateRequest(httpClient *http.Client, authOTT string) (authResponse resp, err := makeRequest( httpClient, options.projectDomain+"/rps/v2/authenticate", - "POST", + http.MethodPost, payload, ) if err != nil { @@ -148,7 +157,7 @@ func accessRequest(httpClient *http.Client, webOTT string) (accessResponse *acce resp, err := makeRequest( httpClient, options.projectDomain+"/rps/v2/access", - "POST", + http.MethodPost, payload, ) if err != nil { diff --git a/integration-tests/register_utils.go b/integration-tests/register_utils.go index b2ccfdd5..7933bf64 100644 --- a/integration-tests/register_utils.go +++ b/integration-tests/register_utils.go @@ -2,14 +2,15 @@ package main import ( b64 "encoding/base64" + "encoding/hex" "encoding/json" - "errors" "fmt" "net/http" "net/url" "code.miracl.com/maas/maas/src/lib/gomiracl" - "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" + "code.miracl.com/maas/maas/src/lib/gomiracl/curve" + "code.miracl.com/maas/maas/src/lib/gomiracl/mpin" ) func createSession(httpClient *http.Client, projectID, userID string) (*sessionResponse, error) { @@ -40,26 +41,27 @@ func createSession(httpClient *http.Client, projectID, userID string) (*sessionR return createSessionResponse, nil } -func register(httpClient *http.Client, projectID, userID, deviceName string, pin int, accessID string) (i identity, err error) { +func register(httpClient *http.Client, projectID, userID, deviceName string, pin int) (i *identity, err error) { // Call to /verification endpoint. - verifyURL, err := verificationRequest(httpClient, userID, deviceName, accessID, projectID) + verifyURL, err := verificationRequest(httpClient, userID, deviceName, projectID) if err != nil { - return identity{}, err + return nil, err } verificationCode, err := getVerificationCode(verifyURL) if err != nil { - return identity{}, err + return nil, err } + // Call to /verification/confirmation endpoint. activationToken, err := verificationConfirmation(httpClient, userID, verificationCode) if err != nil { - return identity{}, err + return nil, err } - id, err := newIdentity(httpClient, userID, deviceName, accessID, activationToken, pin) + id, err := newIdentity(httpClient, userID, deviceName, activationToken, pin) if err != nil { - return identity{}, err + return nil, err } return id, nil @@ -69,7 +71,7 @@ func getProjectID(httpClient *http.Client) (projectID string, err error) { resp, err := makeRequest( httpClient, options.projectDomain+"/.well-known/project-configuration", - "GET", + http.MethodGet, nil, ) if err != nil { @@ -87,45 +89,39 @@ func getProjectID(httpClient *http.Client) (projectID string, err error) { return projectResponse.ID, nil } -func newIdentity(httpClient *http.Client, userID, deviceName, accessID, activationToken string, pin int) (i identity, err error) { - // Call to /rps/v2/user endpoint. - regResponse, err := registerRequest(httpClient, userID, deviceName, accessID, activationToken) - if err != nil { - return identity{}, err - } - - // Call to /signature endpoint. - sigResponse, err := signatureRequest(httpClient, regResponse.MPinID, regResponse.RegOTT) +func newIdentity(httpClient *http.Client, userID, deviceName, activationToken string, pin int) (i *identity, err error) { + privateKey, publicKey, err := curve.BN254CX.GetDVSKeyPair(newRand(), nil) if err != nil { - return identity{}, err + return nil, fmt.Errorf("error generating key pair: %w", err) } - // Call to /dta/ID endpoint. - csResponse, err := clientSecretRequest(httpClient, sigResponse.CS2URL) + // Call to /registration endpoint. + regResponse, err := registrationRequest(httpClient, userID, deviceName, hex.EncodeToString(publicKey), activationToken) if err != nil { - return identity{}, err + return nil, err } - // Combine both client secrets. - Q, err := wrap.RecombineG1BN254CX(hex2bytes(sigResponse.ClientSecretShare), hex2bytes(csResponse.ClientSecret)) + mpinID, err := hex.DecodeString(regResponse.MPinID) if err != nil { - return identity{}, err + return nil, err } - // First extract pin from the combine client secret, in order to get the token. - CS, err := wrap.ExtractPINBN254CX(int(gomiracl.SHA256), hex2bytes(regResponse.MPinID), pin, Q) + // Call to all SecretURLs to get client secrets and combine them to create a client token. + clientToken, err := clientTokenRequests(httpClient, regResponse.SecretURLs, mpinID, publicKey, privateKey, pin) if err != nil { - return identity{}, err + return nil, err } - return identity{ - MPinID: hex2bytes(regResponse.MPinID), - Token: CS, - DTAs: sigResponse.DTAs, + return &identity{ + MPinID: mpinID, + Token: clientToken, + DTAs: regResponse.DTAs, + PublicKey: publicKey, + PrivateKey: privateKey, }, nil } -func verificationRequest(httpClient *http.Client, userID, deviceName, accessID, projectID string) (string, error) { +func verificationRequest(httpClient *http.Client, userID, deviceName, projectID string) (string, error) { clientIDAndSecret := options.clientID + ":" + options.clientSecret authHeaderValue := "Basic " + b64.StdEncoding.EncodeToString([]byte(clientIDAndSecret)) @@ -133,14 +129,12 @@ func verificationRequest(httpClient *http.Client, userID, deviceName, accessID, ProjectID string `json:"projectId"` UserID string `json:"userId"` DeviceName string `json:"deviceName"` - AccessID string `json:"accessId"` Delivery string `json:"delivery"` Authorization string `json:"-"` }{ projectID, userID, deviceName, - accessID, "no", authHeaderValue, } @@ -148,7 +142,7 @@ func verificationRequest(httpClient *http.Client, userID, deviceName, accessID, resp, err := makeRequest( httpClient, options.projectDomain+"/verification", - "POST", + http.MethodPost, payload, header{Key: "Authorization", Value: authHeaderValue}, ) @@ -156,7 +150,7 @@ func verificationRequest(httpClient *http.Client, userID, deviceName, accessID, return "", err } - var verificationResponse *verificationURLResponse + var verificationResponse verificationURLResponse if err := json.Unmarshal(resp, &verificationResponse); err != nil { return "", err @@ -165,23 +159,23 @@ func verificationRequest(httpClient *http.Client, userID, deviceName, accessID, return verificationResponse.VerificationURL, nil } -func registerRequest(httpClient *http.Client, userID, deviceName, accessID, activateCode string) (*registerResponse, error) { - payload := struct { - UserID string `json:"userId"` - DeviceName string `json:"deviceName"` - WID string `json:"wid"` - ActivateCode string `json:"activateCode"` +func registrationRequest(httpClient *http.Client, userID, deviceName, publicKey, activationToken string) (*registrationResponse, error) { + payload := &struct { + ActivationToken string `json:"activationToken"` + DeviceName string `json:"deviceName"` + PublicKey string `json:"publicKey"` + UserID string `json:"userId"` }{ - DeviceName: deviceName, - UserID: userID, - WID: accessID, - ActivateCode: activateCode, + ActivationToken: activationToken, + DeviceName: deviceName, + PublicKey: publicKey, + UserID: userID, } resp, err := makeRequest( httpClient, - options.projectDomain+"/rps/v2/user", - "PUT", + options.projectDomain+"/registration", + http.MethodPost, payload, header{Key: "X-MIRACL-CID", Value: "mcl"}, ) @@ -189,59 +183,62 @@ func registerRequest(httpClient *http.Client, userID, deviceName, accessID, acti return nil, err } - var registerResponse *registerResponse - if err := json.Unmarshal(resp, ®isterResponse); err != nil { + var registrationResponse registrationResponse + + if err := json.Unmarshal(resp, ®istrationResponse); err != nil { return nil, err } - return registerResponse, nil + return ®istrationResponse, nil } -var errInvalidSignatureResponse = errors.New("invalid signature response") - -func signatureRequest(httpClient *http.Client, mpinID, regOTT string) (*signatureResponse, error) { - resp, err := makeRequest( - httpClient, - fmt.Sprintf(options.projectDomain+"/rps/v2/signature/%v?regOTT=%v", mpinID, regOTT), - "GET", - nil, - ) - if err != nil { - return nil, err +func clientTokenRequests(httpClient *http.Client, secretURLs []string, mpinID, publicKey, privateKey []byte, pin int) (token []byte, err error) { + const secretURLsNumber = 2 + if len(secretURLs) != secretURLsNumber { + return nil, fmt.Errorf("client secret urls should be exactly 2; received: %v", len(secretURLs)) } - var sigResponse *signatureResponse + css := make([][]byte, 0, secretURLsNumber) - if err := json.Unmarshal(resp, &sigResponse); err != nil { - return nil, err - } + for _, secretURL := range secretURLs { + resp, err := makeRequest( + httpClient, + secretURL, + http.MethodGet, + nil, + ) + if err != nil { + return nil, err + } - if !(sigResponse.CS2URL != "" && sigResponse.ClientSecretShare != "" && - sigResponse.Curve != "" && sigResponse.DTAs != "") { - return nil, errInvalidSignatureResponse - } + var cssResponse clientSecretResponse - return sigResponse, nil -} + if err := json.Unmarshal(resp, &cssResponse); err != nil { + return nil, err + } -func clientSecretRequest(httpClient *http.Client, cs2url string) (*clientSecretResponse, error) { - resp, err := makeRequest( - httpClient, - cs2url, - "GET", - nil, - ) - if err != nil { - return nil, err - } + secret, err := hex.DecodeString(cssResponse.DVSClientSecret) + if err != nil { + return nil, err + } - var csResponse *clientSecretResponse + css = append(css, secret) + } - if err := json.Unmarshal(resp, &csResponse); err != nil { + clientToken, err := mpin.GetDVSClientToken( + append(mpinID, publicKey...), + pin, + gomiracl.SHA256, + privateKey, + curve.BN254CX, + css[0], + css[1], + ) + if err != nil { return nil, err } - return csResponse, nil + return clientToken.Secret(), nil } func getVerificationCode(verifyURL string) (string, error) { @@ -254,7 +251,10 @@ func getVerificationCode(verifyURL string) (string, error) { } func verificationConfirmation(httpClient *http.Client, userID, code string) (string, error) { - payload := &confirmationRequest{ + payload := &struct { + UserID string `json:"userId"` + Code string `json:"code"` + }{ UserID: userID, Code: code, } @@ -262,14 +262,14 @@ func verificationConfirmation(httpClient *http.Client, userID, code string) (str resp, err := makeRequest( httpClient, options.projectDomain+"/verification/confirmation", - "POST", + http.MethodPost, payload, ) if err != nil { return "", fmt.Errorf("error creating verification confirmation request: %w", err) } - var res *confirmationResponse + var res confirmationResponse if err := json.Unmarshal(resp, &res); err != nil { return "", err diff --git a/integration-tests/sample_test.go b/integration-tests/sample_test.go index ea3fec7c..34731971 100644 --- a/integration-tests/sample_test.go +++ b/integration-tests/sample_test.go @@ -3,7 +3,7 @@ package main import ( "encoding/json" "fmt" - "io/ioutil" + "io" "net/http" "net/url" "testing" @@ -40,7 +40,7 @@ func TestAuth(t *testing.T) { accessID := qrURL.Fragment - identity, err := register(httpClient, projectID, userID, deviceName, pin, accessID) + identity, err := register(httpClient, projectID, userID, deviceName, pin) if err != nil { t.Fatalf("Error registering: %v", err) } @@ -105,7 +105,7 @@ func TestValidateSignature(t *testing.T) { accessID := qrURL.Fragment - identity, err := register(httpClient, projectID, userID, deviceName, pin, accessID) + identity, err := register(httpClient, projectID, userID, deviceName, pin) if err != nil { t.Fatalf("Error registering: %v", err) } @@ -127,7 +127,7 @@ func TestValidateSignature(t *testing.T) { } func modifySignatureHandler(w http.ResponseWriter, r *http.Request) { - body, err := ioutil.ReadAll(r.Body) + body, err := io.ReadAll(r.Body) if err != nil { w.Write([]byte(fmt.Sprintf("ERROR is: %#v", err.Error()))) @@ -136,7 +136,7 @@ func modifySignatureHandler(w http.ResponseWriter, r *http.Request) { defer r.Body.Close() - var jwksURI = options.projectDomain + "/oidc/certs" + jwksURI := options.projectDomain + "/oidc/certs" originalRequestURL := r.Header.Get("X-Forwarded-Host") if originalRequestURL == jwksURI { diff --git a/integration-tests/types.go b/integration-tests/types.go index 5d51f11e..242aa453 100644 --- a/integration-tests/types.go +++ b/integration-tests/types.go @@ -3,9 +3,16 @@ package main // Generic types type identity struct { - MPinID []byte - Token []byte - DTAs string + MPinID []byte + Token []byte + DTAs string + PrivateKey []byte + PublicKey []byte +} + +// MPinID + PublicKey. +func (id *identity) dvsMPinID() []byte { + return append(id.MPinID, id.PublicKey...) } type header struct { @@ -24,12 +31,6 @@ type verificationURLResponse struct { VerificationURL string `json:"verificationURL"` } -type confirmationRequest struct { - UserID string `json:"userId"` - Code string `json:"code"` - ConfirmMissmatch bool `json:"confirmMissmatch"` -} - type confirmationResponse struct { ActivateToken string `json:"actToken"` AccessID string `json:"accessId"` @@ -39,21 +40,15 @@ type confirmationResponse struct { VerificationRedirectURL string `json:"verificationRedirectUrl"` } -type registerResponse struct { - Active bool `json:"active"` - AppID string `json:"appId"` - CustomerID string `json:"customerId"` - ExpireTime int `json:"expireTime"` - MPinID string `json:"mpinId"` - NowTime int `json:"nowTime"` - RegOTT string `json:"regOTT"` -} - -type signatureResponse struct { - ClientSecretShare string `json:"clientSecretShare"` - CS2URL string `json:"cs2url"` - Curve string `json:"curve"` - DTAs string `json:"dtas"` +type registrationResponse struct { + MPinID string `json:"mpinId"` + ProjectID string `json:"projectId"` + DTAs string `json:"dtas"` + Curve string `json:"curve"` + SecretURLs []string `json:"secretUrls"` + VerificationType string `json:"verificationType"` + PINLength int `json:"pinLength"` + MPinIDCreatedAt int `json:"createdAt"` } type clientSecretResponse struct { diff --git a/integration-tests/utils.go b/integration-tests/utils.go index fd4c9a1e..534d6e81 100644 --- a/integration-tests/utils.go +++ b/integration-tests/utils.go @@ -2,13 +2,16 @@ package main import ( "bytes" + "crypto/rand" "encoding/json" "fmt" - "io/ioutil" + "io" mathRand "math/rand" "net/http" "strconv" "time" + + amclRand "code.miracl.com/maas/maas/src/lib/gomiracl/rand" ) func newRequest(url, method string, payload interface{}, headers ...header) (req *http.Request, err error) { @@ -59,7 +62,7 @@ func getResponse(req *http.Request, httpClient *http.Client) (responseBody []byt return nil, nil, fmt.Errorf("unsuccessful request (%s) to %s", strconv.Itoa(resp.StatusCode), req.URL.String()) } - responseBody, err = ioutil.ReadAll(resp.Body) + responseBody, err = io.ReadAll(resp.Body) if err != nil { return nil, nil, err } @@ -78,20 +81,17 @@ func makeRequest(httpClient *http.Client, url, method string, payload interface{ return res, err } -func hex2bytes(s string) []byte { - lgh := len(s) - data := make([]byte, lgh/2) - - for i := 0; i < lgh; i += 2 { - a, _ := strconv.ParseInt(s[i:i+2], 16, 32) - data[i/2] = byte(a) - } - - return data -} - func randPIN() int { mathRand.Seed(time.Now().UnixNano()) return mathRand.Intn(9000) + 1000 } + +func newRand() *amclRand.Rand { + r, err := amclRand.New(rand.Reader, 128) + if err != nil { + panic(err) + } + + return r +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/ANSSI.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/ANSSI.go new file mode 100644 index 00000000..a5af23fe --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/ANSSI.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || ANSSI + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// ANSSI elliptic curve. +var ANSSI = &amclCurve{ + name: "ANSSI", + EGS: bindings.EGSANSSI, + getKeyPair: wrap.ECPKeyPairGenerateANSSI, + validatePubKey: wrap.ECPPublicKeyValidateANSSI, + sign: wrap.ECPSpDsaANSSI, + verify: wrap.ECPVpDsaANSSI, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["ANSSI"] = ANSSI +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BLS383.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BLS383.go new file mode 100644 index 00000000..68d594fe --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BLS383.go @@ -0,0 +1,56 @@ +//go:build !ignoredefaultcurves || BLS383 + +//nolint:dupl // definitions +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// BLS383 elliptic curve. +var BLS383 = &mpinCurve{ + Curve: &amclCurve{ + name: "BLS383", + EGS: bindings.EGSBLS383, + getKeyPair: wrap.ECPKeyPairGenerateBLS383, + validatePubKey: wrap.ECPPublicKeyValidateBLS383, + sign: wrap.ECPSpDsaBLS383, + verify: wrap.ECPVpDsaBLS383, + }, + PFS: bindings.PFSBLS383, + PGS: bindings.PGSBLS383, + getRandomSecret: wrap.RandomGenerateBLS383, + newServerSecretShare: wrap.GetServerSecretBLS383, + newClientSecretShare: wrap.GetClientSecretBLS383, + newTimePermitShare: wrap.GetClientPermitBLS383, + recombineG1: wrap.RecombineG1BLS383, + recombineG2: wrap.RecombineG2BLS383, + extractPin: wrap.ExtractPINBLS383, + clientOnePass: wrap.ClientBLS383, + serverOnePass: wrap.ServerBLS383, + clientPass1: wrap.Client1BLS383, + clientPass2: wrap.Client2BLS383, + serverPass1: wrap.Server1BLS383, + serverPass2: wrap.Server2BLS383, + precompute: wrap.PrecomputeBLS383, + getG1Multiple: wrap.GetG1MultipleBLS383, + serverKey: wrap.ServerKeyBLS383, + clientKey: wrap.ClientKeyBLS383, + getDVSKeyPair: wrap.GetDVSKeyPairBLS383, + + // Wang Chow-Choo + wccRandomGenerate: wrap.WCCRandomGenerateBLS383, + wccHq: wrap.WCCHqBLS383, + wccGetG1Multiple: wrap.WCCGetG1MultipleBLS383, + wccRecombineG1: wrap.WCCRecombineG1BLS383, + wccGetG2Multiple: wrap.WCCGetG2MultipleBLS383, + wccRecombineG2: wrap.WCCRecombineG2BLS383, + wccReceiverKey: wrap.WCCReceiverKeyBLS383, + wccSenderKey: wrap.WCCSenderKeyBLS383, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["BLS383"] = BLS383 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BLS461.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BLS461.go new file mode 100644 index 00000000..300fba00 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BLS461.go @@ -0,0 +1,56 @@ +//go:build !ignoredefaultcurves || BLS461 + +//nolint:dupl,revive // definitions +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// BLS461 elliptic curve. +var BLS461 = &mpinCurve{ + Curve: &amclCurve{ + name: "BLS461", + EGS: bindings.EGSBLS461, + getKeyPair: wrap.ECPKeyPairGenerateBLS461, + validatePubKey: wrap.ECPPublicKeyValidateBLS461, + sign: wrap.ECPSpDsaBLS461, + verify: wrap.ECPVpDsaBLS461, + }, + PFS: bindings.PFSBLS461, + PGS: bindings.PGSBLS461, + getRandomSecret: wrap.RandomGenerateBLS461, + newServerSecretShare: wrap.GetServerSecretBLS461, + newClientSecretShare: wrap.GetClientSecretBLS461, + newTimePermitShare: wrap.GetClientPermitBLS461, + recombineG1: wrap.RecombineG1BLS461, + recombineG2: wrap.RecombineG2BLS461, + extractPin: wrap.ExtractPINBLS461, + clientOnePass: wrap.ClientBLS461, + serverOnePass: wrap.ServerBLS461, + clientPass1: wrap.Client1BLS461, + clientPass2: wrap.Client2BLS461, + serverPass1: wrap.Server1BLS461, + serverPass2: wrap.Server2BLS461, + precompute: wrap.PrecomputeBLS461, + getG1Multiple: wrap.GetG1MultipleBLS461, + serverKey: wrap.ServerKeyBLS461, + clientKey: wrap.ClientKeyBLS461, + getDVSKeyPair: wrap.GetDVSKeyPairBLS461, + + // Wang Chow-Choo + wccRandomGenerate: wrap.WCCRandomGenerateBLS461, + wccHq: wrap.WCCHqBLS461, + wccGetG1Multiple: wrap.WCCGetG1MultipleBLS461, + wccRecombineG1: wrap.WCCRecombineG1BLS461, + wccGetG2Multiple: wrap.WCCGetG2MultipleBLS461, + wccRecombineG2: wrap.WCCRecombineG2BLS461, + wccReceiverKey: wrap.WCCReceiverKeyBLS461, + wccSenderKey: wrap.WCCSenderKeyBLS461, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["BLS461"] = BLS461 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BN254.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BN254.go new file mode 100644 index 00000000..539f8295 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BN254.go @@ -0,0 +1,56 @@ +//go:build !ignoredefaultcurves || BN254 + +//nolint:dupl,revive // definitions +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// BN254 elliptic curve. +var BN254 = &mpinCurve{ + Curve: &amclCurve{ + name: "BN254", + EGS: bindings.EGSBN254, + getKeyPair: wrap.ECPKeyPairGenerateBN254, + validatePubKey: wrap.ECPPublicKeyValidateBN254, + sign: wrap.ECPSpDsaBN254, + verify: wrap.ECPVpDsaBN254, + }, + PFS: bindings.PFSBN254, + PGS: bindings.PGSBN254, + getRandomSecret: wrap.RandomGenerateBN254, + newServerSecretShare: wrap.GetServerSecretBN254, + newClientSecretShare: wrap.GetClientSecretBN254, + newTimePermitShare: wrap.GetClientPermitBN254, + recombineG1: wrap.RecombineG1BN254, + recombineG2: wrap.RecombineG2BN254, + extractPin: wrap.ExtractPINBN254, + clientOnePass: wrap.ClientBN254, + serverOnePass: wrap.ServerBN254, + clientPass1: wrap.Client1BN254, + clientPass2: wrap.Client2BN254, + serverPass1: wrap.Server1BN254, + serverPass2: wrap.Server2BN254, + precompute: wrap.PrecomputeBN254, + getG1Multiple: wrap.GetG1MultipleBN254, + serverKey: wrap.ServerKeyBN254, + clientKey: wrap.ClientKeyBN254, + getDVSKeyPair: wrap.GetDVSKeyPairBN254, + + // Wang Chow-Choo + wccRandomGenerate: wrap.WCCRandomGenerateBN254, + wccHq: wrap.WCCHqBN254, + wccGetG1Multiple: wrap.WCCGetG1MultipleBN254, + wccRecombineG1: wrap.WCCRecombineG1BN254, + wccGetG2Multiple: wrap.WCCGetG2MultipleBN254, + wccRecombineG2: wrap.WCCRecombineG2BN254, + wccReceiverKey: wrap.WCCReceiverKeyBN254, + wccSenderKey: wrap.WCCSenderKeyBN254, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["BN254"] = BN254 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BN254CX.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BN254CX.go new file mode 100644 index 00000000..3c2fd6aa --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BN254CX.go @@ -0,0 +1,56 @@ +//go:build !ignoredefaultcurves || BN254CX + +//nolint:dupl // definitions +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// BN254CX elliptic curve. +var BN254CX = &mpinCurve{ + Curve: &amclCurve{ + name: "BN254CX", + EGS: bindings.EGSBN254CX, + getKeyPair: wrap.ECPKeyPairGenerateBN254CX, + validatePubKey: wrap.ECPPublicKeyValidateBN254CX, + sign: wrap.ECPSpDsaBN254CX, + verify: wrap.ECPVpDsaBN254CX, + }, + PFS: bindings.PFSBN254CX, + PGS: bindings.PGSBN254CX, + getRandomSecret: wrap.RandomGenerateBN254CX, + newServerSecretShare: wrap.GetServerSecretBN254CX, + newClientSecretShare: wrap.GetClientSecretBN254CX, + newTimePermitShare: wrap.GetClientPermitBN254CX, + recombineG1: wrap.RecombineG1BN254CX, + recombineG2: wrap.RecombineG2BN254CX, + extractPin: wrap.ExtractPINBN254CX, + clientOnePass: wrap.ClientBN254CX, + serverOnePass: wrap.ServerBN254CX, + clientPass1: wrap.Client1BN254CX, + clientPass2: wrap.Client2BN254CX, + serverPass1: wrap.Server1BN254CX, + serverPass2: wrap.Server2BN254CX, + precompute: wrap.PrecomputeBN254CX, + getG1Multiple: wrap.GetG1MultipleBN254CX, + serverKey: wrap.ServerKeyBN254CX, + clientKey: wrap.ClientKeyBN254CX, + getDVSKeyPair: wrap.GetDVSKeyPairBN254CX, + + // Wang Chow-Choo + wccRandomGenerate: wrap.WCCRandomGenerateBN254CX, + wccHq: wrap.WCCHqBN254CX, + wccGetG1Multiple: wrap.WCCGetG1MultipleBN254CX, + wccRecombineG1: wrap.WCCRecombineG1BN254CX, + wccGetG2Multiple: wrap.WCCGetG2MultipleBN254CX, + wccRecombineG2: wrap.WCCRecombineG2BN254CX, + wccReceiverKey: wrap.WCCReceiverKeyBN254CX, + wccSenderKey: wrap.WCCSenderKeyBN254CX, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["BN254CX"] = BN254CX +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BRAINPOOL.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BRAINPOOL.go new file mode 100644 index 00000000..a0665fe3 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/BRAINPOOL.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || BRAINPOOL + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// BRAINPOOL elliptic curve. +var BRAINPOOL = &amclCurve{ + name: "BRAINPOOL", + EGS: bindings.EGSBRAINPOOL, + getKeyPair: wrap.ECPKeyPairGenerateBRAINPOOL, + validatePubKey: wrap.ECPPublicKeyValidateBRAINPOOL, + sign: wrap.ECPSpDsaBRAINPOOL, + verify: wrap.ECPVpDsaBRAINPOOL, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["BRAINPOOL"] = BRAINPOOL +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/C41417.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/C41417.go new file mode 100644 index 00000000..183b2fe6 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/C41417.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || C41417 + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// C41417 elliptic curve. +var C41417 = &amclCurve{ + name: "C41417", + EGS: bindings.EGSC41417, + getKeyPair: wrap.ECPKeyPairGenerateC41417, + validatePubKey: wrap.ECPPublicKeyValidateC41417, + sign: wrap.ECPSpDsaC41417, + verify: wrap.ECPVpDsaC41417, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["C41417"] = C41417 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/ED25519.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/ED25519.go new file mode 100644 index 00000000..073b907a --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/ED25519.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || ED25519 + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// ED25519 elliptic curve. +var ED25519 = &amclCurve{ + name: "ED25519", + EGS: bindings.EGSED25519, + getKeyPair: wrap.ECPKeyPairGenerateED25519, + validatePubKey: wrap.ECPPublicKeyValidateED25519, + sign: wrap.ECPSpDsaED25519, + verify: wrap.ECPVpDsaED25519, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["ED25519"] = ED25519 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/FP256BN.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/FP256BN.go new file mode 100644 index 00000000..6d05418d --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/FP256BN.go @@ -0,0 +1,56 @@ +//go:build !ignoredefaultcurves || FP256BN + +//nolint:dupl,revive // definitions +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// FP256BN elliptic curve. +var FP256BN = &mpinCurve{ + Curve: &amclCurve{ + name: "FP256BN", + EGS: bindings.EGSFP256BN, + getKeyPair: wrap.ECPKeyPairGenerateFP256BN, + validatePubKey: wrap.ECPPublicKeyValidateFP256BN, + sign: wrap.ECPSpDsaFP256BN, + verify: wrap.ECPVpDsaFP256BN, + }, + PFS: bindings.PFSFP256BN, + PGS: bindings.PGSFP256BN, + getRandomSecret: wrap.RandomGenerateFP256BN, + newServerSecretShare: wrap.GetServerSecretFP256BN, + newClientSecretShare: wrap.GetClientSecretFP256BN, + newTimePermitShare: wrap.GetClientPermitFP256BN, + recombineG1: wrap.RecombineG1FP256BN, + recombineG2: wrap.RecombineG2FP256BN, + extractPin: wrap.ExtractPINFP256BN, + clientOnePass: wrap.ClientFP256BN, + serverOnePass: wrap.ServerFP256BN, + clientPass1: wrap.Client1FP256BN, + clientPass2: wrap.Client2FP256BN, + serverPass1: wrap.Server1FP256BN, + serverPass2: wrap.Server2FP256BN, + precompute: wrap.PrecomputeFP256BN, + getG1Multiple: wrap.GetG1MultipleFP256BN, + serverKey: wrap.ServerKeyFP256BN, + clientKey: wrap.ClientKeyFP256BN, + getDVSKeyPair: wrap.GetDVSKeyPairFP256BN, + + // Wang Chow-Choo + wccRandomGenerate: wrap.WCCRandomGenerateFP256BN, + wccHq: wrap.WCCHqFP256BN, + wccGetG1Multiple: wrap.WCCGetG1MultipleFP256BN, + wccRecombineG1: wrap.WCCRecombineG1FP256BN, + wccGetG2Multiple: wrap.WCCGetG2MultipleFP256BN, + wccRecombineG2: wrap.WCCRecombineG2FP256BN, + wccReceiverKey: wrap.WCCReceiverKeyFP256BN, + wccSenderKey: wrap.WCCSenderKeyFP256BN, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["FP256BN"] = FP256BN +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/FP512BN.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/FP512BN.go new file mode 100644 index 00000000..48277690 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/FP512BN.go @@ -0,0 +1,56 @@ +//go:build !ignoredefaultcurves || FP512BN + +//nolint:dupl,revive // definitions +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// FP512BN elliptic curve. +var FP512BN = &mpinCurve{ + Curve: &amclCurve{ + name: "FP512BN", + EGS: bindings.EGSFP512BN, + getKeyPair: wrap.ECPKeyPairGenerateFP512BN, + validatePubKey: wrap.ECPPublicKeyValidateFP512BN, + sign: wrap.ECPSpDsaFP512BN, + verify: wrap.ECPVpDsaFP512BN, + }, + PFS: bindings.PFSFP512BN, + PGS: bindings.PGSFP512BN, + getRandomSecret: wrap.RandomGenerateFP512BN, + newServerSecretShare: wrap.GetServerSecretFP512BN, + newClientSecretShare: wrap.GetClientSecretFP512BN, + newTimePermitShare: wrap.GetClientPermitFP512BN, + recombineG1: wrap.RecombineG1FP512BN, + recombineG2: wrap.RecombineG2FP512BN, + extractPin: wrap.ExtractPINFP512BN, + clientOnePass: wrap.ClientFP512BN, + serverOnePass: wrap.ServerFP512BN, + clientPass1: wrap.Client1FP512BN, + clientPass2: wrap.Client2FP512BN, + serverPass1: wrap.Server1FP512BN, + serverPass2: wrap.Server2FP512BN, + precompute: wrap.PrecomputeFP512BN, + getG1Multiple: wrap.GetG1MultipleFP512BN, + serverKey: wrap.ServerKeyFP512BN, + clientKey: wrap.ClientKeyFP512BN, + getDVSKeyPair: wrap.GetDVSKeyPairFP512BN, + + // Wang Chow-Choo + wccRandomGenerate: wrap.WCCRandomGenerateFP512BN, + wccHq: wrap.WCCHqFP512BN, + wccGetG1Multiple: wrap.WCCGetG1MultipleFP512BN, + wccRecombineG1: wrap.WCCRecombineG1FP512BN, + wccGetG2Multiple: wrap.WCCGetG2MultipleFP512BN, + wccRecombineG2: wrap.WCCRecombineG2FP512BN, + wccReceiverKey: wrap.WCCReceiverKeyFP512BN, + wccSenderKey: wrap.WCCSenderKeyFP512BN, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["FP512BN"] = FP512BN +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/GOLDILOCKS.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/GOLDILOCKS.go new file mode 100644 index 00000000..9dfde88d --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/GOLDILOCKS.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || GOLDILOCKS + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// GOLDILOCKS elliptic curve. +var GOLDILOCKS = &amclCurve{ + name: "GOLDILOCKS", + EGS: bindings.EGSGOLDILOCKS, + getKeyPair: wrap.ECPKeyPairGenerateGOLDILOCKS, + validatePubKey: wrap.ECPPublicKeyValidateGOLDILOCKS, + sign: wrap.ECPSpDsaGOLDILOCKS, + verify: wrap.ECPVpDsaGOLDILOCKS, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["GOLDILOCKS"] = GOLDILOCKS +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/HIFIVE.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/HIFIVE.go new file mode 100644 index 00000000..1ab0fd76 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/HIFIVE.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || HIFIVE + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// HIFIVE elliptic curve. +var HIFIVE = &amclCurve{ + name: "HIFIVE", + EGS: bindings.EGSHIFIVE, + getKeyPair: wrap.ECPKeyPairGenerateHIFIVE, + validatePubKey: wrap.ECPPublicKeyValidateHIFIVE, + sign: wrap.ECPSpDsaHIFIVE, + verify: wrap.ECPVpDsaHIFIVE, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["HIFIVE"] = HIFIVE +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST256.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST256.go new file mode 100644 index 00000000..b07f8128 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST256.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NIST256 + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NIST256 elliptic curve. +var NIST256 = &amclCurve{ + name: "NIST256", + EGS: bindings.EGSNIST256, + getKeyPair: wrap.ECPKeyPairGenerateNIST256, + validatePubKey: wrap.ECPPublicKeyValidateNIST256, + sign: wrap.ECPSpDsaNIST256, + verify: wrap.ECPVpDsaNIST256, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NIST256"] = NIST256 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST384.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST384.go new file mode 100644 index 00000000..4f8486ec --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST384.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NIST384 + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NIST384 elliptic curve. +var NIST384 = &amclCurve{ + name: "NIST384", + EGS: bindings.EGSNIST384, + getKeyPair: wrap.ECPKeyPairGenerateNIST384, + validatePubKey: wrap.ECPPublicKeyValidateNIST384, + sign: wrap.ECPSpDsaNIST384, + verify: wrap.ECPVpDsaNIST384, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NIST384"] = NIST384 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST521.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST521.go new file mode 100644 index 00000000..adb8432c --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NIST521.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NIST521 + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NIST521 elliptic curve. +var NIST521 = &amclCurve{ + name: "NIST521", + EGS: bindings.EGSNIST521, + getKeyPair: wrap.ECPKeyPairGenerateNIST521, + validatePubKey: wrap.ECPPublicKeyValidateNIST521, + sign: wrap.ECPSpDsaNIST521, + verify: wrap.ECPVpDsaNIST521, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NIST521"] = NIST521 +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS256E.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS256E.go new file mode 100644 index 00000000..12b475aa --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS256E.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NUMS256E + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NUMS256E elliptic curve. +var NUMS256E = &amclCurve{ + name: "NUMS256E", + EGS: bindings.EGSNUMS256E, + getKeyPair: wrap.ECPKeyPairGenerateNUMS256E, + validatePubKey: wrap.ECPPublicKeyValidateNUMS256E, + sign: wrap.ECPSpDsaNUMS256E, + verify: wrap.ECPVpDsaNUMS256E, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NUMS256E"] = NUMS256E +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS256W.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS256W.go new file mode 100644 index 00000000..a0442bb6 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS256W.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NUMS256W + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NUMS256W elliptic curve. +var NUMS256W = &amclCurve{ + name: "NUMS256W", + EGS: bindings.EGSNUMS256W, + getKeyPair: wrap.ECPKeyPairGenerateNUMS256W, + validatePubKey: wrap.ECPPublicKeyValidateNUMS256W, + sign: wrap.ECPSpDsaNUMS256W, + verify: wrap.ECPVpDsaNUMS256W, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NUMS256W"] = NUMS256W +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS384E.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS384E.go new file mode 100644 index 00000000..7a3977f0 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS384E.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NUMS384E + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NUMS384E elliptic curve. +var NUMS384E = &amclCurve{ + name: "NUMS384E", + EGS: bindings.EGSNUMS384E, + getKeyPair: wrap.ECPKeyPairGenerateNUMS384E, + validatePubKey: wrap.ECPPublicKeyValidateNUMS384E, + sign: wrap.ECPSpDsaNUMS384E, + verify: wrap.ECPVpDsaNUMS384E, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NUMS384E"] = NUMS384E +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS384W.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS384W.go new file mode 100644 index 00000000..9b75465e --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS384W.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NUMS384W + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NUMS384W elliptic curve. +var NUMS384W = &amclCurve{ + name: "NUMS384W", + EGS: bindings.EGSNUMS384W, + getKeyPair: wrap.ECPKeyPairGenerateNUMS384W, + validatePubKey: wrap.ECPPublicKeyValidateNUMS384W, + sign: wrap.ECPSpDsaNUMS384W, + verify: wrap.ECPVpDsaNUMS384W, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NUMS384W"] = NUMS384W +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS512E.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS512E.go new file mode 100644 index 00000000..53bc8e40 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS512E.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NUMS512E + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NUMS512E elliptic curve. +var NUMS512E = &amclCurve{ + name: "NUMS512E", + EGS: bindings.EGSNUMS512E, + getKeyPair: wrap.ECPKeyPairGenerateNUMS512E, + validatePubKey: wrap.ECPPublicKeyValidateNUMS512E, + sign: wrap.ECPSpDsaNUMS512E, + verify: wrap.ECPVpDsaNUMS512E, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NUMS512E"] = NUMS512E +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS512W.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS512W.go new file mode 100644 index 00000000..4fe69520 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/NUMS512W.go @@ -0,0 +1,23 @@ +//go:build !ignoredefaultcurves || NUMS512W + +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// NUMS512W elliptic curve. +var NUMS512W = &amclCurve{ + name: "NUMS512W", + EGS: bindings.EGSNUMS512W, + getKeyPair: wrap.ECPKeyPairGenerateNUMS512W, + validatePubKey: wrap.ECPPublicKeyValidateNUMS512W, + sign: wrap.ECPSpDsaNUMS512W, + verify: wrap.ECPVpDsaNUMS512W, +} + +//nolint:gochecknoinits // It is how building with limited curve set works. +func init() { + All["NUMS512W"] = NUMS512W +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/curve.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/curve.go new file mode 100644 index 00000000..bca3524a --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/curve/curve.go @@ -0,0 +1,271 @@ +// Package curve define elliptic curves. +package curve + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl" + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/rand" +) + +// All are all the curves the package is currently built with. +var All = map[string]Curve{} + +// AllNames are all the curves the package supports. +var AllNames = []string{ + "ANSSI", + "BLS383", + "BLS461", + "BN254", + "BN254CX", + "BRAINPOOL", + "C41417", + "ED25519", + "FP256BN", + "FP512BN", + "GOLDILOCKS", + "HIFIVE", + "NIST256", + "NIST384", + "NIST521", + "NUMS256E", + "NUMS256W", + "NUMS384E", + "NUMS384W", + "NUMS512E", + "NUMS512W", +} + +// Curve is elliptic curve. +type Curve interface { + Name() string + EGroupSize() int + GetKeyPair(rng *rand.Rand, s []byte) (priv, pub []byte, err error) + ValidatePubKey(pub []byte) (err error) + Sign(hash gomiracl.Hash, rng *rand.Rand, k []byte, priv []byte, msg []byte) (c, d []byte, err error) + Verify(hash gomiracl.Hash, pub, msg, c, d []byte) (err error) +} + +// Curve is elliptic curve. +type amclCurve struct { + name string + EGS int + + getKeyPair func(rng *bindings.Rand, s []byte) (priv, pub []byte, err error) + validatePubKey func(pub []byte) (err error) + sign func(hashType int, rng *bindings.Rand, k []byte, priv []byte, msg []byte) (c, d []byte, err error) + verify func(hashType int, pub, msg, c, d []byte) (err error) +} + +// Name is the name of the curve. +func (c *amclCurve) Name() string { + return c.name +} + +// EGroupSize is the curve EGS. +func (c *amclCurve) EGroupSize() int { + return c.EGS +} + +// GetKeyPair generates ECC public/private key pair. +func (c *amclCurve) GetKeyPair(rng *rand.Rand, s []byte) (priv, pub []byte, err error) { + return c.getKeyPair((*bindings.Rand)(rng), s) +} + +// ValidatePubKey validates ECC public key. +func (c *amclCurve) ValidatePubKey(pub []byte) (err error) { + return c.validatePubKey(pub) +} + +// Sign generates ECDSA Signature. +func (c *amclCurve) Sign(hash gomiracl.Hash, rng *rand.Rand, k, priv, msg []byte) (s, d []byte, err error) { + return c.sign(int(hash), (*bindings.Rand)(rng), k, priv, msg) +} + +// Verify verifies ECDSA Signature. +func (c *amclCurve) Verify(hash gomiracl.Hash, pub, msg, s, d []byte) (err error) { + return c.verify(int(hash), pub, msg, s, d) +} + +// mpinCurve is elliptic curve that supports MPin. +type mpinCurve struct { + Curve + + PFS int + PGS int + + getRandomSecret func(rng *bindings.Rand) (secret []byte, err error) + newServerSecretShare func(masterSecret []byte) (share []byte, err error) + newClientSecretShare func(masterSecret, id []byte) (share []byte, err error) + newTimePermitShare func(hashType, date int, masterSecret, id []byte) (timePermit []byte, err error) + recombineG1 func(share1, share2 []byte) (secret []byte, err error) + recombineG2 func(share1, share2 []byte) (secret []byte, err error) + extractPin func(hashType int, id []byte, pin int, clientSecret []byte) (token []byte, err error) + clientOnePass func(hashType, date int, id []byte, rng *bindings.Rand, x []byte, pin int, token, timePermit, msg []byte, time int) (xOut, v, u, ut, y []byte, err error) + serverOnePass func(hashType, date int, serverSecret, u, ut, v, id, msg []byte, time int, pa []byte) (hid, htid, y []byte, err error) + clientPass1 func(hashType, date int, id []byte, rng *bindings.Rand, x []byte, pin int, token, timePermit []byte) (xOut, sec, u, ut []byte, err error) + clientPass2 func(x, y, sec []byte) (vOut []byte, err error) + serverPass1 func(hashType, date int, id []byte) (hid, htid []byte) + serverPass2 func(date int, hid, htid, y, serverSecret, u, ut, vOut, pa []byte) (err error) + precompute func(token, id, pub []byte) (g1, g2 []byte, err error) + getG1Multiple func(rng *bindings.Rand, opType int, x, g []byte) (xOut, w []byte, err error) + serverKey func(hashType int, z, serverSecret, w, p, i, u, ut []byte) (k []byte, err error) + clientKey func(hashType int, g1, g2 []byte, pin int, r, x, p, t []byte) (k []byte, err error) + getDVSKeyPair func(rng *bindings.Rand, z []byte) (zOut, pub []byte, err error) + + // Wang Chow-Choo + wccRandomGenerate func(rng *bindings.Rand) (secret []byte, err error) + wccHq func(hashType int, a, b, c, d []byte) []byte + wccGetG1Multiple func(s, hid []byte) (vG1 []byte, err error) + wccRecombineG1 func(share1, share2 []byte) (whole []byte, err error) + wccGetG2Multiple func(s, hid []byte) (vG2 []byte, err error) + wccRecombineG2 func(share1, share2 []byte) (whole []byte, err error) + wccReceiverKey func(hashType int, y, w, pia, pib, paG1, pgG1, bG2Key, aID []byte) (key []byte, err error) + wccSenderKey func(hashType int, x, pia, pib, pbG2, pgG1, aG1Key, bID []byte) (key []byte, err error) +} + +// FieldSize is the curves field size. +func (c *mpinCurve) FieldSize() int { + return c.PFS +} + +// PGroupSize is the curve PGS. +func (c *mpinCurve) PGroupSize() int { + return c.PGS +} + +// GetRandomSecret generates random secret. +func (c *mpinCurve) GetRandomSecret(rng *rand.Rand) (secret []byte, err error) { + return c.getRandomSecret((*bindings.Rand)(rng)) +} + +// NewServerSecretShare returns new server secret share. +func (c *mpinCurve) NewServerSecretShare(masterSecret []byte) (share []byte, err error) { + return c.newServerSecretShare(masterSecret) +} + +// NewClientSecretShare returns new client secret share. +func (c *mpinCurve) NewClientSecretShare(masterSecret, id []byte) (share []byte, err error) { + return c.newClientSecretShare(masterSecret, id) +} + +// NewTimePermitShare returns new time permit share. +func (c *mpinCurve) NewTimePermitShare(hash gomiracl.Hash, date int, masterSecret, id []byte) (timePermit []byte, err error) { + return c.newTimePermitShare(int(hash), date, masterSecret, id) +} + +// RecombineG1 returns the sum of members from the group G1. +func (c *mpinCurve) RecombineG1(share1, share2 []byte) (secret []byte, err error) { + return c.recombineG1(share1, share2) +} + +// RecombineG2 returns the sum of members from the group G2. +func (c *mpinCurve) RecombineG2(share1, share2 []byte) (secret []byte, err error) { + return c.recombineG2(share1, share2) +} + +// ExtractPin extracts a PIN number from a client secret. +func (c *mpinCurve) ExtractPin(hash gomiracl.Hash, id []byte, pin int, clientSecret []byte) (token []byte, err error) { + return c.extractPin(int(hash), id, pin, clientSecret) +} + +// ClientOnePass performs client side of the one-pass version of the M-Pin +// protocol. +// +//nolint:gocritic // needs refactoring +func (c *mpinCurve) ClientOnePass(hash gomiracl.Hash, date int, id []byte, rng *rand.Rand, x []byte, pin int, token, timePermit, msg []byte, time int) (xOut, v, u, ut, y []byte, err error) { + return c.clientOnePass(int(hash), date, id, (*bindings.Rand)(rng), x, pin, token, timePermit, msg, time) +} + +// ServerOnePass performs server side of the one-pass version of the M-Pin protocol. +func (c *mpinCurve) ServerOnePass(hash gomiracl.Hash, date int, serverSecret, u, ut, v, id, msg []byte, time int, pa []byte) (hid, htid, y []byte, err error) { + return c.serverOnePass(int(hash), date, serverSecret, u, ut, v, id, msg, time, pa) +} + +// ClientPass1 performs first pass of the client side of the 3-pass version of +// the M-Pin protocol. +func (c *mpinCurve) ClientPass1(hash gomiracl.Hash, date int, id []byte, rng *rand.Rand, x []byte, pin int, token, timePermit []byte) (xOut, sec, u, ut []byte, err error) { + return c.clientPass1(int(hash), date, id, (*bindings.Rand)(rng), x, pin, token, timePermit) +} + +// ClientPass2 performs server side of the one-pass version of the M-Pin +// protocol. +func (c *mpinCurve) ClientPass2(x, y, sec []byte) (vOut []byte, err error) { + return c.clientPass2(x, y, sec) +} + +// ServerPass1 performs first pass of the server side of the 3-pass version of +// the M-Pin protocol. +func (c *mpinCurve) ServerPass1(hash gomiracl.Hash, date int, id []byte) (hid, htid []byte) { + return c.serverPass1(int(hash), date, id) +} + +// ServerPass2 performs third pass on the server side of the 3-pass version of +// the M-Pin protocol. +func (c *mpinCurve) ServerPass2(date int, hid, htid, y, serverSecret, u, ut, vOut, pa []byte) (err error) { + return c.serverPass2(date, hid, htid, y, serverSecret, u, ut, vOut, pa) +} + +// Precompute precomputes values for use by the client side of M-Pin Full. +func (c *mpinCurve) Precompute(token, id, pub []byte) (g1, g2 []byte, err error) { + return c.precompute(token, id, pub) +} + +// GetG1Multiple finds a random multiple of a point in G1. +func (c *mpinCurve) GetG1Multiple(rng *rand.Rand, opType int, x, g []byte) (xOut, w []byte, err error) { + return c.getG1Multiple((*bindings.Rand)(rng), opType, x, g) +} + +// ServerKey calculates key on Server side for M-Pin Full. +func (c *mpinCurve) ServerKey(hash gomiracl.Hash, z, serverSecret, w, p, i, u, ut []byte) (k []byte, err error) { + return c.serverKey(int(hash), z, serverSecret, w, p, i, u, ut) +} + +// ClientKey calculates key on Client side for M-Pin Full. +func (c *mpinCurve) ClientKey(hash gomiracl.Hash, g1, g2 []byte, pin int, r, x, p, t []byte) (k []byte, err error) { + return c.clientKey(int(hash), g1, g2, pin, r, x, p, t) +} + +// GetDVSKeyPair generates a random public key for the client. +func (c *mpinCurve) GetDVSKeyPair(rng *rand.Rand, z []byte) (zOut, pub []byte, err error) { + return c.getDVSKeyPair((*bindings.Rand)(rng), z) +} + +// WCCRandomGenerate generate random secret for WCC. +func (c *mpinCurve) WCCGetRandomSecret(rng *rand.Rand) (secret []byte, err error) { + return c.wccRandomGenerate((*bindings.Rand)(rng)) +} + +// WCCHq hashes ec points and id to an integer. +func (c *mpinCurve) WCCHash(hash gomiracl.Hash, a, b, ci, d []byte) []byte { + return c.wccHq(int(hash), a, b, ci, d) +} + +// WCCGetG1Multiple returns value in G1 multiplied by an integer. +func (c *mpinCurve) WCCGetG1Multiple(s, hid []byte) (vG1 []byte, err error) { + return c.wccGetG1Multiple(s, hid) +} + +// WCCRecombineG1 returns the addition of two members from the group G1. +func (c *mpinCurve) WCCRecombineG1(share1, share2 []byte) (whole []byte, err error) { + return c.wccRecombineG1(share1, share2) +} + +// WCCGetG2Multiple returns value in G2 multiplied by an integer. +func (c *mpinCurve) WCCGetG2Multiple(s, hid []byte) (vG2 []byte, err error) { + return c.wccGetG2Multiple(s, hid) +} + +// WCCRecombineG2 returns the addition of two members from the group G2. +func (c *mpinCurve) WCCRecombineG2(share1, share2 []byte) (whole []byte, err error) { + return c.wccRecombineG2(share1, share2) +} + +// WCCReceiverKey returns the shared key on the receiver side. +func (c *mpinCurve) WCCReceiverKey(hash gomiracl.Hash, y, w, pia, pib, paG1, pgG1, bG2Key, aID []byte) (key []byte, err error) { + return c.wccReceiverKey(int(hash), y, w, pia, pib, paG1, pgG1, bG2Key, aID) +} + +// WCCSenderKey returns the shared key on the sender side. +func (c *mpinCurve) WCCSenderKey(hash gomiracl.Hash, x, pia, pib, pbG2, pgG1, aG1Key, bID []byte) (key []byte, err error) { + return c.wccSenderKey(int(hash), x, pia, pib, pbG2, pgG1, aG1Key, bID) +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/error.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/error.go new file mode 100644 index 00000000..18238a05 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/error.go @@ -0,0 +1,10 @@ +package mpin + +import "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + +// IsWrongPin returns true if the err is Wrong PIN. +func IsWrongPin(err error) bool { + amclError, ok := err.(*bindings.Error) //nolint:errorlint // needs refactoring + + return ok && amclError.Code == bindings.BadPin +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/mpin.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/mpin.go new file mode 100644 index 00000000..5ee76ba1 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/mpin.go @@ -0,0 +1,505 @@ +// Package mpin implements the MPin protocol. +package mpin + +import ( + "errors" + + "code.miracl.com/maas/maas/src/lib/gomiracl" + "code.miracl.com/maas/maas/src/lib/gomiracl/curve" + "code.miracl.com/maas/maas/src/lib/gomiracl/rand" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +var ( + errNoShares = errors.New("need at least one share") + errInvalidSecretSize = errors.New("invalid secret size") +) + +// Curve is elliptic curve that supports the MPin protocol. +type Curve interface { + curve.Curve + + FieldSize() int + PGroupSize() int + GetRandomSecret(rng *rand.Rand) (secret []byte, err error) + NewServerSecretShare(masterSecret []byte) (share []byte, err error) + NewClientSecretShare(masterSecret, id []byte) (share []byte, err error) + NewTimePermitShare(hash gomiracl.Hash, date int, masterSecret, id []byte) (timePermit []byte, err error) + RecombineG1(share1, share2 []byte) (secret []byte, err error) + RecombineG2(share1, share2 []byte) (secret []byte, err error) + ExtractPin(hash gomiracl.Hash, id []byte, pin int, clientSecret []byte) (token []byte, err error) + ClientOnePass(hash gomiracl.Hash, date int, id []byte, rng *rand.Rand, x []byte, pin int, token, timePermit, msg []byte, time int) (xOut, v, u, ut, y []byte, err error) + ServerOnePass(hash gomiracl.Hash, date int, serverSecret, u, ut, v, id, msg []byte, time int, pa []byte) (HID, HTID, y []byte, err error) + ClientPass1(hash gomiracl.Hash, date int, id []byte, rng *rand.Rand, x []byte, pin int, token, timePermit []byte) (xOut, sec, u, ut []byte, err error) + ClientPass2(x, y, sec []byte) (vOut []byte, err error) + ServerPass1(hash gomiracl.Hash, date int, id []byte) (hid, htid []byte) + ServerPass2(date int, hid, htid, y, serverSecret, u, ut, vOut, pa []byte) (err error) + Precompute(token, id, pub []byte) (g1, g2 []byte, err error) + GetG1Multiple(rng *rand.Rand, opType int, x, g []byte) (xOut, w []byte, err error) + ServerKey(hash gomiracl.Hash, z, serverSecret, w, p, i, u, ut []byte) (k []byte, err error) + ClientKey(hash gomiracl.Hash, g1, g2 []byte, pin int, r, x, p, t []byte) (k []byte, err error) + GetDVSKeyPair(rng *rand.Rand, z []byte) (zOut, pub []byte, err error) +} + +// MasterSecret is the master secret. +type MasterSecret struct { + secret []byte + curve Curve +} + +// NewMasterSecret returns new MasterSecret. +func NewMasterSecret(c Curve, rng *rand.Rand) (*MasterSecret, error) { + secret, err := c.GetRandomSecret(rng) + if err != nil { + return nil, err + } + + return &MasterSecret{secret: secret, curve: c}, nil +} + +// MasterSecretFromBytes returns new MasterSecret from already generated byte slice +// Returns error if the size is different than expected master secret size for +// the specified curve. +func MasterSecretFromBytes(c Curve, secret []byte) (*MasterSecret, error) { + if len(secret) != c.PGroupSize() { + return nil, errInvalidSecretSize + } + + return &MasterSecret{secret: secret, curve: c}, nil +} + +// Secret returns the secret as bytes. +func (ms *MasterSecret) Secret() []byte { + return ms.secret +} + +// Curve returns the curve. +func (ms *MasterSecret) Curve() Curve { + return ms.curve +} + +// Destroy overwrites the secret. +func (ms *MasterSecret) Destroy() { + gomiracl.CleanMemory(ms.secret) +} + +// ServerSecretShare is the server secret. +type ServerSecretShare []byte + +// NewServerSecretShare creates new Server Secret Share. +func (ms *MasterSecret) NewServerSecretShare() (ServerSecretShare, error) { + secret, err := ms.curve.NewServerSecretShare(ms.secret) + if err != nil { + return nil, err + } + + return secret, nil +} + +// Secret returns the secret as bytes. +func (ss ServerSecretShare) Secret() []byte { + return []byte(ss) +} + +// Destroy overwrites the secret. +func (ss ServerSecretShare) Destroy() { + gomiracl.CleanMemory(ss) +} + +// ServerSecret is the server secret. +type ServerSecret struct { + secret []byte + curve Curve +} + +// NewServerSecret returns ServerSecret by recombining two Server Secret Shares. +func NewServerSecret(c Curve, shares ...ServerSecretShare) (*ServerSecret, error) { + if len(shares) < 1 { + return nil, errNoShares + } + + secret := shares[0] + + for i := 1; i < len(shares); i++ { + var err error + + secret, err = c.RecombineG2(secret, shares[i]) + if err != nil { + return nil, err + } + } + + return &ServerSecret{secret: secret, curve: c}, nil +} + +// ServerPass1Result is the result of Pass1 on the client side. +type ServerPass1Result struct{ HID, HTID, Y []byte } + +// Destroy overwrites the secret. +func (r *ServerPass1Result) Destroy() { + gomiracl.CleanMemory(r.Y) +} + +// Pass1 performes MPin Pass1 for the server side. +func (ss *ServerSecret) Pass1(id []byte, hash gomiracl.Hash, rng *rand.Rand) (*ServerPass1Result, error) { + return ss.Pass1WithTimePermit(id, 0, hash, rng) +} + +// Pass1WithTimePermit performes MPin Pass1 for the server side with TimePermits. +func (ss *ServerSecret) Pass1WithTimePermit(id []byte, date int, hash gomiracl.Hash, rng *rand.Rand) (*ServerPass1Result, error) { + hid, htid := ss.curve.ServerPass1(hash, date, id) + + y, err := ss.curve.GetRandomSecret(rng) + if err != nil { + return nil, err + } + + return &ServerPass1Result{hid, htid, y}, nil +} + +// Pass2 performes MPin Pass2 for the server side. +func (ss *ServerSecret) Pass2(hid, y, u, v []byte) error { + return ss.curve.ServerPass2(0, hid, nil, y, ss.secret, u, nil, v, nil) +} + +// Pass2WithTimePermit performes MPin Pass2 for the server side with TimePermits. +func (ss *ServerSecret) Pass2WithTimePermit(date int, hid, htid, y, u, ut, v, pa []byte) error { + return ss.curve.ServerPass2(date, hid, htid, y, ss.secret, u, ut, v, pa) +} + +// Pass2WithDVS performes MPin Pass2 for the server side with DVS. +func (ss *ServerSecret) Pass2WithDVS(hid, y, u, v, pa []byte) error { + return ss.curve.ServerPass2(0, hid, nil, y, ss.secret, u, nil, v, pa) +} + +// ServerOnePassResult is the result of One Pass. +type ServerOnePassResult struct{ HID, HTID, Y []byte } + +// Destroy overwrites the secret. +func (r *ServerOnePassResult) Destroy() { + if r == nil { + return + } + + gomiracl.CleanMemory(r.Y) +} + +// OnePass performes one pass server side validation. +func (ss *ServerSecret) OnePass(id []byte, hash gomiracl.Hash, time int, u, v []byte) (*ServerOnePassResult, error) { + hid, htid, y, err := ss.curve.ServerOnePass(hash, 0, ss.secret, u, nil, v, id, nil, time, nil) + if err != nil { + return nil, err + } + + return &ServerOnePassResult{hid, htid, y}, nil +} + +// OnePassWithTimePermit performes one pass server side validation with TimePermits. +func (ss *ServerSecret) OnePassWithTimePermit(id []byte, hash gomiracl.Hash, date, time int, u, ut, v []byte) (*ServerOnePassResult, error) { + hid, htid, y, err := ss.curve.ServerOnePass(hash, date, ss.secret, u, ut, v, id, nil, time, nil) + if err != nil { + return nil, err + } + + return &ServerOnePassResult{hid, htid, y}, nil +} + +// OnePassWithDVS performes one pass server side validation with DVS. +func (ss *ServerSecret) OnePassWithDVS(id, msg []byte, time int, u, v, pa []byte, hash gomiracl.Hash) (*ServerOnePassResult, error) { + hid, htid, y, err := ss.curve.ServerOnePass(hash, 0, ss.secret, u, nil, v, id, msg, time, pa) + if err != nil { + return nil, err + } + + return &ServerOnePassResult{hid, htid, y}, nil +} + +// ServerKey calculates key on Server side for MPin Full. +func (ss *ServerSecret) ServerKey(hash gomiracl.Hash, z, w, p, i, u, ut []byte) ([]byte, error) { + return ss.curve.ServerKey(hash, z, ss.Secret(), w, p, i, u, ut) +} + +// Secret returns the secret as bytes. +func (ss *ServerSecret) Secret() []byte { + return ss.secret +} + +// Destroy overwrites the secret. +func (ss *ServerSecret) Destroy() { + gomiracl.CleanMemory(ss.secret) +} + +// ClientSecretShare is the server secret. +type ClientSecretShare []byte + +// NewClientSecretShare creates new Client Secret Share. +func (ms *MasterSecret) NewClientSecretShare(hashedID []byte) (ClientSecretShare, error) { + secret, err := ms.curve.NewClientSecretShare(ms.secret, hashedID) + if err != nil { + return nil, err + } + + return secret, nil +} + +// Secret returns the secret as bytes. +func (ss ClientSecretShare) Secret() []byte { + return []byte(ss) +} + +// Destroy overwrites the secret. +func (ss ClientSecretShare) Destroy() { + gomiracl.CleanMemory(ss) +} + +// ClientToken is the ClientSecret with extracted pin. +type ClientToken struct { + secret []byte + curve Curve +} + +// NewClientToken returns new ClientToken. +func NewClientToken(secret []byte, c Curve) *ClientToken { + return &ClientToken{secret: secret, curve: c} +} + +// GetClientToken returns new ClientToken by recreating two +// ClientSecretShares and extracting pin from the ClientSecret. +func GetClientToken(id []byte, pin int, hash gomiracl.Hash, c Curve, shares ...ClientSecretShare) (*ClientToken, error) { + if len(shares) < 1 { + return nil, errNoShares + } + + secret := shares[0] + + for i := 1; i < len(shares); i++ { + var err error + + secret, err = c.RecombineG1(secret, shares[i]) + if err != nil { + return nil, err + } + } + + defer gomiracl.CleanMemory(secret) + + token, err := c.ExtractPin(hash, id, pin, secret) + if err != nil { + return nil, err + } + + return &ClientToken{secret: token, curve: c}, nil +} + +// GetDVSClientToken returns new Client token from key-escrow less secret. +func GetDVSClientToken(dvsID []byte, pin int, hash gomiracl.Hash, z []byte, c Curve, shares ...ClientSecretShare) (*ClientToken, error) { + if len(shares) < 1 { + return nil, errNoShares + } + + secret := shares[0] + + for i := 1; i < len(shares); i++ { + var err error + + secret, err = c.RecombineG1(secret, shares[i]) + if err != nil { + return nil, err + } + } + + defer gomiracl.CleanMemory(secret) + + _, secret, err := c.GetG1Multiple(nil, 0, z, secret) + if err != nil { + return nil, err + } + + token, err := c.ExtractPin(hash, dvsID, pin, secret) + if err != nil { + return nil, err + } + + return &ClientToken{secret: token, curve: c}, nil +} + +// ClientPass1Proof is the result of Pass1 on the client side. +type ClientPass1Proof struct{ X, SEC, U, UT []byte } + +// Destroy overwrites the secret. +func (p *ClientPass1Proof) Destroy() { + gomiracl.CleanMemory(p.X) + gomiracl.CleanMemory(p.SEC) + gomiracl.CleanMemory(p.U) + gomiracl.CleanMemory(p.UT) +} + +// Pass1 performes MPin Pass1 for the client side. +func (token *ClientToken) Pass1(id []byte, pin int, hash gomiracl.Hash, rng *rand.Rand) (*ClientPass1Proof, error) { + x, sec, u, ut, err := token.curve.ClientPass1(hash, 0, id, rng, nil, pin, token.Secret(), nil) + if err != nil { + return nil, err + } + + return &ClientPass1Proof{x, sec, u, ut}, nil +} + +// Pass1WithTimePermit performes MPin Pass1 for the client side with TimePermits. +func (token *ClientToken) Pass1WithTimePermit(id []byte, pin, date int, tp TimePermit, hash gomiracl.Hash, rng *rand.Rand) (*ClientPass1Proof, error) { + x, sec, u, ut, err := token.curve.ClientPass1(hash, date, id, rng, nil, pin, token.Secret(), tp.Secret()) + if err != nil { + return nil, err + } + + return &ClientPass1Proof{x, sec, u, ut}, nil +} + +// ClientPass2Proof is the result of Pass2 on the client side. +type ClientPass2Proof struct{ V []byte } + +// Destroy overwrites the secret. +func (p *ClientPass2Proof) Destroy() { + gomiracl.CleanMemory(p.V) +} + +// Pass2 performes MPin Pass2 for the client side. +func (token *ClientToken) Pass2(x, y, sec []byte) (*ClientPass2Proof, error) { + v, err := token.curve.ClientPass2(x, y, sec) + if err != nil { + return nil, err + } + + return &ClientPass2Proof{v}, nil +} + +// OnePassProof is the result of OnePass on the client side. +type OnePassProof struct{ X, V, U, UT, Y []byte } + +// Destroy overwrites the secret. +func (p *OnePassProof) Destroy() { + gomiracl.CleanMemory(p.X) + gomiracl.CleanMemory(p.V) + gomiracl.CleanMemory(p.U) + gomiracl.CleanMemory(p.UT) + gomiracl.CleanMemory(p.Y) +} + +// OnePass performes MPin One Pass for the client side. +func (token *ClientToken) OnePass(id []byte, pin, time int, hash gomiracl.Hash, rng *rand.Rand) (*OnePassProof, error) { + return token.OnePassWithTimePermit(id, pin, 0, time, nil, hash, rng) +} + +// OnePassWithDVS performes MPin One Pass for the client side with DVS. +func (token *ClientToken) OnePassWithDVS(id []byte, pin int, msg []byte, time int, hash gomiracl.Hash, rng *rand.Rand) (*OnePassProof, error) { + xout, v, u, ut, y1, err := token.curve.ClientOnePass(hash, 0, id, rng, nil, pin, token.Secret(), nil, msg, time) + if err != nil { + return nil, err + } + + return &OnePassProof{xout, v, u, ut, y1}, nil +} + +// OnePassWithTimePermit performes MPin One Pass for the client side with TimePermits. +func (token *ClientToken) OnePassWithTimePermit(id []byte, pin, date, time int, tp TimePermit, hash gomiracl.Hash, rng *rand.Rand) (*OnePassProof, error) { + xout, v, u, ut, y1, err := token.curve.ClientOnePass(hash, date, id, rng, nil, pin, token.Secret(), tp, nil, time) + if err != nil { + return nil, err + } + + return &OnePassProof{xout, v, u, ut, y1}, nil +} + +// FullPrecompute are the values returned by the precompute function. +type FullPrecompute struct{ G1, G2 []byte } + +// Destroy overwrites the secret. +func (p *FullPrecompute) Destroy() { + gomiracl.CleanMemory(p.G1) + gomiracl.CleanMemory(p.G2) +} + +// Precompute precomputes values for use by the client side of M-Pin Full. +func (token *ClientToken) Precompute(hashedID, pub []byte) (*FullPrecompute, error) { + g1, g2, err := token.curve.Precompute(token.Secret(), hashedID, pub) + if err != nil { + return nil, err + } + + return &FullPrecompute{g1, g2}, nil +} + +// Secret returns the secret as bytes. +func (token *ClientToken) Secret() []byte { + return token.secret +} + +// Destroy overwrites the secret. +func (token *ClientToken) Destroy() { + gomiracl.CleanMemory(token.secret) +} + +// TimePermitShare is Time Permit Share. +type TimePermitShare []byte + +// NewTimePermitShare returns new Time Permit. +func (ms *MasterSecret) NewTimePermitShare(hashedID []byte, date int, hash gomiracl.Hash) (TimePermitShare, error) { + tp, err := ms.curve.NewTimePermitShare(hash, date, ms.secret, hashedID) + if err != nil { + return nil, err + } + + return TimePermitShare(tp), nil +} + +// Secret returns the secret as bytes. +func (tps TimePermitShare) Secret() []byte { + return []byte(tps) +} + +// Destroy overwrites the secret. +func (tps TimePermitShare) Destroy() { + gomiracl.CleanMemory(tps) +} + +// TimePermit is Time Permit. +type TimePermit []byte + +// NewTimePermit returns new Time Permit. +func NewTimePermit(c Curve, shares ...TimePermitShare) (TimePermit, error) { + if len(shares) < 1 { + return nil, errNoShares + } + + timePermit := shares[0] + + for i := 1; i < len(shares); i++ { + var err error + + timePermit, err = c.RecombineG1(timePermit, shares[i]) + if err != nil { + return nil, err + } + } + + return TimePermit(timePermit), nil +} + +// Secret returns the secret as bytes. +func (tp TimePermit) Secret() []byte { + return []byte(tp) +} + +// Destroy overwrites the secret. +func (tp TimePermit) Destroy() { + gomiracl.CleanMemory(tp) +} + +// HashID hashes the identity for given curve. +func HashID(id []byte, hash gomiracl.Hash, c Curve) []byte { + return wrap.HashID(int(hash), id, c.FieldSize()) +} + +// HashAll hashes the MPin transcript. +func HashAll(hash gomiracl.Hash, id, u, cu, y, v, r, w []byte, hSize int) []byte { + return wrap.HashAll(int(hash), id, u, cu, y, v, r, w, hSize) +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/otp.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/otp.go new file mode 100644 index 00000000..b18cabfa --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/mpin/otp.go @@ -0,0 +1,12 @@ +package mpin + +import ( + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/rand" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// GenerateOTP generated new 6 digit OTP. +func GenerateOTP(rng *rand.Rand) int { + return wrap.GenerateOTP((*bindings.Rand)(rng)) +} diff --git a/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/rand/rand.go b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/rand/rand.go new file mode 100644 index 00000000..02df2654 --- /dev/null +++ b/integration-tests/vendor/code.miracl.com/maas/maas/src/lib/gomiracl/rand/rand.go @@ -0,0 +1,43 @@ +// Package rand defines a cryptographically secure random number generator. +package rand + +import ( + "io" + + "code.miracl.com/maas/maas/src/lib/gomiracl" + "code.miracl.com/maas/maas/src/lib/gomiracl/bindings" + "code.miracl.com/maas/maas/src/lib/gomiracl/wrap" +) + +// Rand is a cryptographically secure random number generator. +// Implements io.Reader. +type Rand bindings.Rand + +// New is Rand. +func New(r io.Reader, seedSize int) (*Rand, error) { + seed := make([]byte, seedSize) + defer gomiracl.CleanMemory(seed) + + _, err := io.ReadFull(r, seed) + if err != nil { + return nil, err + } + + return (*Rand)(bindings.NewRand(seed)), nil +} + +// GetByte returns one random byte. +func (rng *Rand) GetByte() byte { + return byte(wrap.GetRandByte((*bindings.Rand)(rng))) +} + +// Read generates len(p) random bytes and writes them into p. It +// always returns len(p) and a nil error. +// Read should not be called concurrently with any other Rand method. +func (rng *Rand) Read(p []byte) (n int, err error) { + for x := 0; x < len(p); x++ { + p[x] = rng.GetByte() + } + + return len(p), nil +} diff --git a/integration-tests/vendor/modules.txt b/integration-tests/vendor/modules.txt index 45099cb1..c4146c2c 100644 --- a/integration-tests/vendor/modules.txt +++ b/integration-tests/vendor/modules.txt @@ -2,6 +2,9 @@ ## explicit; go 1.24 code.miracl.com/maas/maas/src/lib/gomiracl code.miracl.com/maas/maas/src/lib/gomiracl/bindings +code.miracl.com/maas/maas/src/lib/gomiracl/curve +code.miracl.com/maas/maas/src/lib/gomiracl/mpin +code.miracl.com/maas/maas/src/lib/gomiracl/rand code.miracl.com/maas/maas/src/lib/gomiracl/wrap # github.com/google/uuid v1.3.0 ## explicit