id
stringlengths 13
16
| title
stringlengths 0
237
| description
stringlengths 35
3.88k
| patches
listlengths 1
16
| cwe
stringlengths 2
440
|
|---|---|---|---|---|
CVE-2023-4322
|
Heap-based Buffer Overflow in radareorg/radare2
|
Heap-based Buffer Overflow in GitHub repository radareorg/radare2 prior to 5.9.0.
|
[
{
"commit_message": "[PATCH] Fix 1byte heap oobread in the brainfuck disassembler * https://huntr.dev/bounties/06e2484c-d6f1-4497-af67-26549be9fffd/ * Kudos to @7resp4ss for reporting libr/arch/p/bf/plugin.c | 34 +++++++++++++++++++--------------- libr/core/cmd_anal.c | 14 ++++++-------- 2 files changed, 25 insertions(+), 23 deletions(-)",
"patch_text_b64": "RnJvbSBiYTkxOWFkYjc0YWMzNjhiZjc2YjE1MGEwMDM0N2RlZDc4YjU3MmRkIE1vbiBTZXAgMTcgMDA6MDA6MDAgMjAwMQpGcm9tOiBwYW5jYWtlIDxwYW5jYWtlQG5vcGNvZGUub3JnPgpEYXRlOiBNb24sIDE0IEF1ZyAyMDIzIDE1OjU2OjEzICswMjAwClN1YmplY3Q6IFtQQVRDSF0gRml4IDFieXRlIGhlYXAgb29icmVhZCBpbiB0aGUgYnJhaW5mdWNrIGRpc2Fzc2VtYmxlcgoKKiBodHRwczovL2h1bnRyLmRldi9ib3VudGllcy8wNmUyNDg0Yy1kNmYxLTQ0OTctYWY2Ny0yNjU0OWJlOWZmZmQvCiogS3Vkb3MgdG8gQDdyZXNwNHNzIGZvciByZXBvcnRpbmcKLS0tCiBsaWJyL2FyY2gvcC9iZi9wbHVnaW4uYyB8IDM0ICsrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLS0tLS0KIGxpYnIvY29yZS9jbWRfYW5hbC5jICAgIHwgMTQgKysrKysrLS0tLS0tLS0KIDIgZmlsZXMgY2hhbmdlZCwgMjUgaW5zZXJ0aW9ucygrKSwgMjMgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvbGlici9hcmNoL3AvYmYvcGx1Z2luLmMgYi9saWJyL2FyY2gvcC9iZi9wbHVnaW4uYwppbmRleCBlMmY5OWU5NDlhNzNmLi44N2ViZDNjYjAxNGVlIDEwMDY0NAotLS0gYS9saWJyL2FyY2gvcC9iZi9wbHVnaW4uYworKysgYi9saWJyL2FyY2gvcC9iZi9wbHVnaW4uYwpAQCAtMTMsOCArMTMsOCBAQCBzdGF0aWMgc2l6ZV90IGNvdW50Q2hhcihjb25zdCB1dDggKmJ1ZiwgaW50IGxlbiwgY2hhciBjaCkgewogfQogCiBzdGF0aWMgaW50IGdldGlkKGNoYXIgY2gpIHsKLQljb25zdCBjaGFyICprZXlzID0gIltdPD4rLSwuIjsKLQljb25zdCBjaGFyICpjaWR4ID0gc3RyY2hyIChrZXlzLCBjaCk7CisJY29uc3QgY2hhciAqY29uc3Qga2V5cyA9ICJbXTw+Ky0sLiI7CisJY29uc3QgY2hhciAqY29uc3QgY2lkeCA9IHN0cmNociAoa2V5cywgY2gpOwogCXJldHVybiBjaWR4PyBjaWR4IC0ga2V5cyArIDE6IDA7CiB9CiAKQEAgLTEzNiwxMyArMTM2LDExIEBAIHN0YXRpYyBpbnQgYXNzZW1ibGUoY29uc3QgY2hhciAqYnVmLCB1dDggKipvdXRidWYpIHsKICNkZWZpbmUgQlVGU0laRV9JTkMgMzIKIHN0YXRpYyBib29sIGRlY29kZShSQXJjaFNlc3Npb24gKmFzLCBSQW5hbE9wICpvcCwgUkFyY2hEZWNvZGVNYXNrIG1hc2spIHsKIAlpbnQgbGVuID0gb3AtPnNpemU7Ci0JY29uc3QgdXQ4ICpfYnVmID0gb3AtPmJ5dGVzOwotCWNvbnN0IHV0NjQgYWRkciA9IG9wLT5hZGRyOwogCWlmIChsZW4gPCAxKSB7CiAJCXJldHVybiBmYWxzZTsKIAl9Ci0KLQl1dDggKmJ1ZiA9ICh1dDgqKV9idWY7IC8vIFhYWAorCXV0OCAqYnVmID0gb3AtPmJ5dGVzOworCWNvbnN0IHV0NjQgYWRkciA9IG9wLT5hZGRyOwogCXV0NjQgZHN0ID0gMExMOwogCWlmICghb3ApIHsKIAkJcmV0dXJuIDE7CkBAIC0xNjksMjkgKzE2NywzMiBAQCBzdGF0aWMgYm9vbCBkZWNvZGUoUkFyY2hTZXNzaW9uICphcywgUkFuYWxPcCAqb3AsIFJBcmNoRGVjb2RlTWFzayBtYXNrKSB7CiAJCX0KIAkJcl9zdHJidWZfc2V0ICgmb3AtPmVzaWwsICIxLHBjLC0sYnJrLD1bNF0sNCxicmssKz0iKTsKICNpZiAxCi0JCXsKKwkJaWYgKGxlbiA+IDEpIHsKIAkJCWNvbnN0IHV0OCAqcCA9IGJ1ZiArIDE7CiAJCQlpbnQgbGV2ID0gMCwgaSA9IDE7CiAJCQlsZW4tLTsKIAkJCXdoaWxlIChpIDwgbGVuICYmICpwKSB7Ci0JCQkJaWYgKCpwID09ICdbJykgeworCQkJCXN3aXRjaCAoKnApIHsKKwkJCQljYXNlICdbJzoKIAkJCQkJbGV2Kys7Ci0JCQkJfQotCQkJCWlmICgqcCA9PSAnXScpIHsKKwkJCQkJYnJlYWs7CisJCQkJY2FzZSAnXSc6CiAJCQkJCWxldi0tOwotCQkJCQlpZiAobGV2ID09IC0xKSB7Ci0JCQkJCQlkc3QgPSBhZGRyICsgKHNpemVfdCkocCAtIGJ1ZikgKyAxOworCQkJCQlpZiAobGV2IDwgMSkgeworCQkJCQkJc2l6ZV90IGRlbHRhID0gcCAtIGJ1ZjsKKwkJCQkJCWRzdCA9IGFkZHIgKyAoc2l6ZV90KWRlbHRhICsgMTsKIAkJCQkJCW9wLT5qdW1wID0gZHN0OwogCQkJCQkJcl9zdHJidWZfc2V0ICgmb3AtPmVzaWwsICIxLHBjLC0sYnJrLD1bNF0sNCxicmssKz0sIik7CiAJCQkJCQlnb3RvIGJlYWNoOwogCQkJCQl9Ci0JCQkJfQotCQkJCWlmICgqcCA9PSAweDAwIHx8ICpwID09IDB4ZmYpIHsKKwkJCQkJYnJlYWs7CisJCQkJY2FzZSAwOgorCQkJCWNhc2UgMHhmZjoKIAkJCQkJb3AtPnR5cGUgPSBSX0FOQUxfT1BfVFlQRV9JTEw7CiAJCQkJCWdvdG8gYmVhY2g7CiAJCQkJfQogCQkJCWlmIChyZWFkX2F0ICYmIGkgPT0gbGVuIC0gMSkgewotCQkJCQlicmVhazsKKyNpZiAwCiAJCQkJCS8vIFhYWCB1bm5lY2Vzc2FyeSBqdXN0IGJyZWFrCiAJCQkJCWludCBuZXdfYnVmX2xlbiA9IGxlbiArIDEgKyBCVUZTSVpFX0lOQzsKIAkJCQkJdXQ4ICpuZXdfYnVmID0gY2FsbG9jIChuZXdfYnVmX2xlbiwgMSk7CkBAIC0yMDMsNiArMjA0LDkgQEAgc3RhdGljIGJvb2wgZGVjb2RlKFJBcmNoU2Vzc2lvbiAqYXMsIFJBbmFsT3AgKm9wLCBSQXJjaERlY29kZU1hc2sgbWFzaykgewogCQkJCQkJcCA9IGJ1ZiArIGk7CiAJCQkJCQlsZW4gKz0gQlVGU0laRV9JTkM7CiAJCQkJCX0KKyNlbHNlCisJCQkJCWJyZWFrOworI2VuZGlmCiAJCQkJfQogCQkJCXArKzsKIAkJCQlpKys7CmRpZmYgLS1naXQgYS9saWJyL2NvcmUvY21kX2FuYWwuYyBiL2xpYnIvY29yZS9jbWRfYW5hbC5jCmluZGV4IDA2MWJmMjEwZDc0MzIuLmJjMTk0ODU5MTUwZDcgMTAwNjQ0Ci0tLSBhL2xpYnIvY29yZS9jbWRfYW5hbC5jCisrKyBiL2xpYnIvY29yZS9jbWRfYW5hbC5jCkBAIC04NzE5LDkgKzg3MTksOSBAQCBzdGF0aWMgdm9pZCBfYW5hbF9jYWxscyhSQ29yZSAqY29yZSwgdXQ2NCBhZGRyLCB1dDY0IGFkZHJfZW5kLCBib29sIHByaW50Q29tbWFuZAogCQkJCQlpc1ZhbGlkQ2FsbCA9IGZhbHNlOwogCQkJCX0KIAkJCQlpZiAoaXNWYWxpZENhbGwpIHsKLQkJCQkJdXQ4IGJ1Zls0XSA9IHswfTsKLQkJCQkJcl9pb19yZWFkX2F0IChjb3JlLT5pbywgb3AuanVtcCwgYnVmLCA0KTsKLQkJCQkJaXNWYWxpZENhbGwgPSBtZW1jbXAgKGJ1ZiwgIlx4MDBceDAwXHgwMFx4MDAiLCA0KTsKKwkJCQkJdXQ4IHpidWZbNF0gPSB7MH07CisJCQkJCXJfaW9fcmVhZF9hdCAoY29yZS0+aW8sIG9wLmp1bXAsIHpidWYsIDQpOworCQkJCQlpc1ZhbGlkQ2FsbCA9IG1lbWNtcCAoemJ1ZiwgIlx4MDBceDAwXHgwMFx4MDAiLCA0KTsKIAkJCQl9CiAJCQkJaWYgKGlzVmFsaWRDYWxsKSB7CiAjaWYgSkFZUk9fMDMKQEAgLTg4MTcsOSArODgxNyw4IEBAIHN0YXRpYyB2b2lkIGNtZF9hbmFsX2NhbGxzKFJDb3JlICpjb3JlLCBjb25zdCBjaGFyICppbnB1dCwgYm9vbCBwcmludENvbW1hbmRzLCBiCiB9CiAKIHN0YXRpYyB2b2lkIGNtZF9zZGJrKFNkYiAqZGIsIGNvbnN0IGNoYXIgKmlucHV0KSB7Ci0JY2hhciAqb3V0ID0gKGlucHV0WzBdID09ICcgJykKLQkJPyBzZGJfcXVlcnlzIChkYiwgTlVMTCwgMCwgaW5wdXQgKyAxKQotCQk6IHNkYl9xdWVyeXMgKGRiLCBOVUxMLCAwLCAiKiIpOworCWNvbnN0IGNoYXIgKmFyZyA9IChpbnB1dFswXSA9PSAnICcpPyBpbnB1dCArIDE6ICIqIjsKKwljaGFyICpvdXQgPSBzZGJfcXVlcnlzIChkYiwgTlVMTCwgMCwgYXJnKTsKIAlpZiAob3V0KSB7CiAJCXJfY29uc19wcmludGxuIChvdXQpOwogCQlmcmVlIChvdXQpOwpAQCAtOTExOCw3ICs5MTE3LDcgQEAgc3RhdGljIHZvaWQgYW5hbF9heGcoUkNvcmUgKmNvcmUsIGNvbnN0IGNoYXIgKmlucHV0LCBpbnQgbGV2ZWwsIFNkYiAqZGIsIGludCBvcHQKIH0KIAogc3RhdGljIHZvaWQgY21kX2FuYWxfdWNhbGxfcmVmKFJDb3JlICpjb3JlLCB1dDY0IGFkZHIpIHsKLQlSQW5hbEZ1bmN0aW9uICogZmNuID0gcl9hbmFsX2dldF9mdW5jdGlvbl9hdCAoY29yZS0+YW5hbCwgYWRkcik7CisJUkFuYWxGdW5jdGlvbiAqZmNuID0gcl9hbmFsX2dldF9mdW5jdGlvbl9hdCAoY29yZS0+YW5hbCwgYWRkcik7CiAJaWYgKGZjbikgewogCQlyX2NvbnNfcHJpbnRmICgiIDsgJXMiLCBmY24tPm5hbWUpOwogCX0gZWxzZSB7CkBAIC05MjU3LDcgKzkyNTYsNiBAQCBzdGF0aWMgdm9pZCBheGZtKFJDb3JlICpjb3JlKSB7CiAJCQlsYXN0X2FkZHIgPSByZWYtPmFkZHI7CiAJCX0KIAl9Ci0KIAlSVmVjQW5hbFJlZl9mcmVlIChyZWZzKTsKIH0=",
"url": "https://github.com/radareorg/radare2/commit/ba919adb74ac368bf76b150a00347ded78b572dd.patch"
}
] |
CWE-122 Heap-based Buffer Overflow
|
CVE-2015-6506
|
Cross-site scripting (XSS) vulnerability in the cryptography interface in Request Tracker (RT) before 4.2.12 allows remote attackers to inject arbitrary web script or HTML via a crafted public key.
|
[
{
"commit_message": "[PATCH] Escape message crypt status as we insert it into the DOM The ->{'Value'} part of each message is inserted into the DOM with no escaping (to accommodate MakeClicky and callbacks using HTML). Values RT receives from other systems must be escaped or they leave us vulnerable to an XSS injection attack. This also happens to fix a bug where email addresses of senders would in some cases not be shown in the browser. share/html/Elements/CryptStatus | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/bestpractical/rt/commit/36a461947b00b105336adb4997d.patch"
}
] |
n/a
|
|
CVE-2022-24841
|
Improper Authorization in github.com/fleetdm/fleet
|
fleetdm/fleet is an open source device management, built on osquery. All versions of fleet making use of the teams feature are affected by this authorization bypass issue. Fleet instances without teams, or with teams but without restricted team accounts are not affected. In affected versions a team admin can erroneously add themselves as admin, maintainer or observer on other teams. Users are advised to upgrade to version 4.13. There are no known workarounds for this issue.
|
[
{
"commit_message": "[PATCH] Merge pull request from GHSA-pr2g-j78h-84cr MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit * Fix access control issues with users * Fix access control issues with packs * Fix access control issues with software * Changes suggested by Martin * All users can access the global schedule * Restrict access to activities * Add explicit test for team admin escalation vuln * All global users should be able to read all software * Handbook editor pass - Security - GitHub Security (#5108) * Update security.md All edits are recorded by line: 395 replaced “open-source” with “open source” 411 replaced “open-source” with “open source” 439 added “the” before “comment”; replaced “repositories,” with “repositories” 445 deleted “being” before “located” 458 added “and” after “PR” 489 replaced “on” with “in” 493 replaced “open-source” with “open source”; Replaced “privileges,” with “privileges” * Update security.md line 479 * Update security.md added (static analysis tools used to identify problems in code) to line 479 * Fix UI * Fix UI * revert api v1 to latest in documentation (#5149) * revert api v1 to latest in documentation * Update fleetctl doc page Co-authored-by: Noah Talerman <[email protected]> * Add team admin team policy automation; fix e2e * Update to company page of the handbook (#5164) Updated \"Why do we use a wireframe-first approach?\" section of company.md * removed extra data on smaller screens (#5154) * Update for team automations; e2e * Jira Integration: Cypress e2e tests only (#5055) * Update company.md (#5170) This is to update the formatting under \"empathy\" and to fix the spelling of \"help text.\" This was done as per @mikermcneil . This is related to #https://github.com/fleetdm/fleet/pull/4941 and https://github.com/fleetdm/fleet/issues/4902 * fix update updated_at for aggregated_stats (#5112) Update the updated_at column when using ON DUPLICATE UPDATE so that the counts_updated_at is up to date * basic sql formatting in code ie whitespace around operators * Fix e2e test * Fix tests in server/authz Co-authored-by: gillespi314 <[email protected]> Co-authored-by: Desmi-Dizney <[email protected]> Co-authored-by: Michal Nicpon <[email protected]> Co-authored-by: Noah Talerman <[email protected]> Co-authored-by: Mike Thomas <[email protected]> Co-authored-by: Martavis Parker <[email protected]> Co-authored-by: RachelElysia <[email protected]> changes/activities-rbac | 1 + changes/issue-GHSA-pr2g-j78h-84cr | 3 + cypress/integration/free/maintainer.spec.ts | 36 +- cypress/integration/free/observer.spec.ts | 6 +- cypress/integration/premium/admin.spec.ts | 21 + .../integration/premium/maintainer.spec.ts | 35 +- .../integration/premium/team_admin.spec.ts | 13 +- .../premium/team_maintainer_observer.spec.ts | 4 +- .../Homepage/cards/Software/Software.tsx | 12 +- .../MembersPage/MembersPage.tsx | 75 +- .../components/UserForm/UserForm.tsx | 2 +- .../ManagePoliciesPage/ManagePoliciesPage.tsx | 3 +- .../ManageSoftwarePage/ManageSoftwarePage.tsx | 8 +- server/authz/authz.go | 19 + server/authz/policy.rego | 75 +- server/authz/policy_test.go | 48 +- server/fleet/authz.go | 20 +- server/fleet/packs.go | 73 +- server/fleet/software.go | 11 + server/service/activities_test.go | 28 +- server/service/endpoint_utils_test.go | 9 +- server/service/global_schedule.go | 29 +- server/service/global_schedule_test.go | 48 +- server/service/hosts.go | 10 +- server/service/scheduled_queries_test.go | 51 +- server/service/software.go | 8 +- server/service/software_test.go | 149 +++- server/service/team_schedule.go | 18 +- server/service/team_schedule_test.go | 8 +- server/service/users.go | 85 +- server/service/users_test.go | 783 ++++++++++++++++-- 31 files changed, 1339 insertions(+), 352 deletions(-) create mode 100644 changes/activities-rbac create mode 100644 changes/issue-GHSA-pr2g-j78h-84cr",
"patch_text_b64": "From da171d3b8d149c30b8307723cbe6b6e8847cb30c Mon Sep 17 00:00:00 2001
From: Lucas Manuel Rodriguez <lucas@fleetdm.com>
Date: Mon, 18 Apr 2022 14:27:30 -0300
Subject: [PATCH] Merge pull request from GHSA-pr2g-j78h-84cr
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* Fix access control issues with users

* Fix access control issues with packs

* Fix access control issues with software

* Changes suggested by Martin

* All users can access the global schedule

* Restrict access to activities

* Add explicit test for team admin escalation vuln

* All global users should be able to read all software

* Handbook editor pass - Security - GitHub Security (#5108)

* Update security.md

All edits are recorded by line:

395 replaced “open-source” with “open source”
411 replaced “open-source” with “open source”
439 added “the” before “comment”; replaced “repositories,” with “repositories”
445 deleted “being” before “located”
458 added “and” after “PR”
489 replaced “on” with “in”
493 replaced “open-source” with “open source”; Replaced “privileges,” with “privileges”

* Update security.md

line 479

* Update security.md

added (static analysis tools used to identify problems in code) to line 479

* Fix UI

* Fix UI

* revert api v1 to latest in documentation (#5149)

* revert api v1 to latest in documentation

* Update fleetctl doc page

Co-authored-by: Noah Talerman <noahtal@umich.edu>

* Add team admin team policy automation; fix e2e

* Update to company page of the handbook (#5164)

Updated "Why do we use a wireframe-first approach?" section of company.md

* removed extra data on smaller screens (#5154)

* Update for team automations; e2e

* Jira Integration: Cypress e2e tests only (#5055)

* Update company.md (#5170)

This is to update the formatting under "empathy" and to fix the spelling of "help text."
This was done as per @mikermcneil .
This is related to #https://github.com/fleetdm/fleet/pull/4941 and https://github.com/fleetdm/fleet/issues/4902

* fix update updated_at for aggregated_stats (#5112)

Update the updated_at column when using ON DUPLICATE UPDATE so that
the counts_updated_at is up to date

* basic sql formatting in code ie whitespace around operators

* Fix e2e test

* Fix tests in server/authz

Co-authored-by: gillespi314 <73313222+gillespi314@users.noreply.github.com>
Co-authored-by: Desmi-Dizney <99777687+Desmi-Dizney@users.noreply.github.com>
Co-authored-by: Michal Nicpon <39177923+michalnicp@users.noreply.github.com>
Co-authored-by: Noah Talerman <noahtal@umich.edu>
Co-authored-by: Mike Thomas <78363703+mike-j-thomas@users.noreply.github.com>
Co-authored-by: Martavis Parker <47053705+martavis@users.noreply.github.com>
Co-authored-by: RachelElysia <71795832+RachelElysia@users.noreply.github.com>
---
 changes/activities-rbac                       |   1 +
 changes/issue-GHSA-pr2g-j78h-84cr             |   3 +
 cypress/integration/free/maintainer.spec.ts   |  36 +-
 cypress/integration/free/observer.spec.ts     |   6 +-
 cypress/integration/premium/admin.spec.ts     |  21 +
 .../integration/premium/maintainer.spec.ts    |  35 +-
 .../integration/premium/team_admin.spec.ts    |  13 +-
 .../premium/team_maintainer_observer.spec.ts  |   4 +-
 .../Homepage/cards/Software/Software.tsx      |  12 +-
 .../MembersPage/MembersPage.tsx               |  75 +-
 .../components/UserForm/UserForm.tsx          |   2 +-
 .../ManagePoliciesPage/ManagePoliciesPage.tsx |   3 +-
 .../ManageSoftwarePage/ManageSoftwarePage.tsx |   8 +-
 server/authz/authz.go                         |  19 +
 server/authz/policy.rego                      |  75 +-
 server/authz/policy_test.go                   |  48 +-
 server/fleet/authz.go                         |  20 +-
 server/fleet/packs.go                         |  73 +-
 server/fleet/software.go                      |  11 +
 server/service/activities_test.go             |  28 +-
 server/service/endpoint_utils_test.go         |   9 +-
 server/service/global_schedule.go             |  29 +-
 server/service/global_schedule_test.go        |  48 +-
 server/service/hosts.go                       |  10 +-
 server/service/scheduled_queries_test.go      |  51 +-
 server/service/software.go                    |   8 +-
 server/service/software_test.go               | 149 +++-
 server/service/team_schedule.go               |  18 +-
 server/service/team_schedule_test.go          |   8 +-
 server/service/users.go                       |  85 +-
 server/service/users_test.go                  | 783 ++++++++++++++++--
 31 files changed, 1339 insertions(+), 352 deletions(-)
 create mode 100644 changes/activities-rbac
 create mode 100644 changes/issue-GHSA-pr2g-j78h-84cr

diff --git a/changes/activities-rbac b/changes/activities-rbac
new file mode 100644
index 000000000000..d8b80a4efb01
--- /dev/null
+++ b/changes/activities-rbac
@@ -0,0 +1 @@
+* Restrict non-global user from access to activities
\ No newline at end of file
diff --git a/changes/issue-GHSA-pr2g-j78h-84cr b/changes/issue-GHSA-pr2g-j78h-84cr
new file mode 100644
index 000000000000..e66b072a4ece
--- /dev/null
+++ b/changes/issue-GHSA-pr2g-j78h-84cr
@@ -0,0 +1,3 @@
+* Fix access control issues with "user" endpoints.
+* Fix access control issues with "pack" endpoints.
+* Fix access control issues with "software" endpoints.
diff --git a/cypress/integration/free/maintainer.spec.ts b/cypress/integration/free/maintainer.spec.ts
index 994d24d5f57b..a5419ef5ede1 100644
--- a/cypress/integration/free/maintainer.spec.ts
+++ b/cypress/integration/free/maintainer.spec.ts
@@ -189,31 +189,7 @@ describe(
     describe("Manage software page", () => {
       beforeEach(() => cy.visit("/software/manage"));
       it("should restrict global maintainer from 'Manage automations' button", () => {
-        it("hides manages software automations when all teams selected", () => {
-          cy.getAttached(".manage-software-page__header-wrap").within(() => {
-            cy.getAttached(".Select").within(() => {
-              cy.findByText(/all teams/i).should("exist");
-            });
-            cy.getAttached(".manage-software-page__header-wrap").within(() => {
-              cy.findByRole("button", {
-                name: /manage automations/i,
-              }).should("not.exist");
-            });
-          });
-        });
-        it("hides manage automations button when all teams not selected", () => {
-          cy.getAttached(".manage-software-page__header-wrap").within(() => {
-            cy.getAttached(".Select").within(() => {
-              cy.getAttached(".Select-control").click();
-              cy.getAttached(".Select-menu-outer").within(() => {
-                cy.findByText(/apples/i).should("exist");
-              });
-              cy.findByRole("button", {
-                name: /manage automations/i,
-              }).should("not.exist");
-            });
-          });
-        });
+        cy.findByText(/manage automations/).should("not.exist");
       });
     });
     describe("Query pages", () => {
@@ -274,9 +250,13 @@ describe(
         cy.loginWithCySession("mary@organization.com", "user123#");
         cy.visit("/policies/manage");
       });
-      it("allows maintainer to manage automations", () => {
-        cy.findByRole("button", { name: /manage automations/i }).click();
-        cy.findByRole("button", { name: /cancel/i }).click();
+      it("hides manage automations from maintainer", () => {
+        cy.getAttached(".button-wrap").within(() => {
+          cy.findByRole("button", { name: /add a policy/i }).should("exist");
+          cy.findByRole("button", { name: /manage automations/i }).should(
+            "not.exist"
+          );
+        });
       });
       it("allows maintainer to add a policy", () => {
         cy.findByRole("button", { name: /add a policy/i }).click();
diff --git a/cypress/integration/free/observer.spec.ts b/cypress/integration/free/observer.spec.ts
index 689f3a57b9af..bff92244a250 100644
--- a/cypress/integration/free/observer.spec.ts
+++ b/cypress/integration/free/observer.spec.ts
@@ -209,12 +209,10 @@ describe("Free tier - Observer user", () => {
       cy.visit("/policies/manage");
     });
     it("hides manage automations button", () => {
-      cy.findByRole("button", { name: /manage automations/i }).should(
-        "not.exist"
-      );
+      cy.findByText(/manage automations/i).should("not.exist");
     });
     it("hides add a policy button", () => {
-      cy.findByRole("button", { name: /add a policy/i }).should("not.exist");
+      cy.findByText(/add a policy/).should("not.exist");
     });
     it("hides run, edit, or delete a policy", () => {
       cy.getAttached("tbody").within(() => {
diff --git a/cypress/integration/premium/admin.spec.ts b/cypress/integration/premium/admin.spec.ts
index d6c508223ed1..974342d4b39f 100644
--- a/cypress/integration/premium/admin.spec.ts
+++ b/cypress/integration/premium/admin.spec.ts
@@ -564,6 +564,27 @@ describe("Premium tier - Global Admin user", () => {
       });
       cy.findByText(/successfully updated policy automations/i).should("exist");
     });
+    it("allows global admin to automate a team policy", () => {
+      cy.visit("/policies/manage");
+      cy.getAttached(".Select-control").within(() => {
+        cy.findByText(/all teams/i).click();
+      });
+      cy.getAttached(".Select-menu")
+        .contains(/apples/i)
+        .click();
+      cy.getAttached(".button-wrap")
+        .findByRole("button", { name: /manage automations/i })
+        .click();
+      cy.getAttached(".manage-automations-modal").within(() => {
+        cy.getAttached(".fleet-slider").click();
+        cy.getAttached(".fleet-checkbox__input").check({ force: true });
+        cy.getAttached("#webhook-url")
+          .clear()
+          .type("https://example.com/global_admin");
+        cy.findByText(/save/i).click();
+      });
+      cy.findByText(/successfully updated policy automations/i).should("exist");
+    });
     it("allows global admin to delete a team policy", () => {
       cy.visit("/policies/manage");
       cy.getAttached(".Select-control").within(() => {
diff --git a/cypress/integration/premium/maintainer.spec.ts b/cypress/integration/premium/maintainer.spec.ts
index 4c88e81feb4c..0e83b1188d2e 100644
--- a/cypress/integration/premium/maintainer.spec.ts
+++ b/cypress/integration/premium/maintainer.spec.ts
@@ -201,32 +201,8 @@ describe("Premium tier - Maintainer user", () => {
     });
     describe("Manage software page", () => {
       beforeEach(() => cy.visit("/software/manage"));
-      it("should restrict global maintainer from 'Manage automations' button", () => {
-        it("hides manages software automations when all teams selected", () => {
-          cy.getAttached(".manage-software-page__header-wrap").within(() => {
-            cy.getAttached(".Select").within(() => {
-              cy.findByText(/all teams/i).should("exist");
-            });
-            cy.getAttached(".manage-software-page__header-wrap").within(() => {
-              cy.findByRole("button", {
-                name: /manage automations/i,
-              }).should("not.exist");
-            });
-          });
-        });
-        it("hides manage automations button when all teams not selected", () => {
-          cy.getAttached(".manage-software-page__header-wrap").within(() => {
-            cy.getAttached(".Select").within(() => {
-              cy.getAttached(".Select-control").click();
-              cy.getAttached(".Select-menu-outer").within(() => {
-                cy.findByText(/apples/i).should("exist");
-              });
-              cy.findByRole("button", {
-                name: /manage automations/i,
-              }).should("not.exist");
-            });
-          });
-        });
+      it("hides 'Manage automations' button from global maintainer", () => {
+        cy.findByText(/manage automations/i).should("not.exist");
       });
     });
     describe("Query pages", () => {
@@ -250,11 +226,8 @@ describe("Premium tier - Maintainer user", () => {
     });
     describe("Manage policies page", () => {
       beforeEach(() => cy.visit("/policies/manage"));
-      it("allows global maintainer to click 'Manage automations' button", () => {
-        cy.getAttached(".button-wrap")
-          .findByRole("button", { name: /manage automations/i })
-          .click();
-        cy.findByRole("button", { name: /cancel/i }).click();
+      it("hides manage automations button", () => {
+        cy.findByText(/manage hosts/i).should("not.exist");
       });
       it("allows global maintainer to add a new policy", () => {
         cy.getAttached(".button-wrap")
diff --git a/cypress/integration/premium/team_admin.spec.ts b/cypress/integration/premium/team_admin.spec.ts
index 3875acd0384a..93d270190813 100644
--- a/cypress/integration/premium/team_admin.spec.ts
+++ b/cypress/integration/premium/team_admin.spec.ts
@@ -192,10 +192,7 @@ describe("Premium tier - Team Admin user", () => {
   });
   describe("Manage software page", () => {
     beforeEach(() => cy.visit("/software/manage"));
-    it("hides manage automations button since all teams not selected", () => {
-      cy.getAttached(".manage-software-page__header-wrap").within(() => {
-        cy.findByText(/apples/i).should("exist");
-      });
+    it("hides manage automations button", () => {
       cy.findByText(/manage automations/i).should("not.exist");
     });
   });
@@ -283,12 +280,6 @@ describe("Premium tier - Team Admin user", () => {
   });
   describe("Manage policies page", () => {
     beforeEach(() => cy.visit("/policies/manage"));
-    it("hides manage automations button when all teams not selected", () => {
-      cy.getAttached(".manage-policies-page__header-wrap").within(() => {
-        cy.findByText(/apples/i).should("exist");
-      });
-      cy.findByText(/manage automations/i).should("not.exist");
-    });
     it("allows team admin to add a new policy", () => {
       cy.getAttached(".button-wrap")
         .findByRole("button", { name: /add a policy/i })
@@ -358,7 +349,7 @@ describe("Premium tier - Team Admin user", () => {
       cy.findByText(/apples/i).should("exist");
     });
     it("displays the team admin controls", () => {
-      cy.findByRole("button", { name: /add member/i }).click();
+      cy.findByRole("button", { name: /create user/i }).click();
       cy.findByRole("button", { name: /cancel/i }).click();
       cy.findByRole("button", { name: /add hosts/i }).click();
       cy.findByRole("button", { name: /done/i }).click();
diff --git a/cypress/integration/premium/team_maintainer_observer.spec.ts b/cypress/integration/premium/team_maintainer_observer.spec.ts
index 2fe9585d1f5d..a861b4d4eebc 100644
--- a/cypress/integration/premium/team_maintainer_observer.spec.ts
+++ b/cypress/integration/premium/team_maintainer_observer.spec.ts
@@ -276,8 +276,8 @@ describe("Premium tier - Team observer/maintainer user", () => {
         cy.findByText(/apples/i).click();
         cy.findByText(/oranges/i).click();
 
-        // On maintaining team, should see the "Manage automations" button
-        cy.findByText(/manage automations/i).should("exist");
+        // On maintaining team, should not see the "Manage automations" button
+        cy.findByText(/manage automations/i).should("not.exist");
         // On maintaining team, should see "add a policy" and "save" a policy
         cy.findByText(/add a policy/i).click();
 
diff --git a/frontend/pages/Homepage/cards/Software/Software.tsx b/frontend/pages/Homepage/cards/Software/Software.tsx
index 7a07e00d3f75..6615d6451985 100644
--- a/frontend/pages/Homepage/cards/Software/Software.tsx
+++ b/frontend/pages/Homepage/cards/Software/Software.tsx
@@ -1,7 +1,8 @@
-import React, { useState } from "react";
+import React, { useContext, useState } from "react";
 import { useQuery } from "react-query";
 import { Tab, Tabs, TabList, TabPanel } from "react-tabs";
 
+import { AppContext } from "context/app";
 import paths from "router/paths";
 import configAPI from "services/entities/config";
 import softwareAPI, { ISoftwareResponse } from "services/entities/software";
@@ -39,6 +40,10 @@ const Software = ({
   const [pageIndex, setPageIndex] = useState<number>(0);
   const [isSoftwareEnabled, setIsSoftwareEnabled] = useState<boolean>();
 
+  const { availableTeams, currentTeam, isOnGlobalTeam } = useContext(
+    AppContext
+  );
+
   const { data: config } = useQuery(["config"], configAPI.loadAll, {
     onSuccess: (data) => {
       setIsSoftwareEnabled(data?.host_settings?.enable_software_inventory);
@@ -71,8 +76,11 @@ const Software = ({
         teamId: currentTeamId,
       }),
     {
+      enabled:
+        isOnGlobalTeam ||
+        !!availableTeams?.find((t) => t.id === currentTeam?.id),
       keepPreviousData: true,
-      staleTime: 30000, // TODO: Discuss a reasonable staleTime given that counts are only updated infrequently?
+      staleTime: 30000, // stale time can be adjusted if fresher data is desired based on software inventory interval
       onSuccess: (data) => {
         setShowSoftwareUI(true);
         if (isSoftwareEnabled && data.software?.length !== 0) {
diff --git a/frontend/pages/admin/TeamManagementPage/TeamDetailsWrapper/MembersPage/MembersPage.tsx b/frontend/pages/admin/TeamManagementPage/TeamDetailsWrapper/MembersPage/MembersPage.tsx
index 8b65ae1b489b..ba854b48d864 100644
--- a/frontend/pages/admin/TeamManagementPage/TeamDetailsWrapper/MembersPage/MembersPage.tsx
+++ b/frontend/pages/admin/TeamManagementPage/TeamDetailsWrapper/MembersPage/MembersPage.tsx
@@ -51,9 +51,13 @@ const MembersPage = ({
   const teamId = parseInt(team_id, 10);
 
   const { renderFlash } = useContext(NotificationContext);
-  const { config, isGlobalAdmin, currentUser, isPremiumTier } = useContext(
-    AppContext
-  );
+  const {
+    config,
+    currentUser,
+    isGlobalAdmin,
+    isPremiumTier,
+    isTeamAdmin,
+  } = useContext(AppContext);
 
   const smtpConfigured = config?.smtp_settings.configured || false;
   const canUseSso = config?.sso_settings.enable_sso || false;
@@ -137,14 +141,7 @@ const MembersPage = ({
   const toggleCreateMemberModal = useCallback(() => {
     setShowCreateUserModal(!showCreateUserModal);
     setShowAddMemberModal(false);
-    currentUser ? setUserEditing(currentUser) : setUserEditing(undefined);
-  }, [
-    showCreateUserModal,
-    currentUser,
-    setShowCreateUserModal,
-    setUserEditing,
-    setShowAddMemberModal,
-  ]);
+  }, [showCreateUserModal, setShowCreateUserModal, setShowAddMemberModal]);
 
   // FUNCTIONS
 
@@ -153,7 +150,10 @@ const MembersPage = ({
     teamsAPI
       .removeMembers(teamId, removedUsers)
       .then(() => {
-        renderFlash("success", `Successfully removed ${userEditing?.name}`);
+        renderFlash(
+          "success",
+          `Successfully removed ${userEditing?.name || "member"}`
+        );
         // If user removes self from team, redirect to home
         if (currentUser && currentUser.id === removedUsers.users[0].id) {
           window.location.href = "/";
@@ -178,12 +178,15 @@ const MembersPage = ({
     (newMembers: INewMembersBody) => {
       teamsAPI
         .addMembers(teamId, newMembers)
-        .then(() =>
+        .then(() => {
+          const count = newMembers.users.length;
           renderFlash(
             "success",
-            `${newMembers.users.length} members successfully added to ${currentTeam?.name}.`
-          )
-        )
+            `${count} ${
+              count === 1 ? "member" : "members"
+            } successfully added to ${currentTeam?.name}.`
+          );
+        })
         .catch(() =>
           renderFlash("error", "Could not add members. Please try again.")
         )
@@ -288,7 +291,10 @@ const MembersPage = ({
         usersAPI
           .update(userEditing.id, updatedAttrs)
           .then(() => {
-            renderFlash("success", `Successfully edited ${userName}.`);
+            renderFlash(
+              "success",
+              `Successfully edited ${userName || "member"}.`
+            );
 
             if (
               currentUser &&
@@ -317,7 +323,7 @@ const MembersPage = ({
             } else {
               renderFlash(
                 "error",
-                `Could not edit ${userName}. Please try again.`
+                `Could not edit ${userName || "member"}. Please try again.`
               );
             }
           });
@@ -349,13 +355,24 @@ const MembersPage = ({
                   Expecting to see new team members listed here? Try again in a
                   few seconds as the system catches up.
                 </p>
-                <Button
-                  variant="brand"
-                  className={`${noMembersClass}__create-button`}
-                  onClick={toggleAddUserModal}
-                >
-                  Add member
-                </Button>
+                {isGlobalAdmin && (
+                  <Button
+                    variant="brand"
+                    className={`${noMembersClass}__create-button`}
+                    onClick={toggleAddUserModal}
+                  >
+                    Add member
+                  </Button>
+                )}
+                {isTeamAdmin && (
+                  <Button
+                    variant="brand"
+                    className={`${noMembersClass}__create-button`}
+                    onClick={toggleCreateMemberModal}
+                  >
+                    Create user
+                  </Button>
+                )}
               </>
             ) : (
               <>
@@ -396,8 +413,10 @@ const MembersPage = ({
           isLoading={isLoadingMembers}
           defaultSortHeader={"name"}
           defaultSortDirection={"asc"}
-          onActionButtonClick={toggleAddUserModal}
-          actionButtonText={"Add member"}
+          onActionButtonClick={
+            isGlobalAdmin ? toggleAddUserModal : toggleCreateMemberModal
+          }
+          actionButtonText={isGlobalAdmin ? "Add member" : "Create user"}
           actionButtonVariant={"brand"}
           hideActionButton={memberIds.length === 0 && searchString === ""}
           onQueryChange={({ searchQuery }) => setSearchString(searchQuery)}
@@ -424,7 +443,7 @@ const MembersPage = ({
           onSubmit={onEditMemberSubmit}
           defaultName={userEditing?.name}
           defaultEmail={userEditing?.email}
-          defaultGlobalRole={userEditing?.global_role}
+          defaultGlobalRole={userEditing?.global_role || null}
           defaultTeamRole={userEditing?.role}
           defaultTeams={userEditing?.teams}
           availableTeams={teams || []}
diff --git a/frontend/pages/admin/UserManagementPage/components/UserForm/UserForm.tsx b/frontend/pages/admin/UserManagementPage/components/UserForm/UserForm.tsx
index 033f1cf9e7be..50a25faba1d6 100644
--- a/frontend/pages/admin/UserManagementPage/components/UserForm/UserForm.tsx
+++ b/frontend/pages/admin/UserManagementPage/components/UserForm/UserForm.tsx
@@ -121,7 +121,7 @@ const UserForm = ({
   });
 
   const [isGlobalUser, setIsGlobalUser] = useState<boolean>(
-    defaultGlobalRole !== null
+    !!defaultGlobalRole
   );
 
   useEffect(() => {
diff --git a/frontend/pages/policies/ManagePoliciesPage/ManagePoliciesPage.tsx b/frontend/pages/policies/ManagePoliciesPage/ManagePoliciesPage.tsx
index c956be1ceebf..6d508bc98c1b 100644
--- a/frontend/pages/policies/ManagePoliciesPage/ManagePoliciesPage.tsx
+++ b/frontend/pages/policies/ManagePoliciesPage/ManagePoliciesPage.tsx
@@ -138,6 +138,7 @@ const ManagePolicyPage = ({
 
   const canAddOrRemovePolicy =
     isGlobalAdmin || isGlobalMaintainer || isTeamMaintainer || isTeamAdmin;
+  const canManageAutomations = isGlobalAdmin || isTeamAdmin;
 
   const { isLoading: isLoadingWebhooks, refetch: refetchWebhooks } = useQuery<
     IConfig | ILoadTeamResponse,
@@ -364,7 +365,7 @@ const ManagePolicyPage = ({
             </div>
           </div>
           <div className={`${baseClass} button-wrap`}>
-            {canAddOrRemovePolicy &&
+            {canManageAutomations &&
               !isLoadingWebhooks &&
               !isLoadingGlobalPolicies && (
                 <Button
diff --git a/frontend/pages/software/ManageSoftwarePage/ManageSoftwarePage.tsx b/frontend/pages/software/ManageSoftwarePage/ManageSoftwarePage.tsx
index 6f9ca10c7f57..3c1e3a60ee84 100644
--- a/frontend/pages/software/ManageSoftwarePage/ManageSoftwarePage.tsx
+++ b/frontend/pages/software/ManageSoftwarePage/ManageSoftwarePage.tsx
@@ -68,9 +68,9 @@ const ManageSoftwarePage = ({
   const {
     availableTeams,
     currentTeam,
-    setConfig,
     isGlobalAdmin,
     isGlobalMaintainer,
+    isOnGlobalTeam,
   } = useContext(AppContext);
   const { renderFlash } = useContext(NotificationContext);
 
@@ -162,6 +162,9 @@ const ManageSoftwarePage = ({
       return softwareAPI.load(params);
     },
     {
+      enabled:
+        isOnGlobalTeam ||
+        !!availableTeams?.find((t) => t.id === currentTeam?.id),
       keepPreviousData: true,
       staleTime: 30000, // stale time can be adjusted if fresher data is desired based on software inventory interval
     }
@@ -190,6 +193,9 @@ const ManageSoftwarePage = ({
       });
     },
     {
+      enabled:
+        isOnGlobalTeam ||
+        !!availableTeams?.find((t) => t.id === currentTeam?.id),
       keepPreviousData: true,
       staleTime: 30000, // stale time can be adjusted if fresher data is desired based on software inventory interval
       refetchOnWindowFocus: false,
diff --git a/server/authz/authz.go b/server/authz/authz.go
index 98cb7909e6ba..81f627ff9965 100644
--- a/server/authz/authz.go
+++ b/server/authz/authz.go
@@ -138,6 +138,12 @@ type AuthzTyper interface {
 	AuthzType() string
 }
 
+// ExtraAuthzer is the interface to implement extra fields for the policy.
+type ExtraAuthzer interface {
+	// ExtraAuthz returns the extra key/value pairs for the type.
+	ExtraAuthz() (map[string]interface{}, error)
+}
+
 // jsonToInterface turns any type that can be JSON (un)marshaled into an
 // map[string]interface{} for evaluation by the OPA engine. Nil is returned as nil.
 func jsonToInterface(in interface{}) (interface{}, error) {
@@ -169,6 +175,19 @@ func jsonToInterface(in interface{}) (interface{}, error) {
 	if typer, ok := in.(AuthzTyper); ok {
 		out["type"] = typer.AuthzType()
 	}
+	// Add any extra key/values defined by the type.
+	if extra, ok := in.(ExtraAuthzer); ok {
+		extraKVs, err := extra.ExtraAuthz()
+		if err != nil {
+			return nil, fmt.Errorf("extra authz: %w", err)
+		}
+		for k, v := range extraKVs {
+			if _, ok := out[k]; ok {
+				return nil, fmt.Errorf("existing authz value: %s", k)
+			}
+			out[k] = v
+		}
+	}
 
 	return out, nil
 }
diff --git a/server/authz/policy.rego b/server/authz/policy.rego
index 8d2244a568e0..889319bdda1a 100644
--- a/server/authz/policy.rego
+++ b/server/authz/policy.rego
@@ -13,8 +13,12 @@ import input.subject
 read := "read"
 list := "list"
 write := "write"
+
+# User specific actions
 write_role := "write_role"
 change_password := "change_password"
+
+# Query specific actions
 run := "run"
 run_new := "run_new"
 
@@ -95,35 +99,31 @@ allow {
 
 ##
 # Users
+#
+# NOTE: More rules apply to users but they are implemented in Go code.
+# Our end goal is to move all the authorization logic here.
 ##
 
-# Any user can write self (besides role) and change their own password.
+# Any user can read and write self and change their own password.
 allow {
   object.type == "user"
   object.id == subject.id
   object.id != 0
-  action == [write, change_password][_]
+  action == [read, write, change_password][_]
 }
 
-# Any user can read other users.
-allow {
-  object.type == "user"
-  not is_null(subject)
-  action == read
-}
-
-# Admins can write all users + roles + change passwords.
+# Global admins can perform all operations on all users.
 allow {
   object.type == "user"
   subject.global_role == admin
-  action == [write, write_role, change_password][_]
+  action == [read, write, write_role, change_password][_]
 }
 
-## Team admins can create or edit new users, but not change their password.
+# Team admins can perform all operations on the team users (except changing their password).
 allow {
   object.type == "user"
   team_role(subject, object.teams[_].id) == admin
-  action == [write, write_role][_]
+  action == [read, write, write_role][_]
 }
 
 ##
@@ -141,9 +141,9 @@ allow {
 # Activities
 ##
 
-# All users can read activities
+# Only global users can read activities
 allow {
-  not is_null(subject)
+  not is_null(subject.global_role)
   object.type == "activity"
   action == read
 }
@@ -402,26 +402,41 @@ allow {
 # Packs
 ##
 
-# Global admins and maintainers can read/write all packs
+# Global admins and maintainers can read/write all packs.
 allow {
   object.type == "pack"
-  subject.global_role == [admin,maintainer][_]
+  subject.global_role == [admin, maintainer][_]
   action == [read, write][_]
 }
 
-# Team admins and maintainers can read global packs
+# All users can read the global pack.
 allow {
-  is_null(object.team_ids)
   object.type == "pack"
-  team_role(subject, subject.teams[_].id) == [admin,maintainer][_]
+  not is_null(subject)
+  object.is_global_pack == true
   action == read
 }
 
-# Team admins and maintainers can read/write their team packs
+# Team admins, maintainers and observers can read their team's pack.
+#
+# NOTE: Action "read" on a team's pack includes listing its scheduled queries.
 allow {
   object.type == "pack"
-  team_role(subject, object.team_ids[_]) == [admin,maintainer][_]
-  action == [read, write][_]
+  not is_null(object.pack_team_id)
+  team_role(subject, object.pack_team_id) == [admin, maintainer, observer][_]
+  action == read
+}
+
+# Team admins and maintainers can add/remove scheduled queries from/to their team's pack.
+#
+# NOTE: The team's pack is not editable per-se, it's a special pack to group
+# all the team's scheduled queries. So the "write" operation only covers
+# adding/removing scheduled queries from the pack.
+allow {
+  object.type == "pack"
+  not is_null(object.pack_team_id)
+  team_role(subject, object.pack_team_id) == [admin, maintainer][_]
+  action == write
 }
 
 ##
@@ -481,9 +496,17 @@ allow {
 # Software
 ##
 
-# All users can read software
+# Global users can read all software.
 allow {
-  not is_null(subject)
-  object.type == "software"
+  object.type == "software_inventory"
+  subject.global_role == [admin, maintainer, observer][_]
   action == read
 }
+
+# Team users can read all software in their teams.
+allow {
+  not is_null(object.team_id)
+  object.type == "software_inventory"
+  team_role(subject, object.team_id) == [admin, maintainer, observer][_]
+  action == read
+}
\ No newline at end of file
diff --git a/server/authz/policy_test.go b/server/authz/policy_test.go
index e617aca7b974..72452875292a 100644
--- a/server/authz/policy_test.go
+++ b/server/authz/policy_test.go
@@ -115,7 +115,7 @@ func TestAuthorizeUser(t *testing.T) {
 		{user: nil, object: user, action: changePwd, allow: false},
 		{user: nil, object: newUser, action: write, allow: false},
 
-		// Admin can read/write all and create new
+		// Global admin can read/write all and create new.
 		{user: test.UserAdmin, object: user, action: read, allow: true},
 		{user: test.UserAdmin, object: user, action: write, allow: true},
 		{user: test.UserAdmin, object: user, action: writeRole, allow: true},
@@ -126,48 +126,60 @@ func TestAuthorizeUser(t *testing.T) {
 		{user: test.UserAdmin, object: test.UserAdmin, action: writeRole, allow: true},
 		{user: test.UserAdmin, object: test.UserAdmin, action: changePwd, allow: true},
 
-		// Regular users can read all users and write self (besides roles), but not create
-		{user: test.UserMaintainer, object: user, action: read, allow: true},
+		// Global maintainers cannot read/write users.
+		{user: test.UserMaintainer, object: user, action: read, allow: false},
 		{user: test.UserMaintainer, object: user, action: write, allow: false},
 		{user: test.UserMaintainer, object: user, action: writeRole, allow: false},
 		{user: test.UserMaintainer, object: user, action: changePwd, allow: false},
+		// Global maintainers cannot create users.
 		{user: test.UserMaintainer, object: newUser, action: write, allow: false},
+		// Global maintainers can read/write itself (besides roles).
 		{user: test.UserMaintainer, object: test.UserMaintainer, action: read, allow: true},
 		{user: test.UserMaintainer, object: test.UserMaintainer, action: write, allow: true},
 		{user: test.UserMaintainer, object: test.UserMaintainer, action: writeRole, allow: false},
 		{user: test.UserMaintainer, object: test.UserMaintainer, action: changePwd, allow: true},
 
-		{user: test.UserNoRoles, object: user, action: read, allow: true},
+		// Users without roles cannot read/write users.
+		{user: test.UserNoRoles, object: user, action: read, allow: false},
 		{user: test.UserNoRoles, object: user, action: write, allow: false},
 		{user: test.UserNoRoles, object: user, action: writeRole, allow: false},
 		{user: test.UserNoRoles, object: user, action: changePwd, allow: false},
+		// User without roles cannot add new users.
 		{user: test.UserNoRoles, object: newUser, action: write, allow: false},
+		// User without roles can read/write itself (besides roles).
 		{user: test.UserNoRoles, object: test.UserNoRoles, action: read, allow: true},
 		{user: test.UserNoRoles, object: test.UserNoRoles, action: write, allow: true},
 		{user: test.UserNoRoles, object: test.UserNoRoles, action: writeRole, allow: false},
 		{user: test.UserNoRoles, object: test.UserNoRoles, action: changePwd, allow: true},
 
-		{user: test.UserObserver, object: user, action: read, allow: true},
+		// Global observers cannot read/write users.
+		{user: test.UserObserver, object: user, action: read, allow: false},
 		{user: test.UserObserver, object: user, action: write, allow: false},
 		{user: test.UserObserver, object: user, action: writeRole, allow: false},
 		{user: test.UserObserver, object: user, action: changePwd, allow: false},
+		// Global observers cannot create users.
 		{user: test.UserObserver, object: newUser, action: write, allow: false},
+		// Global observers can read/write itself (besides roles).
 		{user: test.UserObserver, object: test.UserObserver, action: read, allow: true},
 		{user: test.UserObserver, object: test.UserObserver, action: write, allow: true},
 		{user: test.UserObserver, object: test.UserObserver, action: writeRole, allow: false},
 		{user: test.UserObserver, object: test.UserObserver, action: changePwd, allow: true},
 
-		// Team Admin can create/write/write role of any team user, but not change password
-		{user: teamAdmin, object: user, action: read, allow: true},
+		// Team admins cannot read/write global users.
+		{user: teamAdmin, object: user, action: read, allow: false},
 		{user: teamAdmin, object: user, action: write, allow: false},
 		{user: teamAdmin, object: user, action: writeRole, allow: false},
 		{user: teamAdmin, object: user, action: changePwd, allow: false},
+		// Team admins cannot create new global users.
 		{user: teamAdmin, object: newUser, action: write, allow: false},
+		// Team admins can read/write team users (except change their password).
 		{user: teamAdmin, object: teamObserver, action: read, allow: true},
 		{user: teamAdmin, object: teamObserver, action: write, allow: true},
 		{user: teamAdmin, object: teamObserver, action: writeRole, allow: true},
 		{user: teamAdmin, object: teamObserver, action: changePwd, allow: false},
+		// Team admins can add new users to the team.
 		{user: teamAdmin, object: newTeamUser, action: write, allow: true},
+		// Team admins can read/write itself.
 		{user: teamAdmin, object: teamAdmin, action: read, allow: true},
 		{user: teamAdmin, object: teamAdmin, action: write, allow: true},
 		{user: teamAdmin, object: teamAdmin, action: writeRole, allow: true},
@@ -622,25 +634,25 @@ func TestAuthorizeTeamPacks(t *testing.T) {
 		{
 			user: test.UserTeamMaintainerTeam1,
 			object: &fleet.Pack{
-				TeamIDs: []uint{1},
+				Type: ptr.String("team-1"),
 			},
 			action: read,
 			allow:  true,
 		},
-		// Team observer cannot read packs of the team.
+		// Team observer can read packs of the team.
 		{
 			user: test.UserTeamObserverTeam1TeamAdminTeam2,
 			object: &fleet.Pack{
-				TeamIDs: []uint{1},
+				Type: ptr.String("team-1"),
 			},
 			action: read,
-			allow:  false,
+			allow:  true,
 		},
 		// Team observer cannot write packs of the team.
 		{
 			user: test.UserTeamObserverTeam1TeamAdminTeam2,
 			object: &fleet.Pack{
-				TeamIDs: []uint{1},
+				Type: ptr.String("team-1"),
 			},
 			action: write,
 			allow:  false,
@@ -649,7 +661,7 @@ func TestAuthorizeTeamPacks(t *testing.T) {
 		{
 			user: test.UserTeamAdminTeam1,
 			object: &fleet.Pack{
-				TeamIDs: []uint{2},
+				Type: ptr.String("team-2"),
 			},
 			action: read,
 			allow:  false,
@@ -658,24 +670,24 @@ func TestAuthorizeTeamPacks(t *testing.T) {
 		{
 			user: test.UserTeamAdminTeam1,
 			object: &fleet.Pack{
-				TeamIDs: []uint{2},
+				Type: ptr.String("team-2"),
 			},
 			action: read,
 			allow:  false,
 		},
-		// Team maintainers can read global packs.
+		// Team maintainers cannot read global packs.
 		{
 			user:   test.UserTeamMaintainerTeam1,
 			object: &fleet.Pack{},
 			action: read,
-			allow:  true,
+			allow:  false,
 		},
-		// Team admins can read global packs.
+		// Team admins cannot read global packs.
 		{
 			user:   test.UserTeamAdminTeam1,
 			object: &fleet.Pack{},
 			action: read,
-			allow:  true,
+			allow:  false,
 		},
 		// Team admins cannot write global packs.
 		{
diff --git a/server/fleet/authz.go b/server/fleet/authz.go
index 01491e764eb8..f73967aced84 100644
--- a/server/fleet/authz.go
+++ b/server/fleet/authz.go
@@ -7,12 +7,26 @@ const (
 	ActionList = "list"
 	// ActionWrite refers to writing (CRUD operations) an entity.
 	ActionWrite = "write"
+
+	//
+	// User specific actions
+	//
+
 	// ActionWriteRole is a write to a user's global roles and teams.
+	//
+	// While the Write action allows setting the role on creation of a user, the
+	// ActionWriteRole action is required to modify an existing user's password.
 	ActionWriteRole = "write_role"
-	// ActionChangePassword is the permission to change a user's password. While
-	// the Write action allows setting the password on creation of a user, the
-	// ChangePassword action is required to modify an existing user's password.
+	// ActionChangePassword is the permission to change a user's password.
+	//
+	// While the Write action allows setting the password on creation of a user, the
+	// ActionChangePassword action is required to modify an existing user's password.
 	ActionChangePassword = "change_password"
+
+	//
+	// Query specific actions
+	//
+
 	// ActionRun is the action for running a live query.
 	ActionRun = "run"
 	// ActionRunNew is the action for running a new live query.
diff --git a/server/fleet/packs.go b/server/fleet/packs.go
index 014d53f8736a..286452e8bf45 100644
--- a/server/fleet/packs.go
+++ b/server/fleet/packs.go
@@ -2,6 +2,10 @@ package fleet
 
 import (
 	"errors"
+	"strconv"
+	"strings"
+
+	"github.com/fleetdm/fleet/v4/server/ptr"
 )
 
 type PackListOptions struct {
@@ -12,20 +16,65 @@ type PackListOptions struct {
 }
 
 // Pack is the structure which represents an osquery query pack.
+//
+// NOTE: A "team pack" is a special type of pack with Pack.Type="team-$TEAM_ID".
+// Such team packs hold the scheduled queries for a team. This is different from a
+// pack that has a team as target (Pack.Teams and Pack.TeamIDs fields).
 type Pack struct {
 	UpdateCreateTimestamps
-	ID          uint     `json:"id"`
-	Name        string   `json:"name"`
-	Description string   `json:"description,omitempty"`
-	Platform    string   `json:"platform,omitempty"`
-	Disabled    bool     `json:"disabled"`
-	Type        *string  `json:"type" db:"pack_type"`
-	Labels      []Target `json:"labels"`
-	LabelIDs    []uint   `json:"label_ids"`
-	Hosts       []Target `json:"hosts"`
-	HostIDs     []uint   `json:"host_ids"`
-	Teams       []Target `json:"teams"`
-	TeamIDs     []uint   `json:"team_ids"`
+	ID          uint   `json:"id"`
+	Name        string `json:"name"`
+	Description string `json:"description,omitempty"`
+	Platform    string `json:"platform,omitempty"`
+	Disabled    bool   `json:"disabled"`
+	// Type indicates the type of the pack:
+	//	- "global" is the type of the global pack.
+	//	- "team-$ID" is the type for team packs.
+	//	- nil is the type for a user created pack.
+	Type     *string  `json:"type" db:"pack_type"`
+	Labels   []Target `json:"labels"`
+	LabelIDs []uint   `json:"label_ids"`
+	Hosts    []Target `json:"hosts"`
+	HostIDs  []uint   `json:"host_ids"`
+	Teams    []Target `json:"teams"`
+	// TeamIDs holds the ID of the teams this pack should target.
+	TeamIDs []uint `json:"team_ids"`
+}
+
+// isTeamPack returns true if the pack is a pack specifically made for a team.
+func (p *Pack) isTeamPack() bool {
+	return p.Type != nil && strings.HasPrefix(*p.Type, "team-")
+}
+
+// isGlobalPack returns true if the pack is the global pack.
+func (p *Pack) isGlobalPack() bool {
+	return p.Type != nil && *p.Type == "global"
+}
+
+// TeamPack returns the team ID for a team's pack.
+// Returns (nil, nil) if the pack is not a team pack.
+func (p *Pack) teamPack() (*uint, error) {
+	if !p.isTeamPack() {
+		return nil, nil
+	}
+	t := strings.TrimPrefix(*p.Type, "team-")
+	teamID, err := strconv.ParseUint(t, 10, 64)
+	if err != nil {
+		return nil, err
+	}
+	return ptr.Uint(uint(teamID)), nil
+}
+
+// ExtraAuthz implements authz.ExtraAuthzer.
+func (p *Pack) ExtraAuthz() (map[string]interface{}, error) {
+	packTeamID, err := p.teamPack()
+	if err != nil {
+		return nil, err
+	}
+	return map[string]interface{}{
+		"pack_team_id":   packTeamID,
+		"is_global_pack": p.isGlobalPack(),
+	}, nil
 }
 
 // Verify verifies the pack's fields are valid.
diff --git a/server/fleet/software.go b/server/fleet/software.go
index 9479dfa13022..b6e7fbd7c3d8 100644
--- a/server/fleet/software.go
+++ b/server/fleet/software.go
@@ -43,6 +43,17 @@ func (Software) AuthzType() string {
 	return "software"
 }
 
+// AuthzSoftwareInventory is used for access controls on software inventory.
+type AuthzSoftwareInventory struct {
+	// TeamID is the ID of the team. A value of nil means global scope.
+	TeamID *uint `json:"team_id"`
+}
+
+// AuthzType implements authz.AuthzTyper.
+func (s *AuthzSoftwareInventory) AuthzType() string {
+	return "software_inventory"
+}
+
 type VulnerabilitiesSlice []SoftwareCVE
 
 // HostSoftware is the set of software installed on a specific host
diff --git a/server/service/activities_test.go b/server/service/activities_test.go
index a32aef06d01b..4cd9f094cd71 100644
--- a/server/service/activities_test.go
+++ b/server/service/activities_test.go
@@ -15,6 +15,9 @@ func TestListActivities(t *testing.T) {
 	ds := new(mock.Store)
 	svc := newTestService(t, ds, nil, nil)
 
+	globalUsers := []*fleet.User{test.UserAdmin, test.UserMaintainer, test.UserObserver}
+	teamUsers := []*fleet.User{test.UserTeamAdminTeam1, test.UserTeamMaintainerTeam1, test.UserTeamObserverTeam1}
+
 	ds.ListActivitiesFunc = func(ctx context.Context, opts fleet.ListOptions) ([]*fleet.Activity, error) {
 		return []*fleet.Activity{
 			{ID: 1},
@@ -22,15 +25,24 @@ func TestListActivities(t *testing.T) {
 		}, nil
 	}
 
-	// admin user
-	activities, err := svc.ListActivities(test.UserContext(test.UserAdmin), fleet.ListOptions{})
-	require.NoError(t, err)
-	require.Len(t, activities, 2)
+	// any global user can read activities
+	for _, u := range globalUsers {
+		activities, err := svc.ListActivities(test.UserContext(u), fleet.ListOptions{})
+		require.NoError(t, err)
+		require.Len(t, activities, 2)
+	}
+
+	// team users cannot read activities
+	for _, u := range teamUsers {
+		_, err := svc.ListActivities(test.UserContext(u), fleet.ListOptions{})
+		require.Error(t, err)
+		require.Contains(t, err.Error(), authz.ForbiddenErrorMessage)
+	}
 
-	// anyone can read activities
-	activities, err = svc.ListActivities(test.UserContext(test.UserNoRoles), fleet.ListOptions{})
-	require.NoError(t, err)
-	require.Len(t, activities, 2)
+	// user with no roles cannot read activities
+	_, err := svc.ListActivities(test.UserContext(test.UserNoRoles), fleet.ListOptions{})
+	require.Error(t, err)
+	require.Contains(t, err.Error(), authz.ForbiddenErrorMessage)
 
 	// no user in context
 	_, err = svc.ListActivities(context.Background(), fleet.ListOptions{})
diff --git a/server/service/endpoint_utils_test.go b/server/service/endpoint_utils_test.go
index 6ef852d30142..7cabebbd3cef 100644
--- a/server/service/endpoint_utils_test.go
+++ b/server/service/endpoint_utils_test.go
@@ -11,7 +11,6 @@ import (
 	"testing"
 	"time"
 
-	authz_ctx "github.com/fleetdm/fleet/v4/server/contexts/authz"
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/mock"
 	"github.com/fleetdm/fleet/v4/server/ptr"
@@ -294,15 +293,11 @@ func TestEndpointer(t *testing.T) {
 
 	e := newUserAuthenticatedEndpointer(svc, fleetAPIOptions, r, "v1", "2021-11")
 	nopHandler := func(ctx context.Context, request interface{}, svc fleet.Service) (interface{}, error) {
-		if authctx, ok := authz_ctx.FromContext(ctx); ok {
-			authctx.SetChecked()
-		}
+		setAuthCheckedOnPreAuthErr(ctx)
 		return "nop", nil
 	}
 	overrideHandler := func(ctx context.Context, request interface{}, svc fleet.Service) (interface{}, error) {
-		if authctx, ok := authz_ctx.FromContext(ctx); ok {
-			authctx.SetChecked()
-		}
+		setAuthCheckedOnPreAuthErr(ctx)
 		return "override", nil
 	}
 
diff --git a/server/service/global_schedule.go b/server/service/global_schedule.go
index afc6b77c2aa8..8a65793e9a30 100644
--- a/server/service/global_schedule.go
+++ b/server/service/global_schedule.go
@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/ptr"
@@ -36,7 +37,9 @@ func getGlobalScheduleEndpoint(ctx context.Context, request interface{}, svc fle
 }
 
 func (svc *Service) GetGlobalScheduledQueries(ctx context.Context, opts fleet.ListOptions) ([]*fleet.ScheduledQuery, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{}, fleet.ActionRead); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String("global"),
+	}, fleet.ActionRead); err != nil {
 		return nil, err
 	}
 
@@ -88,7 +91,9 @@ func globalScheduleQueryEndpoint(ctx context.Context, request interface{}, svc f
 }
 
 func (svc *Service) GlobalScheduleQuery(ctx context.Context, sq *fleet.ScheduledQuery) (*fleet.ScheduledQuery, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{}, fleet.ActionRead); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String("global"),
+	}, fleet.ActionRead); err != nil {
 		return nil, err
 	}
 
@@ -131,7 +136,9 @@ func modifyGlobalScheduleEndpoint(ctx context.Context, request interface{}, svc
 }
 
 func (svc *Service) ModifyGlobalScheduledQueries(ctx context.Context, id uint, query fleet.ScheduledQueryPayload) (*fleet.ScheduledQuery, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{}, fleet.ActionWrite); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String("global"),
+	}, fleet.ActionWrite); err != nil {
 		return nil, err
 	}
 
@@ -170,9 +177,23 @@ func deleteGlobalScheduleEndpoint(ctx context.Context, request interface{}, svc
 }
 
 func (svc *Service) DeleteGlobalScheduledQueries(ctx context.Context, id uint) error {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{}, fleet.ActionWrite); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String("global"),
+	}, fleet.ActionWrite); err != nil {
 		return err
 	}
 
+	globalPack, err := svc.ds.EnsureGlobalPack(ctx)
+	if err != nil {
+		return err
+	}
+	scheduledQuery, err := svc.ds.ScheduledQuery(ctx, id)
+	if err != nil {
+		return err
+	}
+	if scheduledQuery.PackID != globalPack.ID {
+		return fmt.Errorf("scheduled query %d is not global", id)
+	}
+
 	return svc.DeleteScheduledQuery(ctx, id)
 }
diff --git a/server/service/global_schedule_test.go b/server/service/global_schedule_test.go
index 655d41ec6280..024121389308 100644
--- a/server/service/global_schedule_test.go
+++ b/server/service/global_schedule_test.go
@@ -40,40 +40,40 @@ func TestGlobalScheduleAuth(t *testing.T) {
 		shouldFailRead  bool
 	}{
 		{
-			"global admin",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleAdmin)},
-			false,
-			false,
+			name:            "global admin",
+			user:            &fleet.User{GlobalRole: ptr.String(fleet.RoleAdmin)},
+			shouldFailWrite: false,
+			shouldFailRead:  false,
 		},
 		{
-			"global maintainer",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleMaintainer)},
-			false,
-			false,
+			name:            "global maintainer",
+			user:            &fleet.User{GlobalRole: ptr.String(fleet.RoleMaintainer)},
+			shouldFailWrite: false,
+			shouldFailRead:  false,
 		},
 		{
-			"global observer",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleObserver)},
-			true,
-			true,
+			name:            "global observer",
+			user:            &fleet.User{GlobalRole: ptr.String(fleet.RoleObserver)},
+			shouldFailWrite: true,
+			shouldFailRead:  false,
 		},
 		{
-			"team admin",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleAdmin}}},
-			true,
-			false,
+			name:            "team admin",
+			user:            &fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleAdmin}}},
+			shouldFailWrite: true,
+			shouldFailRead:  false,
 		},
 		{
-			"team maintainer",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}},
-			true,
-			false,
+			name:            "team maintainer",
+			user:            &fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}},
+			shouldFailWrite: true,
+			shouldFailRead:  false,
 		},
 		{
-			"team observer",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
-			true,
-			true,
+			name:            "team observer",
+			user:            &fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
+			shouldFailWrite: true,
+			shouldFailRead:  false,
 		},
 	}
 	for _, tt := range testCases {
diff --git a/server/service/hosts.go b/server/service/hosts.go
index 403b8758fb66..664dd00628fd 100644
--- a/server/service/hosts.go
+++ b/server/service/hosts.go
@@ -7,7 +7,6 @@ import (
 	"time"
 
 	"github.com/fleetdm/fleet/v4/server/contexts/authz"
-	authz_ctx "github.com/fleetdm/fleet/v4/server/contexts/authz"
 	"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
 	"github.com/fleetdm/fleet/v4/server/contexts/logging"
 	"github.com/fleetdm/fleet/v4/server/contexts/viewer"
@@ -275,7 +274,7 @@ func getHostEndpoint(ctx context.Context, request interface{}, svc fleet.Service
 }
 
 func (svc *Service) GetHost(ctx context.Context, id uint) (*fleet.HostDetail, error) {
-	alreadyAuthd := svc.authz.IsAuthenticatedWith(ctx, authz_ctx.AuthnDeviceToken)
+	alreadyAuthd := svc.authz.IsAuthenticatedWith(ctx, authz.AuthnDeviceToken)
 	if !alreadyAuthd {
 		// First ensure the user has access to list hosts, then check the specific
 		// host once team_id is loaded.
@@ -560,7 +559,7 @@ func refetchHostEndpoint(ctx context.Context, request interface{}, svc fleet.Ser
 }
 
 func (svc *Service) RefetchHost(ctx context.Context, id uint) error {
-	if !svc.authz.IsAuthenticatedWith(ctx, authz_ctx.AuthnDeviceToken) {
+	if !svc.authz.IsAuthenticatedWith(ctx, authz.AuthnDeviceToken) {
 		if err := svc.authz.Authorize(ctx, &fleet.Host{}, fleet.ActionList); err != nil {
 			return err
 		}
@@ -676,7 +675,7 @@ func listHostDeviceMappingEndpoint(ctx context.Context, request interface{}, svc
 }
 
 func (svc *Service) ListHostDeviceMapping(ctx context.Context, id uint) ([]*fleet.HostDeviceMapping, error) {
-	if !svc.authz.IsAuthenticatedWith(ctx, authz_ctx.AuthnDeviceToken) {
+	if !svc.authz.IsAuthenticatedWith(ctx, authz.AuthnDeviceToken) {
 		if err := svc.authz.Authorize(ctx, &fleet.Host{}, fleet.ActionList); err != nil {
 			return nil, err
 		}
@@ -720,7 +719,7 @@ func getMacadminsDataEndpoint(ctx context.Context, request interface{}, svc flee
 }
 
 func (svc *Service) MacadminsData(ctx context.Context, id uint) (*fleet.MacadminsData, error) {
-	if !svc.authz.IsAuthenticatedWith(ctx, authz_ctx.AuthnDeviceToken) {
+	if !svc.authz.IsAuthenticatedWith(ctx, authz.AuthnDeviceToken) {
 		if err := svc.authz.Authorize(ctx, &fleet.Host{}, fleet.ActionList); err != nil {
 			return nil, err
 		}
@@ -932,5 +931,4 @@ func (svc *Service) OSVersions(ctx context.Context, teamID *uint, platform *stri
 	}
 
 	return osVersions, nil
-
 }
diff --git a/server/service/scheduled_queries_test.go b/server/service/scheduled_queries_test.go
index ac73d7b73d7d..28153ce6dd42 100644
--- a/server/service/scheduled_queries_test.go
+++ b/server/service/scheduled_queries_test.go
@@ -43,40 +43,43 @@ func TestScheduledQueriesAuth(t *testing.T) {
 		shouldFailRead  bool
 	}{
 		{
-			"global admin",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleAdmin)},
-			false,
-			false,
+			name:            "global admin",
+			user:            &fleet.User{GlobalRole: ptr.String(fleet.RoleAdmin)},
+			shouldFailWrite: false,
+			shouldFailRead:  false,
 		},
 		{
-			"global maintainer",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleMaintainer)},
-			false,
-			false,
+			name:            "global maintainer",
+			user:            &fleet.User{GlobalRole: ptr.String(fleet.RoleMaintainer)},
+			shouldFailWrite: false,
+			shouldFailRead:  false,
 		},
 		{
-			"global observer",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleObserver)},
-			true,
-			true,
+			name:            "global observer",
+			user:            &fleet.User{GlobalRole: ptr.String(fleet.RoleObserver)},
+			shouldFailWrite: true,
+			shouldFailRead:  true,
 		},
+		// Team users cannot read or write scheduled queries using the below service APIs.
+		// Team users must use the "Team" endpoints (GetTeamScheduledQueries, TeamScheduleQuery,
+		// ModifyTeamScheduledQueries and DeleteTeamScheduledQueries).
 		{
-			"team admin",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleAdmin}}},
-			true,
-			false,
+			name:            "team admin",
+			user:            &fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleAdmin}}},
+			shouldFailWrite: true,
+			shouldFailRead:  true,
 		},
 		{
-			"team maintainer",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}},
-			true,
-			false,
+			name:            "team maintainer",
+			user:            &fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}},
+			shouldFailWrite: true,
+			shouldFailRead:  true,
 		},
 		{
-			"team observer",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
-			true,
-			true,
+			name:            "team observer",
+			user:            &fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
+			shouldFailWrite: true,
+			shouldFailRead:  true,
 		},
 	}
 	for _, tt := range testCases {
diff --git a/server/service/software.go b/server/service/software.go
index 845160f33d43..f8ae36023149 100644
--- a/server/service/software.go
+++ b/server/service/software.go
@@ -44,7 +44,9 @@ func listSoftwareEndpoint(ctx context.Context, request interface{}, svc fleet.Se
 }
 
 func (svc Service) ListSoftware(ctx context.Context, opt fleet.SoftwareListOptions) ([]fleet.Software, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Software{}, fleet.ActionRead); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.AuthzSoftwareInventory{
+		TeamID: opt.TeamID,
+	}, fleet.ActionRead); err != nil {
 		return nil, err
 	}
 
@@ -82,7 +84,9 @@ func countSoftwareEndpoint(ctx context.Context, request interface{}, svc fleet.S
 }
 
 func (svc Service) CountSoftware(ctx context.Context, opt fleet.SoftwareListOptions) (int, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Software{}, fleet.ActionRead); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.AuthzSoftwareInventory{
+		TeamID: opt.TeamID,
+	}, fleet.ActionRead); err != nil {
 		return 0, err
 	}
 
diff --git a/server/service/software_test.go b/server/service/software_test.go
index b3e3f49338b8..f5b390d30659 100644
--- a/server/service/software_test.go
+++ b/server/service/software_test.go
@@ -23,7 +23,11 @@ func TestService_ListSoftware(t *testing.T) {
 		return []fleet.Software{}, nil
 	}
 
-	user := &fleet.User{ID: 3, Email: "foo@bar.com", GlobalRole: ptr.String(fleet.RoleObserver)}
+	user := &fleet.User{
+		ID:         3,
+		Email:      "foo@bar.com",
+		GlobalRole: ptr.String(fleet.RoleAdmin),
+	}
 
 	svc := newTestService(t, ds, nil, nil)
 	ctx := context.Background()
@@ -48,3 +52,146 @@ func TestService_ListSoftware(t *testing.T) {
 	assert.Equal(t, fleet.ListOptions{PerPage: 11, Page: 2, OrderKey: "id", OrderDirection: fleet.OrderAscending}, calledWithOpt.ListOptions)
 	assert.True(t, calledWithOpt.WithHostCounts)
 }
+
+func TestServiceSoftwareInventoryAuth(t *testing.T) {
+	ds := new(mock.Store)
+
+	ds.ListSoftwareFunc = func(ctx context.Context, opt fleet.SoftwareListOptions) ([]fleet.Software, error) {
+		return []fleet.Software{}, nil
+	}
+	ds.CountSoftwareFunc = func(ctx context.Context, opt fleet.SoftwareListOptions) (int, error) {
+		return 0, nil
+	}
+	svc := newTestService(t, ds, nil, nil)
+
+	for _, tc := range []struct {
+		name                 string
+		user                 *fleet.User
+		shouldFailGlobalRead bool
+		shouldFailTeamRead   bool
+	}{
+		{
+			name: "global-admin",
+			user: &fleet.User{
+				ID:         1,
+				GlobalRole: ptr.String(fleet.RoleAdmin),
+			},
+			shouldFailGlobalRead: false,
+			shouldFailTeamRead:   false,
+		},
+		{
+			name: "global-maintainer",
+			user: &fleet.User{
+				ID:         1,
+				GlobalRole: ptr.String(fleet.RoleMaintainer),
+			},
+			shouldFailGlobalRead: false,
+			shouldFailTeamRead:   false,
+		},
+		{
+			name: "global-observer",
+			user: &fleet.User{
+				ID:         1,
+				GlobalRole: ptr.String(fleet.RoleObserver),
+			},
+			shouldFailGlobalRead: false,
+			shouldFailTeamRead:   false,
+		},
+		{
+			name: "team-admin-belongs-to-team",
+			user: &fleet.User{
+				ID: 1,
+				Teams: []fleet.UserTeam{{
+					Team: fleet.Team{ID: 1},
+					Role: fleet.RoleAdmin,
+				}},
+			},
+			shouldFailGlobalRead: true,
+			shouldFailTeamRead:   false,
+		},
+		{
+			name: "team-maintainer-belongs-to-team",
+			user: &fleet.User{
+				ID: 1,
+				Teams: []fleet.UserTeam{{
+					Team: fleet.Team{ID: 1},
+					Role: fleet.RoleMaintainer,
+				}},
+			},
+			shouldFailGlobalRead: true,
+			shouldFailTeamRead:   false,
+		},
+		{
+			name: "team-observer-belongs-to-team",
+			user: &fleet.User{
+				ID: 1,
+				Teams: []fleet.UserTeam{{
+					Team: fleet.Team{ID: 1},
+					Role: fleet.RoleObserver,
+				}},
+			},
+			shouldFailGlobalRead: true,
+			shouldFailTeamRead:   false,
+		},
+		{
+			name: "team-admin-does-not-belong-to-team",
+			user: &fleet.User{
+				ID: 1,
+				Teams: []fleet.UserTeam{{
+					Team: fleet.Team{ID: 2},
+					Role: fleet.RoleAdmin,
+				}},
+			},
+			shouldFailGlobalRead: true,
+			shouldFailTeamRead:   true,
+		},
+		{
+			name: "team-maintainer-does-not-belong-to-team",
+			user: &fleet.User{
+				ID: 1,
+				Teams: []fleet.UserTeam{{
+					Team: fleet.Team{ID: 2},
+					Role: fleet.RoleMaintainer,
+				}},
+			},
+			shouldFailGlobalRead: true,
+			shouldFailTeamRead:   true,
+		},
+		{
+			name: "team-observer-does-not-belong-to-team",
+			user: &fleet.User{
+				ID: 1,
+				Teams: []fleet.UserTeam{{
+					Team: fleet.Team{ID: 2},
+					Role: fleet.RoleObserver,
+				}},
+			},
+			shouldFailGlobalRead: true,
+			shouldFailTeamRead:   true,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			ctx := viewer.NewContext(context.Background(), viewer.Viewer{User: tc.user})
+
+			// List all software.
+			_, err := svc.ListSoftware(ctx, fleet.SoftwareListOptions{})
+			checkAuthErr(t, tc.shouldFailGlobalRead, err)
+
+			// Count all software.
+			_, err = svc.CountSoftware(ctx, fleet.SoftwareListOptions{})
+			checkAuthErr(t, tc.shouldFailGlobalRead, err)
+
+			// List software for a team.
+			_, err = svc.ListSoftware(ctx, fleet.SoftwareListOptions{
+				TeamID: ptr.Uint(1),
+			})
+			checkAuthErr(t, tc.shouldFailTeamRead, err)
+
+			// Count software for a team.
+			_, err = svc.CountSoftware(ctx, fleet.SoftwareListOptions{
+				TeamID: ptr.Uint(1),
+			})
+			checkAuthErr(t, tc.shouldFailTeamRead, err)
+		})
+	}
+}
diff --git a/server/service/team_schedule.go b/server/service/team_schedule.go
index 46de4c4ae90c..b281ac48e25c 100644
--- a/server/service/team_schedule.go
+++ b/server/service/team_schedule.go
@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"fmt"
 
 	"github.com/fleetdm/fleet/v4/server/fleet"
 	"github.com/fleetdm/fleet/v4/server/ptr"
@@ -36,7 +37,9 @@ func getTeamScheduleEndpoint(ctx context.Context, request interface{}, svc fleet
 }
 
 func (svc Service) GetTeamScheduledQueries(ctx context.Context, teamID uint, opts fleet.ListOptions) ([]*fleet.ScheduledQuery, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{TeamIDs: []uint{teamID}}, fleet.ActionRead); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String(fmt.Sprintf("team-%d", teamID)),
+	}, fleet.ActionRead); err != nil {
 		return nil, err
 	}
 
@@ -92,14 +95,15 @@ func teamScheduleQueryEndpoint(ctx context.Context, request interface{}, svc fle
 	if err != nil {
 		return teamScheduleQueryResponse{Err: err}, nil
 	}
-	_ = resp
 	return teamScheduleQueryResponse{
 		Scheduled: resp,
 	}, nil
 }
 
 func (svc Service) TeamScheduleQuery(ctx context.Context, teamID uint, q *fleet.ScheduledQuery) (*fleet.ScheduledQuery, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{TeamIDs: []uint{teamID}}, fleet.ActionWrite); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String(fmt.Sprintf("team-%d", teamID)),
+	}, fleet.ActionWrite); err != nil {
 		return nil, err
 	}
 
@@ -140,7 +144,9 @@ func modifyTeamScheduleEndpoint(ctx context.Context, request interface{}, svc fl
 }
 
 func (svc Service) ModifyTeamScheduledQueries(ctx context.Context, teamID uint, scheduledQueryID uint, query fleet.ScheduledQueryPayload) (*fleet.ScheduledQuery, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{TeamIDs: []uint{teamID}}, fleet.ActionWrite); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String(fmt.Sprintf("team-%d", teamID)),
+	}, fleet.ActionWrite); err != nil {
 		return nil, err
 	}
 
@@ -180,7 +186,9 @@ func deleteTeamScheduleEndpoint(ctx context.Context, request interface{}, svc fl
 }
 
 func (svc Service) DeleteTeamScheduledQueries(ctx context.Context, teamID uint, scheduledQueryID uint) error {
-	if err := svc.authz.Authorize(ctx, &fleet.Pack{TeamIDs: []uint{teamID}}, fleet.ActionWrite); err != nil {
+	if err := svc.authz.Authorize(ctx, &fleet.Pack{
+		Type: ptr.String(fmt.Sprintf("team-%d", teamID)),
+	}, fleet.ActionWrite); err != nil {
 		return err
 	}
 	return svc.ds.DeleteScheduledQuery(ctx, scheduledQueryID)
diff --git a/server/service/team_schedule_test.go b/server/service/team_schedule_test.go
index bf5e363a5706..9535a333ffdd 100644
--- a/server/service/team_schedule_test.go
+++ b/server/service/team_schedule_test.go
@@ -2,6 +2,7 @@ package service
 
 import (
 	"context"
+	"fmt"
 	"testing"
 
 	"github.com/fleetdm/fleet/v4/server/contexts/viewer"
@@ -15,7 +16,10 @@ func TestTeamScheduleAuth(t *testing.T) {
 	svc := newTestService(t, ds, nil, nil)
 
 	ds.EnsureTeamPackFunc = func(ctx context.Context, teamID uint) (*fleet.Pack, error) {
-		return &fleet.Pack{ID: 999}, nil
+		return &fleet.Pack{
+			ID:   999,
+			Type: ptr.String(fmt.Sprintf("team-%d", teamID)),
+		}, nil
 	}
 	ds.ListScheduledQueriesInPackWithStatsFunc = func(ctx context.Context, id uint, opts fleet.ListOptions) ([]*fleet.ScheduledQuery, error) {
 		return nil, nil
@@ -76,7 +80,7 @@ func TestTeamScheduleAuth(t *testing.T) {
 			"team observer, belongs to team",
 			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
 			true,
-			true,
+			false,
 		},
 		{
 			"team maintainer, DOES NOT belong to team",
diff --git a/server/service/users.go b/server/service/users.go
index 4533830409c0..3b61b4787c49 100644
--- a/server/service/users.go
+++ b/server/service/users.go
@@ -11,6 +11,7 @@ import (
 
 	"github.com/fleetdm/fleet/v4/server"
 	"github.com/fleetdm/fleet/v4/server/authz"
+	authz_ctx "github.com/fleetdm/fleet/v4/server/contexts/authz"
 	"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
 	"github.com/fleetdm/fleet/v4/server/contexts/viewer"
 	"github.com/fleetdm/fleet/v4/server/fleet"
@@ -140,7 +141,11 @@ func listUsersEndpoint(ctx context.Context, request interface{}, svc fleet.Servi
 }
 
 func (svc *Service) ListUsers(ctx context.Context, opt fleet.UserListOptions) ([]*fleet.User, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.User{}, fleet.ActionRead); err != nil {
+	user := &fleet.User{}
+	if opt.TeamID != 0 {
+		user.Teams = []fleet.UserTeam{{Team: fleet.Team{ID: opt.TeamID}}}
+	}
+	if err := svc.authz.Authorize(ctx, user, fleet.ActionRead); err != nil {
 		return nil, err
 	}
 
@@ -216,12 +221,27 @@ func getUserEndpoint(ctx context.Context, request interface{}, svc fleet.Service
 	return getUserResponse{User: user, AvailableTeams: availableTeams}, nil
 }
 
+// setAuthCheckedOnPreAuthErr can be used to set the authentication as checked
+// in case of errors that happened before an auth check can be performed.
+// Otherwise the endpoints return a "authentication skipped" error instead of
+// the actual returned error.
+func setAuthCheckedOnPreAuthErr(ctx context.Context) {
+	if az, ok := authz_ctx.FromContext(ctx); ok {
+		az.SetChecked()
+	}
+}
+
 func (svc *Service) User(ctx context.Context, id uint) (*fleet.User, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.User{ID: id}, fleet.ActionRead); err != nil {
-		return nil, err
+	user, err := svc.ds.UserByID(ctx, id)
+	if err != nil {
+		setAuthCheckedOnPreAuthErr(ctx)
+		return nil, ctxerr.Wrap(ctx, err)
 	}
 
-	return svc.ds.UserByID(ctx, id)
+	if err := svc.authz.Authorize(ctx, user, fleet.ActionRead); err != nil {
+		return nil, err
+	}
+	return user, nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -251,12 +271,9 @@ func modifyUserEndpoint(ctx context.Context, request interface{}, svc fleet.Serv
 }
 
 func (svc *Service) ModifyUser(ctx context.Context, userID uint, p fleet.UserPayload) (*fleet.User, error) {
-	if err := svc.authz.Authorize(ctx, &fleet.User{}, fleet.ActionRead); err != nil {
-		return nil, err
-	}
-
 	user, err := svc.User(ctx, userID)
 	if err != nil {
+		setAuthCheckedOnPreAuthErr(ctx)
 		return nil, err
 	}
 
@@ -326,7 +343,10 @@ func (svc *Service) ModifyUser(ctx context.Context, userID uint, p fleet.UserPay
 
 	if p.GlobalRole != nil && *p.GlobalRole != "" {
 		if currentUser.GlobalRole == nil {
-			return nil, ctxerr.New(ctx, "Cannot edit global role as a team member")
+			return nil, authz.ForbiddenWithInternal(
+				"cannot edit global role as a team member",
+				currentUser, user, fleet.ActionWriteRole,
+			)
 		}
 
 		if p.Teams != nil && len(*p.Teams) > 0 {
@@ -336,7 +356,10 @@ func (svc *Service) ModifyUser(ctx context.Context, userID uint, p fleet.UserPay
 		user.Teams = []fleet.UserTeam{}
 	} else if p.Teams != nil {
 		if !isAdminOfTheModifiedTeams(currentUser, user.Teams, *p.Teams) {
-			return nil, ctxerr.New(ctx, "Cannot modify teams in that way")
+			return nil, authz.ForbiddenWithInternal(
+				"cannot modify teams in that way",
+				currentUser, user, fleet.ActionWriteRole,
+			)
 		}
 		user.Teams = *p.Teams
 		user.GlobalRole = nil
@@ -379,10 +402,14 @@ func deleteUserEndpoint(ctx context.Context, request interface{}, svc fleet.Serv
 }
 
 func (svc *Service) DeleteUser(ctx context.Context, id uint) error {
-	if err := svc.authz.Authorize(ctx, &fleet.User{ID: id}, fleet.ActionWrite); err != nil {
+	user, err := svc.ds.UserByID(ctx, id)
+	if err != nil {
+		setAuthCheckedOnPreAuthErr(ctx)
+		return ctxerr.Wrap(ctx, err)
+	}
+	if err := svc.authz.Authorize(ctx, user, fleet.ActionWrite); err != nil {
 		return err
 	}
-
 	return svc.ds.DeleteUser(ctx, id)
 }
 
@@ -616,27 +643,42 @@ func (svc *Service) ChangeUserEmail(ctx context.Context, token string) (string,
 	return svc.ds.ConfirmPendingEmailChange(ctx, vc.UserID(), token)
 }
 
+// isAdminOfTheModifiedTeams checks whether the current user is allowed to modify the user
+// roles in the teams.
+//
+// TODO: End-goal is to move all this logic to policy.rego.
 func isAdminOfTheModifiedTeams(currentUser *fleet.User, originalUserTeams, newUserTeams []fleet.UserTeam) bool {
-	// If the user is of the right global role, then they can modify the teams
-	if currentUser.GlobalRole != nil && (*currentUser.GlobalRole == fleet.RoleAdmin || *currentUser.GlobalRole == fleet.RoleMaintainer) {
+	// Global admins can modify all user teams roles.
+	if currentUser.GlobalRole != nil && *currentUser.GlobalRole == fleet.RoleAdmin {
 		return true
 	}
 
-	// otherwise, gather the resulting teams
-	resultingTeams := make(map[uint]string)
+	// Otherwise, make a map of the original and resulting teams.
+	newTeams := make(map[uint]string)
 	for _, team := range newUserTeams {
-		resultingTeams[team.ID] = team.Role
+		newTeams[team.ID] = team.Role
+	}
+	originalTeams := make(map[uint]struct{})
+	for _, team := range originalUserTeams {
+		originalTeams[team.ID] = struct{}{}
 	}
 
-	// and see which ones were removed or changed from the original
+	// See which ones were removed or changed from the original.
 	teamsAffected := make(map[uint]struct{})
 	for _, team := range originalUserTeams {
-		if resultingTeams[team.ID] != team.Role {
+		if newTeams[team.ID] != team.Role {
+			teamsAffected[team.ID] = struct{}{}
+		}
+	}
+
+	// See which ones of the new are not in the original.
+	for _, team := range newUserTeams {
+		if _, ok := originalTeams[team.ID]; !ok {
 			teamsAffected[team.ID] = struct{}{}
 		}
 	}
 
-	// then gather the teams the current user is admin for
+	// Then gather the teams the current user is admin for.
 	currentUserTeamAdmin := make(map[uint]struct{})
 	for _, team := range currentUser.Teams {
 		if team.Role == fleet.RoleAdmin {
@@ -644,7 +686,8 @@ func isAdminOfTheModifiedTeams(currentUser *fleet.User, originalUserTeams, newUs
 		}
 	}
 
-	// and let's check that the teams that were either removed or changed are also teams this user is an admin of
+	// And finally, let's check that the teams that were either removed
+	// or changed are also teams this user is an admin of.
 	for teamID := range teamsAffected {
 		if _, ok := currentUserTeamAdmin[teamID]; !ok {
 			return false
diff --git a/server/service/users_test.go b/server/service/users_test.go
index c68aeda26574..b7597a008fdc 100644
--- a/server/service/users_test.go
+++ b/server/service/users_test.go
@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/fleetdm/fleet/v4/server/authz"
 	"github.com/fleetdm/fleet/v4/server/contexts/ctxerr"
 	"github.com/fleetdm/fleet/v4/server/contexts/viewer"
 	"github.com/fleetdm/fleet/v4/server/datastore/mysql"
@@ -41,18 +42,27 @@ func TestUserAuth(t *testing.T) {
 	ds.InviteByEmailFunc = func(ctx context.Context, email string) (*fleet.Invite, error) {
 		return nil, errors.New("AA")
 	}
+
+	userTeamMaintainerID := uint(999)
+	userGlobalMaintainerID := uint(888)
+	var self *fleet.User // to be set by tests
 	ds.UserByIDFunc = func(ctx context.Context, id uint) (*fleet.User, error) {
-		if id == 999 {
+		switch id {
+		case userTeamMaintainerID:
 			return &fleet.User{
-				ID:    999,
+				ID:    userTeamMaintainerID,
 				Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}},
 			}, nil
+		case userGlobalMaintainerID:
+			return &fleet.User{
+				ID:         userGlobalMaintainerID,
+				GlobalRole: ptr.String(fleet.RoleMaintainer),
+			}, nil
+		default:
+			return self, nil
 		}
-		return &fleet.User{
-			ID:         888,
-			GlobalRole: ptr.String(fleet.RoleMaintainer),
-		}, nil
 	}
+
 	ds.SaveUserFunc = func(ctx context.Context, user *fleet.User) error {
 		return nil
 	}
@@ -70,92 +80,277 @@ func TestUserAuth(t *testing.T) {
 	}
 
 	testCases := []struct {
-		name                  string
-		user                  *fleet.User
+		name string
+		user *fleet.User
+
 		shouldFailGlobalWrite bool
 		shouldFailTeamWrite   bool
-		shouldFailRead        bool
-		shouldFailDeleteReset bool
+
+		shouldFailWriteRoleGlobalToGlobal    bool
+		shouldFailWriteRoleGlobalToTeam      bool
+		shouldFailWriteRoleTeamToAnotherTeam bool
+		shouldFailWriteRoleTeamToGlobal      bool
+
+		shouldFailWriteRoleOwnDomain bool
+
+		shouldFailGlobalRead bool
+		shouldFailTeamRead   bool
+
+		shouldFailGlobalDelete bool
+		shouldFailTeamDelete   bool
+
+		shouldFailGlobalPasswordReset bool
+		shouldFailTeamPasswordReset   bool
+
+		shouldFailGlobalChangePassword bool
+		shouldFailTeamChangePassword   bool
+
+		shouldFailListAll  bool
+		shouldFailListTeam bool
 	}{
 		{
-			"global admin",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleAdmin)},
-			false,
-			false,
-			false,
-			false,
+			name:                                 "global admin",
+			user:                                 &fleet.User{ID: 1000, GlobalRole: ptr.String(fleet.RoleAdmin)},
+			shouldFailGlobalWrite:                false,
+			shouldFailTeamWrite:                  false,
+			shouldFailWriteRoleGlobalToGlobal:    false,
+			shouldFailWriteRoleGlobalToTeam:      false,
+			shouldFailWriteRoleTeamToAnotherTeam: false,
+			shouldFailWriteRoleTeamToGlobal:      false,
+			shouldFailWriteRoleOwnDomain:         false,
+			shouldFailGlobalRead:                 false,
+			shouldFailTeamRead:                   false,
+			shouldFailGlobalDelete:               false,
+			shouldFailTeamDelete:                 false,
+			shouldFailGlobalPasswordReset:        false,
+			shouldFailTeamPasswordReset:          false,
+			shouldFailGlobalChangePassword:       false,
+			shouldFailTeamChangePassword:         false,
+			shouldFailListAll:                    false,
+			shouldFailListTeam:                   false,
 		},
 		{
-			"global maintainer",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleMaintainer)},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "global maintainer",
+			user:                                 &fleet.User{ID: 1000, GlobalRole: ptr.String(fleet.RoleMaintainer)},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         true,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 		{
-			"global observer",
-			&fleet.User{GlobalRole: ptr.String(fleet.RoleObserver)},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "global observer",
+			user:                                 &fleet.User{ID: 1000, GlobalRole: ptr.String(fleet.RoleObserver)},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         true,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 		{
-			"team admin, belongs to team",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleAdmin}}},
-			true,
-			false,
-			false,
-			true,
+			name:                                 "team admin, belongs to team",
+			user:                                 &fleet.User{ID: 1000, Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleAdmin}}},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  false,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         false,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   false,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 false,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   false,
 		},
 		{
-			"team maintainer, belongs to team",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "team maintainer, belongs to team",
+			user:                                 &fleet.User{ID: 1000, Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         true,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 		{
-			"team observer, belongs to team",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "team observer, belongs to team",
+			user:                                 &fleet.User{ID: 1000, Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleObserver}}},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         true,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 		{
-			"team maintainer, DOES NOT belong to team",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleMaintainer}}},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "team maintainer, DOES NOT belong to team",
+			user:                                 &fleet.User{ID: 1000, Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleMaintainer}}},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         true,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 		{
-			"team admin, DOES NOT belong to team",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleAdmin}}},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "team admin, DOES NOT belong to team",
+			user:                                 &fleet.User{ID: 1000, Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleAdmin}}},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         false, // this is testing changing its own role in the team it belongs to.
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 		{
-			"team observer, DOES NOT belong to team",
-			&fleet.User{Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleObserver}}},
-			true,
-			true,
-			false,
-			true,
+			name:                                 "team observer, DOES NOT belong to team",
+			user:                                 &fleet.User{ID: 1000, Teams: []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleObserver}}},
+			shouldFailGlobalWrite:                true,
+			shouldFailTeamWrite:                  true,
+			shouldFailWriteRoleGlobalToGlobal:    true,
+			shouldFailWriteRoleGlobalToTeam:      true,
+			shouldFailWriteRoleTeamToAnotherTeam: true,
+			shouldFailWriteRoleTeamToGlobal:      true,
+			shouldFailWriteRoleOwnDomain:         true,
+			shouldFailGlobalRead:                 true,
+			shouldFailTeamRead:                   true,
+			shouldFailGlobalDelete:               true,
+			shouldFailTeamDelete:                 true,
+			shouldFailGlobalPasswordReset:        true,
+			shouldFailTeamPasswordReset:          true,
+			shouldFailGlobalChangePassword:       true,
+			shouldFailTeamChangePassword:         true,
+			shouldFailListAll:                    true,
+			shouldFailListTeam:                   true,
 		},
 	}
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
 			ctx := viewer.NewContext(context.Background(), viewer.Viewer{User: tt.user})
 
+			tt.user.SetPassword("p4ssw0rd.", 10, 10)
+
+			// To test a user reading/modifying itself.
+			u := *tt.user
+			self = &u
+
+			// A user can always read itself (read rego action).
+			_, err := svc.User(ctx, tt.user.ID)
+			require.NoError(t, err)
+
+			// A user can always write itself (write rego action).
+			_, err = svc.ModifyUser(ctx, tt.user.ID, fleet.UserPayload{Name: ptr.String("Foo")})
+			require.NoError(t, err)
+
+			// A user can always change its own password (change_password rego action).
+			_, err = svc.ModifyUser(ctx, tt.user.ID, fleet.UserPayload{Password: ptr.String("p4ssw0rd."), NewPassword: ptr.String("p4ssw0rd.3")})
+			require.NoError(t, err)
+
+			changeRole := func(role string) string {
+				switch role {
+				case fleet.RoleMaintainer:
+					return fleet.RoleAdmin // promote
+				case fleet.RoleAdmin:
+					return fleet.RoleMaintainer // demote
+				case fleet.RoleObserver:
+					return fleet.RoleAdmin // promote
+				default:
+					t.Fatalf("unknown role: %s", role)
+					return ""
+				}
+			}
+
+			// Test a user modifying its own role within its domain (write_role rego action).
+			if tt.user.GlobalRole != nil {
+				_, err = svc.ModifyUser(ctx, tt.user.ID, fleet.UserPayload{GlobalRole: ptr.String(changeRole(*tt.user.GlobalRole))})
+				checkAuthErr(t, tt.shouldFailWriteRoleOwnDomain, err)
+			} else { // Team user
+				ownTeamDifferentRole := []fleet.UserTeam{
+					{
+						Team: fleet.Team{ID: tt.user.Teams[0].ID},
+						Role: changeRole(tt.user.Teams[0].Role),
+					},
+				}
+				_, err = svc.ModifyUser(ctx, tt.user.ID, fleet.UserPayload{Teams: &ownTeamDifferentRole})
+				checkAuthErr(t, tt.shouldFailWriteRoleOwnDomain, err)
+			}
+
 			teams := []fleet.UserTeam{{Team: fleet.Team{ID: 1}, Role: fleet.RoleMaintainer}}
-			_, err := svc.CreateUser(ctx, fleet.UserPayload{
+			_, err = svc.CreateUser(ctx, fleet.UserPayload{
 				Name:     ptr.String("Some Name"),
 				Email:    ptr.String("some@email.com"),
 				Password: ptr.String("passw0rd."),
@@ -171,29 +366,54 @@ func TestUserAuth(t *testing.T) {
 			})
 			checkAuthErr(t, tt.shouldFailGlobalWrite, err)
 
-			_, err = svc.ModifyUser(ctx, 999, fleet.UserPayload{Teams: &teams})
+			_, err = svc.ModifyUser(ctx, userGlobalMaintainerID, fleet.UserPayload{Name: ptr.String("Foo")})
+			checkAuthErr(t, tt.shouldFailGlobalWrite, err)
+
+			_, err = svc.ModifyUser(ctx, userTeamMaintainerID, fleet.UserPayload{Name: ptr.String("Bar")})
 			checkAuthErr(t, tt.shouldFailTeamWrite, err)
 
-			_, err = svc.ModifyUser(ctx, 888, fleet.UserPayload{Teams: &teams})
-			checkAuthErr(t, tt.shouldFailGlobalWrite, err)
+			_, err = svc.ModifyUser(ctx, userGlobalMaintainerID, fleet.UserPayload{GlobalRole: ptr.String(fleet.RoleMaintainer)})
+			checkAuthErr(t, tt.shouldFailWriteRoleGlobalToGlobal, err)
 
-			_, err = svc.ModifyUser(ctx, 888, fleet.UserPayload{GlobalRole: ptr.String(fleet.RoleMaintainer)})
-			checkAuthErr(t, tt.shouldFailGlobalWrite, err)
+			_, err = svc.ModifyUser(ctx, userGlobalMaintainerID, fleet.UserPayload{Teams: &teams})
+			checkAuthErr(t, tt.shouldFailWriteRoleGlobalToTeam, err)
 
-			err = svc.DeleteUser(ctx, 999)
-			checkAuthErr(t, tt.shouldFailDeleteReset, err)
+			anotherTeams := []fleet.UserTeam{{Team: fleet.Team{ID: 2}, Role: fleet.RoleMaintainer}}
+			_, err = svc.ModifyUser(ctx, userTeamMaintainerID, fleet.UserPayload{Teams: &anotherTeams})
+			checkAuthErr(t, tt.shouldFailWriteRoleTeamToAnotherTeam, err)
 
-			_, err = svc.RequirePasswordReset(ctx, 999, false)
-			checkAuthErr(t, tt.shouldFailDeleteReset, err)
+			_, err = svc.ModifyUser(ctx, userTeamMaintainerID, fleet.UserPayload{GlobalRole: ptr.String(fleet.RoleMaintainer)})
+			checkAuthErr(t, tt.shouldFailWriteRoleTeamToGlobal, err)
 
-			_, err = svc.ListUsers(ctx, fleet.UserListOptions{})
-			checkAuthErr(t, tt.shouldFailRead, err)
+			_, err = svc.User(ctx, userGlobalMaintainerID)
+			checkAuthErr(t, tt.shouldFailGlobalRead, err)
+
+			_, err = svc.User(ctx, userTeamMaintainerID)
+			checkAuthErr(t, tt.shouldFailTeamRead, err)
+
+			err = svc.DeleteUser(ctx, userGlobalMaintainerID)
+			checkAuthErr(t, tt.shouldFailGlobalDelete, err)
+
+			err = svc.DeleteUser(ctx, userTeamMaintainerID)
+			checkAuthErr(t, tt.shouldFailTeamDelete, err)
+
+			_, err = svc.RequirePasswordReset(ctx, userGlobalMaintainerID, false)
+			checkAuthErr(t, tt.shouldFailGlobalPasswordReset, err)
 
-			_, err = svc.User(ctx, 999)
-			checkAuthErr(t, tt.shouldFailRead, err)
+			_, err = svc.RequirePasswordReset(ctx, userTeamMaintainerID, false)
+			checkAuthErr(t, tt.shouldFailTeamPasswordReset, err)
 
-			_, err = svc.User(ctx, 888)
-			checkAuthErr(t, tt.shouldFailRead, err)
+			_, err = svc.ModifyUser(ctx, userGlobalMaintainerID, fleet.UserPayload{NewPassword: ptr.String("passw0rd.2")})
+			checkAuthErr(t, tt.shouldFailGlobalChangePassword, err)
+
+			_, err = svc.ModifyUser(ctx, userTeamMaintainerID, fleet.UserPayload{NewPassword: ptr.String("passw0rd.2")})
+			checkAuthErr(t, tt.shouldFailTeamChangePassword, err)
+
+			_, err = svc.ListUsers(ctx, fleet.UserListOptions{})
+			checkAuthErr(t, tt.shouldFailListAll, err)
+
+			_, err = svc.ListUsers(ctx, fleet.UserListOptions{TeamID: 1})
+			checkAuthErr(t, tt.shouldFailListTeam, err)
 		})
 	}
 }
@@ -677,3 +897,406 @@ func TestAuthenticatedUser(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, user, admin1)
 }
+
+func TestIsAdminOfTheModifiedTeams(t *testing.T) {
+	type teamWithRole struct {
+		teamID uint
+		role   string
+	}
+	type roles struct {
+		global *string
+		teams  []teamWithRole
+	}
+	for _, tc := range []struct {
+		name string
+		// actionUserRoles are the roles of the user executing the role change action.
+		actionUserRoles roles
+		// targetUserOriginalTeams are the original teams the target user belongs to.
+		targetUserOriginalTeams []teamWithRole
+		// targetUserNewTeams are the new teams the target user will be added to.
+		targetUserNewTeams []teamWithRole
+
+		expected bool
+	}{
+		{
+			name: "global-admin-allmighty",
+			actionUserRoles: roles{
+				global: ptr.String(fleet.RoleAdmin),
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "global-maintainer-cannot-modify-team-users",
+			actionUserRoles: roles{
+				global: ptr.String(fleet.RoleMaintainer),
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleMaintainer,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-of-original-and-new",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleAdmin,
+					},
+					{
+						teamID: 2,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "team-admin-of-one-original-and-leave-other-team-unmodified",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleMaintainer,
+					},
+					{
+						teamID: 2,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleMaintainer,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleMaintainer,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleMaintainer,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "team-admin-of-original-only",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleAdmin,
+					},
+					{
+						teamID: 2,
+						role:   fleet.RoleMaintainer,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-of-new-only",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleObserver,
+					},
+					{
+						teamID: 2,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-but-new-another-team-observer",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleObserver,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-but-new-another-team-admin",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-but-original-another-team",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-but-change-role-another-team",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleMaintainer,
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "team-admin-of-one-original-only",
+			actionUserRoles: roles{
+				teams: []teamWithRole{
+					{
+						teamID: 1,
+						role:   fleet.RoleMaintainer,
+					},
+					{
+						teamID: 2,
+						role:   fleet.RoleAdmin,
+					},
+				},
+			},
+			targetUserOriginalTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleMaintainer,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleMaintainer,
+				},
+			},
+			targetUserNewTeams: []teamWithRole{
+				{
+					teamID: 1,
+					role:   fleet.RoleAdmin,
+				},
+				{
+					teamID: 2,
+					role:   fleet.RoleAdmin,
+				},
+			},
+			expected: false,
+		},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			userTeamsFn := func(twr []teamWithRole) []fleet.UserTeam {
+				var userTeams []fleet.UserTeam
+				for _, ot := range twr {
+					userTeams = append(userTeams, fleet.UserTeam{
+						Team: fleet.Team{ID: ot.teamID},
+						Role: ot.role,
+					})
+				}
+				return userTeams
+			}
+
+			actionUserTeams := userTeamsFn(tc.actionUserRoles.teams)
+			originalUserTeams := userTeamsFn(tc.targetUserOriginalTeams)
+			newUserTeams := userTeamsFn(tc.targetUserNewTeams)
+
+			result := isAdminOfTheModifiedTeams(
+				&fleet.User{
+					GlobalRole: tc.actionUserRoles.global,
+					Teams:      actionUserTeams,
+				},
+				originalUserTeams,
+				newUserTeams,
+			)
+			require.Equal(t, tc.expected, result)
+		})
+	}
+}
+
+// TestAdminAddRoleOtherTeam is an explicit test to check that
+// that an admin cannot add itself to another team.
+func TestTeamAdminAddRoleOtherTeam(t *testing.T) {
+	ds := new(mock.Store)
+	svc := newTestService(t, ds, nil, nil)
+
+	// adminTeam2 is a team admin of team with ID=2.
+	adminTeam2 := &fleet.User{
+		ID: 1,
+		Teams: []fleet.UserTeam{
+			{
+				Team: fleet.Team{ID: 2},
+				Role: fleet.RoleAdmin,
+			},
+		},
+	}
+
+	ds.UserByIDFunc = func(ctx context.Context, id uint) (*fleet.User, error) {
+		if id != 1 {
+			return nil, &notFoundError{}
+		}
+		return adminTeam2, nil
+	}
+	ds.SaveUserFunc = func(ctx context.Context, user *fleet.User) error {
+		return nil
+	}
+
+	ctx := viewer.NewContext(context.Background(), viewer.Viewer{User: adminTeam2})
+	adminTeam2.SetPassword("p4ssw0rd.", 10, 10)
+
+	// adminTeam2 tries to add itself to team with ID=3 as admin.
+	_, err := svc.ModifyUser(ctx, adminTeam2.ID, fleet.UserPayload{
+		Teams: &[]fleet.UserTeam{
+			{
+				Team: fleet.Team{ID: 2},
+				Role: fleet.RoleAdmin,
+			},
+			{
+				Team: fleet.Team{ID: 3},
+				Role: fleet.RoleAdmin,
+			},
+		},
+	})
+	require.Equal(t, (&authz.Forbidden{}).Error(), err.Error())
+	require.False(t, ds.SaveUserFuncInvoked)
+}",
"url": "https://github.com/fleetdm/fleet/commit/da171d3b8d149c30b8307723cbe6b6e8847cb30c.patch"
}
] |
CWE-284: Improper Access Control
|
CVE-2023-0795
|
LibTIFF 4.4.0 has an out-of-bounds read in tiffcrop in tools/tiffcrop.c:3488, allowing attackers to cause a denial-of-service via a crafted tiff file. For users that compile libtiff from sources, the fix is available with commit afaabc3e.
|
[
{
"commit_message": "[PATCH] tiffcrop: Amend rotateImage() not to toggle the input (main) image width and length parameters when only cropped image sections are rotated. Remove buffptr from region structure because never used. Closes #492 #493 #494 #495 #499 #518 #519 tools/tiffcrop.c | 59 ++++++++++++++++++++++++++++-------------------- 1 file changed, 35 insertions(+), 24 deletions(-)",
"patch_text_b64": "From 69818e2f2d246e6631ac2a2da692c3706b849c38 Mon Sep 17 00:00:00 2001
From: Su_Laus <sulau@freenet.de>
Date: Sun, 29 Jan 2023 11:09:26 +0100
Subject: [PATCH] tiffcrop: Amend rotateImage() not to toggle the input (main)
 image width and length parameters when only cropped image sections are
 rotated. Remove buffptr from region structure because never used.

Closes #492 #493 #494 #495 #499 #518 #519
---
 tools/tiffcrop.c | 59 ++++++++++++++++++++++++++++--------------------
 1 file changed, 35 insertions(+), 24 deletions(-)

diff --git a/tools/tiffcrop.c b/tools/tiffcrop.c
index ebea74759..519871ec5 100644
--- a/tools/tiffcrop.c
+++ b/tools/tiffcrop.c
@@ -296,7 +296,6 @@ struct region
     uint32_t width;    /* width in pixels */
     uint32_t length;   /* length in pixels */
     uint32_t buffsize; /* size of buffer needed to hold the cropped region */
-    unsigned char *buffptr; /* address of start of the region */
 };
 
 /* Cropping parameters from command line and image data
@@ -577,7 +576,7 @@ static int rotateContigSamples24bits(uint16_t, uint16_t, uint16_t, uint32_t,
 static int rotateContigSamples32bits(uint16_t, uint16_t, uint16_t, uint32_t,
                                      uint32_t, uint32_t, uint8_t *, uint8_t *);
 static int rotateImage(uint16_t, struct image_data *, uint32_t *, uint32_t *,
-                       unsigned char **, size_t *);
+                       unsigned char **, size_t *, int);
 static int mirrorImage(uint16_t, uint16_t, uint16_t, uint32_t, uint32_t,
                        unsigned char *);
 static int invertImage(uint16_t, uint16_t, uint16_t, uint32_t, uint32_t,
@@ -5782,7 +5781,6 @@ static void initCropMasks(struct crop_mask *cps)
         cps->regionlist[i].width = 0;
         cps->regionlist[i].length = 0;
         cps->regionlist[i].buffsize = 0;
-        cps->regionlist[i].buffptr = NULL;
         cps->zonelist[i].position = 0;
         cps->zonelist[i].total = 0;
     }
@@ -7266,9 +7264,13 @@ static int correct_orientation(struct image_data *image,
                       (uint16_t)(image->adjustments & ROTATE_ANY));
             return (-1);
         }
-
-        if (rotateImage(rotation, image, &image->width, &image->length,
-                        work_buff_ptr, NULL))
+        /* Dummy variable in order not to switch two times the
+         * image->width,->length within rotateImage(),
+         * but switch xres, yres there. */
+        uint32_t width = image->width;
+        uint32_t length = image->length;
+        if (rotateImage(rotation, image, &width, &length, work_buff_ptr, NULL,
+                        TRUE))
         {
             TIFFError("correct_orientation", "Unable to rotate image");
             return (-1);
@@ -7377,7 +7379,6 @@ static int extractCompositeRegions(struct image_data *image,
         /* These should not be needed for composite images */
         crop->regionlist[i].width = crop_width;
         crop->regionlist[i].length = crop_length;
-        crop->regionlist[i].buffptr = crop_buff;
 
         src_rowsize = ((img_width * bps * spp) + 7) / 8;
         dst_rowsize = (((crop_width * bps * count) + 7) / 8);
@@ -7640,7 +7641,6 @@ static int extractSeparateRegion(struct image_data *image,
 
     crop->regionlist[region].width = crop_width;
     crop->regionlist[region].length = crop_length;
-    crop->regionlist[region].buffptr = crop_buff;
 
     src = read_buff;
     dst = crop_buff;
@@ -8635,7 +8635,8 @@ static int processCropSelections(struct image_data *image,
              * accordingly. */
             size_t rot_buf_size = 0;
             if (rotateImage(crop->rotation, image, &crop->combined_width,
-                            &crop->combined_length, &crop_buff, &rot_buf_size))
+                            &crop->combined_length, &crop_buff, &rot_buf_size,
+                            FALSE))
             {
                 TIFFError("processCropSelections",
                           "Failed to rotate composite regions by %" PRIu32
@@ -8759,9 +8760,10 @@ static int processCropSelections(struct image_data *image,
                  * its size individually. Therefore, seg_buffs size  needs to be
                  * updated accordingly. */
                 size_t rot_buf_size = 0;
-                if (rotateImage(
-                        crop->rotation, image, &crop->regionlist[i].width,
-                        &crop->regionlist[i].length, &crop_buff, &rot_buf_size))
+                if (rotateImage(crop->rotation, image,
+                                &crop->regionlist[i].width,
+                                &crop->regionlist[i].length, &crop_buff,
+                                &rot_buf_size, FALSE))
                 {
                     TIFFError("processCropSelections",
                               "Failed to rotate crop region by %" PRIu16
@@ -8905,7 +8907,7 @@ static int createCroppedImage(struct image_data *image, struct crop_mask *crop,
         CROP_ROTATE) /* rotate should be last as it can reallocate the buffer */
     {
         if (rotateImage(crop->rotation, image, &crop->combined_width,
-                        &crop->combined_length, crop_buff_ptr, NULL))
+                        &crop->combined_length, crop_buff_ptr, NULL, TRUE))
         {
             TIFFError("createCroppedImage",
                       "Failed to rotate image or cropped selection by %" PRIu16
@@ -9621,7 +9623,8 @@ static int rotateContigSamples32bits(uint16_t rotation, uint16_t spp,
 /* Rotate an image by a multiple of 90 degrees clockwise */
 static int rotateImage(uint16_t rotation, struct image_data *image,
                        uint32_t *img_width, uint32_t *img_length,
-                       unsigned char **ibuff_ptr, size_t *rot_buf_size)
+                       unsigned char **ibuff_ptr, size_t *rot_buf_size,
+                       int rot_image_params)
 {
     int shift_width;
     uint32_t bytes_per_pixel, bytes_per_sample;
@@ -9869,11 +9872,15 @@ static int rotateImage(uint16_t rotation, struct image_data *image,
 
             *img_width = length;
             *img_length = width;
-            image->width = length;
-            image->length = width;
-            res_temp = image->xres;
-            image->xres = image->yres;
-            image->yres = res_temp;
+            /* Only toggle image parameters if whole input image is rotated. */
+            if (rot_image_params)
+            {
+                image->width = length;
+                image->length = width;
+                res_temp = image->xres;
+                image->xres = image->yres;
+                image->yres = res_temp;
+            }
             break;
 
         case 270:
@@ -9956,11 +9963,15 @@ static int rotateImage(uint16_t rotation, struct image_data *image,
 
             *img_width = length;
             *img_length = width;
-            image->width = length;
-            image->length = width;
-            res_temp = image->xres;
-            image->xres = image->yres;
-            image->yres = res_temp;
+            /* Only toggle image parameters if whole input image is rotated. */
+            if (rot_image_params)
+            {
+                image->width = length;
+                image->length = width;
+                res_temp = image->xres;
+                image->xres = image->yres;
+                image->yres = res_temp;
+            }
             break;
         default:
             break;
-- 
GitLab",
"url": "https://gitlab.com/libtiff/libtiff/-/commit/afaabc3e50d4e5d80a94143f7e3c997e7e410f68"
}
] |
Out-of-bounds read in libtiff
|
|
CVE-2019-25084
|
Hide Files on GitHub options.js addEventListener cross site scripting
|
A vulnerability, which was classified as problematic, has been found in Hide Files on GitHub up to 2.x. This issue affects the function addEventListener of the file extension/options.js. The manipulation leads to cross site scripting. The attack may be initiated remotely. Upgrading to version 3.0.0 is able to address this issue. The name of the patch is 9de0c57df81db1178e0e79431d462f6d9842742e. It is recommended to upgrade the affected component. The associated identifier of this vulnerability is VDB-216767.
|
[
{
"commit_message": "[PATCH] Avoid self-XSS (#73) extension/api.js | 17 +++++++++++++++++ extension/options.js | 6 +++--- 2 files changed, 20 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/sindresorhus/hide-files-on-github/commit/9de0c57df81db1178e0e79431d462f6d9842742e.patch"
}
] |
CWE-79 Cross Site Scripting
|
CVE-2023-23624
|
Discourse's exclude_tags param could leak which topics had a specific hidden tag
|
Discourse is an open-source discussion platform. Prior to version 3.0.1 on the `stable` branch and version 3.1.0.beta2 on the `beta` and `tests-passed` branches, someone can use the `exclude_tag param` to filter out topics and deduce which ones were using a specific hidden tag. This affects any Discourse site using hidden tags in public categories. This issue is patched in version 3.0.1 on the `stable` branch and version 3.1.0.beta2 on the `beta` and `tests-passed` branches. As a workaround, secure any categories that are using hidden tags, change any existing hidden tags to not include private data, or remove any hidden tags currently in use.
|
[
{
"commit_message": "[PATCH] SECURITY: Update to exclude tag topic filter (#20006) Ignores tags specified in exclude_tag topics param that a user does not have access to. Co-authored-by: Blake Erickson <[email protected]> lib/topic_query.rb | 19 +++++++++++-------- spec/lib/topic_query_spec.rb | 8 ++++++++ 2 files changed, 19 insertions(+), 8 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/discourse/discourse/commit/f55e0fe7910149c431861c18ce407d1be0d6091a.patch"
}
] |
CWE-200: Exposure of Sensitive Information to an Unauthorized Actor
|
CVE-2016-5771
|
spl_array.c in the SPL extension in PHP before 5.5.37 and 5.6.x before 5.6.23 improperly interacts with the unserialize implementation and garbage collection, which allows remote attackers to execute arbitrary code or cause a denial of service (use-after-free and application crash) via crafted serialized data.
|
[
{
"commit_message": "[PATCH] Fixed ##72433: Use After Free Vulnerability in PHP's GC algorithm and unserialize Zend/tests/gc_024.phpt | 2 +- ext/spl/spl_array.c | 11 ++++++++ ext/standard/tests/strings/bug72433.phpt | 32 ++++++++++++++++++++++++ 3 files changed, 44 insertions(+), 1 deletion(-) create mode 100644 ext/standard/tests/strings/bug72433.phpt",
"patch_text_b64": "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",
"url": "http://github.com/php/php-src/commit/3f627e580acfdaf0595ae3b115b8bec677f203ee.patch"
}
] |
n/a
|
|
CVE-2022-4414
|
Cross-site Scripting (XSS) - DOM in nuxt/framework
|
Cross-site Scripting (XSS) - DOM in GitHub repository nuxt/framework prior to v3.0.0-rc.13.
|
[
{
"commit_message": "[PATCH] fix(nuxt): ensure payload url has no protocol (#8675) packages/nuxt/src/app/composables/payload.ts | 11 +++++++---- 1 file changed, 7 insertions(+), 4 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/nuxt/framework/commit/19a2cd14929ca9b55720cb81f71687830a9e59a4.patch"
}
] |
CWE-79 Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
|
CVE-2016-1000005
|
mcrypt_get_block_size did not enforce that the provided "module" parameter was a string, leading to type confusion if other types of data were passed in. This issue affects HHVM versions prior to 3.9.5, all versions between 3.10.0 and 3.12.3 (inclusive), and all versions between 3.13.0 and 3.14.1 (inclusive).
|
[
{
"commit_message": "[PATCH] Fix param types for mcrypt_get_block_size() to match PHP Reviewed By: edwinsmith Differential Revision: D3447281 fbshipit-source-id: a88549307faad886f5a0f78d421aa28e08d21b1c hphp/runtime/ext/mcrypt/ext_mcrypt.cpp | 4 ++-- hphp/runtime/ext/mcrypt/ext_mcrypt.php | 2 +- hphp/test/slow/ext_mcrypt/ext_mcrypt.php | 1 + hphp/test/slow/ext_mcrypt/ext_mcrypt.php.expectf | 2 ++ 4 files changed, 6 insertions(+), 3 deletions(-)",
"patch_text_b64": "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",
"url": "https://github.com/facebook/hhvm/commit/39e7e177473350b3a5c34e8824af3b98e25efa89.patch"
}
] |
n/a
|
|
CVE-2018-8794
| "rdesktop versions up to and including v1.8.3 contain an Integer Overflow that leads to an Out-Of-Bo(...TRUNCATED)
| [{"commit_message":"[PATCH] Malicious RDP server security fixes This commit includes fixes for a set(...TRUNCATED)
|
CWE-680: Integer Overflow to Buffer Overflow
|
Description
This dataset, CIRCL/vulnerability-cwe-patch, provides structured real-world vulnerabilities enriched with CWE identifiers and actual patches from platforms like GitHub and GitLab. It was built to support the development of tools for vulnerability classification, triage, and automated repair. Each entry includes metadata such as CVE/GHSA ID, a description, CWE categorization, and links to verified patch commits with associated diff content and commit messages.
The dataset is automatically extracted using a pipeline that fetches vulnerability records from several sources, filters out entries without patches, and verifies patch links for accessibility. Extracted patches are fetched, encoded in base64, and stored alongside commit messages for training and evaluation of ML models. Source Data
The dataset comprises 16,123 vulnerabilities and 18,810 associated patches. For training, we consider only those patches corresponding to vulnerabilities annotated with at least one CWE.
How to use with datasets
>>> import json
>>> from datasets import load_dataset
>>> dataset = load_dataset("CIRCL/vulnerability-cwe-patch")
>>> vulnerabilities = ["CVE-2025-60249", "CVE-2025-32413"]
>>> filtered_entries = dataset.filter(lambda elem: elem["id"] in vulnerabilities)
>>> for entry in filtered_entries["train"]:
... print(entry["cwe"])
... for patch in entry["patches"]:
... print(f" {patch['commit_message']}")
...
CWE-79 Improper Neutralization of Input During Web Page Generation (XSS or 'Cross-site Scripting')
[PATCH] fix: [security] Fixed a stored XSS vulnerability in user bios. Thanks to Dawid Czarnecki for reporting the issue.
CWE-79 Improper Neutralization of Input During Web Page Generation (XSS or 'Cross-site Scripting')
[PATCH] fix: [security] sanitize user input in comments, bundles, and sightings - Escaped untrusted data in templates and tables to prevent XSS - Replaced unsafe innerHTML assignments with createElement/textContent - Encoded dynamic URLs using encodeURIComponent - Improved validation in Comment, Bundle, and Sighting models Credit: @Wachizungu
Schema
Each example contains:
- id: Vulnerability identifier (e.g., CVE-2023-XXXX, GHSA-XXXX)
- title: Human-readable title of the vulnerability
- description: Detailed vulnerability description
- patches: List of patch records, each with:
url: Verified patch URL (GitHub/GitLab)
patch_text_b64: Base64-encoded unified diff
commit_message: Associated commit message
- cwe: List of CWE identifiers and names
The vulnerabilities can be sourced from:
- NVD CVE List — enriched with commit references
- GitHub Security Advisories (GHSA)
- GitLab advisories
- CSAF feeds from vendors including Red Hat, Cisco, and CISA
Use Cases
The dataset supports a range of security-focused machine learning tasks:
* Vulnerability classification
* CWE prediction from descriptions
* Patch generation from natural language
* Commit message understanding
Associated Code
The dataset is generated with the extraction pipeline from vulnerability-lookup/ML-Gateway, which includes logic for fetching, filtering, validating, and encoding patch data.
- Downloads last month
- 178