Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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.yaml
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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)
+ })
+ }
+}