Integrating ConnectIPS with Go — RSA Tokens, Validation

go get golang.org/x/crypto/pkcs12

package connectips
 
import (
	"crypto"
	"crypto/rand"
	"crypto/rsa"
	"crypto/sha256"
	"encoding/base64"
	"fmt"
 
	"golang.org/x/crypto/pkcs12"
)
 
// LoadKey extracts the RSA private key from a PKCS12 (.pfx) keystore.
func LoadKey(pfx []byte, password string) (*rsa.PrivateKey, error) {
	key, _, err := pkcs12.Decode(pfx, password)
	if err != nil {
		return nil, fmt.Errorf("decode pfx: %w", err)
	}
	rsaKey, ok := key.(*rsa.PrivateKey)
	if !ok {
		return nil, fmt.Errorf("keystore key is not RSA")
	}
	return rsaKey, nil
}
 
// Sign returns the Base64 SHA256withRSA signature of message — a ConnectIPS token.
func Sign(key *rsa.PrivateKey, message string) (string, error) {
	digest := sha256.Sum256([]byte(message))
	sig, err := rsa.SignPKCS1v15(rand.Reader, key, crypto.SHA256, digest[:])
	if err != nil {
		return "", err
	}
	return base64.StdEncoding.EncodeToString(sig), nil
}

package connectips
 
import (
	"crypto/rsa"
	"os"
)
 
type Config struct {
	BaseURL    string // https://uat.connectips.com
	MerchantID string // e.g. 550
	AppID      string // MER-550-APP-1
	AppName    string
	Password   string // web-service password (Basic auth)
	SuccessURL string // pre-registered with NCHL
	FailureURL string
	Key        *rsa.PrivateKey // loaded from the .pfx
}
 
func FromEnv() (Config, error) {
	pfx, err := os.ReadFile(os.Getenv("CONNECTIPS_PFX_PATH"))
	if err != nil {
		return Config{}, err
	}
	key, err := LoadKey(pfx, os.Getenv("CONNECTIPS_KEYSTORE_PASSWORD"))
	if err != nil {
		return Config{}, err
	}
	return Config{
		BaseURL:    os.Getenv("CONNECTIPS_URL"),
		MerchantID: os.Getenv("CONNECTIPS_MERCHANT_ID"),
		AppID:      os.Getenv("CONNECTIPS_APP_ID"),
		AppName:    os.Getenv("CONNECTIPS_APP_NAME"),
		Password:   os.Getenv("CONNECTIPS_PASSWORD"),
		SuccessURL: os.Getenv("CONNECTIPS_SUCCESS_URL"),
		FailureURL: os.Getenv("CONNECTIPS_FAILURE_URL"),
		Key:        key,
	}, nil
}

CONNECTIPS_URL=https://uat.connectips.com
CONNECTIPS_MERCHANT_ID=550
CONNECTIPS_APP_ID=MER-550-APP-1
CONNECTIPS_APP_NAME=YourApp
CONNECTIPS_PASSWORD=your_webservice_password
CONNECTIPS_PFX_PATH=./secrets/CREDITOR.pfx
CONNECTIPS_KEYSTORE_PASSWORD=your_keystore_password
CONNECTIPS_SUCCESS_URL=https://your-app.example.com/payments/connectips/return
CONNECTIPS_FAILURE_URL=https://your-app.example.com/payments/connectips/failed

package connectips
 
import (
	"fmt"
	"time"
)
 
type PaymentForm struct {
	Action string
	Fields map[string]string
	Order  []string // stable field order for form rendering
}
 
