Skip to content

Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.

test(e2e): cover project roles, conditions, deny rules and role validation

varonixd7839762e77c
diff --git a/tests/suites/secretmanager/permissions/builtin_role_test.go b/tests/suites/secretmanager/permissions/builtin_role_test.go
new file mode 100644
index 0000000000..808a79671f
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/builtin_role_test.go
@@ -0,0 +1,126 @@
+package permissions_test
+
+import (
+ "bytes"
+ "encoding/json"
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/stretchr/testify/require"
+)
+
+func TestBuiltInRole_SecretRoutes(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ // sweep calls every main secret route once as pr and returns each status by route.
+ sweep := func(t *testing.T, pr *harness.Principal, proj *fixture.Project) map[string]int {
+ t.Helper()
+ return map[string]int{
+ "list": listSecrets(t, pr, proj, "dev", "/", false).status,
+ "get": readSecret(t, pr, proj, "dev", "/", "API_KEY").StatusCode(),
+ "create": createSecret(t, pr, proj, "dev", "/", "NEW_KEY", "new").StatusCode(),
+ "update": updateSecret(t, pr, proj, "dev", "/", "API_KEY",
+ api.UpdateSecretV4JSONRequestBody{SecretValue: new("changed")}).StatusCode(),
+ "delete": deleteSecret(t, pr, proj, "dev", "/", "OLD_KEY").StatusCode(),
+ }
+ }
+
+ t.Run("should give a viewer names and values but no writes", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "value")
+ secretmanager.CreateSecret(t, proj, "dev", "OLD_KEY", "old")
+ viewer := proj.NewMachineIdentity(t, fixture.WithRoles("viewer"))
+
+ // Action
+ statuses := sweep(t, viewer, proj)
+
+ // Assert
+ require.Equal(t, map[string]int{
+ "list": http.StatusOK, "get": http.StatusOK,
+ "create": http.StatusForbidden, "update": http.StatusForbidden, "delete": http.StatusForbidden,
+ }, statuses)
+ require.Equal(t, "value", listSecrets(t, viewer, proj, "dev", "/", false).values["API_KEY"])
+ require.Equal(t, map[string]string{"API_KEY": "value", "OLD_KEY": "old"}, secretsAt(t, proj, "dev", "/"))
+ })
+
+ t.Run("should give a member full secret crud but no policy management", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "value")
+ secretmanager.CreateSecret(t, proj, "dev", "OLD_KEY", "old")
+ member := proj.NewUser(t, fixture.WithPrincipalName("member"))
+
+ // Action
+ statuses := sweep(t, member, proj)
+ policy := createApprovalPolicy(t, member, proj, tn.Admin)
+ role := createRole(t, member, proj, "member-made", allow("secrets", "describeSecret"))
+
+ // Assert
+ require.Equal(t, map[string]int{
+ "list": http.StatusOK, "get": http.StatusOK,
+ "create": http.StatusOK, "update": http.StatusOK, "delete": http.StatusOK,
+ }, statuses)
+ require.Equal(t, map[string]string{"API_KEY": "changed", "NEW_KEY": "new"}, secretsAt(t, proj, "dev", "/"))
+ require.Equalf(t, http.StatusForbidden, policy.StatusCode(), "creating a policy as a member: %s", apierr.Body(policy.Body))
+ require.Equalf(t, http.StatusForbidden, role.StatusCode(), "creating a role as a member: %s", apierr.Body(role.Body))
+ })
+
+ t.Run("should refuse no-access on every secrets route", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "value")
+ secretmanager.CreateSecret(t, proj, "dev", "OLD_KEY", "old")
+ outsider := proj.NewMachineIdentity(t, fixture.WithRoles("no-access"))
+
+ // Action
+ statuses := sweep(t, outsider, proj)
+
+ // Assert
+ require.Equal(t, map[string]int{
+ "list": http.StatusForbidden, "get": http.StatusForbidden,
+ "create": http.StatusForbidden, "update": http.StatusForbidden, "delete": http.StatusForbidden,
+ }, statuses)
+ require.Equal(t, map[string]string{"API_KEY": "value", "OLD_KEY": "old"}, secretsAt(t, proj, "dev", "/"))
+ })
+}
+
+func createApprovalPolicy(t *testing.T, actor *harness.Principal, proj *fixture.Project, approver *harness.Principal) *api.CreateSecretApprovalPolicyResponse {
+ t.Helper()
+ var item api.CreateSecretApprovalPolicyJSONBody_Approvers_Item
+ require.NoError(t, item.FromCreateSecretApprovalPolicyJSONBodyApprovers1(api.CreateSecretApprovalPolicyJSONBodyApprovers1{
+ Type: api.CreateSecretApprovalPolicyJSONBodyApprovers1TypeUser,
+ Id: new(approver.ID.String()),
+ }))
+ res, err := actor.API.CreateSecretApprovalPolicyWithResponse(t.Context(), api.CreateSecretApprovalPolicyJSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: new("dev"),
+ SecretPath: "/",
+ Approvals: new(float32(1)),
+ Approvers: []api.CreateSecretApprovalPolicyJSONBody_Approvers_Item{item},
+ })
+ require.NoError(t, err)
+ return res
+}
+
+func createRole(t *testing.T, actor *harness.Principal, proj *fixture.Project, slug string, permissions ...fixture.Permission) *api.CreateProjectRoleResponse {
+ t.Helper()
+ body, err := json.Marshal(map[string]any{"slug": slug, "name": slug, "permissions": permissions})
+ require.NoError(t, err)
+ res, err := actor.API.CreateProjectRoleWithBodyWithResponse(t.Context(), proj.ID, "application/json", bytes.NewReader(body))
+ require.NoError(t, err)
+ return res
+}
diff --git a/tests/suites/secretmanager/permissions/condition_test.go b/tests/suites/secretmanager/permissions/condition_test.go
new file mode 100644
index 0000000000..5d52098d67
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/condition_test.go
@@ -0,0 +1,200 @@
+package permissions_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRole_Conditions(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ // pathReader seeds one secret per path in dev and an identity whose role reads secrets
+ // under the condition.
+ pathReader := func(t *testing.T, condition map[string]any, paths ...string) (*fixture.Project, *harness.Principal) {
+ t.Helper()
+ proj := newProject(t, h.NewTenant(t))
+ for _, p := range paths {
+ if p != "/" {
+ secretmanager.CreateFolder(t, proj, "dev", p)
+ }
+ secretmanager.CreateSecret(t, proj, "dev", "KEY", "v", secretmanager.WithPath(p))
+ }
+ proj.NewRole(t, "conditional", allowWhere("secrets", condition, "read"))
+ return proj, proj.NewMachineIdentity(t, fixture.WithRoles("conditional"))
+ }
+
+ // readableAt is the paths whose list the reader is allowed.
+ readableAt := func(t *testing.T, reader *harness.Principal, proj *fixture.Project, paths ...string) []string {
+ t.Helper()
+ allowed := []string{}
+ for _, p := range paths {
+ got := listSecrets(t, reader, proj, "dev", p, false)
+ if got.status == http.StatusOK && got.values["KEY"] == "v" {
+ allowed = append(allowed, p)
+ }
+ }
+ return allowed
+ }
+
+ t.Run("should allow only the exact path when secretPath is a plain string", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ paths := []string{"/", "/a", "/a/b"}
+ proj, reader := pathReader(t, map[string]any{"secretPath": "/a"}, paths...)
+
+ // Action
+ allowed := readableAt(t, reader, proj, paths...)
+
+ // Assert
+ require.Equal(t, []string{"/a"}, allowed)
+ })
+
+ t.Run("should allow the folder itself and every descendant for a recursive glob", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ paths := []string{"/", "/a", "/a/b", "/a/b/c", "/ab"}
+ proj, reader := pathReader(t, map[string]any{"secretPath": map[string]any{"$glob": "/a/**"}}, paths...)
+
+ // Action
+ allowed := readableAt(t, reader, proj, paths...)
+
+ // Assert
+ require.Equal(t, []string{"/a", "/a/b", "/a/b/c"}, allowed)
+ })
+
+ t.Run("should allow only direct children for a single-level glob", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ paths := []string{"/a", "/a/b", "/a/b/c"}
+ proj, reader := pathReader(t, map[string]any{"secretPath": map[string]any{"$glob": "/a/*"}}, paths...)
+
+ // Action
+ allowed := readableAt(t, reader, proj, paths...)
+
+ // Assert
+ require.Equal(t, []string{"/a/b"}, allowed)
+ })
+
+ t.Run("should allow only the listed paths for $in", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ paths := []string{"/a", "/b", "/c"}
+ proj, reader := pathReader(t, map[string]any{"secretPath": map[string]any{"$in": []string{"/a", "/c"}}}, paths...)
+
+ // Action
+ allowed := readableAt(t, reader, proj, paths...)
+
+ // Assert
+ require.Equal(t, []string{"/a", "/c"}, allowed)
+ })
+
+ t.Run("should allow every path but the excluded one for $ne", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ paths := []string{"/a", "/b", "/c"}
+ proj, reader := pathReader(t, map[string]any{"secretPath": map[string]any{"$ne": "/b"}}, paths...)
+
+ // Action
+ allowed := readableAt(t, reader, proj, paths...)
+
+ // Assert
+ require.Equal(t, []string{"/a", "/c"}, allowed)
+ })
+
+ t.Run("should allow only the matching environments for environment $in and $glob", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ for _, env := range []string{"dev", "staging", "prod"} {
+ secretmanager.CreateSecret(t, proj, env, "KEY", env)
+ }
+ proj.NewRole(t, "env-in", allowWhere("secrets", map[string]any{
+ "environment": map[string]any{"$in": []string{"dev", "prod"}}}, "read"))
+ proj.NewRole(t, "env-glob", allowWhere("secrets", map[string]any{
+ "environment": map[string]any{"$glob": "st*"}}, "read"))
+ byIn := proj.NewMachineIdentity(t, fixture.WithRoles("env-in"))
+ byGlob := proj.NewMachineIdentity(t, fixture.WithRoles("env-glob"))
+
+ readable := func(pr *harness.Principal) []string {
+ envs := []string{}
+ for _, env := range []string{"dev", "staging", "prod"} {
+ if listSecrets(t, pr, proj, env, "/", false).values["KEY"] == env {
+ envs = append(envs, env)
+ }
+ }
+ return envs
+ }
+
+ // Action
+ inEnvs, globEnvs := readable(byIn), readable(byGlob)
+
+ // Assert
+ require.Equal(t, []string{"dev", "prod"}, inEnvs)
+ require.Equal(t, []string{"staging"}, globEnvs)
+ })
+
+ t.Run("should list only the names matching a secretName glob", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ for _, name := range []string{"DB_HOST", "DB_PASS", "API_KEY"} {
+ secretmanager.CreateSecret(t, proj, "dev", name, "v")
+ }
+ proj.NewRole(t, "db-reader", allowWhere("secrets", map[string]any{
+ "secretName": map[string]any{"$glob": "DB_*"}}, "read"))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("db-reader"))
+
+ // Action
+ got := listSecrets(t, reader, proj, "dev", "/", false)
+
+ // Assert
+ require.Equalf(t, http.StatusOK, got.status, "listing: %s", got.body)
+ require.ElementsMatch(t, []string{"DB_HOST", "DB_PASS"}, keysOf(got.values))
+ })
+
+ t.Run("should require every listed tag for $all and any of them for $in", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ red, blue := secretmanager.CreateTag(t, proj, "red"), secretmanager.CreateTag(t, proj, "blue")
+ tagged(t, proj, "RED_ONLY", red)
+ tagged(t, proj, "BOTH", red, blue)
+ proj.NewRole(t, "all-tags", allowWhere("secrets", map[string]any{
+ "secretTags": map[string]any{"$all": []string{"red", "blue"}}}, "read"))
+ proj.NewRole(t, "any-tag", allowWhere("secrets", map[string]any{
+ "secretTags": map[string]any{"$in": []string{"red", "blue"}}}, "read"))
+ needsAll := proj.NewMachineIdentity(t, fixture.WithRoles("all-tags"))
+ needsAny := proj.NewMachineIdentity(t, fixture.WithRoles("any-tag"))
+
+ // Action
+ withAll := listSecrets(t, needsAll, proj, "dev", "/", false)
+ withAny := listSecrets(t, needsAny, proj, "dev", "/", false)
+
+ // Assert
+ require.ElementsMatch(t, []string{"BOTH"}, keysOf(withAll.values))
+ require.ElementsMatch(t, []string{"RED_ONLY", "BOTH"}, keysOf(withAny.values))
+ })
+}
+
+func tagged(t *testing.T, proj *fixture.Project, name string, tagIDs ...string) {
+ t.Helper()
+ res, err := proj.Tenant().Admin.API.CreateSecretV4WithResponse(t.Context(), name,
+ api.CreateSecretV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev", SecretValue: "v", TagIds: &tagIDs})
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "creating %s: %s", name, res.Body)
+}
diff --git a/tests/suites/secretmanager/permissions/deny_test.go b/tests/suites/secretmanager/permissions/deny_test.go
new file mode 100644
index 0000000000..598ffe6e11
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/deny_test.go
@@ -0,0 +1,122 @@
+package permissions_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRole_DenyRules(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ readAll := allow("secrets", "read")
+
+ t.Run("should let a deny on an environment win over an allow from another role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "KEY", "dev-value")
+ secretmanager.CreateSecret(t, proj, "prod", "KEY", "prod-value")
+ proj.NewRole(t, "reads-all", readAll)
+ proj.NewRole(t, "no-prod", deny(allowWhere("secrets", map[string]any{"environment": "prod"}, "read")))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("reads-all", "no-prod"))
+
+ // Action
+ prod := listSecrets(t, reader, proj, "prod", "/", false)
+
+ // Assert
+ require.NotContains(t, prod.values, "KEY")
+ require.NotContains(t, string(prod.body), "prod-value")
+ require.Equal(t, "dev-value", listSecrets(t, reader, proj, "dev", "/", false).values["KEY"])
+ })
+
+ t.Run("should let a deny on a path win over an allow from another role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateFolder(t, proj, "dev", "/locked")
+ secretmanager.CreateSecret(t, proj, "dev", "OPEN", "open-value")
+ secretmanager.CreateSecret(t, proj, "dev", "LOCKED", "locked-value", secretmanager.WithPath("/locked"))
+ proj.NewRole(t, "reads-all", readAll)
+ proj.NewRole(t, "no-locked", deny(allowWhere("secrets", map[string]any{"secretPath": "/locked"}, "read")))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("reads-all", "no-locked"))
+
+ // Action
+ locked := listSecrets(t, reader, proj, "dev", "/locked", false)
+
+ // Assert
+ require.NotContains(t, locked.values, "LOCKED")
+ require.NotContains(t, string(locked.body), "locked-value")
+ require.Equal(t, "open-value", listSecrets(t, reader, proj, "dev", "/", false).values["OPEN"])
+ })
+
+ t.Run("should let a deny on a secret name win over an allow from another role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "OPEN", "open-value")
+ secretmanager.CreateSecret(t, proj, "dev", "TOP_SECRET", "hidden-value")
+ proj.NewRole(t, "reads-all", readAll)
+ proj.NewRole(t, "no-top-secret", deny(allowWhere("secrets", map[string]any{"secretName": "TOP_SECRET"}, "read")))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("reads-all", "no-top-secret"))
+
+ // Action
+ got := listSecrets(t, reader, proj, "dev", "/", false)
+
+ // Assert
+ require.Equalf(t, http.StatusOK, got.status, "listing: %s", got.body)
+ require.Equal(t, map[string]string{"OPEN": "open-value"}, got.values)
+ require.NotContains(t, string(got.body), "hidden-value")
+ })
+
+ t.Run("should let a deny from a group role win over an allow on the direct role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ secretmanager.CreateFolder(t, proj, "dev", "/locked")
+ secretmanager.CreateSecret(t, proj, "dev", "OPEN", "open-value")
+ secretmanager.CreateSecret(t, proj, "dev", "LOCKED", "locked-value", secretmanager.WithPath("/locked"))
+ proj.NewRole(t, "group-deny", deny(allowWhere("secrets", map[string]any{"secretPath": "/locked"},
+ "describeSecret", "readValue")))
+ member := proj.NewUser(t, fixture.WithPrincipalName("member"))
+ group := fixture.NewGroup(t, tn)
+ group.AddUser(t, member)
+ proj.GrantGroup(t, group, "group-deny")
+
+ // Action
+ locked := listSecrets(t, member, proj, "dev", "/locked", false)
+
+ // Assert
+ require.NotContains(t, locked.values, "LOCKED")
+ require.NotContains(t, string(locked.body), "locked-value")
+ require.Equal(t, "open-value", listSecrets(t, member, proj, "dev", "/", false).values["OPEN"])
+ })
+
+ t.Run("should refuse the list when one role allows the legacy read and another denies readValue", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+ proj.NewRole(t, "legacy-read", readAll)
+ proj.NewRole(t, "no-values", deny(allow("secrets", "readValue")))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("legacy-read", "no-values"))
+
+ // Action
+ got := listSecrets(t, reader, proj, "dev", "/", false)
+
+ // Assert
+ require.Equalf(t, http.StatusForbidden, got.status, "listing: %s", got.body)
+ require.NotContains(t, string(got.body), "plaintext")
+ })
+}
diff --git a/tests/suites/secretmanager/permissions/describe_test.go b/tests/suites/secretmanager/permissions/describe_test.go
new file mode 100644
index 0000000000..26d2c0f33f
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/describe_test.go
@@ -0,0 +1,124 @@
+package permissions_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRole_DescribeOnly(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ describeOnly := allow("secrets", "describeSecret")
+
+ t.Run("should refuse the whole list with values for a describe-only role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+ proj.NewRole(t, "describer", describeOnly)
+ describer := proj.NewMachineIdentity(t, fixture.WithRoles("describer"))
+
+ // Action
+ got := listSecrets(t, describer, proj, "dev", "/", false)
+
+ // Assert
+ require.Equalf(t, http.StatusForbidden, got.status, "listing: %s", got.body)
+ require.NotContains(t, string(got.body), "plaintext")
+ })
+
+ t.Run("should list a describe-only role's secrets on the dashboard with the values masked", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+ proj.NewRole(t, "describer", describeOnly, allow("secret-imports", "read"))
+ describer := proj.NewUser(t, fixture.WithRoles("describer"))
+
+ // Action
+ res, err := describer.API.ListProjectSecretsDetailsWithResponse(t.Context(),
+ &api.ListProjectSecretsDetailsParams{ProjectId: proj.ID, Environment: "dev"})
+
+ // Assert
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "dashboard listing returned %d: %s", res.StatusCode(), res.Body)
+ require.NotNil(t, res.JSON200.Secrets)
+ require.Len(t, *res.JSON200.Secrets, 1)
+ require.Equal(t, "API_KEY", (*res.JSON200.Secrets)[0].SecretKey)
+ require.True(t, (*res.JSON200.Secrets)[0].SecretValueHidden)
+ require.NotContains(t, string(res.Body), "plaintext")
+ })
+
+ t.Run("should silently leave out subfolder secrets without read-value from a recursive list", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateFolder(t, proj, "dev", "/sub")
+ secretmanager.CreateSecret(t, proj, "dev", "ROOT_KEY", "root-value")
+ secretmanager.CreateSecret(t, proj, "dev", "SUB_KEY", "sub-value", secretmanager.WithPath("/sub"))
+ proj.NewRole(t, "root-values", describeOnly, allowWhere("secrets", map[string]any{"secretPath": "/"}, "readValue"))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("root-values"))
+
+ // Action
+ got := listSecrets(t, reader, proj, "dev", "/", true)
+
+ // Assert
+ require.Equalf(t, http.StatusOK, got.status, "listing recursively: %s", got.body)
+ require.Equal(t, map[string]string{"ROOT_KEY": "root-value"}, got.values)
+ require.Equal(t, http.StatusForbidden, listSecrets(t, reader, proj, "dev", "/sub", false).status,
+ "the same secret refuses the list when its own folder is the one requested")
+ })
+
+ t.Run("should refuse get-by-name with the value and return it hidden without", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+ proj.NewRole(t, "describer", describeOnly)
+ describer := proj.NewMachineIdentity(t, fixture.WithRoles("describer"))
+
+ // Action
+ withValue := readSecret(t, describer, proj, "dev", "/", "API_KEY")
+ withoutValue, err := describer.API.GetSecretByNameV4WithResponse(t.Context(), "API_KEY", &api.GetSecretByNameV4Params{
+ ProjectId: proj.ID,
+ Environment: new("dev"),
+ ViewSecretValue: new(api.GetSecretByNameV4ParamsViewSecretValueFalse),
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, withValue.StatusCode(), "reading with the value: %s", withValue.Body)
+ require.NotContains(t, string(withValue.Body), "plaintext")
+ require.NotNilf(t, withoutValue.JSON200, "reading without the value returned %d: %s", withoutValue.StatusCode(), withoutValue.Body)
+ require.True(t, withoutValue.JSON200.Secret.SecretValueHidden)
+ require.NotContains(t, string(withoutValue.Body), "plaintext")
+ })
+
+ t.Run("should refuse get-by-id for a describe-only role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ created := secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+ proj.NewRole(t, "describer", describeOnly)
+ describer := proj.NewMachineIdentity(t, fixture.WithRoles("describer"))
+
+ // Action
+ res, err := describer.API.GetSecretByIdV4WithResponse(t.Context(), created.ID)
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "reading by id: %s", res.Body)
+ require.NotContains(t, string(res.Body), "plaintext")
+ })
+}
diff --git a/tests/suites/secretmanager/permissions/error_test.go b/tests/suites/secretmanager/permissions/error_test.go
new file mode 100644
index 0000000000..5e859dd5b7
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/error_test.go
@@ -0,0 +1,53 @@
+package permissions_test
+
+import (
+ "fmt"
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestProjectPermission_Errors(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should name the project in the not-a-member refusal", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "plaintext")
+ outsider := tn.NewMachineIdentity(t)
+
+ // Action
+ got := listSecrets(t, outsider, proj, "dev", "/", false)
+
+ // Assert
+ require.Equalf(t, http.StatusForbidden, got.status, "listing as a non-member: %s", got.body)
+ require.Contains(t, string(got.body), fmt.Sprintf(
+ "You are not a member of this project with ID %s. Please assign this identity to the project with the appropriate permissions, then try again.",
+ proj.ID))
+ require.NotContains(t, string(got.body), "plaintext")
+ })
+
+ t.Run("should refuse a secret-manager operation on a cert-manager project, naming the type", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := fixture.NewProject(t, tn, fixture.WithProjectType("cert-manager"))
+
+ // Action
+ res := createSecret(t, tn.Admin, proj, "dev", "/", "API_KEY", "value")
+
+ // Assert
+ require.Equalf(t, http.StatusBadRequest, res.StatusCode(), "creating a secret: %s", res.Body)
+ require.Equal(t, "The project is of type cert-manager. Operations of type secret-manager are not allowed.",
+ res.JSON400.Message)
+ })
+}
diff --git a/tests/suites/secretmanager/permissions/helpers_test.go b/tests/suites/secretmanager/permissions/helpers_test.go
new file mode 100644
index 0000000000..1b8ee92ce8
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/helpers_test.go
@@ -0,0 +1,120 @@
+package permissions_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/stretchr/testify/require"
+)
+
+func newProject(t *testing.T, tn *harness.Tenant) *fixture.Project {
+ t.Helper()
+ return fixture.NewProject(t, tn, fixture.WithProjectType("secret-manager"))
+}
+
+func allow(subject string, actions ...string) fixture.Permission {
+ return fixture.Permission{Subject: subject, Action: actions}
+}
+
+func allowWhere(subject string, conditions map[string]any, actions ...string) fixture.Permission {
+ return fixture.Permission{Subject: subject, Action: actions, Conditions: conditions}
+}
+
+func deny(p fixture.Permission) fixture.Permission {
+ p.Inverted = true
+ return p
+}
+
+// listing is one v4 list: its status and, on success, each secret's value by key.
+type listing struct {
+ status int
+ body []byte
+ values map[string]string
+ hidden map[string]bool
+}
+
+func listSecrets(t *testing.T, pr *harness.Principal, proj *fixture.Project, env, secretPath string, recursive bool) listing {
+ t.Helper()
+ params := &api.ListSecretsV4Params{
+ ProjectId: &proj.ID,
+ Environment: &env,
+ SecretPath: &secretPath,
+ ViewSecretValue: new(api.ListSecretsV4ParamsViewSecretValueTrue),
+ }
+ if recursive {
+ params.Recursive = new(api.ListSecretsV4ParamsRecursiveTrue)
+ }
+ res, err := pr.API.ListSecretsV4WithResponse(t.Context(), params)
+ require.NoError(t, err)
+ out := listing{status: res.StatusCode(), body: res.Body, values: map[string]string{}, hidden: map[string]bool{}}
+ if res.JSON200 != nil {
+ for _, s := range res.JSON200.Secrets {
+ out.values[s.SecretKey] = s.SecretValue
+ out.hidden[s.SecretKey] = s.SecretValueHidden
+ }
+ }
+ return out
+}
+
+func readSecret(t *testing.T, pr *harness.Principal, proj *fixture.Project, env, secretPath, name string) *api.GetSecretByNameV4Response {
+ t.Helper()
+ res, err := pr.API.GetSecretByNameV4WithResponse(t.Context(), name, &api.GetSecretByNameV4Params{
+ ProjectId: proj.ID,
+ Environment: &env,
+ SecretPath: &secretPath,
+ ViewSecretValue: new(api.GetSecretByNameV4ParamsViewSecretValueTrue),
+ })
+ require.NoError(t, err)
+ return res
+}
+
+func createSecret(t *testing.T, pr *harness.Principal, proj *fixture.Project, env, secretPath, name, value string) *api.CreateSecretV4Response {
+ t.Helper()
+ res, err := pr.API.CreateSecretV4WithResponse(t.Context(), name, api.CreateSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: env,
+ SecretPath: &secretPath,
+ SecretValue: value,
+ })
+ require.NoError(t, err)
+ return res
+}
+
+func updateSecret(t *testing.T, pr *harness.Principal, proj *fixture.Project, env, secretPath, name string, body api.UpdateSecretV4JSONRequestBody) *api.UpdateSecretV4Response {
+ t.Helper()
+ body.ProjectId, body.Environment, body.SecretPath = proj.ID, env, &secretPath
+ res, err := pr.API.UpdateSecretV4WithResponse(t.Context(), name, body)
+ require.NoError(t, err)
+ return res
+}
+
+func deleteSecret(t *testing.T, pr *harness.Principal, proj *fixture.Project, env, secretPath, name string) *api.DeleteSecretV4Response {
+ t.Helper()
+ res, err := pr.API.DeleteSecretV4WithResponse(t.Context(), name, api.DeleteSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ Environment: env,
+ SecretPath: &secretPath,
+ })
+ require.NoError(t, err)
+ return res
+}
+
+// secretsAt is what the administrator sees in one folder, by key.
+func secretsAt(t *testing.T, proj *fixture.Project, env, secretPath string) map[string]string {
+ t.Helper()
+ got := listSecrets(t, proj.Tenant().Admin, proj, env, secretPath, false)
+ require.Equalf(t, http.StatusOK, got.status, "listing %s:%s as the admin: %s", env, secretPath, apierr.Body(got.body))
+ return got.values
+}
+
+func keysOf(values map[string]string) []string {
+ keys := make([]string, 0, len(values))
+ for k := range values {
+ keys = append(keys, k)
+ }
+ return keys
+}
diff --git a/tests/suites/secretmanager/permissions/main_test.go b/tests/suites/secretmanager/permissions/main_test.go
new file mode 100644
index 0000000000..35487c6de1
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/main_test.go
@@ -0,0 +1,9 @@
+package permissions_test
+
+import (
+ "testing"
+
+ "github.com/Infisical/infisical/tests/harness"
+)
+
+func TestMain(m *testing.M) { harness.Main(m, harness.Shared) }
diff --git a/tests/suites/secretmanager/permissions/move_test.go b/tests/suites/secretmanager/permissions/move_test.go
new file mode 100644
index 0000000000..59364295d4
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/move_test.go
@@ -0,0 +1,96 @@
+package permissions_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/google/uuid"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRole_MoveAndDuplicate(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ everything := allow("secrets", "describeSecret", "readValue", "create", "edit", "delete")
+
+ t.Run("should refuse a move and move nothing for each missing grant", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ missing := map[string]fixture.Permission{
+ "create at the destination": deny(allowWhere("secrets", map[string]any{"environment": "prod"}, "create")),
+ "edit at the destination": deny(allowWhere("secrets", map[string]any{"environment": "prod"}, "edit")),
+ "delete at the source": deny(allowWhere("secrets", map[string]any{"environment": "dev"}, "delete")),
+ "read-value at the source": deny(allowWhere("secrets", map[string]any{"environment": "dev"}, "readValue")),
+ "describe at the source": deny(allowWhere("secrets", map[string]any{"environment": "dev"}, "describeSecret")),
+ "control: every grant present": allow("secrets", "describeSecret"),
+ }
+ type attempt struct {
+ proj *fixture.Project
+ secret secretmanager.Secret
+ movedBy *harness.Principal
+ }
+ attempts := map[string]attempt{}
+ for name, rule := range missing {
+ proj := newProject(t, tn)
+ secret := secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "value")
+ proj.NewRole(t, "mover", everything, rule)
+ attempts[name] = attempt{proj: proj, secret: secret, movedBy: proj.NewMachineIdentity(t, fixture.WithRoles("mover"))}
+ }
+
+ // Action
+ statuses := map[string]int{}
+ for name, a := range attempts {
+ res, err := a.movedBy.API.MoveSecretsV4WithResponse(t.Context(), api.MoveSecretsV4JSONRequestBody{
+ ProjectId: a.proj.ID,
+ SourceEnvironment: "dev",
+ DestinationEnvironment: "prod",
+ SecretIds: []string{a.secret.ID},
+ })
+ require.NoError(t, err)
+ statuses[name] = res.StatusCode()
+ }
+
+ // Assert
+ for name, a := range attempts {
+ if name == "control: every grant present" {
+ require.Equal(t, http.StatusOK, statuses[name], name)
+ continue
+ }
+ require.Equal(t, http.StatusForbidden, statuses[name], "missing %s", name)
+ require.Equal(t, map[string]string{"API_KEY": "value"}, secretsAt(t, a.proj, "dev", "/"), "missing %s", name)
+ require.Empty(t, secretsAt(t, a.proj, "prod", "/"), "missing %s", name)
+ }
+ })
+
+ t.Run("should refuse a duplicate into an environment the actor cannot write", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ source := secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "value")
+ proj.NewRole(t, "dev-writer",
+ allowWhere("secrets", map[string]any{"environment": "dev"}, "describeSecret", "readValue", "create", "edit"),
+ allowWhere("secrets", map[string]any{"environment": "prod"}, "describeSecret", "readValue"))
+ writer := proj.NewMachineIdentity(t, fixture.WithRoles("dev-writer"))
+
+ // Action
+ res, err := writer.API.DuplicateSecretV4WithResponse(t.Context(), api.DuplicateSecretV4JSONRequestBody{
+ ProjectId: proj.ID,
+ SourceEnvironment: "dev",
+ DestinationEnvironment: "prod",
+ SecretIds: []uuid.UUID{uuid.MustParse(source.ID)},
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "duplicating: %s", res.Body)
+ require.Empty(t, secretsAt(t, proj, "prod", "/"))
+ })
+}
diff --git a/tests/suites/secretmanager/permissions/role_test.go b/tests/suites/secretmanager/permissions/role_test.go
new file mode 100644
index 0000000000..694f8591e5
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/role_test.go
@@ -0,0 +1,228 @@
+package permissions_test
+
+import (
+ "bytes"
+ "encoding/json"
+ "net/http"
+ "strings"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/fakes/license"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/Infisical/infisical/tests/internal/spec"
+ "github.com/stretchr/testify/require"
+)
+
+func TestProjectRole_Validation(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ // refused creates a role as the administrator, requires the status, checks the role
+ // was not stored, and returns the body for the message.
+ refused := func(t *testing.T, proj *fixture.Project, status int, slug string, permissions ...fixture.Permission) string {
+ t.Helper()
+ res := createRole(t, proj.Tenant().Admin, proj, slug, permissions...)
+ require.Equalf(t, status, res.StatusCode(), "creating role %s: %s", slug, apierr.Body(res.Body))
+ require.NotContains(t, roleSlugs(t, proj.Tenant().Admin, proj.ID), slug)
+ return string(res.Body)
+ }
+
+ t.Run("should refuse read combined with read value or describe secret", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+
+ // Action
+ body := refused(t, proj, http.StatusBadRequest, "mixed", allow("secrets", "read", "readValue"))
+
+ // Assert
+ require.Contains(t, body, "You have selected Read, and Read Value. You cannot select Read Value or Describe Secret if you "+
+ "have selected Read. The Read permission is a legacy action which has been replaced by Describe Secret and Read Value.")
+ })
+
+ t.Run("should refuse a condition the action does not allow", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+
+ // Action
+ body := refused(t, proj, http.StatusBadRequest, "bad-condition",
+ allowWhere("identity", map[string]any{"identityId": "00000000-0000-0000-0000-000000000000"}, "create"))
+
+ // Assert
+ require.Contains(t, body, `Condition \"identityId\" is not allowed for action \"create\" on subject \"identity\"`)
+ })
+
+ t.Run("should refuse a secret path condition without a leading slash", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+
+ // Action
+ body := refused(t, proj, http.StatusUnprocessableEntity, "no-slash",
+ allowWhere("secrets", map[string]any{"secretPath": "app"}, "read"))
+
+ // Assert
+ require.Contains(t, body, "Invalid Secret Path; it must start with a '/'")
+ })
+
+ t.Run("should refuse a glob the matcher cannot parse", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ spec.Why(t, `picomatch accepts nearly any pattern; the one input it refuses to parse is one
+ longer than its 64 KiB limit, so that is the only way to reach "Invalid glob pattern".`)
+ tooLong := "/" + strings.Repeat("a", 64*1024+1)
+
+ // Action
+ body := refused(t, proj, http.StatusUnprocessableEntity, "bad-glob",
+ allowWhere("secrets", map[string]any{"secretPath": map[string]any{"$glob": tooLong}}, "read"))
+
+ // Assert
+ require.Contains(t, body, "Invalid glob pattern")
+ })
+
+ t.Run("should refuse a duplicate slug and keep the first role", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ proj.NewRole(t, "reader", allow("secrets", "read"))
+
+ // Action
+ res := createRole(t, proj.Tenant().Admin, proj, "reader", allow("secrets", "describeSecret", "create"))
+
+ // Assert
+ require.Equalf(t, http.StatusBadRequest, res.StatusCode(), "creating a duplicate: %s", apierr.Body(res.Body))
+ require.Equal(t, "Role with reader already exists", res.JSON400.Message)
+ require.Equal(t, 1, countSlug(roleSlugs(t, proj.Tenant().Admin, proj.ID), "reader"))
+ })
+
+ t.Run("should refuse deleting a role in use with a message that names identities even when a user holds it", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ role := createRole(t, proj.Tenant().Admin, proj, "held", allow("secrets", "read"))
+ require.NotNil(t, role.JSON200)
+ proj.NewUser(t, fixture.WithPrincipalName("holder"), fixture.WithRoles("held"))
+
+ // Action
+ res, err := proj.Tenant().Admin.API.DeleteProjectRoleWithResponse(t.Context(), proj.ID, role.JSON200.Role.Id.String())
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusBadRequest, res.StatusCode(), "deleting a role in use: %s", apierr.Body(res.Body))
+ require.Equal(t, "Role is assigned to 1 identity membership. Re-assign membership role to delete this role.",
+ res.JSON400.Message)
+ require.Contains(t, roleSlugs(t, proj.Tenant().Admin, proj.ID), "held")
+ })
+}
+
+func TestProjectRole_License(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ withoutRBAC := license.Enterprise().Without(license.RBAC)
+
+ t.Run("should refuse a custom role create when the plan does not include rbac", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t, harness.WithPlan(withoutRBAC))
+ proj := newProject(t, tn)
+
+ // Action
+ res := createRole(t, tn.Admin, proj, "reader", allow("secrets", "read"))
+
+ // Assert
+ require.Equalf(t, http.StatusBadRequest, res.StatusCode(), "creating a role: %s", apierr.Body(res.Body))
+ require.Equal(t, "Failed to create custom role due to plan RBAC restriction. Upgrade to Infisical Enterprise plan to create custom roles.",
+ res.JSON400.Message)
+ require.NotContains(t, roleSlugs(t, tn.Admin, proj.ID), "reader")
+ })
+
+ t.Run("should refuse a custom role update when the plan does not include rbac", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ role := createRole(t, tn.Admin, proj, "reader", allow("secrets", "read"))
+ require.NotNil(t, role.JSON200)
+ tn.SetPlan(t, withoutRBAC)
+ body, err := json.Marshal(map[string]any{"name": "renamed"})
+ require.NoError(t, err)
+
+ // Action
+ res, err := tn.Admin.API.UpdateProjectRoleWithBodyWithResponse(t.Context(), proj.ID, role.JSON200.Role.Id.String(),
+ "application/json", bytes.NewReader(body))
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusBadRequest, res.StatusCode(), "updating a role: %s", apierr.Body(res.Body))
+ require.Equal(t, "Failed to update custom role due to plan RBAC restriction. Upgrade to Infisical Enterprise plan to update custom roles.",
+ res.JSON400.Message)
+ got, err := tn.Admin.API.GetProjectRoleBySlugWithResponse(t.Context(), proj.ID, "reader")
+ require.NoError(t, err)
+ require.NotNil(t, got.JSON200)
+ require.Equal(t, "reader", got.JSON200.Role.Name)
+ })
+
+ t.Run("should keep an assigned custom role working after a downgrade", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "value")
+ proj.NewRole(t, "reader", allow("secrets", "read"))
+ reader := proj.NewMachineIdentity(t, fixture.WithRoles("reader"))
+ tn.SetPlan(t, withoutRBAC)
+
+ // Action
+ got := listSecrets(t, reader, proj, "dev", "/", false)
+
+ // Assert
+ require.Equalf(t, http.StatusOK, got.status, "listing after the downgrade: %s", got.body)
+ require.Equal(t, map[string]string{"API_KEY": "value"}, got.values)
+ })
+
+ t.Run("should still list and delete custom roles after a downgrade", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ role := createRole(t, tn.Admin, proj, "reader", allow("secrets", "read"))
+ require.NotNil(t, role.JSON200)
+ tn.SetPlan(t, withoutRBAC)
+
+ // Action
+ listed := roleSlugs(t, tn.Admin, proj.ID)
+ res, err := tn.Admin.API.DeleteProjectRoleWithResponse(t.Context(), proj.ID, role.JSON200.Role.Id.String())
+
+ // Assert
+ require.NoError(t, err)
+ require.Contains(t, listed, "reader")
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "deleting after the downgrade: %s", apierr.Body(res.Body))
+ require.NotContains(t, roleSlugs(t, tn.Admin, proj.ID), "reader")
+ })
+}
+
+func countSlug(slugs []string, slug string) int {
+ n := 0
+ for _, s := range slugs {
+ if s == slug {
+ n++
+ }
+ }
+ return n
+}
diff --git a/tests/suites/secretmanager/permissions/subject_test.go b/tests/suites/secretmanager/permissions/subject_test.go
new file mode 100644
index 0000000000..357187d724
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/subject_test.go
@@ -0,0 +1,279 @@
+package permissions_test
+
+import (
+ "bytes"
+ "encoding/json"
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/google/uuid"
+ "github.com/stretchr/testify/require"
+)
+
+// The built-in viewer reads every subject below and writes none of them, so each
+// subtest is a write the viewer is refused.
+func TestViewer_OtherSubjects(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ viewerOf := func(t *testing.T) (*fixture.Project, *harness.Principal) {
+ t.Helper()
+ proj := newProject(t, h.NewTenant(t))
+ return proj, proj.NewMachineIdentity(t, fixture.WithRoles("viewer"))
+ }
+
+ t.Run("should refuse a viewer creating a folder", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+
+ // Action
+ res, err := viewer.API.CreateSecretFolderWithResponse(t.Context(), api.CreateSecretFolderJSONRequestBody{
+ ProjectId: proj.ID, Environment: "dev", Name: "app",
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "creating a folder: %s", res.Body)
+ folders, err := proj.Tenant().Admin.API.ListSecretFoldersWithResponse(t.Context(),
+ &api.ListSecretFoldersParams{ProjectId: proj.ID, Environment: "dev", Path: "/"})
+ require.NoError(t, err)
+ require.NotNil(t, folders.JSON200)
+ require.Empty(t, folders.JSON200.Folders)
+ })
+
+ t.Run("should refuse a viewer creating an import", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+ body := api.CreateSecretImportJSONRequestBody{ProjectId: proj.ID, Environment: "dev"}
+ body.Import.Environment, body.Import.Path = "prod", "/"
+
+ // Action
+ res, err := viewer.API.CreateSecretImportWithResponse(t.Context(), body)
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "creating an import: %s", res.Body)
+ imports, err := proj.Tenant().Admin.API.ListSecretImportsWithResponse(t.Context(),
+ &api.ListSecretImportsParams{ProjectId: proj.ID, Environment: "dev"})
+ require.NoError(t, err)
+ require.NotNil(t, imports.JSON200)
+ require.Empty(t, imports.JSON200.SecretImports)
+ })
+
+ t.Run("should refuse a viewer creating a tag", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+
+ // Action
+ res, err := viewer.API.CreateSecretTagWithResponse(t.Context(), proj.ID,
+ api.CreateSecretTagJSONRequestBody{Slug: "viewer-tag", Color: "#2563eb"})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "creating a tag: %s", res.Body)
+ tags, err := proj.Tenant().Admin.API.ListSecretTagsWithResponse(t.Context(), proj.ID)
+ require.NoError(t, err)
+ require.NotNil(t, tags.JSON200)
+ require.Empty(t, tags.JSON200.Tags)
+ })
+
+ t.Run("should refuse a viewer creating an environment", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+
+ // Action
+ res, err := viewer.API.CreateEnvironmentWithResponse(t.Context(), proj.ID,
+ api.CreateEnvironmentJSONRequestBody{Name: "QA", Slug: "qa"})
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "creating an environment: %s", res.Body)
+ got, err := proj.Tenant().Admin.API.GetProjectByIdWithResponse(t.Context(), proj.ID)
+ require.NoError(t, err)
+ require.NotNil(t, got.JSON200)
+ slugs := []string{}
+ for _, env := range got.JSON200.Project.Environments {
+ slugs = append(slugs, env.Slug)
+ }
+ require.ElementsMatch(t, proj.Environments, slugs)
+ })
+
+ t.Run("should refuse a viewer creating a webhook", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+
+ // Action
+ res, err := viewer.API.CreateWebhookWithResponse(t.Context(), api.CreateWebhookJSONRequestBody{
+ ProjectId: proj.ID, Environment: "dev", WebhookUrl: "https://hooks.example.com/infisical",
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "creating a webhook: %s", res.Body)
+ hooks, err := proj.Tenant().Admin.API.ListWebhooksWithResponse(t.Context(), &api.ListWebhooksParams{ProjectId: proj.ID})
+ require.NoError(t, err)
+ require.NotNil(t, hooks.JSON200)
+ require.Empty(t, hooks.JSON200.Webhooks)
+ })
+
+ t.Run("should refuse a viewer rolling back a commit", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "first")
+ secretmanager.UpdateSecret(t, proj, "dev", "API_KEY", "second")
+ first := oldestCommit(t, proj)
+
+ // Action
+ res, err := viewer.API.RollbackFolderCommitWithResponse(t.Context(), first.CommitId, api.RollbackFolderCommitJSONRequestBody{
+ ProjectId: proj.ID, Environment: "dev", FolderId: first.FolderId,
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "rolling back: %s", res.Body)
+ require.Equal(t, map[string]string{"API_KEY": "second"}, secretsAt(t, proj, "dev", "/"))
+ })
+
+ t.Run("should refuse a viewer leasing a dynamic secret", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+ newTOTPDynamicSecret(t, proj, "otp")
+
+ // Action
+ res, err := viewer.API.CreateDynamicSecretLeaseWithResponse(t.Context(), api.CreateDynamicSecretLeaseJSONRequestBody{
+ ProjectSlug: proj.Slug, EnvironmentSlug: "dev", DynamicSecretName: "otp",
+ })
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "leasing: %s", res.Body)
+ leases, err := proj.Tenant().Admin.API.ListDynamicSecretLeasesWithResponse(t.Context(), "otp",
+ &api.ListDynamicSecretLeasesParams{ProjectSlug: proj.Slug, EnvironmentSlug: "dev"})
+ require.NoError(t, err)
+ require.NotNilf(t, leases.JSON200, "listing leases returned %d: %s", leases.StatusCode(), leases.Body)
+ require.Empty(t, leases.JSON200.Leases)
+ })
+
+ t.Run("should refuse a viewer triggering a secret sync", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+ syncID := newRepoSync(t, proj)
+
+ // Action
+ res, err := viewer.API.SyncGitHubSecretSyncWithResponse(t.Context(), syncID)
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "triggering the sync: %s", res.Body)
+ got, err := proj.Tenant().Admin.API.GetGitHubSecretSyncWithResponse(t.Context(), syncID)
+ require.NoError(t, err)
+ require.NotNil(t, got.JSON200)
+ require.Nil(t, got.JSON200.SecretSync.LastSyncJobId)
+ })
+
+ t.Run("should refuse a viewer creating a secret rotation", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj, viewer := viewerOf(t)
+ body, err := json.Marshal(map[string]any{
+ "name": "rotation",
+ "projectId": proj.ID,
+ "environment": "dev",
+ "secretPath": "/",
+ "connectionId": uuid.NewString(),
+ "rotationInterval": 30,
+ "parameters": map[string]any{"username1": "app_a", "username2": "app_b"},
+ "secretsMapping": map[string]any{"username": "DB_USER", "password": "DB_PASS"},
+ })
+ require.NoError(t, err)
+
+ // Action
+ res, err := viewer.API.CreatePostgreSQLCredentialsRotationWithBodyWithResponse(t.Context(),
+ "application/json", bytes.NewReader(body))
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "creating a rotation: %s", res.Body)
+ require.Empty(t, secretsAt(t, proj, "dev", "/"))
+ })
+}
+
+type commit struct {
+ CommitId string
+ FolderId string
+}
+
+func oldestCommit(t *testing.T, proj *fixture.Project) commit {
+ t.Helper()
+ res, err := proj.Tenant().Admin.API.ListFolderCommitsWithResponse(t.Context(), &api.ListFolderCommitsParams{
+ ProjectId: proj.ID, Environment: "dev", Path: new("/"),
+ })
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "listing commits returned %d: %s", res.StatusCode(), apierr.Body(res.Body))
+ require.NotEmpty(t, res.JSON200.Commits)
+ oldest := res.JSON200.Commits[len(res.JSON200.Commits)-1]
+ return commit{CommitId: oldest.Id, FolderId: oldest.FolderId}
+}
+
+func newTOTPDynamicSecret(t *testing.T, proj *fixture.Project, name string) {
+ t.Helper()
+ body, err := json.Marshal(map[string]any{
+ "projectSlug": proj.Slug,
+ "environmentSlug": "dev",
+ "name": name,
+ "defaultTTL": "1h",
+ "provider": map[string]any{
+ "type": "totp",
+ "inputs": map[string]any{"configType": "manual", "secret": "JBSWY3DPEHPK3PXP"},
+ },
+ })
+ require.NoError(t, err)
+ res, err := proj.Tenant().Admin.API.CreateDynamicSecretWithBodyWithResponse(t.Context(), "application/json", bytes.NewReader(body))
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "creating dynamic secret %s: %s", name, apierr.Body(res.Body))
+}
+
+// newRepoSync creates a sync with auto-sync off, so nothing runs until it is triggered.
+func newRepoSync(t *testing.T, proj *fixture.Project) uuid.UUID {
+ t.Helper()
+ conn := fixture.NewAppConnection(t, proj.Tenant(), fixture.GitHubPATAppConnection)
+ var dest api.CreateGitHubSecretSyncJSONBody_DestinationConfig
+ require.NoError(t, dest.FromCreateGitHubSecretSyncJSONBodyDestinationConfig1(
+ api.CreateGitHubSecretSyncJSONBodyDestinationConfig1{Owner: "acme", Repo: "app", Scope: "repository"}))
+ body := api.CreateGitHubSecretSyncJSONRequestBody{
+ Name: "sync-" + uuid.NewString()[:8],
+ ProjectId: proj.ID,
+ ConnectionId: conn.ID,
+ Environment: "dev",
+ SecretPath: "/",
+ DestinationConfig: dest,
+ IsAutoSyncEnabled: new(false),
+ }
+ body.SyncOptions.InitialSyncBehavior = "overwrite-destination"
+ res, err := proj.Tenant().Admin.API.CreateGitHubSecretSyncWithResponse(t.Context(), body)
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "creating a sync returned %d: %s", res.StatusCode(), apierr.Body(res.Body))
+ return res.JSON200.SecretSync.Id
+}
diff --git a/tests/suites/secretmanager/permissions/template_test.go b/tests/suites/secretmanager/permissions/template_test.go
new file mode 100644
index 0000000000..94e43658df
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/template_test.go
@@ -0,0 +1,98 @@
+package permissions_test
+
+import (
+ "net/http"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/Infisical/infisical/tests/internal/apierr"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRole_IdentityTemplating(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should scope a machine identity by its metadata in the secret path", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ tn := h.NewTenant(t)
+ proj := newProject(t, tn)
+ for _, team := range []string{"backend", "frontend"} {
+ secretmanager.CreateFolder(t, proj, "dev", "/"+team)
+ secretmanager.CreateSecret(t, proj, "dev", "KEY", team, secretmanager.WithPath("/"+team))
+ }
+ proj.NewRole(t, "own-team", allowWhere("secrets",
+ map[string]any{"secretPath": "/{{identity.metadata.team}}"}, "read"))
+ identity := tn.NewMachineIdentity(t)
+ setIdentityMetadata(t, tn, identity, "team", "backend")
+ proj.Grant(t, identity, "own-team")
+
+ // Action
+ own := listSecrets(t, identity, proj, "dev", "/backend", false)
+ other := listSecrets(t, identity, proj, "dev", "/frontend", false)
+
+ // Assert
+ require.Equalf(t, http.StatusOK, own.status, "listing its own team's folder: %s", own.body)
+ require.Equal(t, map[string]string{"KEY": "backend"}, own.values)
+ require.NotContains(t, other.values, "KEY")
+ })
+
+ t.Run("should refuse a role whose template uses a non-identity expression or an unknown helper", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ templates := map[string]string{
+ "non-identity": "/{{user.id}}",
+ "unknown-helper": "/{{lookup identity.metadata.team}}",
+ }
+
+ // Action
+ statuses, messages := map[string]int{}, map[string]string{}
+ for slug, template := range templates {
+ res := createRole(t, proj.Tenant().Admin, proj, slug, allowWhere("secrets", map[string]any{"secretPath": template}, "read"))
+ statuses[slug] = res.StatusCode()
+ if res.JSON400 != nil {
+ messages[slug] = res.JSON400.Message
+ }
+ }
+
+ // Assert
+ require.Equal(t, map[string]int{"non-identity": http.StatusBadRequest, "unknown-helper": http.StatusBadRequest}, statuses)
+ require.Equal(t, map[string]string{
+ "non-identity": "Template sanitization failed: Role Creation",
+ "unknown-helper": "Template sanitization failed: Role Creation",
+ }, messages)
+ slugs := roleSlugs(t, proj.Tenant().Admin, proj.ID)
+ require.NotContains(t, slugs, "non-identity")
+ require.NotContains(t, slugs, "unknown-helper")
+ })
+}
+
+func setIdentityMetadata(t *testing.T, tn *harness.Tenant, identity *harness.Principal, key, value string) {
+ t.Helper()
+ metadata := []struct {
+ Key string `json:"key"`
+ Value string `json:"value"`
+ }{{Key: key, Value: value}}
+ res, err := tn.Admin.API.UpdateMachineIdentityWithResponse(t.Context(), identity.ID.String(),
+ api.UpdateMachineIdentityJSONRequestBody{Metadata: &metadata})
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusOK, res.StatusCode(), "setting %s's metadata: %s", identity.Name, apierr.Body(res.Body))
+}
+
+func roleSlugs(t *testing.T, pr *harness.Principal, projectID string) []string {
+ t.Helper()
+ res, err := pr.API.ListProjectRolesWithResponse(t.Context(), projectID)
+ require.NoError(t, err)
+ require.NotNilf(t, res.JSON200, "listing roles returned %d: %s", res.StatusCode(), apierr.Body(res.Body))
+ slugs := []string{}
+ for _, role := range res.JSON200.Roles {
+ slugs = append(slugs, role.Slug)
+ }
+ return slugs
+}
diff --git a/tests/suites/secretmanager/permissions/write_test.go b/tests/suites/secretmanager/permissions/write_test.go
new file mode 100644
index 0000000000..400d1c6ced
--- /dev/null
+++ b/tests/suites/secretmanager/permissions/write_test.go
@@ -0,0 +1,114 @@
+package permissions_test
+
+import (
+ "net/http"
+ "slices"
+ "testing"
+
+ "github.com/Infisical/infisical/tests/clients/api"
+ "github.com/Infisical/infisical/tests/fixture"
+ "github.com/Infisical/infisical/tests/fixture/secretmanager"
+ "github.com/Infisical/infisical/tests/harness"
+ "github.com/stretchr/testify/require"
+)
+
+func TestRole_ConditionalWrites(t *testing.T) {
+ t.Parallel()
+ h := harness.From(t)
+
+ t.Run("should allow a create only in the permitted path", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateFolder(t, proj, "dev", "/allowed")
+ secretmanager.CreateFolder(t, proj, "dev", "/other")
+ proj.NewRole(t, "writer", allowWhere("secrets", map[string]any{"secretPath": "/allowed"}, "read", "create"))
+ writer := proj.NewMachineIdentity(t, fixture.WithRoles("writer"))
+
+ // Action
+ inside := createSecret(t, writer, proj, "dev", "/allowed", "KEY", "v")
+ outside := createSecret(t, writer, proj, "dev", "/other", "KEY", "v")
+
+ // Assert
+ require.Equalf(t, http.StatusOK, inside.StatusCode(), "creating in /allowed: %s", inside.Body)
+ require.Equalf(t, http.StatusForbidden, outside.StatusCode(), "creating in /other: %s", outside.Body)
+ require.Empty(t, secretsAt(t, proj, "dev", "/other"))
+ require.Equal(t, map[string]string{"KEY": "v"}, secretsAt(t, proj, "dev", "/allowed"))
+ })
+
+ t.Run("should refuse a rename onto a denied name and keep the old name", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateSecret(t, proj, "dev", "DEV_KEY", "v")
+ proj.NewRole(t, "no-prod-names",
+ allow("secrets", "read", "create", "edit"),
+ deny(allowWhere("secrets", map[string]any{"secretName": map[string]any{"$glob": "PROD_*"}}, "edit")))
+ editor := proj.NewMachineIdentity(t, fixture.WithRoles("no-prod-names"))
+
+ // Action
+ res := updateSecret(t, editor, proj, "dev", "/", "DEV_KEY", api.UpdateSecretV4JSONRequestBody{NewSecretName: new("PROD_KEY")})
+
+ // Assert
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "renaming: %s", res.Body)
+ require.Equal(t, map[string]string{"DEV_KEY": "v"}, secretsAt(t, proj, "dev", "/"))
+ require.Equal(t, http.StatusOK, updateSecret(t, editor, proj, "dev", "/", "DEV_KEY",
+ api.UpdateSecretV4JSONRequestBody{NewSecretName: new("STAGING_KEY")}).StatusCode(), "a rename onto an allowed name")
+ })
+
+ t.Run("should check the new tag set and refuse an update that adds a denied tag", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ restricted := secretmanager.CreateTag(t, proj, "restricted")
+ secretmanager.CreateSecret(t, proj, "dev", "API_KEY", "v")
+ proj.NewRole(t, "no-restricted",
+ allow("secrets", "read", "edit"),
+ deny(allowWhere("secrets", map[string]any{"secretTags": map[string]any{"$in": []string{"restricted"}}}, "edit")))
+ editor := proj.NewMachineIdentity(t, fixture.WithRoles("no-restricted"))
+
+ // Action
+ res := updateSecret(t, editor, proj, "dev", "/", "API_KEY", api.UpdateSecretV4JSONRequestBody{
+ SecretValue: new("changed"),
+ TagIds: &[]string{restricted},
+ })
+
+ // Assert
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "tagging: %s", res.Body)
+ stored := readSecret(t, proj.Tenant().Admin, proj, "dev", "/", "API_KEY")
+ require.NotNil(t, stored.JSON200)
+ require.Equal(t, "v", stored.JSON200.Secret.SecretValue)
+ require.Empty(t, stored.JSON200.Secret.Tags)
+ require.Equal(t, http.StatusOK, updateSecret(t, editor, proj, "dev", "/", "API_KEY",
+ api.UpdateSecretV4JSONRequestBody{SecretValue: new("changed")}).StatusCode(), "the same update without the tag")
+ })
+
+ t.Run("should refuse the whole batch when one item is outside the permitted path", func(t *testing.T) {
+ t.Parallel()
+
+ // Setup
+ proj := newProject(t, h.NewTenant(t))
+ secretmanager.CreateFolder(t, proj, "dev", "/allowed")
+ secretmanager.CreateFolder(t, proj, "dev", "/denied")
+ secretmanager.CreateSecret(t, proj, "dev", "IN", "old", secretmanager.WithPath("/allowed"))
+ secretmanager.CreateSecret(t, proj, "dev", "OUT", "old", secretmanager.WithPath("/denied"))
+ proj.NewRole(t, "allowed-editor", allowWhere("secrets", map[string]any{"secretPath": "/allowed"}, "read", "edit"))
+ editor := proj.NewMachineIdentity(t, fixture.WithRoles("allowed-editor"))
+ body := api.UpdateManySecretsV4JSONRequestBody{ProjectId: proj.ID, Environment: "dev"}
+ body.Secrets = slices.Grow(body.Secrets, 2)[:2]
+ body.Secrets[0].SecretKey, body.Secrets[0].SecretPath, body.Secrets[0].SecretValue = "IN", new("/allowed"), new("new")
+ body.Secrets[1].SecretKey, body.Secrets[1].SecretPath, body.Secrets[1].SecretValue = "OUT", new("/denied"), new("new")
+
+ // Action
+ res, err := editor.API.UpdateManySecretsV4WithResponse(t.Context(), body)
+
+ // Assert
+ require.NoError(t, err)
+ require.Equalf(t, http.StatusForbidden, res.StatusCode(), "batch update: %s", res.Body)
+ require.Equal(t, map[string]string{"IN": "old"}, secretsAt(t, proj, "dev", "/allowed"))
+ require.Equal(t, map[string]string{"OUT": "old"}, secretsAt(t, proj, "dev", "/denied"))
+ })
+}