mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
471745b431
Bound work an anonymous or low-privilege caller can force:
- Bound thumbnail decoding by declared pixel count before decoding and
remember images that cannot be thumbnailed (over the bound or not
decodable), so a small image declaring billions of pixels is served
as-is instead of decoded on every request. Transient storage read
errors are not remembered. The bound lives in internal/imagelimit and
is shared with EXIF stripping.
- Cap request bodies at 16 MiB for procedures that carry no file bytes;
only inline attachment creation, transcription, and chunked uploads
keep their larger caps.
- Digest over-long submitted usernames before using them as sign-in
limiter keys, add header and idle timeouts to the HTTP server, limit
filter expression size, and cap the SQLite regexp cache.
Close correctness gaps:
- Delete the thumbnail the file server actually writes (.v2.jpeg), its
failure marker, and the legacy name when an attachment is removed.
- Decide EXIF stripping from the sniffed content as well as the declared
type, so a mislabeled JPEG keeps no metadata.
- Revoke every other session when a password changes; an admin reset
revokes all of the target's sessions. Prune expired refresh tokens.
- Enforce the 2 MiB avatar limit the web client already applies.
- Keep S3 object keys unique when the path template has no {uuid}.
- Reject negative attachment page tokens.
- Charge memo archive imports against the write and upload budgets,
charge repeated validate-only plans, discard only attachments an
import actually stored, and refuse archives that declare far more
bytes than they hold.
- Load database-stored attachment bytes only after authorization.
- Remove the unused, unguarded linkmeta.GetImage fetcher.
Frontend: send no referrer when loading external images in memos and
link previews, and drop picture/source from the sanitizer so every
remote image goes through the https-only src rule.
Dependencies: grpc 1.83.1 and x/crypto 0.56.0 for reported advisories.
131 lines
3.5 KiB
Go
131 lines
3.5 KiB
Go
package filter
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/google/cel-go/cel"
|
|
"github.com/pkg/errors"
|
|
)
|
|
|
|
// Engine parses CEL filters into a dialect-agnostic condition tree.
|
|
type Engine struct {
|
|
schema Schema
|
|
env *cel.Env
|
|
// nowFunc resolves the value of the `now` variable. It is frozen once per
|
|
// Compile so a single filter sees a single instant, and is overridable in
|
|
// tests for deterministic folding.
|
|
nowFunc func() time.Time
|
|
}
|
|
|
|
// NewEngine builds a new Engine for the provided schema.
|
|
// maxFilterExpressionSize bounds a filter expression in code points. Every
|
|
// term compiles to its own SQL predicate, so the expression length is what
|
|
// bounds the query the database has to run.
|
|
const maxFilterExpressionSize = 8 << 10
|
|
|
|
func NewEngine(schema Schema) (*Engine, error) {
|
|
options := append([]cel.EnvOption{cel.ParserExpressionSizeLimit(maxFilterExpressionSize)}, schema.EnvOptions...)
|
|
env, err := cel.NewEnv(options...)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to create CEL environment")
|
|
}
|
|
return &Engine{
|
|
schema: schema,
|
|
env: env,
|
|
nowFunc: time.Now,
|
|
}, nil
|
|
}
|
|
|
|
// Program stores a compiled filter condition.
|
|
type Program struct {
|
|
schema Schema
|
|
condition Condition
|
|
}
|
|
|
|
// ConditionTree exposes the underlying condition tree.
|
|
func (p *Program) ConditionTree() Condition {
|
|
return p.condition
|
|
}
|
|
|
|
// Compile parses the filter string into an executable program.
|
|
func (e *Engine) Compile(_ context.Context, filter string) (*Program, error) {
|
|
if strings.TrimSpace(filter) == "" {
|
|
return nil, errors.New("filter expression is empty")
|
|
}
|
|
|
|
ast, issues := e.env.Compile(filter)
|
|
if issues != nil && issues.Err() != nil {
|
|
return nil, errors.Wrap(issues.Err(), "failed to compile filter")
|
|
}
|
|
parsed, err := cel.AstToParsedExpr(ast)
|
|
if err != nil {
|
|
return nil, errors.Wrap(err, "failed to convert AST")
|
|
}
|
|
|
|
cond, err := buildCondition(parsed.GetExpr(), parseContext{schema: e.schema, now: e.nowFunc()})
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
|
|
return &Program{
|
|
schema: e.schema,
|
|
condition: cond,
|
|
}, nil
|
|
}
|
|
|
|
// CompileToStatement compiles and renders the filter in a single step.
|
|
func (e *Engine) CompileToStatement(ctx context.Context, filter string, opts RenderOptions) (Statement, error) {
|
|
program, err := e.Compile(ctx, filter)
|
|
if err != nil {
|
|
return Statement{}, err
|
|
}
|
|
return program.Render(opts)
|
|
}
|
|
|
|
// RenderOptions configure SQL rendering.
|
|
type RenderOptions struct {
|
|
Dialect DialectName
|
|
PlaceholderOffset int
|
|
DisableNullChecks bool
|
|
}
|
|
|
|
// Statement contains the rendered SQL fragment and its args.
|
|
type Statement struct {
|
|
SQL string
|
|
Args []any
|
|
}
|
|
|
|
// Render converts the program into a dialect-specific SQL fragment.
|
|
func (p *Program) Render(opts RenderOptions) (Statement, error) {
|
|
renderer := newRenderer(p.schema, opts)
|
|
return renderer.Render(p.condition)
|
|
}
|
|
|
|
var (
|
|
defaultOnce sync.Once
|
|
defaultInst *Engine
|
|
defaultErr error
|
|
defaultAttachmentOnce sync.Once
|
|
defaultAttachmentInst *Engine
|
|
defaultAttachmentErr error
|
|
)
|
|
|
|
// DefaultEngine returns the process-wide memo filter engine.
|
|
func DefaultEngine() (*Engine, error) {
|
|
defaultOnce.Do(func() {
|
|
defaultInst, defaultErr = NewEngine(NewSchema())
|
|
})
|
|
return defaultInst, defaultErr
|
|
}
|
|
|
|
// DefaultAttachmentEngine returns the process-wide attachment filter engine.
|
|
func DefaultAttachmentEngine() (*Engine, error) {
|
|
defaultAttachmentOnce.Do(func() {
|
|
defaultAttachmentInst, defaultAttachmentErr = NewEngine(NewAttachmentSchema())
|
|
})
|
|
return defaultAttachmentInst, defaultAttachmentErr
|
|
}
|