func (c Config) BuildPaymentForm(txnID string, amountPaisa int, referenceID, remarks, particulars string) (PaymentForm, error) {
	txnDate := time.Now().Format("02-01-2006") // DD-MM-YYYY
 
	f := map[string]string{
		"MERCHANTID":  c.MerchantID,
		"APPID":       c.AppID,
		"APPNAME":     c.AppName,
		"TXNID":       txnID,
		"TXNDATE":     txnDate,
		"TXNCRNCY":    "NPR",
		"TXNAMT":      fmt.Sprintf("%d", amountPaisa),
		"REFERENCEID": referenceID,
		"REMARKS":     remarks,
		"PARTICULARS": particulars,
	}
 
	// EXACT order, comma-joined, NO spaces, literal TOKEN=TOKEN suffix.
	message := fmt.Sprintf(
		"MERCHANTID=%s,APPID=%s,APPNAME=%s,TXNID=%s,TXNDATE=%s,TXNCRNCY=%s,"+
			"TXNAMT=%s,REFERENCEID=%s,REMARKS=%s,PARTICULARS=%s,TOKEN=TOKEN",
		f["MERCHANTID"], f["APPID"], f["APPNAME"], f["TXNID"], f["TXNDATE"],
		f["TXNCRNCY"], f["TXNAMT"], f["REFERENCEID"], f["REMARKS"], f["PARTICULARS"],
	)
 
	token, err := Sign(c.Key, message)
	if err != nil {
		return PaymentForm{}, err
	}
	f["TOKEN"] = token
 
	return PaymentForm{
		Action: c.BaseURL + "/connectipswebgw/loginpage",
		Fields: f,
		Order: []string{
			"MERCHANTID", "APPID", "APPNAME", "TXNID", "TXNDATE", "TXNCRNCY",
			"TXNAMT", "REFERENCEID", "REMARKS", "PARTICULARS", "TOKEN",
		},
	}, nil
}

package connectips
 
import (
	"html"
	"net/http"
	"strings"
)
 
// WriteAutoSubmitForm sends a self-submitting form that bounces the browser to
// ConnectIPS. html.EscapeString guards every value against injection.
func (f PaymentForm) WriteAutoSubmitForm(w http.ResponseWriter) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 
	var b strings.Builder
	b.WriteString(`<!doctype html><html><body onload="document.forms[0].submit()">`)
	b.WriteString(`<form method="POST" action="` + html.EscapeString(f.Action) + `">`)
	for _, k := range f.Order {
		b.WriteString(`<input type="hidden" name="` + html.EscapeString(k) +
			`" value="` + html.EscapeString(f.Fields[k]) + `">`)
	}
	b.WriteString(`</form></body></html>`)
 
	_, _ = w.Write([]byte(b.String()))
}

package connectips
 
import (
	"bytes"
	"context"
	"encoding/base64"
	"encoding/json"
	"fmt"
	"net/http"
	"strconv"
)
 
type Validation struct {
	Status     string `json:"status"`     // "SUCCESS" when paid
	StatusDesc string `json:"statusDesc"`
	TxnAmt     string `json:"txnAmt"`     // echoed back as a string
}
 
func (c Config) ValidateTxn(ctx context.Context, txnID string, amountPaisa int) (*Validation, error) {
	// 4-field token, UPPERCASE keys, no TOKEN=TOKEN suffix.
	token, err := Sign(c.Key, fmt.Sprintf(
		"MERCHANTID=%s,APPID=%s,REFERENCEID=%s,TXNAMT=%d",
		c.MerchantID, c.AppID, txnID, amountPaisa,
	))
	if err != nil {
		return nil, err
	}
 
	mid, _ := strconv.Atoi(c.MerchantID)
	// camelCase body; referenceId carries the original TXNID.
	body, _ := json.Marshal(map[string]any{
		"merchantId":  mid,
		"appId":       c.AppID,
		"referenceId": txnID,
		"txnAmt":      amountPaisa,
		"token":       token,
	})
 
	url := c.BaseURL + "/connectipswebws/api/creditor/validatetxn"
	req, _ := http.NewRequestWithContext(ctx, http.MethodPost, url, bytes.NewReader(body))
	req.Header.Set("Content-Type", "application/json")
	auth := base64.StdEncoding.EncodeToString([]byte(c.AppID + ":" + c.Password))
	req.Header.Set("Authorization", "Basic "+auth)
 
	res, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	if res.StatusCode != http.StatusOK {
		return nil, fmt.Errorf("validatetxn failed: HTTP %d", res.StatusCode)
	}
 
	var v Validation
	if err := json.NewDecoder(res.Body).Decode(&v); err != nil {
		return nil, err
	}
	return &v, nil
}

