weak

Author: dungdm93

core/pkg/model/serde.go

@@ -11,6 +11,7 @@ import (
 	"encoding/json/v2"
 	"errors"
 	"fmt"
+	"math"
 	"reflect"
 	"strconv"
 	"strings"
@@ -145,15 +146,33 @@ func weaklyInteger[I integer]() func(d *jsontext.Decoder, n *I) error {
 	signed := t.Kind() <= reflect.Int64
 	bitSize := t.Bits()
 
+	var minVal, maxVal int64
+	var maxUintVal uint64
+	if signed {
+		if bitSize == 64 {
+			minVal = math.MinInt64
+			maxVal = math.MaxInt64
+		} else {
+			minVal = int64(-1) << (bitSize - 1)
+			maxVal = int64(1<<(bitSize-1) - 1)
+		}
+	} else {
+		if bitSize == 64 {
+			maxUintVal = math.MaxUint64
+		} else {
+			maxUintVal = uint64(1<<bitSize - 1)
+		}
+	}
+
 	return func(d *jsontext.Decoder, n *I) error {
 		switch k := d.PeekKind(); k {
 		case jsontext.KindNumber:
 			if tok, err := d.ReadToken(); err != nil {
 				return err
 			} else if signed {
-				return convertTok(n, tok, jsontext.Token.Int)
+				return convertSignedTok(n, tok, minVal, maxVal)
 			} else {
-				return convertTok(n, tok, jsontext.Token.Uint)
+				return convertUnsignedTok(n, tok, maxUintVal)
 			}
 
 		case jsontext.KindString:
@@ -168,9 +187,9 @@ func weaklyInteger[I integer]() func(d *jsontext.Decoder, n *I) error {
 				*n = 0
 				return nil
 			} else if signed {
-				return parseString(n, s, bitSize, strconv.ParseInt)
+				return parseSignedString(n, s, bitSize, minVal, maxVal)
 			} else {
-				return parseString(n, s, bitSize, strconv.ParseUint)
+				return parseUnsignedString(n, s, bitSize, maxUintVal)
 			}
 		case jsontext.KindNull:
 			if _, err := d.ReadToken(); err != nil {
@@ -232,24 +251,76 @@ func weaklyFloat[F float]() func(d *jsontext.Decoder, f *F) error {
 	}
 }
 
-func convertTok[I, J integer](n *I, tok jsontext.Token, fn func(jsontext.Token) (J, error)) error {
-	if v, err := fn(tok); err == nil {
+func convertSignedTok[I integer](n *I, tok jsontext.Token, minVal, maxVal int64) error {
+	if v, err := tok.Int(); err == nil {
+		if v < minVal || v > maxVal {
+			return fmt.Errorf("integer %d out of range", v)
+		}
 		*n = I(v)
-	} else if f, err := tok.Float(); err == nil {
-		*n = I(f)
-	} else {
+		return nil
+	}
+	f, err := tok.Float()
+	if err != nil {
 		return err
 	}
+	if math.IsNaN(f) || math.IsInf(f, 0) || f < float64(minVal) || f > float64(maxVal) {
+		return fmt.Errorf("number %g out of range", f)
+	}
+	*n = I(int64(f))
 	return nil
 }
 
-func parseString[I, J integer](n *I, s string, bitSize int, fn func(string, int, int) (J, error)) error {
-	if v, err := fn(s, 0, bitSize); err == nil {
+func convertUnsignedTok[I integer](n *I, tok jsontext.Token, maxVal uint64) error {
+	if v, err := tok.Uint(); err == nil {
+		if v > maxVal {
+			return fmt.Errorf("unsigned integer %d out of range", v)
+		}
 		*n = I(v)
-	} else if f, err := strconv.ParseFloat(s, 64); err == nil {
-		*n = I(f)
-	} else {
+		return nil
+	}
+	f, err := tok.Float()
+	if err != nil {
 		return err
 	}
+	if math.IsNaN(f) || math.IsInf(f, 0) || f < 0 || f > float64(maxVal) {
+		return fmt.Errorf("number %g out of range", f)
+	}
+	*n = I(uint64(f))
+	return nil
+}
+
+func parseSignedString[I integer](n *I, s string, bitSize int, minVal, maxVal int64) error {
+	if v, err := strconv.ParseInt(s, 0, bitSize); err == nil {
+		*n = I(v)
+		return nil
+	} else if errors.Is(err, strconv.ErrRange) {
+		return err
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return err
+	}
+	if math.IsNaN(f) || math.IsInf(f, 0) || f < float64(minVal) || f > float64(maxVal) {
+		return fmt.Errorf("number %g out of range", f)
+	}
+	*n = I(int64(f))
+	return nil
+}
+
+func parseUnsignedString[I integer](n *I, s string, bitSize int, maxVal uint64) error {
+	if v, err := strconv.ParseUint(s, 0, bitSize); err == nil {
+		*n = I(v)
+		return nil
+	} else if errors.Is(err, strconv.ErrRange) {
+		return err
+	}
+	f, err := strconv.ParseFloat(s, 64)
+	if err != nil {
+		return err
+	}
+	if math.IsNaN(f) || math.IsInf(f, 0) || f < 0 || f > float64(maxVal) {
+		return fmt.Errorf("number %g out of range", f)
+	}
+	*n = I(uint64(f))
 	return nil
 }