From cef10336da29109d39dce0652e32226ec3f1b91f Mon Sep 17 00:00:00 2001 From: Yunus Ardaguney Date: Tue, 10 Nov 2026 01:56:15 +0300 Subject: [PATCH 1/2] fix(normalizer): validate numeric float64 inputs in typed read normalizer (#3762) The typed-read argument normalizer only checked string values for out-of-range and non-integer values, letting raw float64 numbers bypass validation and fail in json.Unmarshal with a raw Go struct decode error (leaking internal types). Validate both string and float64 number inputs uniformly against inSignedIntRange and integers, rejecting out-of-range numbers cleanly. Reported-by: Rafe Walker Signed-off-by: Yunus Ardaguney --- pkg/github/typed_read_normalizers.go | 44 ++++++++++++------------- pkg/github/typed_search_outputs_test.go | 4 +++ 2 files changed, 25 insertions(+), 23 deletions(-) diff --git a/pkg/github/typed_read_normalizers.go b/pkg/github/typed_read_normalizers.go index d53f3ad2f8..5c42d7c297 100644 --- a/pkg/github/typed_read_normalizers.go +++ b/pkg/github/typed_read_normalizers.go @@ -40,34 +40,32 @@ func normalizeTypedReadArguments(uppercaseFields []string, preserveZeroPage bool if err := json.Unmarshal(value, &number); err != nil { return nil, err } - if text, ok := number.(string); ok { - parsed, err := strconv.ParseFloat(text, 64) - if err != nil || math.IsNaN(parsed) || math.IsInf(parsed, 0) || parsed != math.Trunc(parsed) || !inSignedIntRange(parsed, strconv.IntSize) { + var parsed float64 + switch v := number.(type) { + case string: + var err error + parsed, err = strconv.ParseFloat(v, 64) + if err != nil { return nil, fmt.Errorf("parameter %s is not a valid number", field) } - number = int(parsed) + case float64: + parsed = v + default: + continue } - if field == "page" && !preserveZeroPage { - if parsed, ok := number.(float64); ok && parsed == 0 { - delete(args, field) - continue - } - if parsed, ok := number.(int); ok && parsed == 0 { - delete(args, field) - continue - } + if math.IsNaN(parsed) || math.IsInf(parsed, 0) || parsed != math.Trunc(parsed) || !inSignedIntRange(parsed, strconv.IntSize) { + return nil, fmt.Errorf("parameter %s is not a valid number", field) } - if field == "perPage" { - if parsed, ok := number.(float64); ok && parsed == 0 { - delete(args, field) - continue - } - if parsed, ok := number.(int); ok && parsed == 0 { - delete(args, field) - continue - } + intVal := int(parsed) + if field == "page" && !preserveZeroPage && intVal == 0 { + delete(args, field) + continue + } + if field == "perPage" && intVal == 0 { + delete(args, field) + continue } - normalized, err := json.Marshal(number) + normalized, err := json.Marshal(intVal) if err != nil { return nil, err } diff --git a/pkg/github/typed_search_outputs_test.go b/pkg/github/typed_search_outputs_test.go index b92d3c6a59..4fbc23ba4d 100644 --- a/pkg/github/typed_search_outputs_test.go +++ b/pkg/github/typed_search_outputs_test.go @@ -383,6 +383,10 @@ func TestNormalizeTypedReadArgumentsRejectsOutOfRangeIntegers(t *testing.T) { `{"page":"9223372036854775808"}`, `{"perPage":"9223372036854775807"}`, `{"page":"-9223372036854777856"}`, + `{"page": 9223372036854775808}`, + `{"perPage": 9223372036854775807}`, + `{"page": -9223372036854777856}`, + `{"page": 1.5}`, } { t.Run(input, func(t *testing.T) { _, err := normalize(json.RawMessage(input)) From 0e26ad4b22b555886ec35f5a87c5e4e89912fa71 Mon Sep 17 00:00:00 2001 From: Yunus Ardaguney Date: Sun, 15 Nov 2026 15:10:49 +0300 Subject: [PATCH 2/2] fix(normalizer): validate numeric tokens losslessly before int conversion Decode with UseNumber and parse integer tokens exactly, so values such as -9223372036854775809 are rejected instead of rounding into range. Decimal and exponent forms are checked as exact rationals after bounding token length and exponent. --- pkg/github/typed_read_normalizers.go | 71 +++++++++++++++++++++---- pkg/github/typed_search_outputs_test.go | 28 +++++++++- 2 files changed, 88 insertions(+), 11 deletions(-) diff --git a/pkg/github/typed_read_normalizers.go b/pkg/github/typed_read_normalizers.go index 5c42d7c297..3f4dbca32a 100644 --- a/pkg/github/typed_read_normalizers.go +++ b/pkg/github/typed_read_normalizers.go @@ -1,15 +1,45 @@ package github import ( + "bytes" "encoding/json" + "errors" "fmt" "math" + "math/big" "strconv" "strings" "github.com/github/github-mcp-server/v2/pkg/inventory" ) +// maxNumericTokenLen and maxNumericExponent bound decimal or exponent number +// tokens before they are checked as exact rationals. +const ( + maxNumericTokenLen = 64 + maxNumericExponent = 40 +) + +// exactIntegerToken reports the int64 value of a JSON number token written in +// decimal or exponent form, but only when the token is exactly an integer that +// fits in int64. +func exactIntegerToken(token string) (int64, bool) { + if len(token) > maxNumericTokenLen { + return 0, false + } + if i := strings.IndexAny(token, "eE"); i >= 0 { + exp, err := strconv.Atoi(token[i+1:]) + if err != nil || exp > maxNumericExponent || exp < -maxNumericExponent { + return 0, false + } + } + exact, ok := new(big.Rat).SetString(token) + if !ok || !exact.IsInt() || !exact.Num().IsInt64() { + return 0, false + } + return exact.Num().Int64(), true +} + func normalizeTypedReadArguments(uppercaseFields []string, preserveZeroPage bool) inventory.InputNormalizer { return func(raw json.RawMessage) (json.RawMessage, error) { var args map[string]json.RawMessage @@ -37,26 +67,47 @@ func normalizeTypedReadArguments(uppercaseFields []string, preserveZeroPage bool continue } var number any - if err := json.Unmarshal(value, &number); err != nil { + decoder := json.NewDecoder(bytes.NewReader(value)) + decoder.UseNumber() + if err := decoder.Decode(&number); err != nil { return nil, err } - var parsed float64 + var intVal int switch v := number.(type) { case string: - var err error - parsed, err = strconv.ParseFloat(v, 64) + parsed, err := strconv.ParseFloat(v, 64) if err != nil { return nil, fmt.Errorf("parameter %s is not a valid number", field) } - case float64: - parsed = v + if math.IsNaN(parsed) || math.IsInf(parsed, 0) || parsed != math.Trunc(parsed) || !inSignedIntRange(parsed, strconv.IntSize) { + return nil, fmt.Errorf("parameter %s is not a valid number", field) + } + intVal = int(parsed) + case json.Number: + // Validate the original token before any lossy float64 conversion. + // Plain integer tokens are parsed exactly. Decimal or exponent + // forms are checked as exact rationals; the token length and + // exponent are bounded first so a hostile exponent cannot make + // the exact check expensive. + integer, err := strconv.ParseInt(v.String(), 10, strconv.IntSize) + if err != nil { + var numErr *strconv.NumError + if errors.As(err, &numErr) && errors.Is(numErr.Err, strconv.ErrRange) { + return nil, fmt.Errorf("parameter %s is not a valid number", field) + } + exact, ok := exactIntegerToken(v.String()) + if !ok { + return nil, fmt.Errorf("parameter %s is not a valid number", field) + } + integer = exact + } + if int64(int(integer)) != integer { + return nil, fmt.Errorf("parameter %s is not a valid number", field) + } + intVal = int(integer) default: continue } - if math.IsNaN(parsed) || math.IsInf(parsed, 0) || parsed != math.Trunc(parsed) || !inSignedIntRange(parsed, strconv.IntSize) { - return nil, fmt.Errorf("parameter %s is not a valid number", field) - } - intVal := int(parsed) if field == "page" && !preserveZeroPage && intVal == 0 { delete(args, field) continue diff --git a/pkg/github/typed_search_outputs_test.go b/pkg/github/typed_search_outputs_test.go index 4fbc23ba4d..b98a6c3df7 100644 --- a/pkg/github/typed_search_outputs_test.go +++ b/pkg/github/typed_search_outputs_test.go @@ -4,6 +4,7 @@ import ( "context" "encoding/json" "net/http" + "strconv" "testing" "github.com/github/github-mcp-server/v2/internal/toolsnaps" @@ -384,8 +385,13 @@ func TestNormalizeTypedReadArgumentsRejectsOutOfRangeIntegers(t *testing.T) { `{"perPage":"9223372036854775807"}`, `{"page":"-9223372036854777856"}`, `{"page": 9223372036854775808}`, - `{"perPage": 9223372036854775807}`, `{"page": -9223372036854777856}`, + `{"page": -9223372036854775809}`, + `{"perPage": -9223372036854775809.0}`, + `{"page": -9.223372036854775809e18}`, + `{"page": 1.00000000000000001}`, + `{"page": 1e999999999}`, + `{"page": 1e-999999999}`, `{"page": 1.5}`, } { t.Run(input, func(t *testing.T) { @@ -395,6 +401,26 @@ func TestNormalizeTypedReadArgumentsRejectsOutOfRangeIntegers(t *testing.T) { } } +func TestNormalizeTypedReadArgumentsPreservesExactNumbers(t *testing.T) { + normalize := normalizeTypedReadArguments(nil, false) + for _, value := range []string{"25.0", "2.5e1", "250e-1"} { + t.Run(value, func(t *testing.T) { + normalized, err := normalize(json.RawMessage(`{"page":` + value + `}`)) + require.NoError(t, err) + assert.JSONEq(t, `{"page":25}`, string(normalized)) + }) + } + if strconv.IntSize == 64 { + for _, value := range []string{"9223372036854775807", "-9223372036854775808", "9007199254740993"} { + t.Run(value, func(t *testing.T) { + normalized, err := normalize(json.RawMessage(`{"perPage":` + value + `}`)) + require.NoError(t, err) + assert.Equal(t, `{"perPage":`+value+`}`, string(normalized)) + }) + } + } +} + func mustMarshalJSON(t *testing.T, value any) string { t.Helper() encoded, err := json.Marshal(value)