{
  "merchantId": 550,
  "appId": "MER-550-APP-1",
  "referenceId": "txn-123",
  "txnAmt": "500",
  "token": null,
  "status": "SUCCESS",
  "statusDesc": "TRANSACTION SUCESSFULL"
}

package main
 
import (
	"net/http"
	"os"
 
	"yourapp/connectips"
)
 
// OrderStore is your DB layer. MarkPaid must be a single atomic statement —
// e.g. UPDATE orders SET status='PAID' WHERE id=$1 AND status='PENDING' —
// returning true only for the first caller that wins the row.
type OrderStore interface {
	ByID(id string) (Order, error)
	ByTxnID(txnID string) (Order, error)
	MarkPaid(id string) (bool, error)
	MarkFailed(id string) error
	Fulfil(id string) error
}
 
func StartPayment(cfg connectips.Config, store OrderStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		order, err := store.ByID(r.PathValue("orderId"))
		if err != nil {
			http.Error(w, "unknown order", http.StatusNotFound)
			return
		}
		form, err := cfg.BuildPaymentForm(
			order.TxnID, order.ExpectedAmountPaisa, // from the DB, not the request
			order.ID, "Order "+order.ID, "Checkout",
		)
		if err != nil {
			http.Error(w, "could not start payment", http.StatusInternalServerError)
			return
		}
		form.WriteAutoSubmitForm(w)
	}
}
 
func HandleReturn(cfg connectips.Config, store OrderStore) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		status, _ := Settle(r.Context(), cfg, store, r.URL.Query().Get("TXNID"))
		base := os.Getenv("CLIENT_URL")
		dest := base + "/payment/failed"
		if status == "PAID" {
			dest = base + "/payment/success"
		}
		http.Redirect(w, r, dest, http.StatusSeeOther)
	}
}

package payments
 
import (
	"context"
	"crypto/rand"
	"encoding/hex"
)
 
// newTxnID returns a unique transaction id (<= 20 chars).
func newTxnID() string {
	b := make([]byte, 6)
	_, _ = rand.Read(b)
	return "T" + hex.EncodeToString(b)
}
 
func (s *Service) CreatePayment(ctx context.Context, orderID string) (txnID string, amountPaisa int, err error) {
	order, err := s.orders.ByID(ctx, orderID)
	if err != nil {
		return "", 0, err
	}
 
	// Re-price from line items in YOUR database; ignore any client total.
	rupees := 0
	for _, li := range order.LineItems {
		rupees += li.UnitPrice * li.Qty
	}
	amountPaisa = rupees * 100 // paisa, integer
 
	txnID = newTxnID()
	if err := s.orders.InitPayment(ctx, orderID, txnID, amountPaisa); err != nil {
		return "", 0, err
	}
	return txnID, amountPaisa, nil
}

package payments
 
import (
	"context"
	"fmt"
	"strconv"
	"time"
 
	"yourapp/connectips"
)
 
func Settle(ctx context.Context, cfg connectips.Config, store OrderStore, txnID string) (string, error) {
	order, err := store.ByTxnID(txnID)
	if err != nil {
		return "", err
	}
	if order.Status != "PENDING" { // refresh / retry safe
		return order.Status, nil
	}
 
	ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
	defer cancel()
 
	// Source of truth — not the redirect query.
	v, err := cfg.ValidateTxn(ctx, txnID, order.ExpectedAmountPaisa)
	if err != nil {
		return "", err
	}
	if v.Status != "SUCCESS" {
		_ = store.MarkFailed(order.ID)
		return "FAILED", nil
	}
 
	// Re-check the validated amount against what we stored.
	if v.TxnAmt != strconv.Itoa(order.ExpectedAmountPaisa) {
		return "", fmt.Errorf("amount mismatch: got %s, expected %d", v.TxnAmt, order.ExpectedAmountPaisa)
	}
 
	// Atomic: only the first caller flips PENDING -> PAID and fulfils.
	if won, _ := store.MarkPaid(order.ID); won {
		_ = store.Fulfil(order.ID) // runs once, ever
	}
	return "PAID", nil
}