fix(api): hide org roles from non-members (#40042)

`GET /users/{username}/orgs/{org}/permissions` returned a user's team
roles to anyone who could see the org, revealing concealed members and
their roles. Now only the user, unrestricted org members and site admins
get the real answer, everyone else gets the non-member response:

- Outsiders get no roles, for public members too.
- Restricted members only get their own roles.
- Public-only tokens get none, and site admins need an `all`-scoped
token.

Assisted-by: Claude Code:claude-opus-5-5

---------

Co-authored-by: silverwind <me@silverwind.io>
This commit is contained in:
Basavaraj S mandsilverwind authored and GitHub committed 2026-11-13 19:37:56 +00:00
1 parent 1f614953a2
commit eaa4fe918d
2 files changed
+55 -169

No files matched your search

+17
View File
@@ -150,6 +150,23 @@ func GetUserOrgsPermissions(ctx *context.APIContext) {
}
org := organization.OrgFromUser(o)
canViewRoles := false
if !user_model.IsPublicOnlyDoer(ctx.Doer) {
canViewRoles = ctx.Doer.ID == ctx.ContextUser.ID || user_model.DoerIsSiteAdminFullAccess(ctx.Doer)
if !canViewRoles && !ctx.Doer.IsRestricted {
isDoerMember, err := org.IsOrgMember(ctx, ctx.Doer.ID)
if err != nil {
ctx.APIErrorInternal(err)
return
}
canViewRoles = isDoerMember
}
}
if !canViewRoles {
ctx.JSON(http.StatusOK, op)
return
}
authorizeLevel, err := org.GetOrgUserMaxAuthorizeLevel(ctx, ctx.ContextUser.ID)
if err != nil {
ctx.APIErrorInternal(err)
+38 -169
View File
@@ -4,8 +4,8 @@
package integration
import (
"fmt"
"net/http"
"net/http/httptest"
"testing"
auth_model "gitea.dev/models/auth"
@@ -18,172 +18,41 @@ import (
func TestPermissionsAPI(t *testing.T) {
defer tests.PrepareTestEnv(t)()
t.Run("TokenNeeded", testTokenNeeded)
t.Run("WithOwnerUser", testWithOwnerUser)
t.Run("CanWriteUser", testCanWriteUser)
t.Run("AdminUser", testAdminUser)
t.Run("AdminCanNotCreateRepo", testAdminCanNotCreateRepo)
t.Run("CanReadUser", testCanReadUser)
t.Run("UnknownUser", testUnknownUser)
t.Run("UnknownOrganization", testUnknownOrganization)
t.Run("HiddenMemberPermissionsForbidden", testHiddenMemberPermissionsForbidden)
t.Run("PrivateOrgPermissionsNotFound", testPrivateOrgPermissionsNotFound)
}
type apiUserOrgPermTestCase struct {
LoginUser string
User string
Organization string
ExpectedOrganizationPermissions api.OrganizationPermissions
}
func testTokenNeeded(t *testing.T) {
req := NewRequest(t, "GET", "/api/v1/users/user1/orgs/org6/permissions")
MakeRequest(t, req, http.StatusUnauthorized)
}
func sampleTest(t *testing.T, auoptc apiUserOrgPermTestCase) {
session := loginUser(t, auoptc.LoginUser)
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadOrganization, auth_model.AccessTokenScopeReadUser)
req := NewRequest(t, "GET", fmt.Sprintf("/api/v1/users/%s/orgs/%s/permissions", auoptc.User, auoptc.Organization)).
AddTokenAuth(token)
resp := MakeRequest(t, req, http.StatusOK)
apiOP := DecodeJSON(t, resp, &api.OrganizationPermissions{})
assert.Equal(t, auoptc.ExpectedOrganizationPermissions.IsOwner, apiOP.IsOwner)
assert.Equal(t, auoptc.ExpectedOrganizationPermissions.IsAdmin, apiOP.IsAdmin)
assert.Equal(t, auoptc.ExpectedOrganizationPermissions.CanWrite, apiOP.CanWrite)
assert.Equal(t, auoptc.ExpectedOrganizationPermissions.CanRead, apiOP.CanRead)
assert.Equal(t, auoptc.ExpectedOrganizationPermissions.CanCreateRepository, apiOP.CanCreateRepository)
}
func testWithOwnerUser(t *testing.T) {
sampleTest(t, apiUserOrgPermTestCase{
LoginUser: "user2",
User: "user2",
Organization: "org3",
ExpectedOrganizationPermissions: api.OrganizationPermissions{
IsOwner: true,
IsAdmin: true,
CanWrite: true,
CanRead: true,
CanCreateRepository: true,
},
})
}
func testCanWriteUser(t *testing.T) {
sampleTest(t, apiUserOrgPermTestCase{
LoginUser: "user4",
User: "user4",
Organization: "org3",
ExpectedOrganizationPermissions: api.OrganizationPermissions{
IsOwner: false,
IsAdmin: false,
CanWrite: true,
CanRead: true,
CanCreateRepository: false,
},
})
}
func testAdminUser(t *testing.T) {
sampleTest(t, apiUserOrgPermTestCase{
LoginUser: "user1",
User: "user28",
Organization: "org3",
ExpectedOrganizationPermissions: api.OrganizationPermissions{
IsOwner: false,
IsAdmin: true,
CanWrite: true,
CanRead: true,
CanCreateRepository: true,
},
})
}
func testAdminCanNotCreateRepo(t *testing.T) {
sampleTest(t, apiUserOrgPermTestCase{
LoginUser: "user1",
User: "user28",
Organization: "org6",
ExpectedOrganizationPermissions: api.OrganizationPermissions{
IsOwner: false,
IsAdmin: true,
CanWrite: true,
CanRead: true,
CanCreateRepository: false,
},
})
}
func testCanReadUser(t *testing.T) {
sampleTest(t, apiUserOrgPermTestCase{
LoginUser: "user1",
User: "user24",
Organization: "org25",
ExpectedOrganizationPermissions: api.OrganizationPermissions{
IsOwner: false,
IsAdmin: false,
CanWrite: false,
CanRead: true,
CanCreateRepository: false,
},
})
}
func testUnknownUser(t *testing.T) {
session := loginUser(t, "user1")
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadUser, auth_model.AccessTokenScopeReadOrganization)
req := NewRequest(t, "GET", "/api/v1/users/unknown/orgs/org25/permissions").
AddTokenAuth(token)
resp := MakeRequest(t, req, http.StatusNotFound)
apiError := DecodeJSON(t, resp, &api.APIError{})
assert.Equal(t, "user not found", apiError.Message)
}
func testUnknownOrganization(t *testing.T) {
session := loginUser(t, "user1")
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadUser, auth_model.AccessTokenScopeReadOrganization)
req := NewRequest(t, "GET", "/api/v1/users/user1/orgs/unknown/permissions").
AddTokenAuth(token)
MakeRequest(t, req, http.StatusNotFound)
}
func testHiddenMemberPermissionsForbidden(t *testing.T) {
session := loginUser(t, "user8")
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadUser, auth_model.AccessTokenScopeReadOrganization)
req := NewRequest(t, "GET", "/api/v1/users/user5/orgs/privated_org/permissions").
AddTokenAuth(token)
MakeRequest(t, req, http.StatusNotFound)
adminSession := loginUser(t, "user1")
adminToken := getTokenForLoggedInUser(t, adminSession, auth_model.AccessTokenScopeReadUser, auth_model.AccessTokenScopeReadOrganization)
adminReq := NewRequest(t, "GET", "/api/v1/users/user5/orgs/privated_org/permissions").
AddTokenAuth(adminToken)
resp := MakeRequest(t, adminReq, http.StatusOK)
apiOP := DecodeJSON(t, resp, &api.OrganizationPermissions{})
assert.Equal(t, &api.OrganizationPermissions{
IsOwner: false,
IsAdmin: false,
CanWrite: true,
CanRead: true,
CanCreateRepository: true,
}, apiOP)
}
func testPrivateOrgPermissionsNotFound(t *testing.T) {
session := loginUser(t, "user8")
token := getTokenForLoggedInUser(t, session, auth_model.AccessTokenScopeReadUser, auth_model.AccessTokenScopeReadOrganization)
req := NewRequest(t, "GET", "/api/v1/users/user5/orgs/privated_org/permissions").
AddTokenAuth(token)
MakeRequest(t, req, http.StatusNotFound)
MakeRequest(t, NewRequest(t, "GET", "/api/v1/users/user1/orgs/org6/permissions"), http.StatusUnauthorized)
userToken := func(doer string, scopes ...auth_model.AccessTokenScope) string {
return getUserToken(t, doer, append(scopes, auth_model.AccessTokenScopeReadOrganization, auth_model.AccessTokenScopeReadUser)...)
}
requestPermissions := func(t *testing.T, token, username, orgName string, expectedStatus int) *httptest.ResponseRecorder {
return MakeRequest(t, NewRequestf(t, "GET", "/api/v1/users/%s/orgs/%s/permissions", username, orgName).AddTokenAuth(token), expectedStatus)
}
adminToken := userToken("user1", auth_model.AccessTokenScopeAll)
ownerToken := userToken("user2")
outsiderToken := userToken("user8")
assert.Equal(t, "user not found", DecodeJSON(t, requestPermissions(t, adminToken, "unknown", "org25", http.StatusNotFound), &api.APIError{}).Message)
requestPermissions(t, adminToken, "user1", "unknown", http.StatusNotFound)
requestPermissions(t, outsiderToken, "user5", "privated_org", http.StatusNotFound)
for _, testCase := range []struct {
name, token, username, orgName string
expected api.OrganizationPermissions
}{
{"Owner", ownerToken, "user2", "org3", api.OrganizationPermissions{IsOwner: true, IsAdmin: true, CanWrite: true, CanRead: true, CanCreateRepository: true}},
{"SelfConcealed", userToken("user4"), "user4", "org3", api.OrganizationPermissions{CanWrite: true, CanRead: true}},
{"PublicOnlyTokenSelf", userToken("user2", auth_model.AccessTokenScopePublicOnly), "user2", "org3", api.OrganizationPermissions{}},
{"MemberSeesConcealed", ownerToken, "user4", "org3", api.OrganizationPermissions{CanWrite: true, CanRead: true}},
{"OutsiderConcealed", outsiderToken, "user4", "org3", api.OrganizationPermissions{}},
{"OutsiderPublic", outsiderToken, "user28", "org3", api.OrganizationPermissions{}},
{"RestrictedMemberConcealedTeammate", userToken("user29"), "user20", "org17", api.OrganizationPermissions{}},
{"SiteAdmin", adminToken, "user28", "org3", api.OrganizationPermissions{IsAdmin: true, CanWrite: true, CanRead: true, CanCreateRepository: true}},
{"SiteAdminCanNotCreateRepo", adminToken, "user28", "org6", api.OrganizationPermissions{IsAdmin: true, CanWrite: true, CanRead: true}},
{"SiteAdminCanRead", adminToken, "user24", "org25", api.OrganizationPermissions{CanRead: true}},
{"SiteAdminPrivateOrgConcealed", adminToken, "user5", "privated_org", api.OrganizationPermissions{CanWrite: true, CanRead: true, CanCreateRepository: true}},
{"SiteAdminScopedTokenConcealed", userToken("user1"), "user5", "privated_org", api.OrganizationPermissions{}},
} {
t.Run(testCase.name, func(t *testing.T) {
assert.Equal(t, testCase.expected, *DecodeJSON(t, requestPermissions(t, testCase.token, testCase.username, testCase.orgName, http.StatusOK), &api.OrganizationPermissions{}))
})
}
}