user: TestGetAdditionalGroups/group_entry_with_out-of-range_gid fails on 32-bit architectures (GOARCH=386 / arm)

[siretart]

Description

When running tests in github.com/moby/sys/user on 32-bit architectures (e.g. GOARCH=386 or GOARCH=arm), TestGetAdditionalGroups/group_entry_with_out-of-range_gid fails:

=== RUN   TestGetAdditionalGroups
=== RUN   TestGetAdditionalGroups/group_entry_with_out-of-range_gid
    user_test.go:651: Parse(struct { doc string; groups []string; expected []int; hasError bool }{doc:"group entry with out-of-range gid", groups:[]string{"toolarge"}, expected:[]int(nil), hasError:true}) expects error but has none
--- FAIL: TestGetAdditionalGroups (0.01s)
    --- FAIL: TestGetAdditionalGroups/group_entry_with_out-of-range_gid (0.00s)
FAIL	github.com/moby/sys/user	0.008s

Steps to Reproduce

cd user
GOARCH=386 go test -v . -run "TestGetAdditionalGroups/group_entry_with_out-of-range_gid"

Root Cause Analysis

1. In user/user_test.go, the test defines groupContent with:

   toolarge:x:2147483648:
   

   where 2147483648 is math.MaxInt32 + 1.

2. In user/user.go, parseParts() parses GID entries into *int via:

   case *int:
       *e, _ = strconv.Atoi(string(p))

   Conversion errors returned by strconv.Atoi are explicitly ignored (_).

3. On 64-bit systems (int is int64), strconv.Atoi("2147483648") succeeds and sets *e = 2147483648. GetAdditionalGroups() then checks if g.Gid < minID || g.Gid > maxID (where maxID is 2147483647), correctly returning ErrRange.

4. On 32-bit systems (int is int32), strconv.Atoi("2147483648") overflows int32 and returns strconv.ErrRange while setting *e = math.MaxInt32 (2147483647). Because the conversion error is discarded, g.Gid becomes 2147483647. Since 2147483647 <= maxID, GetAdditionalGroups() considers the GID valid, does not return an error, and the test fails.

Suggested Fix

parseParts (or Group.Gid / User.Uid / User.Gid parsing) should either:

1. Parse IDs as int64 (e.g. strconv.ParseInt(string(p), 10, 64)) or validate strconv.ErrRange before truncating/converting to int, or
2. Check whether the string value exceeds maxID (or check for strconv.ErrRange) when validating group/user entries so that 32-bit platforms reject out-of-range values consistently with 64-bit platforms.

[siretart]

Here is a minimal, clean patch that resolves the issue by parsing IDs using 64-bit integers and validating against [minID, maxID] bounds:

diff --git a/user/user.go b/user/user.go
index e747767..f38c073 100644
--- a/user/user.go
+++ b/user/user.go
@@ -79,7 +79,12 @@ func parseParts(parts [][]byte, v ...any) {
 			*e = string(p)
 		case *int:
 			// "numbers", with conversion errors ignored because of some misbehaving configuration files.
-			*e, _ = strconv.Atoi(string(p))
+			v, _ := strconv.ParseInt(string(p), 10, 64)
+			if v < minID || v > maxID {
+				*e = -1
+			} else {
+				*e = int(v)
+			}
 		case *int64:
 			*e, _ = strconv.ParseInt(string(p), 10, 64)
 		case *[]string:
diff --git a/user/user_test.go b/user/user_test.go
index 8d08e1c..ef08c26 100644
--- a/user/user_test.go
+++ b/user/user_test.go
@@ -60,6 +60,16 @@ func TestParseLine(t *testing.T) {
 	if a != "b" || b != "c" || d != 12 {
 		t.Fatalf("a should be 'b' and b should be 'c', and d should be 12 ('%v', '%v', %v)", a, b, d)
 	}
+
+	parseLine([]byte("2147483648"), &d)
+	if d != -1 {
+		t.Fatalf("d should be -1 for maxID+1 (%v)", d)
+	}
+
+	parseLine([]byte("9223372036854775808"), &d)
+	if d != -1 {
+		t.Fatalf("d should be -1 for maxInt64+1 (%v)", d)
+	}
 }
 
 func TestParsePasswdFilter(t *testing.T) {

Why This Works

• strconv.ParseInt(string(p), 10, 64) parses values up to math.MaxInt64 without 32-bit truncation.
• Non-numeric strings (syntax error) return 0 (which fits in [minID, maxID]), preserving existing fallback behavior for malformed lines.
• Values outside [minID, maxID] (or strings exceeding MaxInt64 that return ErrRange with MaxInt64/MinInt64) trigger the v < minID || v > maxID branch and set *e = -1 consistently on both 32-bit and 64-bit architectures.