Infisical is the open-source platform for securing secrets, certificates, access, and AI Agents.
TypeScript acmeagentsai-agentscertificate-managementdevsecopsenvironment-variableskubernetesopen-sourcepampkipostgresprivate-caprivileged-access-managementsecret-managementsecret-managersecretssecrets-managementsecuritysecurity-toolsvault
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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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.gonew file mode 100644index 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"))+ })+}