Integer validation issue

[ShouheiNishi]

Since the numeric value is converted to float64 during JSON validation in body in function `openapi3filter.ValidateRequestBody’, the precision of integer value in updated request body is lost, and the range check is not performed correctly.

You can see this issue in the test code below.

package openapi3filter_test

import (
        "bytes"
        "context"
        "encoding/json"
        "math"
        "math/big"
        "net/http"
        "testing"

        "github.com/getkin/kin-openapi/openapi3"
        "github.com/getkin/kin-openapi/openapi3filter"
        "github.com/getkin/kin-openapi/routers/gorillamux"
        "github.com/stretchr/testify/assert"
        "github.com/stretchr/testify/require"
)

func TestIntMax(t *testing.T) {
        spec := `
openapi: 3.0.0
info:
  version: 1.0.0
  title: test large integer value
paths:
  /test:
    post:
      requestBody:
        content:
          application/json:
            schema:
              type: object
              properties:
                testInteger:
                  type: integer
                  format: int64
                testDefault:
                  type: boolean
                  default: false
      responses:
        '200':
          description: Successful response
`[1:]

        loader := openapi3.NewLoader()

        doc, err := loader.LoadFromData([]byte(spec))
        require.NoError(t, err)

        err = doc.Validate(loader.Context)
        require.NoError(t, err)

        router, err := gorillamux.NewRouter(doc)
        require.NoError(t, err)

        testOne := func(value *big.Int, pass bool) {
                valueString := value.String()

                req, err := http.NewRequest(http.MethodPost, "/test", bytes.NewReader([]byte(`{"testInteger":`+valueString+`}`)))
                require.NoError(t, err)
                req.Header.Set("Content-Type", "application/json")

                route, pathParams, err := router.FindRoute(req)
                require.NoError(t, err)

                err = openapi3filter.ValidateRequest(
                        context.Background(),
                        &openapi3filter.RequestValidationInput{
                                Request:    req,
                                PathParams: pathParams,
                                Route:      route,
                        })
                if pass {
                        require.NoError(t, err)

                        dec := json.NewDecoder(req.Body)
                        dec.UseNumber()
                        var jsonAfter map[string]interface{}
                        err = dec.Decode(&jsonAfter)
                        require.NoError(t, err)

                        valueAfter := jsonAfter["testInteger"]
                        require.IsType(t, json.Number(""), valueAfter)
                        assert.Equal(t, valueString, string(valueAfter.(json.Number)))
                } else {
                        if assert.Error(t, err) {
                                var serr *openapi3.SchemaError
                                if assert.ErrorAs(t, err, &serr) {
                                        assert.Equal(t, "number must be an int64", serr.Reason)
                                }
                        }
                }
        }

        bigMaxInt64 := big.NewInt(math.MaxInt64)
        bigMaxInt64Plus1 := new(big.Int).Add(bigMaxInt64, big.NewInt(1))
        bigMinInt64 := big.NewInt(math.MinInt64)
        bigMinInt64Minus1 := new(big.Int).Sub(bigMinInt64, big.NewInt(1))

        testOne(bigMaxInt64, true)
        testOne(bigMaxInt64Plus1, false)
        testOne(bigMinInt64, true)
        testOne(bigMinInt64Minus1, false)
}

[ShouheiNishi]

We currently create a fix. But not sure if you need the ability to determine whether a value such as the following is an integer.

value string	is integer?
9223372036854775807	integer and fit to int64
9223372036854775808	integer
9223372036854775807.0	integer and fit to int64
9223372036854775808.0	integer
9223372036854775808.1	not-integer
9.2233720368547758070e+18	integer and fit to int64
9.2233720368547758071e+18	not-integer
0.(100000 digits number 1)e+100000	integer
0.(100001 digits number 1)e+100000	not-integer

[fenollp]

Thanks for this high quality bug report! I'm not sure I understand your question. Do you mean to ask whether this lib intends to support numbers that don't fit in a double?

[ShouheiNishi]

I think it is necessary to specify UseNumber() in the JSON decoder during JSON validation so that integer precision is not lost when setting the default value.

However, encoding/json is not able to unmarshal exponential notation to integer types. https://github.com/golang/go/issues/6384 I can’t decide if all numeric notation allowed by the JSON standard must be validate correctly.

[ShouheiNishi]

PR https://github.com/getkin/kin-openapi/pull/738

Since the numeric value is converted to float64 during JSON validation in body in function `openapi3filter.ValidateRequestBody’, the precision of integer value in updated request body is lost,

Fix only fix this issue.

and the range check is not performed correctly.

Not fix yet.