Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: implement MongoDB dynamic masking milestone 1 (#19445)
h3n4l213ec0ffd5b7
diff --git a/backend/api/v1/catalog_masking_mongodb.go b/backend/api/v1/catalog_masking_mongodb.gonew file mode 100644index 0000000000..7a27184bcd--- /dev/null+++ b/backend/api/v1/catalog_masking_mongodb.go@@ -0,0 +1,47 @@+package v1++import (+ "encoding/json"++ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/component/masker"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ mongoparser "github.com/bytebase/bytebase/backend/plugin/parser/mongodb"+)++func checkMongoDBRequestBlocked(analysis *mongoparser.MaskingAnalysis) error {+ if analysis == nil {+ return nil+ }+ if analysis.API == mongoparser.MaskableAPIUnsupportedRead {+ operation := analysis.Operation+ if operation == "" {+ operation = "unknown"+ }+ return errors.Errorf("MongoDB operation %q on collection %q is not supported for dynamic masking in this release. Supported operations are find() and findOne()", operation+"()", analysis.Collection)+ }+ return nil+}++func maskMongoDBDocumentString(document string, objectSchema *storepb.ObjectSchema, semanticTypeToMasker map[string]masker.Masker) (string, error) {+ if document == "" || objectSchema == nil {+ return document, nil+ }++ var parsed any+ if err := json.Unmarshal([]byte(document), &parsed); err != nil {+ return "", errors.Wrap(err, "failed to unmarshal MongoDB result document")+ }++ masked, err := walkAndMaskJSONRecursive(parsed, objectSchema, semanticTypeToMasker)+ if err != nil {+ return "", errors.Wrap(err, "failed to mask MongoDB result document")+ }++ maskedJSON, err := json.Marshal(masked)+ if err != nil {+ return "", errors.Wrap(err, "failed to marshal masked MongoDB result document")+ }+ return string(maskedJSON), nil+}diff --git a/backend/api/v1/catalog_masking_mongodb_test.go b/backend/api/v1/catalog_masking_mongodb_test.gonew file mode 100644index 0000000000..8149c76a59--- /dev/null+++ b/backend/api/v1/catalog_masking_mongodb_test.go@@ -0,0 +1,219 @@+package v1++import (+ "io"+ "os"+ "testing"++ "github.com/stretchr/testify/require"+ "gopkg.in/yaml.v3"++ "github.com/bytebase/bytebase/backend/component/masker"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ mongoparser "github.com/bytebase/bytebase/backend/plugin/parser/mongodb"+)++type mongodbMaskingTestData struct {+ MaskDocument []mongodbMaskDocumentCase `yaml:"maskDocument"`+ CheckBlocked []mongodbCheckBlockedCase `yaml:"checkBlocked"`+}++type mongodbMaskDocumentCase struct {+ Description string `yaml:"description"`+ Schema string `yaml:"schema"`+ Input string `yaml:"input"`+ Want string `yaml:"want"`+}++type mongodbCheckBlockedCase struct {+ Description string `yaml:"description"`+ AnalysisNil bool `yaml:"analysisNil"`+ API string `yaml:"api"`+ Operation string `yaml:"operation"`+ Collection string `yaml:"collection"`+ WantError bool `yaml:"wantError"`+ WantErrorContains string `yaml:"wantErrorContains"`+}++func loadMongoDBMaskingTestData(t *testing.T) *mongodbMaskingTestData {+ t.Helper()+ f, err := os.Open("test-data/mongodb_masking.yaml")+ require.NoError(t, err)+ raw, err := io.ReadAll(f)+ require.NoError(t, err)+ require.NoError(t, f.Close())++ var data mongodbMaskingTestData+ require.NoError(t, yaml.Unmarshal(raw, &data))+ return &data+}++func mustMongoSchema(t *testing.T, schemaName string) *storepb.ObjectSchema {+ t.Helper()+ switch schemaName {+ case "nested":+ return &storepb.ObjectSchema{+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "name": {Type: storepb.ObjectSchema_STRING},+ "contact": {+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "phone": {Type: storepb.ObjectSchema_STRING, SemanticType: "bb.default"},+ "city": {Type: storepb.ObjectSchema_STRING},+ },+ },+ },+ },+ },+ },+ },+ }+ case "array":+ return &storepb.ObjectSchema{+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "tags": {+ Type: storepb.ObjectSchema_ARRAY,+ Kind: &storepb.ObjectSchema_ArrayKind_{+ ArrayKind: &storepb.ObjectSchema_ArrayKind{+ Kind: &storepb.ObjectSchema{Type: storepb.ObjectSchema_STRING, SemanticType: "bb.default"},+ },+ },+ },+ "count": {Type: storepb.ObjectSchema_NUMBER},+ },+ },+ },+ }+ case "tagged-node":+ return &storepb.ObjectSchema{+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "profile": {+ Type: storepb.ObjectSchema_OBJECT,+ SemanticType: "bb.default",+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "ssn": {Type: storepb.ObjectSchema_STRING},+ "address": {Type: storepb.ObjectSchema_STRING},+ },+ },+ },+ },+ "name": {Type: storepb.ObjectSchema_STRING},+ },+ },+ },+ }+ case "extended-json":+ return &storepb.ObjectSchema{+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "_id": {+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "$oid": {Type: storepb.ObjectSchema_STRING},+ },+ },+ },+ },+ "email": {Type: storepb.ObjectSchema_STRING, SemanticType: "bb.default"},+ "createdAt": {+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{+ Properties: map[string]*storepb.ObjectSchema{+ "$date": {Type: storepb.ObjectSchema_STRING},+ },+ },+ },+ },+ },+ },+ },+ }+ case "non-object":+ return &storepb.ObjectSchema{+ Type: storepb.ObjectSchema_OBJECT,+ Kind: &storepb.ObjectSchema_StructKind_{+ StructKind: &storepb.ObjectSchema_StructKind{},+ },+ }+ default:+ require.Failf(t, "unknown schema", "schema %q not found", schemaName)+ return nil+ }+}++func mustMaskableAPI(t *testing.T, api string) mongoparser.MaskableAPI {+ t.Helper()+ switch api {+ case "unsupported":+ return mongoparser.MaskableAPIUnsupported+ case "find":+ return mongoparser.MaskableAPIFind+ case "findOne":+ return mongoparser.MaskableAPIFindOne+ case "unsupportedRead":+ return mongoparser.MaskableAPIUnsupportedRead+ default:+ require.Failf(t, "unknown api", "api %q not found", api)+ return mongoparser.MaskableAPIUnsupported+ }+}++func TestMaskMongoDBDocumentString(t *testing.T) {+ td := loadMongoDBMaskingTestData(t)+ maskers := map[string]masker.Masker{+ "bb.default": masker.NewDefaultFullMasker(),+ }++ for _, tc := range td.MaskDocument {+ t.Run(tc.Description, func(t *testing.T) {+ schema := mustMongoSchema(t, tc.Schema)+ got, err := maskMongoDBDocumentString(tc.Input, schema, maskers)+ require.NoError(t, err)+ requireJSONEqual(t, tc.Want, got)+ })+ }+}++func TestCheckMongoDBRequestBlocked(t *testing.T) {+ td := loadMongoDBMaskingTestData(t)++ for _, tc := range td.CheckBlocked {+ t.Run(tc.Description, func(t *testing.T) {+ var analysis *mongoparser.MaskingAnalysis+ if !tc.AnalysisNil {+ analysis = &mongoparser.MaskingAnalysis{+ API: mustMaskableAPI(t, tc.API),+ Operation: tc.Operation,+ Collection: tc.Collection,+ }+ }+ err := checkMongoDBRequestBlocked(analysis)+ if tc.WantError {+ require.Error(t, err)+ if tc.WantErrorContains != "" {+ require.Contains(t, err.Error(), tc.WantErrorContains)+ }+ return+ }+ require.NoError(t, err)+ })+ }+}diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex c7a71e0e7c..18c02dcdf7 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -33,6 +33,7 @@ import ("github.com/bytebase/bytebase/backend/plugin/db"parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"esparser "github.com/bytebase/bytebase/backend/plugin/parser/elasticsearch"+ mongoparser "github.com/bytebase/bytebase/backend/plugin/parser/mongodb""github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/runner/schemasync""github.com/bytebase/bytebase/backend/store"@@ -589,11 +590,43 @@ func queryRetry(}}+ maskingEnabled := !queryContext.Explain && !queryContext.SkipMasking &&+ licenseService.IsFeatureEnabledForInstance(v1pb.PlanFeature_FEATURE_DATA_MASKING, instance) == nil++ // Pre-execution check for MongoDB: enforce Milestone 1 supported APIs and reject+ // sensitive predicates before sending the query to the server.+ if maskingEnabled && instance.Metadata.GetEngine() == storepb.Engine_MONGODB {+ for _, stmt := range statements {+ analysis, analyzeErr := mongoparser.AnalyzeMaskingStatement(stmt.Text)+ if analyzeErr != nil || analysis == nil || analysis.Collection == "" {+ continue+ }++ objectSchema, schemaErr := getMongoDBCollectionObjectSchema(ctx, stores, database.InstanceID, database.DatabaseName, analysis.Collection)+ if schemaErr != nil {+ return nil, nil, time.Duration(0), connect.NewError(connect.CodeInternal, errors.Wrapf(schemaErr, "failed to get object schema for collection %q", analysis.Collection))+ }+ if objectSchema == nil {+ continue+ }++ if err := checkMongoDBRequestBlocked(analysis); err != nil {+ return nil, nil, time.Duration(0), connect.NewError(connect.CodeInvalidArgument, err)+ }++ for _, field := range analysis.PredicateFields {+ semanticType := lookupSemanticTypeByDotPath(field, objectSchema)+ if semanticType != "" {+ return nil, nil, time.Duration(0), connect.NewError(connect.CodeInvalidArgument,+ errors.Errorf("using field %q tagged by semantic type %q in query predicate is not allowed", field, semanticType))+ }+ }+ }+ }+// Pre-execution check for Elasticsearch: reject blocked APIs and predicate violations// before sending the query to the server.- if !queryContext.Explain && !queryContext.SkipMasking &&- instance.Metadata.GetEngine() == storepb.Engine_ELASTICSEARCH &&- licenseService.IsFeatureEnabledForInstance(v1pb.PlanFeature_FEATURE_DATA_MASKING, instance) == nil {+ if maskingEnabled && instance.Metadata.GetEngine() == storepb.Engine_ELASTICSEARCH {for _, stmt := range statements {parsed, parseErr := esparser.ParseElasticsearchREST(stmt.Text)if parseErr != nil || len(parsed.Requests) == 0 {@@ -714,7 +747,7 @@ func queryRetry(}}- if !queryContext.SkipMasking && licenseService.IsFeatureEnabledForInstance(v1pb.PlanFeature_FEATURE_DATA_MASKING, instance) == nil && !queryContext.Explain {+ if maskingEnabled {slog.Debug("mask query results", slog.String("instance", instance.ResourceID), slog.String("database", database.DatabaseName))// TODO(zp): Refactor Document Database and RDBMS to use the same masking logic.if instance.Metadata.GetEngine() == storepb.Engine_COSMOSDB {@@ -774,6 +807,50 @@ func queryRetry(}}}+ } else if instance.Metadata.GetEngine() == storepb.Engine_MONGODB {+ semanticTypeToMaskerMap, err := buildSemanticTypeToMaskerMap(ctx, stores)+ if err != nil {+ return nil, nil, duration, connect.NewError(connect.CodeInternal, errors.New(err.Error()))+ }++ for _, result := range results {+ analysis, analyzeErr := mongoparser.AnalyzeMaskingStatement(result.Statement)+ if analyzeErr != nil || analysis == nil || analysis.Collection == "" {+ continue+ }+ if analysis.API != mongoparser.MaskableAPIFind && analysis.API != mongoparser.MaskableAPIFindOne {+ continue+ }++ objectSchema, schemaErr := getMongoDBCollectionObjectSchema(ctx, stores, database.InstanceID, database.DatabaseName, analysis.Collection)+ if schemaErr != nil {+ return nil, nil, duration, connect.NewError(connect.CodeInternal, errors.Wrapf(schemaErr, "failed to get object schema for collection %q", analysis.Collection))+ }+ if objectSchema == nil {+ continue+ }++ for _, row := range result.Rows {+ if len(row.Values) == 0 {+ continue+ }+ value := row.Values[0].GetStringValue()+ if value == "" {+ continue+ }++ maskedValue, maskErr := maskMongoDBDocumentString(value, objectSchema, semanticTypeToMaskerMap)+ if maskErr != nil {+ return nil, nil, duration, connect.NewError(connect.CodeInternal, errors.Wrapf(maskErr, "failed to mask MongoDB response"))+ }++ row.Values[0] = &v1pb.RowValue{+ Kind: &v1pb.RowValue_StringValue{+ StringValue: maskedValue,+ },+ }+ }+ }} else if instance.Metadata.GetEngine() == storepb.Engine_ELASTICSEARCH {for _, result := range results {parsed, err := esparser.ParseElasticsearchREST(result.Statement)@@ -909,6 +986,35 @@ func getCosmosDBContainerObjectSchema(ctx context.Context, stores *store.Store,return nil, nil}+func getMongoDBCollectionObjectSchema(ctx context.Context, stores *store.Store, instanceID string, databaseName string, collectionName string) (*storepb.ObjectSchema, error) {+ dbMetadata, err := stores.GetDBSchema(ctx, &store.FindDBSchemaMessage{+ InstanceID: instanceID,+ DatabaseName: databaseName,+ })+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get database schema: %q", databaseName)+ }++ if dbMetadata == nil {+ return nil, nil+ }++ schemas := dbMetadata.GetConfig().GetSchemas()+ if len(schemas) == 0 {+ return nil, nil+ }++ for _, schema := range schemas {+ for _, table := range schema.GetTables() {+ if table.GetName() == collectionName {+ return table.GetObjectSchema(), nil+ }+ }+ }++ return nil, nil+}+func getSensitivePredicateColumnErrorMessages(sensitiveColumns []parserbase.ColumnResource) string {var buf bytes.Buffer_, _ = buf.WriteString("Using sensitive columns in WHERE clause is not allowed: ")diff --git a/backend/api/v1/test-data/mongodb_masking.yaml b/backend/api/v1/test-data/mongodb_masking.yamlnew file mode 100644index 0000000000..d65c5d6f3d--- /dev/null+++ b/backend/api/v1/test-data/mongodb_masking.yaml@@ -0,0 +1,49 @@+maskDocument:+ - description: mask nested object field+ schema: nested+ input: '{"name":"Alice","contact":{"phone":"123-456","city":"NYC"}}'+ want: '{"name":"Alice","contact":{"phone":"******","city":"NYC"}}'++ - description: mask array elements by semantic type+ schema: array+ input: '{"tags":["alpha","beta"],"count":2}'+ want: '{"tags":["******","******"],"count":2}'++ - description: tagged node replaces entire subtree+ schema: tagged-node+ input: '{"profile":{"ssn":"123-45-6789","address":"Main St"},"name":"Alice"}'+ want: '{"profile":"******","name":"Alice"}'++ - description: extended json style object is safe+ schema: extended-json+ input: '{"_id":{"$oid":"67d4aaee17bd0f3857a98b58"},"email":"[email protected]","createdAt":{"$date":"2025-01-01T00:00:00Z"}}'+ want: '{"_id":{"$oid":"67d4aaee17bd0f3857a98b58"},"email":"******","createdAt":{"$date":"2025-01-01T00:00:00Z"}}'++ - description: non object payload is handled safely+ schema: non-object+ input: '"raw-string-result"'+ want: '"raw-string-result"'++checkBlocked:+ - description: nil analysis allowed+ analysisNil: true+ wantError: false++ - description: find allowed+ api: find+ operation: find+ collection: users+ wantError: false++ - description: findOne allowed+ api: findOne+ operation: findOne+ collection: users+ wantError: false++ - description: unsupported read blocked+ api: unsupportedRead+ operation: aggregate+ collection: users+ wantError: true+ wantErrorContains: aggregate()diff --git a/backend/plugin/parser/mongodb/masking.go b/backend/plugin/parser/mongodb/masking.gonew file mode 100644index 0000000000..68cadcc392--- /dev/null+++ b/backend/plugin/parser/mongodb/masking.go@@ -0,0 +1,340 @@+package mongodb++import (+ "slices"+ "strconv"+ "strings"++ "github.com/antlr4-go/antlr/v4"+ "github.com/pkg/errors"++ mongoparser "github.com/bytebase/parser/mongodb"+)++// MaskableAPI categorizes MongoDB collection reads for masking behavior.+type MaskableAPI int++const (+ // MaskableAPIUnsupported means the statement is not relevant for MongoDB masking.+ MaskableAPIUnsupported MaskableAPI = iota+ // MaskableAPIFind means db.<collection>.find(...).+ MaskableAPIFind+ // MaskableAPIFindOne means db.<collection>.findOne(...).+ MaskableAPIFindOne+ // MaskableAPIUnsupportedRead means a read API that is blocked in Milestone 1.+ MaskableAPIUnsupportedRead+)++// MaskingAnalysis contains MongoDB statement data needed by masking checks.+type MaskingAnalysis struct {+ API MaskableAPI+ Operation string+ Collection string+ PredicateFields []string+}++// AnalyzeMaskingStatement analyzes a MongoDB shell statement for masking checks.+// It returns nil,nil for statements that are not relevant to masking flow.+func AnalyzeMaskingStatement(statement string) (*MaskingAnalysis, error) {+ raw := parseMongoShellRaw(statement)+ if raw == nil || raw.Tree == nil {+ return nil, nil+ }+ if len(raw.Errors) > 0 {+ return nil, errors.Errorf("failed to parse MongoDB statement: %s", raw.Errors[0].Message)+ }++ if len(raw.Tree.AllStatement()) != 1 {+ return nil, nil+ }++ listener := &maskingAnalysisListener{}+ antlr.ParseTreeWalkerDefault.Walk(listener, raw.Tree)+ if listener.analysis == nil {+ return nil, nil+ }+ return listener.analysis, nil+}++type maskingAnalysisListener struct {+ *mongoparser.BaseMongoShellParserListener++ analysis *MaskingAnalysis+}++func (l *maskingAnalysisListener) EnterCollectionOperation(ctx *mongoparser.CollectionOperationContext) {+ if l.analysis != nil {+ return+ }++ collection := extractCollectionName(ctx.CollectionAccess())+ if collection == "" {+ return+ }++ chain := ctx.MethodChain()+ if chain == nil {+ return+ }+ mc := chain.CollectionMethodCall()+ if mc == nil {+ return+ }++ analysis := classifyMaskingMethod(mc)+ if analysis == nil {+ return+ }+ analysis.Collection = collection+ if len(analysis.PredicateFields) > 0 {+ slices.Sort(analysis.PredicateFields)+ }+ l.analysis = analysis+}++func classifyMaskingMethod(mc mongoparser.ICollectionMethodCallContext) *MaskingAnalysis {+ switch {+ case mc.FindMethod() != nil:+ return &MaskingAnalysis{+ API: MaskableAPIFind,+ Operation: "find",+ PredicateFields: extractFindPredicateFields(mc.FindMethod().Arguments()),+ }+ case mc.FindOneMethod() != nil:+ return &MaskingAnalysis{+ API: MaskableAPIFindOne,+ Operation: "findOne",+ PredicateFields: extractFindPredicateFields(mc.FindOneMethod().Arguments()),+ }+ case mc.CountDocumentsMethod() != nil:+ return unsupportedReadAnalysis("countDocuments")+ case mc.EstimatedDocumentCountMethod() != nil:+ return unsupportedReadAnalysis("estimatedDocumentCount")+ case mc.CollectionCountMethod() != nil:+ return unsupportedReadAnalysis("count")+ case mc.DistinctMethod() != nil:+ return unsupportedReadAnalysis("distinct")+ case mc.AggregateMethod() != nil:+ return unsupportedReadAnalysis("aggregate")+ case mc.GetIndexesMethod() != nil:+ return unsupportedReadAnalysis("getIndexes")+ case mc.StatsMethod() != nil:+ return unsupportedReadAnalysis("stats")+ case mc.StorageSizeMethod() != nil:+ return unsupportedReadAnalysis("storageSize")+ case mc.TotalIndexSizeMethod() != nil:+ return unsupportedReadAnalysis("totalIndexSize")+ case mc.TotalSizeMethod() != nil:+ return unsupportedReadAnalysis("totalSize")+ case mc.DataSizeMethod() != nil:+ return unsupportedReadAnalysis("dataSize")+ case mc.IsCappedMethod() != nil:+ return unsupportedReadAnalysis("isCapped")+ case mc.ValidateMethod() != nil:+ return unsupportedReadAnalysis("validate")+ case mc.LatencyStatsMethod() != nil:+ return unsupportedReadAnalysis("latencyStats")+ case mc.GetShardDistributionMethod() != nil:+ return unsupportedReadAnalysis("getShardDistribution")+ case mc.GetShardVersionMethod() != nil:+ return unsupportedReadAnalysis("getShardVersion")+ case mc.AnalyzeShardKeyMethod() != nil:+ return unsupportedReadAnalysis("analyzeShardKey")+ default:+ return nil+ }+}++func unsupportedReadAnalysis(operation string) *MaskingAnalysis {+ return &MaskingAnalysis{+ API: MaskableAPIUnsupportedRead,+ Operation: operation,+ }+}++func extractCollectionName(access mongoparser.ICollectionAccessContext) string {+ switch access := access.(type) {+ case *mongoparser.DotAccessContext:+ if id := access.Identifier(); id != nil {+ return id.GetText()+ }+ case *mongoparser.BracketAccessContext:+ if sl := access.StringLiteral(); sl != nil {+ return unquoteMongoString(sl.GetText())+ }+ case *mongoparser.GetCollectionAccessContext:+ if sl := access.StringLiteral(); sl != nil {+ return unquoteMongoString(sl.GetText())+ }+ }+ return ""+}++func unquoteMongoString(s string) string {+ if s == "" {+ return ""+ }+ if unquoted, err := strconv.Unquote(s); err == nil {+ return unquoted+ }+ return strings.Trim(s, `"'`)+}++func extractFindPredicateFields(args mongoparser.IArgumentsContext) []string {+ if args == nil {+ return nil+ }+ allArgs := args.AllArgument()+ if len(allArgs) == 0 {+ return nil+ }++ first := allArgs[0]+ if first == nil || first.Value() == nil {+ return nil+ }++ doc := extractDocumentValue(first.Value())+ if doc == nil {+ return nil+ }++ fields := make(map[string]struct{})+ collectPredicateFieldsFromDocument(doc, "", fields)+ if len(fields) == 0 {+ return nil+ }++ result := make([]string, 0, len(fields))+ for field := range fields {+ result = append(result, field)+ }+ return result+}++func extractDocumentValue(value mongoparser.IValueContext) mongoparser.IDocumentContext {+ if value == nil {+ return nil+ }+ switch value := value.(type) {+ case *mongoparser.DocumentValueContext:+ return value.Document()+ default:+ return nil+ }+}++func extractArrayValue(value mongoparser.IValueContext) mongoparser.IArrayContext {+ if value == nil {+ return nil+ }+ switch value := value.(type) {+ case *mongoparser.ArrayValueContext:+ return value.Array()+ default:+ return nil+ }+}++func collectPredicateFieldsFromDocument(doc mongoparser.IDocumentContext, prefix string, fields map[string]struct{}) {+ if doc == nil {+ return+ }+ for _, pair := range doc.AllPair() {+ collectPredicateFieldsFromPair(pair, prefix, fields)+ }+}++func collectPredicateFieldsFromPair(pair mongoparser.IPairContext, prefix string, fields map[string]struct{}) {+ if pair == nil || pair.Key() == nil {+ return+ }++ key := extractPairKey(pair.Key())+ if key == "" {+ return+ }++ if strings.HasPrefix(key, "$") {+ collectLogicalPredicateFieldsByKey(key, pair.Value(), prefix, fields)+ return+ }++ fullPath := buildPredicateFieldPath(prefix, key)+ fields[fullPath] = struct{}{}+ collectPredicateFieldValue(pair.Value(), fullPath, fields)+}++func collectLogicalPredicateFieldsByKey(key string, value mongoparser.IValueContext, prefix string, fields map[string]struct{}) {+ if !isLogicalOperator(key) {+ return+ }+ collectLogicalOperatorValue(value, prefix, fields)+}++func buildPredicateFieldPath(prefix, key string) string {+ if prefix == "" {+ return key+ }+ return prefix + "." + key+}++func collectPredicateFieldValue(value mongoparser.IValueContext, fullPath string, fields map[string]struct{}) {+ if childDoc := extractDocumentValue(value); childDoc != nil {+ collectPredicateFieldsFromDocument(childDoc, fullPath, fields)+ return+ }+ if childArr := extractArrayValue(value); childArr != nil {+ collectPredicateFieldsFromArray(childArr, fullPath, fields)+ }+}++func collectPredicateFieldsFromArray(arr mongoparser.IArrayContext, prefix string, fields map[string]struct{}) {+ if arr == nil {+ return+ }+ for _, v := range arr.AllValue() {+ if childDoc := extractDocumentValue(v); childDoc != nil {+ collectPredicateFieldsFromDocument(childDoc, prefix, fields)+ }+ }+}++func collectLogicalOperatorValue(value mongoparser.IValueContext, prefix string, fields map[string]struct{}) {+ if value == nil {+ return+ }+ if doc := extractDocumentValue(value); doc != nil {+ collectPredicateFieldsFromDocument(doc, prefix, fields)+ return+ }+ if arr := extractArrayValue(value); arr != nil {+ collectPredicateFieldsFromArray(arr, prefix, fields)+ }+}++func extractPairKey(keyCtx mongoparser.IKeyContext) string {+ switch keyCtx := keyCtx.(type) {+ case *mongoparser.UnquotedKeyContext:+ if id := keyCtx.Identifier(); id != nil {+ return id.GetText()+ }+ case *mongoparser.QuotedKeyContext:+ if sl := keyCtx.StringLiteral(); sl != nil {+ return unquoteMongoString(sl.GetText())+ }+ }+ if keyCtx == nil {+ return ""+ }+ return keyCtx.GetText()+}++func isLogicalOperator(key string) bool {+ switch key {+ case "$and", "$or", "$nor":+ return true+ default:+ return false+ }+}diff --git a/backend/plugin/parser/mongodb/masking_test.go b/backend/plugin/parser/mongodb/masking_test.gonew file mode 100644index 0000000000..e707b5e462--- /dev/null+++ b/backend/plugin/parser/mongodb/masking_test.go@@ -0,0 +1,118 @@+package mongodb++import (+ "testing"++ "github.com/stretchr/testify/require"+)++func TestAnalyzeMaskingStatement(t *testing.T) {+ tests := []struct {+ description string+ statement string+ want *MaskingAnalysis+ wantError bool+ }{+ {+ description: "find with dot access and direct predicate field",+ statement: `db.users.find({email: "[email protected]"})`,+ want: &MaskingAnalysis{+ API: MaskableAPIFind,+ Operation: "find",+ Collection: "users",+ PredicateFields: []string{"email"},+ },+ },+ {+ description: "findOne with bracket access and dot path key",+ statement: `db["users"].findOne({"contact.phone": "123"})`,+ want: &MaskingAnalysis{+ API: MaskableAPIFindOne,+ Operation: "findOne",+ Collection: "users",+ PredicateFields: []string{"contact.phone"},+ },+ },+ {+ description: "find with getCollection access and logical operators",+ statement: `db.getCollection("users").find({+ $or: [+ {email: "[email protected]"},+ {contact: {phone: "123"}}+ ],+ $and: [+ {"profile.ssn": "111"},+ {name: "alice"}+ ],+ $nor: [{status: "inactive"}]+ })`,+ want: &MaskingAnalysis{+ API: MaskableAPIFind,+ Operation: "find",+ Collection: "users",+ PredicateFields: []string{+ "contact",+ "contact.phone",+ "email",+ "name",+ "profile.ssn",+ "status",+ },+ },+ },+ {+ description: "aggregate is unsupported read api",+ statement: `db.users.aggregate([{$match: {name: "alice"}}])`,+ want: &MaskingAnalysis{+ API: MaskableAPIUnsupportedRead,+ Operation: "aggregate",+ Collection: "users",+ },+ },+ {+ description: "countDocuments is unsupported read api",+ statement: `db.users.countDocuments({})`,+ want: &MaskingAnalysis{+ API: MaskableAPIUnsupportedRead,+ Operation: "countDocuments",+ Collection: "users",+ },+ },+ {+ description: "distinct is unsupported read api",+ statement: `db.users.distinct("name")`,+ want: &MaskingAnalysis{+ API: MaskableAPIUnsupportedRead,+ Operation: "distinct",+ Collection: "users",+ },+ },+ {+ description: "write method is not relevant to masking analyzer",+ statement: `db.users.insertOne({name: "alice"})`,+ want: nil,+ },+ {+ description: "multiple statements are ignored",+ statement: `db.users.find({name: "alice"}); db.users.findOne({name: "bob"})`,+ want: nil,+ },+ {+ description: "parse error returns error",+ statement: `db.users.find({`,+ wantError: true,+ },+ }++ for _, tc := range tests {+ t.Run(tc.description, func(t *testing.T) {+ got, err := AnalyzeMaskingStatement(tc.statement)+ if tc.wantError {+ require.Error(t, err)+ return+ }+ require.NoError(t, err)+ require.Equal(t, tc.want, got)+ })+ }+}