Add support for BankID "order token", not sure about naming

Author: joeledstrom

.github/workflows/tests.yaml

@@ -0,0 +1,22 @@
+name: tests
+on:
+  pull_request:
+    branches:
+      - master
+  push:
+    branches:
+      - master
+      - order-ref-token
+  workflow_dispatch: {}
+jobs:
+  run-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+      - uses: actions/setup-go@v5
+        with:
+          go-version: 'stable'
+      - name: run
+        run: |-
+          cd test
+          go test --race -v .

api/models.go

@@ -1,5 +1,7 @@
 package api
 
+import "time"
+
 type (
 	// BankIdV6Response used as a catch all response for V2
 	// Deprecated: stick to V1 or move to V3
@@ -39,7 +41,7 @@ type (
 
 	// BankIdv6AuthSignRequestV3 is used to start either an auth or sign request against BankID
 	BankIdv6AuthSignRequestV3 struct {
-		// EndUserIp The user IP address as it is seen by your service
+		// EndUserIp The user IP address as it is seen by your service. Required.
 		EndUserIp string `json:"endUserIp"`
 
 		// ReturnUrl Orders started on the same device as where the user's BankID is stored (started with autostart
@@ -64,6 +66,9 @@ type (
 		// Once if true, will start an auth/sign and just return a single QR code, if false, auth/sign endpoint return
 		// an SSE / NDJSON stream and send a new QR-code each second, for 30 seconds before returning
 		Once bool `json:"once,omitempty"`
+
+		// OrderTokenExpire if order tokens are enabled, sets token expire time.
+		OrderTokenExpire time.Duration `json:"order_token_expire,omitempty"`
 	}
 
 	// BankIdV6AuthSignResponseV3 is sent as a successful reply to an auth or sign request. If SSE / NDJSON is used, a
@@ -77,6 +82,9 @@ type (
 
 		// QR contain the data for the QR-code
 		QR string `json:"qr"`
+
+		// OrderToken is returned if order token support is enabled.
+		OrderToken string `json:"orderToken,omitempty"`
 	}
 
 	// BankIdv6CollectRequestV3 is used to collect status on a started auth / sign request
@@ -90,6 +98,11 @@ type (
 		// WaitUntilFinished allows the request to wait until the referenced request has either completed or failed,
 		// and will not return on state changes during the ongoing process.
 		WaitUntilFinished bool `json:"waitUntilFinished"`
+
+		// OrderToken optionally pass an order token. This is an alternative to OrderRef.
+		// If you use this the end user IP of the user who triggered collect is required for verification
+		OrderToken string `json:"orderToken"`
+		EndUserIp  string `json:"endUserIp"`
 	}
 
 	// BankIdV6CollectResponseV3 is sent for a successful collect, if WaitUntilFinished is set in the request, it will

cmd/twoferd/main.go

@@ -13,10 +13,10 @@ import (
 
 	"github.com/labstack/echo/v4"
 	"github.com/labstack/echo/v4/middleware"
-
 	"github.com/modfin/twofer/internal/config"
 	"github.com/modfin/twofer/internal/eid/bankid"
 	"github.com/modfin/twofer/internal/httpserve"
+	"github.com/modfin/twofer/internal/ordertoken"
 	"github.com/modfin/twofer/internal/servotp"
 	"github.com/modfin/twofer/internal/servpwd"
 	"github.com/modfin/twofer/internal/servqr"
@@ -153,6 +153,16 @@ func startEid(e *echo.Echo) {
 		return
 	}
 
+	bankIdCfg := config.Get().BankID
+	var otm *ordertoken.Manager
+	if bankIdCfg.OrderTokenJwtEc256 != "" || bankIdCfg.OrderTokenJwtEc256Pub != "" || len(bankIdCfg.OrderTokenEncryptionKey) > 0 {
+		fmt.Println("  - Enabling BankId Order Token support")
+		otm, err = ordertoken.NewManager(bankIdCfg.OrderTokenJwtEc256, bankIdCfg.OrderTokenJwtEc256Pub, bankIdCfg.OrderTokenEncryptionKey)
+		if err != nil {
+			fmt.Printf("failed to initate bankId order token support %v", err)
+		}
+	}
+
 	//err = bankid.APIv51.Ping()
 	//if err != nil {
 	//	fmt.Printf("  - Err: Could not ping bankid v5.1. %v", err)
@@ -164,7 +174,7 @@ func startEid(e *echo.Echo) {
 
 	fmt.Println("  - Adding BankId v6.0")
 	fmt.Println("  - BankId Client Cert NotAfter:", bankid.ParsedClientCert().NotAfter)
-	httpserve.RegisterBankIDServer(e, bankid.APIv60, getStreamEncoder(config.Get().StreamEncoder))
+	httpserve.RegisterBankIDServer(e, bankid.APIv60, otm, getStreamEncoder(config.Get().StreamEncoder))
 	err = bankid.APIv60.Ping()
 	if err != nil {
 		fmt.Printf("  - Err: Could not ping bankid. %v", err)

internal/config/config.go

@@ -36,15 +36,18 @@ type OTP struct {
 }
 
 type BankID struct {
-	Enabled        bool          `env:"EID_BANKID_ENABLE" envDefault:"FALSE"`
-	URL            *url.URL      `env:"EID_BANKID_URL"`
-	RootCA         string        `env:"EID_BANKID_ROOT_CA_PEM"`
-	RootCAFile     string        `env:"EID_BANKID_ROOT_CA_PEM_FILE,file"`
-	ClientCert     string        `env:"EID_BANKID_CLIENT_CERT"`
-	ClientCertFile string        `env:"EID_BANKID_CLIENT_CERT_FILE,file"`
-	ClientKey      string        `env:"EID_BANKID_CLIENT_KEY"`
-	ClientKeyFile  string        `env:"EID_BANKID_CLIENT_KEY_FILE,file"`
-	PollInterval   time.Duration `env:"EID_BANKID_POLL_INTERVAL" envDefault:"2s"` // Poll BankID every two seconds as default (according to their spec)
+	Enabled                 bool          `env:"EID_BANKID_ENABLE" envDefault:"FALSE"`
+	URL                     *url.URL      `env:"EID_BANKID_URL"`
+	RootCA                  string        `env:"EID_BANKID_ROOT_CA_PEM"`
+	RootCAFile              string        `env:"EID_BANKID_ROOT_CA_PEM_FILE,file"`
+	ClientCert              string        `env:"EID_BANKID_CLIENT_CERT"`
+	ClientCertFile          string        `env:"EID_BANKID_CLIENT_CERT_FILE,file"`
+	ClientKey               string        `env:"EID_BANKID_CLIENT_KEY"`
+	ClientKeyFile           string        `env:"EID_BANKID_CLIENT_KEY_FILE,file"`
+	PollInterval            time.Duration `env:"EID_BANKID_POLL_INTERVAL" envDefault:"2s"` // Poll BankID every two seconds as default (according to their spec)
+	OrderTokenEncryptionKey []string      `env:"EID_BANKID_ORDER_TOKEN_ENCRYPTION_KEY" envSeparator:" "`
+	OrderTokenJwtEc256      string        `env:"EID_BANKID_ORDER_TOKEN_JWT_EC_256"`
+	OrderTokenJwtEc256Pub   string        `env:"EID_BANKID_ORDER_TOKEN_JWT_EC_256_PUB"`
 }
 
 func (b BankID) GetRootCA() []byte {

internal/httpserve/bankid.go

@@ -6,13 +6,15 @@ import (
 	"errors"
 	"fmt"
 	"io"
+	"net"
 	"net/http"
 	"strconv"
 	"time"
 
 	"github.com/labstack/echo/v4"
 	"github.com/modfin/twofer/api"
 	"github.com/modfin/twofer/internal/bankid"
+	"github.com/modfin/twofer/internal/ordertoken"
 	"github.com/modfin/twofer/internal/sse"
 	"github.com/modfin/twofer/stream"
 )
@@ -21,16 +23,16 @@ const qrCodeUpdatePeriod = time.Second
 
 type NewStreamEncoder func(http.ResponseWriter) (stream.Encoder, error)
 
-func RegisterBankIDServer(e *echo.Echo, client *bankid.API, newEncoder NewStreamEncoder) {
+func RegisterBankIDServer(e *echo.Echo, client *bankid.API, otm *ordertoken.Manager, newEncoder NewStreamEncoder) {
 	e.POST("/bankid/v6/auth", auth(client))
 	e.POST("/bankid/v6/authv2", authSign(client.Auth, client.WatchForChangeV2, qrCodeUpdatePeriod, newEncoder)) // Deprecated: Don't use
-	e.POST("/bankid/v6/authv3", authSignV3(client.Auth, qrCodeUpdatePeriod, newEncoder))                        // Same as 'auth' except won't poll BankID collect API (since a completed/failed orderRef can only be collected once)
+	e.POST("/bankid/v6/authv3", authSignV3(client.Auth, qrCodeUpdatePeriod, newEncoder, otm))                   // Same as 'auth' except won't poll BankID collect API (since a completed/failed orderRef can only be collected once)
 	e.POST("/bankid/v6/sign", sign(client))
 	e.POST("/bankid/v6/signv2", authSign(client.Sign, client.WatchForChangeV2, qrCodeUpdatePeriod, newEncoder)) // Deprecated: Don't use
-	e.POST("/bankid/v6/signv3", authSignV3(client.Sign, qrCodeUpdatePeriod, newEncoder))                        // Same as 'sign' except won't poll BankID collect API (since a completed/failed orderRef can only be collected once)
+	e.POST("/bankid/v6/signv3", authSignV3(client.Sign, qrCodeUpdatePeriod, newEncoder, otm))                   // Same as 'sign' except won't poll BankID collect API (since a completed/failed orderRef can only be collected once)
 	e.POST("/bankid/v6/change", change(client))
 	e.POST("/bankid/v6/collect", collect(client))
-	e.POST("/bankid/v6/collectV3", collectV3(client))
+	e.POST("/bankid/v6/collectV3", collectV3(client, otm))
 	e.POST("/bankid/v6/cancel", cancel(client))
 	e.POST("/bankid/v6/cancelV3", cancelV3(client))
 }
@@ -490,14 +492,17 @@ func bankIdv6ErrorResponseV3(err error, detail string) api.BankIdv6ErrorResponse
 // or change endpoints after the first QR-code has been returned. It also returns one or more
 // api.BankIdV6AuthSignResponseV3 structs for a successful auth/sign request. For failed requests,
 // a api.BankIdv6ErrorResponseV3 is returned instead.
-func authSignV3(authOrSignFn authSignFn, qrPeriod time.Duration, newStreamEncoder NewStreamEncoder) func(echo.Context) error {
+func authSignV3(authOrSignFn authSignFn, qrPeriod time.Duration, newStreamEncoder NewStreamEncoder, otm *ordertoken.Manager) func(echo.Context) error {
 	return func(c echo.Context) error {
 		request, err := readBody[api.BankIdv6AuthSignRequestV3](c.Request().Body)
 		if err != nil {
 			fmt.Printf("ERR: read request body error: %v\n", err)
 			return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(err, "read request body error"))
 		}
-
+		if ip := net.ParseIP(request.EndUserIp); ip == nil {
+			fmt.Printf("ERR: error parsing endUserIp\n")
+			return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(nil, "error parsing endUserIp"))
+		}
 		// Convert from public API to internal struct
 		br := bankid.Requirement{
 			PinCode:        request.PinCode,
@@ -518,11 +523,25 @@ func authSignV3(authOrSignFn authSignFn, qrPeriod time.Duration, newStreamEncode
 			return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(err, "auth/sign request error"))
 		}
 
+		orderToken := ""
+		if otm != nil {
+			t, err := otm.Create(request.OrderTokenExpire, ordertoken.Payload{
+				OrderRef:  res.OrderRef,
+				EndUserIp: request.EndUserIp,
+			})
+			if err != nil {
+				fmt.Printf("ERR: error creating order token: %v\n", err)
+				return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(err, "error creating order token"))
+			}
+			orderToken = t
+		}
+
 		bankIdV6AuthSignResponseV3 := func(r *bankid.AuthSignResponse, qrNo int) api.BankIdV6AuthSignResponseV3 {
 			return api.BankIdV6AuthSignResponseV3{
-				OrderRef: r.OrderRef,
-				URI:      fmt.Sprintf("bankid:///?autostarttoken=%s&redirect=null", r.AutoStartToken),
-				QR:       r.BuildQrCode(qrNo),
+				OrderRef:   r.OrderRef,
+				URI:        fmt.Sprintf("bankid:///?autostarttoken=%s&redirect=null", r.AutoStartToken),
+				QR:         r.BuildQrCode(qrNo),
+				OrderToken: orderToken,
 			}
 		}
 
@@ -554,14 +573,25 @@ func authSignV3(authOrSignFn authSignFn, qrPeriod time.Duration, newStreamEncode
 
 // Pretty much the same as collect and change, except that it will return an api.BankIdV6CollectResponseV3 struct for
 // successful requests, for failed requests, an api.BankIdv6ErrorResponseV3 is returned instead.
-func collectV3(client *bankid.API) func(echo.Context) error {
+func collectV3(client *bankid.API, otm *ordertoken.Manager) func(echo.Context) error {
 	return func(c echo.Context) error {
 		request, err := readBody[api.BankIdv6CollectRequestV3](c.Request().Body)
 		if err != nil {
 			fmt.Printf("ERR: read request body error: %v\n", err)
 			return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(err, "read request body error"))
 		}
 
+		if otm != nil {
+			claims, err := otm.Parse(request.OrderToken, request.EndUserIp)
+			if err != nil && errors.Is(err, ordertoken.ErrOrderIpMismatch) {
+				return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(err, "order token ip mismatch with request ip"))
+			}
+			if err != nil {
+				return c.JSON(http.StatusInternalServerError, bankIdv6ErrorResponseV3(err, "error parsing order token"))
+			}
+			request.OrderRef = claims.OrderRef
+		}
+
 		var res *bankid.CollectResponse
 		if request.WaitForChange || request.WaitUntilFinished {
 			res, err = client.ChangeV3(c.Request().Context(), &bankid.ChangeRequest{
@@ -575,6 +605,9 @@ func collectV3(client *bankid.API) func(echo.Context) error {
 			fmt.Printf("ERR: collect request error: %v\n", err)
 			return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(err, "collect request error"))
 		}
+		if otm != nil && res.CompletionData.Device.IpAddress != request.EndUserIp {
+			return c.JSON(http.StatusBadRequest, bankIdv6ErrorResponseV3(nil, "order token ip mismatch with device ip"))
+		}
 
 		reply := api.BankIdV6CollectResponseV3{
 			OrderRef: res.OrderRef,

internal/ordertoken/ordertoken.go

@@ -0,0 +1,108 @@
+package ordertoken
+
+import (
+	"crypto/ecdsa"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"time"
+
+	"github.com/golang-jwt/jwt/v5"
+	"github.com/modfin/twofer/internal/crypt"
+)
+
+type claims struct {
+	jwt.RegisteredClaims
+	Payload []byte `json:"payload"`
+}
+
+type Payload struct {
+	OrderRef  string `json:"orderRef"`
+	EndUserIp string `json:"endUserIp"`
+}
+
+type Manager struct {
+	privateKey *ecdsa.PrivateKey
+	publicKey  *ecdsa.PublicKey
+	cryptStore crypt.Store
+}
+
+var ErrOrderIpMismatch = errors.New("order ip mismatch")
+
+func NewManager(ec256 string, ec256pub string, encryptionKey []string) (*Manager, error) {
+	privateKey, err := jwt.ParseECPrivateKeyFromPEM([]byte(ec256))
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse ECDSA private key: %w", err)
+	}
+	publicKey, err := jwt.ParseECPublicKeyFromPEM([]byte(ec256pub))
+	if err != nil {
+		return nil, fmt.Errorf("unable to parse ECDSA public key: %w", err)
+	}
+	s, err := crypt.New(encryptionKey)
+	if err != nil {
+		return nil, fmt.Errorf("unable to create crypt store: %w", err)
+	}
+	return &Manager{
+		privateKey: privateKey,
+		publicKey:  publicKey,
+		cryptStore: s,
+	}, nil
+}
+
+// Parse parses and validates an order token and returns it's encrypted payload
+func (m *Manager) Parse(orderToken string, endUserIp string) (Payload, error) {
+	var claims claims
+	_, err := jwt.ParseWithClaims(orderToken, &claims, func(token *jwt.Token) (interface{}, error) {
+		if token.Method.Alg() != jwt.SigningMethodES256.Alg() {
+			return nil, fmt.Errorf("unexpected jwt signing method=%v", token.Header["alg"])
+		}
+		return m.publicKey, nil
+	})
+	if err != nil {
+		return Payload{}, err
+	}
+	p, err := m.cryptStore.Decrypt(claims.Payload)
+	if err != nil {
+		return Payload{}, fmt.Errorf("failed to decrypt payload: %w", err)
+	}
+	var payload Payload
+	err = json.Unmarshal(p, &payload)
+	if err != nil {
+		return Payload{}, fmt.Errorf("failed to unmarshal payload: %w", err)
+	}
+	if payload.EndUserIp != endUserIp {
+		return Payload{}, ErrOrderIpMismatch
+	}
+	if payload.OrderRef == "" {
+		return Payload{}, errors.New("order ref empty")
+	}
+	return payload, nil
+}
+
+func (m *Manager) Create(expire time.Duration, payload Payload) (string, error) {
+	if expire <= 0 {
+		return "", errors.New("order token expire must be positive")
+	}
+	b, err := json.Marshal(payload)
+	if err != nil {
+		return "", fmt.Errorf("failed to marshal payload: %w", err)
+	}
+	p, err := m.cryptStore.Encrypt(b)
+	if err != nil {
+		return "", fmt.Errorf("failed to encrypt payload: %w", err)
+	}
+	t := time.Now()
+	c := claims{
+		RegisteredClaims: jwt.RegisteredClaims{
+			IssuedAt:  &jwt.NumericDate{Time: t},
+			ExpiresAt: &jwt.NumericDate{Time: t.Add(expire)},
+			Issuer:    "twofer",
+		},
+		Payload: p,
+	}
+	token, err := jwt.NewWithClaims(jwt.SigningMethodES256, c).SignedString(m.privateKey)
+	if err != nil {
+		return "", err
+	}
+	return token, nil
+}