mirror of
https://github.com/hanzoai/team.git
synced 2026-09-30 01:57:35 +00:00
Alejandro García MontoroandGitHub
2e7d762a6c
* Cap markdown block nesting depth blockQuoteStart and listStart recursed once per nested '>' or list marker on a line, guarded only by an indentation check that bounds CommonMark indentation, not nesting count. A single crafted line (e.g. "- " repeated tens of thousands of times) forced recursion and slice-copy work that grew super-linearly with nesting depth, letting an authenticated user burn a disproportionate amount of server CPU per request. Thread a depth counter through blockStart, blockStartOrParagraph, blockQuoteStart, and listStart, and stop opening new nested blocks past maxNestingDepth. This bounds nesting whether it is built by one line or accrued across many, and caps the recursion and copy cost to a small constant regardless of input size. Also apply the existing maxLen byte cap directly inside Parse(), not just Inspect(), so any caller of Parse is protected uniformly. * Add tests for markdown block nesting depth cap Cover the new maxNestingDepth guard: rejecting a well-formed block quote/list item once the depth limit is reached, capping recursion for a single deeply-nested line, and honoring depth already accrued by open ancestor blocks. Also cover Parse()'s byte-length cap and add benchmarks showing the nesting-depth cases now scale roughly linearly with input size instead of super-linearly. * Reject oversized posts before markdown parsing createPost, updatePost, and patchPost ran PostWithProxyRemovedFromImageURLs, which parses the raw message, before the message-length check inside Post.IsValid ever ran. An oversized message paid the full parsing cost even though it was always going to be rejected. Add rejectOversizedMessage, mirroring the rune-count check in Post.IsValid, and call it in all three handlers before any markdown processing touches the message. * Add tests for oversized post/patch rejection Cover the rejectOversizedMessage check added for createPost, updatePost, and patchPost: a message over MaxPostSize is rejected with a 400 in all three handlers before it reaches markdown processing. * Sync markdown parse cap with real max post size Parse and Inspect capped input at a hardcoded ~128KB, assuming a 64KB max post size. The real configured limit comes from the posts.message column and can be raised past that default, so on installations with an enlarged column, markdown parsing (mentions, links, formatting) was silently skipped for legitimately-sized posts. Have the markdown package pull its cap from a function registered via SetMaxPostSizeFunc, defaulting to the old conservative constant only if nothing was ever registered. PlatformService.New registers PlatformService.MaxPostSize itself once the store is ready, so the cap always reflects the real limit regardless of which code path parses markdown first, and the store layer stays unaware that markdown parsing exists. * Add tests for markdown max post size sync Cover SetMaxPostSizeFunc raising the cap and being called on every MaxLen invocation. Also verify, end to end against a real database, that PlatformService.New wires markdown.MaxLen to the real configured max post size. * Fix tests * Address review comments - Simplify setting the maximum number of runes for a post - Simplify comments - Rename variables and functions to reflect whether they represent bytes or runes.
81 lines
2.7 KiB
Go
81 lines
2.7 KiB
Go
// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
|
|
// See LICENSE.txt for license information.
|
|
|
|
package markdown
|
|
|
|
import (
|
|
"fmt"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// countBlocksByType tallies the concrete type of each block in a flat block chain, such as the one
|
|
// returned by blockQuoteStart/listStart/blockStart, which append each nesting level's block(s)
|
|
// directly onto the same slice as its descendants.
|
|
func countBlocksByType(blocks []Block) map[string]int {
|
|
counts := map[string]int{}
|
|
for _, block := range blocks {
|
|
counts[fmt.Sprintf("%T", block)]++
|
|
}
|
|
return counts
|
|
}
|
|
|
|
func TestBlockStart(t *testing.T) {
|
|
t.Run("block quote nesting is capped at maxNestingDepth", func(t *testing.T) {
|
|
markdown := "> foo"
|
|
blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
|
|
assert.Nil(t, blocks)
|
|
})
|
|
|
|
t.Run("list nesting is capped at maxNestingDepth", func(t *testing.T) {
|
|
markdown := "- foo"
|
|
blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
|
|
assert.Nil(t, blocks)
|
|
})
|
|
|
|
t.Run("a single line cannot recurse past maxNestingDepth nested block quotes", func(t *testing.T) {
|
|
n := maxNestingDepth + 8
|
|
markdown := strings.Repeat("> ", n) + "x"
|
|
blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, 0)
|
|
require.NotEmpty(t, blocks)
|
|
|
|
counts := countBlocksByType(blocks)
|
|
assert.Equal(t, maxNestingDepth, counts["*markdown.BlockQuote"])
|
|
assert.Equal(t, 1, counts["*markdown.Paragraph"])
|
|
})
|
|
|
|
t.Run("a single line cannot recurse past maxNestingDepth nested list items", func(t *testing.T) {
|
|
n := maxNestingDepth + 8
|
|
markdown := strings.Repeat("- ", n) + "x"
|
|
blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, 0)
|
|
require.NotEmpty(t, blocks)
|
|
|
|
counts := countBlocksByType(blocks)
|
|
assert.Equal(t, maxNestingDepth, counts["*markdown.List"])
|
|
assert.Equal(t, maxNestingDepth, counts["*markdown.ListItem"])
|
|
assert.Equal(t, 1, counts["*markdown.Paragraph"])
|
|
})
|
|
|
|
t.Run("nesting already accrued by open ancestor blocks counts toward the cap", func(t *testing.T) {
|
|
markdown := "> > > x"
|
|
blocks := blockStart(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth-2)
|
|
require.NotEmpty(t, blocks)
|
|
|
|
counts := countBlocksByType(blocks)
|
|
assert.Equal(t, 2, counts["*markdown.BlockQuote"])
|
|
assert.Equal(t, 1, counts["*markdown.Paragraph"])
|
|
})
|
|
}
|
|
|
|
func TestBlockStartOrParagraph(t *testing.T) {
|
|
t.Run("falls back to a paragraph once the nesting depth is exhausted", func(t *testing.T) {
|
|
markdown := "> foo"
|
|
blocks := blockStartOrParagraph(markdown, 0, Range{0, len(markdown)}, nil, nil, maxNestingDepth)
|
|
require.Len(t, blocks, 1)
|
|
assert.IsType(t, &Paragraph{}, blocks[0])
|
|
})
|
|
}
|