diff --git a/README.md b/README.md index 0fd532a..f755569 100644 --- a/README.md +++ b/README.md @@ -573,6 +573,19 @@ GeneratedObject image = new MinecraftTooltipGenerator.Builder() - **Caching** of rendered objects via Caffeine - **Alternate fonts** including Galactic (Standard Galactic Alphabet) and Illageralt +## Render limits + +Text and options usually reach the generators from untrusted users, so every renderer checks a shared pixel budget (`RenderLimits`) before it allocates a canvas. A render over budget fails with a `GeneratorValidationException` instead of exhausting the heap. Both limits are system properties: + +| Property | Default | Limits | +|---|---|---| +| `generator.render.maxCanvasPixels` | 25,000,000 | Pixels in one canvas (about 100 MB of ARGB) | +| `generator.render.maxAnimationPixels` | 400,000,000 | Pixels summed over every frame of one animation | + +The animation default leaves room for the largest stock render, a full chest with the 182-frame enchant glint (about 256 million pixels, roughly 1 GB while it renders). Lower it on a host with a small heap. + +Individual inputs are bounded as well: icon placeholder repeat counts (`%%dot:N%%`) clamp to 100, tooltip padding clamps to 255, inventories take at most 64 rows and 64 slots per row, scene `scale` is at most 16, scene margins, spacing and offsets at most 4096, and one content template fill produces at most 1,000,000 characters of output. + ## Requirements - Java 25 diff --git a/generator/src/main/java/net/aerh/imagegenerator/effect/impl/GlintImageEffect.java b/generator/src/main/java/net/aerh/imagegenerator/effect/impl/GlintImageEffect.java index 1069fa9..6e8ee4e 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/effect/impl/GlintImageEffect.java +++ b/generator/src/main/java/net/aerh/imagegenerator/effect/impl/GlintImageEffect.java @@ -1,5 +1,6 @@ package net.aerh.imagegenerator.effect.impl; +import net.aerh.imagegenerator.image.RenderLimits; import net.aerh.imagegenerator.effect.EffectContext; import net.aerh.imagegenerator.effect.EffectResult; import net.aerh.imagegenerator.effect.ImageEffect; @@ -52,6 +53,7 @@ public EffectResult apply(EffectContext context) { int frameCount = (int) Math.ceil((double) TOTAL_DURATION_MS / FRAME_DELAY_MS); int width = baseImage.getWidth(); int height = baseImage.getHeight(); + RenderLimits.checkFrames(width, height, frameCount); int[] basePixels = baseImage.getRGB(0, 0, width, height, null, 0, width); double spriteSpanU = BASE_SPRITE_PIXELS / glintTexture.getWidth(); diff --git a/generator/src/main/java/net/aerh/imagegenerator/image/GeneratorImageBuilder.java b/generator/src/main/java/net/aerh/imagegenerator/image/GeneratorImageBuilder.java index fc260fd..675f3e4 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/image/GeneratorImageBuilder.java +++ b/generator/src/main/java/net/aerh/imagegenerator/image/GeneratorImageBuilder.java @@ -166,6 +166,8 @@ private GeneratedObject buildStaticInternal(List generatedObjec throw new GeneratorException("Calculated image dimensions are invalid (width=" + totalWidth + ", height=" + maxHeight + ")"); } + RenderLimits.checkCanvas((long) totalWidth + 2 * IMAGE_BORDER_PADDING_PX, (long) maxHeight + 2 * IMAGE_BORDER_PADDING_PX); + BufferedImage finalImage = new BufferedImage(totalWidth + 2 * IMAGE_BORDER_PADDING_PX, maxHeight + 2 * IMAGE_BORDER_PADDING_PX, BufferedImage.TYPE_INT_ARGB); Graphics2D graphics = finalImage.createGraphics(); try { @@ -241,6 +243,8 @@ private GeneratedObject buildAnimatedInternal(List generatedObj throw new GeneratorException("Calculated animated image dimensions are invalid (width=" + totalWidth + ", height=" + maxHeight + ")"); } + RenderLimits.checkFrames((long) totalWidth + 2 * IMAGE_BORDER_PADDING_PX, (long) maxHeight + 2 * IMAGE_BORDER_PADDING_PX, maxFrames); + List compositeFrames = new ArrayList<>(); // Generate each frame @@ -319,6 +323,8 @@ private GeneratedObject buildTickTimedComposite(List generatedO + totalWidth + ", height=" + maxHeight + ")"); } + RenderLimits.checkFrames((long) totalWidth + 2 * IMAGE_BORDER_PADDING_PX, (long) maxHeight + 2 * IMAGE_BORDER_PADDING_PX, timeline.steps().size()); + List compositeFrames = new ArrayList<>(timeline.steps().size()); for (AnimationTimeline.Step step : timeline.steps()) { BufferedImage compositeFrame = new BufferedImage(totalWidth + 2 * IMAGE_BORDER_PADDING_PX, maxHeight + 2 * IMAGE_BORDER_PADDING_PX, BufferedImage.TYPE_INT_ARGB); diff --git a/generator/src/main/java/net/aerh/imagegenerator/image/MinecraftTooltip.java b/generator/src/main/java/net/aerh/imagegenerator/image/MinecraftTooltip.java index 82596f3..d24f995 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/image/MinecraftTooltip.java +++ b/generator/src/main/java/net/aerh/imagegenerator/image/MinecraftTooltip.java @@ -33,6 +33,9 @@ @Slf4j public class MinecraftTooltip { + /** The widest padding, in px per side, a tooltip accepts; larger values are clamped. */ + public static final int MAX_PADDING = 255; + private static final Map>> OBFUSCATION_WIDTH_MAPS = new HashMap<>(); // Integer key represents font style index (0: regular, 1: bold, 2: italic, 3: bold-italic) private static final int[] UNICODE_BLOCK_RANGES = { 0x0020, 0x007E, // Basic Latin @@ -314,6 +317,12 @@ public boolean hasFirstLinePadding() { * * @return The padded {@link BufferedImage} frame. */ + /** Checks the padded frame size against the shared pixel budget before any frame is allocated. */ + private void checkFrameBudget(int frameWidth, int frameHeight, int frameCount) { + long padding = Math.max(0, this.getPadding()) * 2L; + RenderLimits.checkFrames(frameWidth + padding, frameHeight + padding, frameCount); + } + private BufferedImage addPadding(BufferedImage frame) { if (this.getPadding() <= 0) { return frame; @@ -1072,6 +1081,7 @@ public MinecraftTooltip render() { } int framesToGenerate = this.isAnimated ? this.animationFrameCount : 1; + checkFrameBudget(frameWidth, frameHeight, framesToGenerate); BufferedImage themeLayer = isThemed() ? buildThemeLayer(frameWidth, frameHeight, this.themeSprites) : null; for (int i = 0; i < framesToGenerate; i++) { @@ -1152,6 +1162,7 @@ private MinecraftTooltip renderAnimatedChrome(int frameWidth, int frameHeight, b sources.add(Collections.nCopies(this.animationFrameCount, obfuscationTicks)); } AnimationTimeline timeline = AnimationTimeline.of(sources); + checkFrameBudget(frameWidth, frameHeight, timeline.steps().size()); Map themeLayers = new HashMap<>(); List delays = new ArrayList<>(timeline.steps().size()); @@ -1289,7 +1300,7 @@ public Builder withLines(@NotNull Iterable lines) { } public Builder withPadding(int padding) { - this.padding = Math.max(0, padding); + this.padding = Math.max(0, Math.min(padding, MAX_PADDING)); return this; } diff --git a/generator/src/main/java/net/aerh/imagegenerator/image/RenderLimits.java b/generator/src/main/java/net/aerh/imagegenerator/image/RenderLimits.java new file mode 100644 index 0000000..3613a31 --- /dev/null +++ b/generator/src/main/java/net/aerh/imagegenerator/image/RenderLimits.java @@ -0,0 +1,85 @@ +package net.aerh.imagegenerator.image; + +import net.aerh.imagegenerator.exception.GeneratorValidationException; + +/** + * The shared pixel budget every renderer checks before it allocates a canvas. Request options and + * text reach the renderers from untrusted callers, and a canvas costs four bytes per pixel per frame, + * so an unchecked size turns a short input into gigabytes of heap. Checking the size up front fails + * the one request with a {@link GeneratorValidationException} instead of exhausting the JVM. + * + *

Both limits are read from system properties on each check, so a host can raise or lower them:

+ *
    + *
  • {@value #MAX_CANVAS_PIXELS_PROPERTY} - pixels in one canvas (default + * {@value #DEFAULT_MAX_CANVAS_PIXELS}, about 100 MB of ARGB)
  • + *
  • {@value #MAX_ANIMATION_PIXELS_PROPERTY} - pixels summed over every frame of one animation + * (default {@value #DEFAULT_MAX_ANIMATION_PIXELS}; a full chest with the 182-frame enchant glint + * needs about 256 million)
  • + *
+ */ +public final class RenderLimits { + + public static final String MAX_CANVAS_PIXELS_PROPERTY = "generator.render.maxCanvasPixels"; + public static final String MAX_ANIMATION_PIXELS_PROPERTY = "generator.render.maxAnimationPixels"; + + public static final long DEFAULT_MAX_CANVAS_PIXELS = 25_000_000L; + public static final long DEFAULT_MAX_ANIMATION_PIXELS = 400_000_000L; + + private RenderLimits() { + } + + /** The most pixels one canvas may hold. */ + public static long maxCanvasPixels() { + return positiveProperty(MAX_CANVAS_PIXELS_PROPERTY, DEFAULT_MAX_CANVAS_PIXELS); + } + + /** The most pixels all frames of one animation may hold together. */ + public static long maxAnimationPixels() { + return positiveProperty(MAX_ANIMATION_PIXELS_PROPERTY, DEFAULT_MAX_ANIMATION_PIXELS); + } + + /** + * Rejects a single canvas that is over the canvas budget. Takes {@code long} sizes so callers can + * pass arithmetic that would overflow an {@code int}. + * + * @throws GeneratorValidationException if either side is not positive or the area is over budget + */ + public static void checkCanvas(long width, long height) { + checkFrames(width, height, 1); + } + + /** + * Rejects an animation whose canvas is over the canvas budget or whose frames together are over + * the animation budget. + * + * @throws GeneratorValidationException if the size is not positive or over either budget + */ + public static void checkFrames(long width, long height, long frameCount) { + if (width <= 0 || height <= 0 || width > Integer.MAX_VALUE || height > Integer.MAX_VALUE) { + throw new GeneratorValidationException("Image size %sx%s is out of range", + String.valueOf(width), String.valueOf(height)); + } + + long maxCanvas = maxCanvasPixels(); + long area = width * height; + if (area > maxCanvas) { + throw new GeneratorValidationException( + "Image is too large to render: %sx%s is over the limit of %s pixels", + String.valueOf(width), String.valueOf(height), String.valueOf(maxCanvas)); + } + + long frames = Math.max(1, frameCount); + long maxAnimation = maxAnimationPixels(); + // area fits in 2^62 and frames is small, but guard the product anyway + if (frames > 1 && area > maxAnimation / frames) { + throw new GeneratorValidationException( + "Animation is too large to render: %s frames of %sx%s is over the limit of %s pixels in total", + String.valueOf(frames), String.valueOf(width), String.valueOf(height), String.valueOf(maxAnimation)); + } + } + + private static long positiveProperty(String property, long fallback) { + Long configured = Long.getLong(property); + return configured != null && configured > 0 ? configured : fallback; + } +} diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftContainerGenerator.java b/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftContainerGenerator.java index 287397c..2e3df7c 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftContainerGenerator.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftContainerGenerator.java @@ -1,5 +1,6 @@ package net.aerh.imagegenerator.impl; +import net.aerh.imagegenerator.image.RenderLimits; import com.google.gson.JsonElement; import com.google.gson.JsonObject; import lombok.AccessLevel; @@ -246,6 +247,7 @@ ColorSegment toSegment(ChatColor defaultColor) { private GeneratedObject renderStatic(@Nullable GenerationContext generationContext) { int pixelSize = 2 * scaleFactor; Layout layout = computeLayout(pixelSize); + RenderLimits.checkCanvas(layout.canvasWidth(), layout.canvasHeight()); BufferedImage canvas = new BufferedImage(layout.canvasWidth(), layout.canvasHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D graphics = canvas.createGraphics(); try { @@ -316,6 +318,7 @@ private GeneratedObject renderAnimated(@Nullable GenerationContext generationCon BufferedImage staticBackground = backgroundAnimation == null && PackId.isActive(packId) ? repository().resolveContainerBackground(packId).orElse(null) : null; + RenderLimits.checkFrames(layout.canvasWidth(), layout.canvasHeight(), timeline.steps().size()); List frames = new ArrayList<>(timeline.steps().size()); for (AnimationTimeline.Step step : timeline.steps()) { BufferedImage canvas = new BufferedImage(layout.canvasWidth(), layout.canvasHeight(), BufferedImage.TYPE_INT_ARGB); diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftHudLineGenerator.java b/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftHudLineGenerator.java index 1f826df..2f54575 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftHudLineGenerator.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftHudLineGenerator.java @@ -1,5 +1,6 @@ package net.aerh.imagegenerator.impl; +import net.aerh.imagegenerator.image.RenderLimits; import lombok.AccessLevel; import lombok.RequiredArgsConstructor; import lombok.ToString; @@ -125,6 +126,7 @@ public static int lineTopGuiPx(int lineIndex) { canvasHeightGuiPx = Math.max(canvasHeightGuiPx, lineTopGuiPx(lineIndex) + artBottomGuiPx); } + RenderLimits.checkCanvas((long) guiWidth * pixelSize, (long) canvasHeightGuiPx * pixelSize); BufferedImage canvas = new BufferedImage(canvasWidth, canvasHeightGuiPx * pixelSize, BufferedImage.TYPE_INT_ARGB); Graphics2D graphics = canvas.createGraphics(); diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftInventoryGenerator.java b/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftInventoryGenerator.java index 1e75568..5308dd8 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftInventoryGenerator.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/MinecraftInventoryGenerator.java @@ -1,5 +1,6 @@ package net.aerh.imagegenerator.impl; +import net.aerh.imagegenerator.image.RenderLimits; import lombok.Getter; import lombok.ToString; import lombok.extern.slf4j.Slf4j; @@ -40,6 +41,9 @@ @ToString public class MinecraftInventoryGenerator implements Generator { + /** The most rows, and the most slots in a row, an inventory may have. */ + public static final int MAX_SLOTS_PER_AXIS = 64; + private static final Color NORMAL_TEXT_COLOR = new Color(255, 255, 255); private static final Color DROP_SHADOW_COLOR = new Color(63, 63, 63); private static final Color INVENTORY_BACKGROUND = new Color(198, 198, 198); @@ -173,6 +177,7 @@ private void initializeImage() { int imageWidth = (slotsPerRow * slotSize) + (borderSize * 2); int imageHeight = (rows * slotSize) + titleHeight + borderSize; + RenderLimits.checkCanvas((long) slotsPerRow * slotSize + borderSize * 2L, (long) rows * slotSize + titleHeight + borderSize); this.inventoryImage = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB); this.g2d = inventoryImage.createGraphics(); @@ -732,6 +737,7 @@ private List buildAnimationFrames(List items) { return frames; } + RenderLimits.checkFrames(inventoryImage.getWidth(), inventoryImage.getHeight(), maxFrames); for (int frameIndex = 0; frameIndex < maxFrames; frameIndex++) { BufferedImage frame = new BufferedImage(inventoryImage.getWidth(), inventoryImage.getHeight(), BufferedImage.TYPE_INT_ARGB); Graphics2D frameGraphics = frame.createGraphics(); @@ -801,6 +807,7 @@ private SceneAnimation buildTextureAnimationFrames(List items) { AnimationTimeline timeline = AnimationTimeline.of(sources); List originalImages = animatedItems.stream().map(InventoryItem::getItemImage).toList(); + RenderLimits.checkFrames(inventoryImage.getWidth(), inventoryImage.getHeight(), timeline.steps().size()); List frames = new ArrayList<>(timeline.steps().size()); for (AnimationTimeline.Step step : timeline.steps()) { BufferedImage frame = new BufferedImage(inventoryImage.getWidth(), inventoryImage.getHeight(), BufferedImage.TYPE_INT_ARGB); @@ -933,6 +940,9 @@ protected void validate() { if (rows <= 0 || slotsPerRow <= 0) { throw new IllegalArgumentException("rows and slotsPerRow must be positive"); } + if (rows > MAX_SLOTS_PER_AXIS || slotsPerRow > MAX_SLOTS_PER_AXIS) { + throw new IllegalArgumentException("rows and slotsPerRow must be at most " + MAX_SLOTS_PER_AXIS); + } } @Override diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/StrictJson.java b/generator/src/main/java/net/aerh/imagegenerator/impl/StrictJson.java index 2af9613..dfd032f 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/StrictJson.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/StrictJson.java @@ -31,6 +31,11 @@ @Slf4j public final class StrictJson { + /** The longest number literal accepted, in characters. */ + private static final int MAX_NUMBER_LENGTH = 64; + /** The largest decimal exponent, in either direction, a number literal may carry. */ + private static final int MAX_NUMBER_SCALE = 400; + private StrictJson() { } @@ -107,7 +112,7 @@ public static JsonElement readElement(JsonReader reader, String what) throws IOE return new JsonPrimitive(reader.nextString()); } case NUMBER -> { - return new JsonPrimitive(new BigDecimal(reader.nextString())); + return new JsonPrimitive(readNumber(reader.nextString(), what)); } case BOOLEAN -> { return new JsonPrimitive(reader.nextBoolean()); @@ -157,6 +162,28 @@ public static void warnUnknownKeys(JsonObject object, Set allowed, Strin * * @throws IllegalArgumentException naming the key when the value is absent or not an integer */ + /** + * Parses one number literal, rejecting the ones whose plain form would be enormous. A literal like + * {@code 1e900000000} is a dozen bytes of input, but printing or rescaling it materialises hundreds + * of megabytes of digits, so both its length and its exponent are bounded here. + */ + private static BigDecimal readNumber(String literal, String what) { + if (literal.length() > MAX_NUMBER_LENGTH) { + throw new IllegalArgumentException("Number in " + what + " JSON is too long (over " + + MAX_NUMBER_LENGTH + " characters)"); + } + BigDecimal value; + try { + value = new BigDecimal(literal); + } catch (NumberFormatException e) { + throw new IllegalArgumentException("Malformed number in " + what + " JSON: " + literal); + } + if (Math.abs((long) value.scale()) > MAX_NUMBER_SCALE) { + throw new IllegalArgumentException("Number in " + what + " JSON is out of range: " + literal); + } + return value; + } + public static int requireInt(JsonObject object, String key) { JsonElement element = object.get(key); if (element == null || !element.isJsonPrimitive() || !element.getAsJsonPrimitive().isNumber()) { diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneCompositor.java b/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneCompositor.java index 7a58513..49625e0 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneCompositor.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneCompositor.java @@ -1,5 +1,6 @@ package net.aerh.imagegenerator.impl.scene; +import net.aerh.imagegenerator.image.RenderLimits; import net.aerh.imagegenerator.exception.GeneratorException; import net.aerh.imagegenerator.item.GeneratedObject; import net.aerh.imagegenerator.pack.AnimationTimeline; @@ -62,9 +63,11 @@ static GeneratedObject compose(List placed, int width, int height) } } if (sources.isEmpty()) { + RenderLimits.checkCanvas(width, height); return new GeneratedObject(composeFrame(placed, width, height, null)); } AnimationTimeline timeline = AnimationTimeline.of(sources); + RenderLimits.checkFrames(width, height, timeline.steps().size()); List compositeFrames = new ArrayList<>(timeline.steps().size()); for (AnimationTimeline.Step step : timeline.steps()) { diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneParser.java b/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneParser.java index 830be03..5dc0a09 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneParser.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/scene/SceneParser.java @@ -47,6 +47,11 @@ */ final class SceneParser { + /** The largest scene `scale`; the canvas grows with its square. */ + static final int MAX_SCALE = 16; + /** The largest margin, spacing, HUD width, column count and placement offset, in px or cells. */ + static final int MAX_OFFSET_PX = 4096; + /** The scene schema version this build understands. Newer documents are rejected. */ static final int SCHEMA_VERSION = 1; @@ -97,6 +102,7 @@ static Scene parse(String json) { if (scale < 1) { throw new IllegalArgumentException("Scene `scale` must be at least 1, got: " + scale); } + requireAtMost(scale, MAX_SCALE, "Scene `scale`"); } int margin = 0; @@ -105,6 +111,7 @@ static Scene parse(String json) { if (margin < 0) { throw new IllegalArgumentException("Scene `margin` must not be negative, got: " + margin); } + requireAtMost(margin, MAX_OFFSET_PX, "Scene `margin`"); } if (!root.has("regions")) { @@ -353,6 +360,7 @@ private static ParsedContent parseHud(JsonObject object, String name) { if (guiWidth < 1) { throw new IllegalArgumentException(context + " `gui_width` must be at least 1, got: " + guiWidth); } + requireAtMost(guiWidth, MAX_OFFSET_PX, context + " `gui_width`"); } Boolean textShadow = object.has("text_shadow") ? StrictJson.requireBoolean(object, "text_shadow", context) @@ -493,6 +501,7 @@ private static ParsedContent parseArrangement(ArrangementKind kind, JsonObject o if (spacing < 0) { throw new IllegalArgumentException(context + " `spacing` must not be negative, got: " + spacing); } + requireAtMost(spacing, MAX_OFFSET_PX, context + " `spacing`"); } Align alignment = object.has("alignment") ? parseAlign(StrictJson.requireString(object, "alignment", context), name, "alignment") @@ -508,6 +517,7 @@ private static ParsedContent parseArrangement(ArrangementKind kind, JsonObject o if (columns < 1) { throw new IllegalArgumentException(context + " `columns` must be at least 1, got: " + columns); } + requireAtMost(columns, MAX_OFFSET_PX, context + " `columns`"); if (object.has("cell")) { String cell = StrictJson.requireString(object, "cell", context); if (!cell.equals("slot")) { @@ -571,9 +581,19 @@ private static int requireIntElement(JsonElement element, String context) { if (intValue != value) { throw new IllegalArgumentException(context + " must be an [x, y] integer pair, got: " + value); } + if (Math.abs((long) intValue) > MAX_OFFSET_PX) { + throw new IllegalArgumentException(context + " values must be within -" + MAX_OFFSET_PX + + " to " + MAX_OFFSET_PX + ", got: " + intValue); + } return intValue; } + private static void requireAtMost(int value, int max, String what) { + if (value > max) { + throw new IllegalArgumentException(what + " must be at most " + max + ", got: " + value); + } + } + /** A parsed region content together with the content-specific keys allowed on its region object. */ private record ParsedContent(Content content, Set contentKeys) { } diff --git a/generator/src/main/java/net/aerh/imagegenerator/impl/template/ContentTemplate.java b/generator/src/main/java/net/aerh/imagegenerator/impl/template/ContentTemplate.java index bfa871c..b33f3e6 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/impl/template/ContentTemplate.java +++ b/generator/src/main/java/net/aerh/imagegenerator/impl/template/ContentTemplate.java @@ -72,6 +72,9 @@ @Slf4j public final class ContentTemplate { + /** The most output one fill may produce, counted as text characters plus one per JSON node. */ + public static final int MAX_FILL_OUTPUT_CHARS = 1_000_000; + /** Marker key naming the repeatable section an array-element object belongs to. */ static final String REPEAT_KEY = "template_repeat"; /** Highest {@code schema_version} this build understands. */ @@ -180,7 +183,7 @@ public JsonObject fill(Map values, Map globalValues = resolveGlobalValues(values); - return (JsonObject) transformElement(content, globalValues, rows); + return (JsonObject) transformElement(content, globalValues, rows, new FillBudget()); } /** @@ -243,12 +246,13 @@ private Map resolveGlobalValues(Map values) { * capture's own values reproduces the capture exactly. */ private JsonElement transformElement(JsonElement element, Map scope, - Map>> rows) { + Map>> rows, FillBudget budget) { + budget.charge(1); if (element.isJsonObject()) { JsonObject source = element.getAsJsonObject(); JsonObject out = new JsonObject(); for (Map.Entry entry : source.entrySet()) { - out.add(entry.getKey(), transformElement(entry.getValue(), scope, rows)); + out.add(entry.getKey(), transformElement(entry.getValue(), scope, rows, budget)); } return out; } @@ -256,15 +260,21 @@ private JsonElement transformElement(JsonElement element, Map sc JsonArray out = new JsonArray(); for (JsonElement child : element.getAsJsonArray()) { if (isRepeatMarker(child)) { - expandRepeat(child.getAsJsonObject(), scope, rows, out); + expandRepeat(child.getAsJsonObject(), scope, rows, out, budget); } else { - out.add(transformElement(child, scope, rows)); + out.add(transformElement(child, scope, rows, budget)); } } return out; } if (element.isJsonPrimitive() && element.getAsJsonPrimitive().isString()) { - return new JsonPrimitive(render(element.getAsString(), name -> resolveValue(name, scope))); + String text = element.getAsString(); + budget.charge(text.length()); + return new JsonPrimitive(render(text, name -> { + String value = resolveValue(name, scope); + budget.charge(value.length()); + return value; + })); } // Numbers, booleans and null carry no tokens; copy them so the returned tree owns no // references into the template. @@ -277,7 +287,7 @@ private JsonElement transformElement(JsonElement element, Map sc * nothing is appended - the marker object is removed. */ private void expandRepeat(JsonObject marker, Map scope, - Map>> rows, JsonArray out) { + Map>> rows, JsonArray out, FillBudget budget) { String section = marker.get(REPEAT_KEY).getAsString(); List> sectionRows = rows.get(section); if (sectionRows == null || sectionRows.isEmpty()) { @@ -297,7 +307,7 @@ private void expandRepeat(JsonObject marker, Map scope, } Map merged = new HashMap<>(scope); merged.putAll(row); - out.add(transformElement(stripped, merged, rows)); + out.add(transformElement(stripped, merged, rows, budget)); } } @@ -314,6 +324,23 @@ private String resolveValue(String name, Map scope) { throw new IllegalArgumentException("Required placeholder `" + name + "` was not supplied a value"); } + /** + * Running size of one {@link #fill} output. Substitution multiplies tokens by value length by + * row count, so a small template and small values can still expand without bound; the fill + * fails once its output passes {@link #MAX_FILL_OUTPUT_CHARS}. + */ + private static final class FillBudget { + private long used; + + void charge(long amount) { + used += amount; + if (used > MAX_FILL_OUTPUT_CHARS) { + throw new IllegalArgumentException("Filled template is too large: over " + + MAX_FILL_OUTPUT_CHARS + " characters and nodes of output"); + } + } + } + // ------------------------------------------------------------- token scanning /** Sink a scanned {@code {name}} token resolves through - records or substitutes it. */ diff --git a/generator/src/main/java/net/aerh/imagegenerator/parser/text/IconParser.java b/generator/src/main/java/net/aerh/imagegenerator/parser/text/IconParser.java index e00f088..81a4340 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/parser/text/IconParser.java +++ b/generator/src/main/java/net/aerh/imagegenerator/parser/text/IconParser.java @@ -10,6 +10,9 @@ public class IconParser implements StringParser { + /** The most times one icon placeholder may repeat its character. */ + public static final int MAX_REPEAT = 100; + @Override public String parse(String input) { return parse(input, ParseContext.empty()); @@ -57,7 +60,7 @@ private String parseIcon(Icon icon, String extra, ParseContext context) { try { int amount = Integer.parseInt(extra); - return character.repeat(amount); + return character.repeat(clampRepeat(amount)); } catch (NumberFormatException e) { return character; } @@ -98,7 +101,15 @@ private String parseIconReference(String extra, ParseContext context) { return null; } - return character.repeat(count); + return character.repeat(clampRepeat(count)); + } + + /** + * Keeps a repeat count from user text within {@code 0..}{@link #MAX_REPEAT}. The count is part of + * the placeholder a user types, so without a ceiling a few characters expand to gigabytes. + */ + private static int clampRepeat(int count) { + return Math.max(0, Math.min(count, MAX_REPEAT)); } private String resolveIconCharacter(String target, ParseContext context) { diff --git a/generator/src/main/java/net/aerh/imagegenerator/tools/InventoryRequest.java b/generator/src/main/java/net/aerh/imagegenerator/tools/InventoryRequest.java index 8418918..415c3d1 100644 --- a/generator/src/main/java/net/aerh/imagegenerator/tools/InventoryRequest.java +++ b/generator/src/main/java/net/aerh/imagegenerator/tools/InventoryRequest.java @@ -1,5 +1,6 @@ package net.aerh.imagegenerator.tools; +import net.aerh.imagegenerator.impl.MinecraftInventoryGenerator; import net.aerh.imagegenerator.exception.GeneratorValidationException; import net.aerh.imagegenerator.impl.tooltip.MinecraftTooltipGenerator; import net.aerh.imagegenerator.pack.PackId; @@ -29,6 +30,10 @@ public record InventoryRequest(int rows, int slotsPerRow, String inventoryString if (slotsPerRow <= 0) { throw new GeneratorValidationException("slotsPerRow must be positive"); } + if (rows > MinecraftInventoryGenerator.MAX_SLOTS_PER_AXIS || slotsPerRow > MinecraftInventoryGenerator.MAX_SLOTS_PER_AXIS) { + throw new GeneratorValidationException("rows and slotsPerRow must be at most %s", + String.valueOf(MinecraftInventoryGenerator.MAX_SLOTS_PER_AXIS)); + } hoveredItemString = Strings.blankToNull(hoveredItemString); containerName = Strings.blankToNull(containerName); } diff --git a/generator/src/test/java/net/aerh/imagegenerator/image/RenderLimitsTest.java b/generator/src/test/java/net/aerh/imagegenerator/image/RenderLimitsTest.java new file mode 100644 index 0000000..57cbf20 --- /dev/null +++ b/generator/src/test/java/net/aerh/imagegenerator/image/RenderLimitsTest.java @@ -0,0 +1,140 @@ +package net.aerh.imagegenerator.image; + +import net.aerh.imagegenerator.exception.GeneratorException; +import net.aerh.imagegenerator.exception.GeneratorValidationException; +import net.aerh.imagegenerator.impl.MinecraftInventoryGenerator; +import net.aerh.imagegenerator.impl.scene.MinecraftSceneGenerator; +import net.aerh.imagegenerator.impl.template.ContentTemplate; +import net.aerh.imagegenerator.impl.tooltip.MinecraftTooltipGenerator; +import net.aerh.imagegenerator.item.GeneratedObject; +import net.aerh.imagegenerator.parser.text.IconParser; +import net.aerh.imagegenerator.tools.InventoryRequest; +import org.junit.jupiter.api.Test; + +import java.util.Map; + +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertThrows; +import static org.junit.jupiter.api.Assertions.assertTimeoutPreemptively; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.time.Duration; + +/** + * The shared pixel budget and the input clamps that keep short, untrusted input from asking for + * gigabytes: each case here used to exhaust the heap or burn seconds of CPU. + */ +class RenderLimitsTest { + + @Test + void canvasWithinBudgetPasses() { + assertDoesNotThrow(() -> RenderLimits.checkCanvas(1_408, 1_000)); + // A full chest with the 182-frame glint is the largest stock animation and must keep working. + assertDoesNotThrow(() -> RenderLimits.checkFrames(1_408, 1_000, 182)); + } + + @Test + void oversizedCanvasIsRejected() { + assertThrows(GeneratorValidationException.class, () -> RenderLimits.checkCanvas(10_000, 10_000)); + assertThrows(GeneratorValidationException.class, () -> RenderLimits.checkCanvas(0, 10)); + assertThrows(GeneratorValidationException.class, () -> RenderLimits.checkCanvas(-5, 10)); + assertThrows(GeneratorValidationException.class, + () -> RenderLimits.checkCanvas(Integer.MAX_VALUE + 1L, 1)); + } + + @Test + void oversizedAnimationIsRejected() { + assertDoesNotThrow(() -> RenderLimits.checkCanvas(4_000, 4_000)); + assertThrows(GeneratorValidationException.class, () -> RenderLimits.checkFrames(4_000, 4_000, 182)); + } + + @Test + void limitsFollowSystemProperties() { + System.setProperty(RenderLimits.MAX_CANVAS_PIXELS_PROPERTY, "100"); + try { + assertEquals(100, RenderLimits.maxCanvasPixels()); + assertThrows(GeneratorValidationException.class, () -> RenderLimits.checkCanvas(11, 10)); + assertDoesNotThrow(() -> RenderLimits.checkCanvas(10, 10)); + } finally { + System.clearProperty(RenderLimits.MAX_CANVAS_PIXELS_PROPERTY); + } + assertEquals(RenderLimits.DEFAULT_MAX_CANVAS_PIXELS, RenderLimits.maxCanvasPixels()); + } + + @Test + void iconRepeatCountIsClamped() { + IconParser parser = new IconParser(); + assertEquals("•".repeat(IconParser.MAX_REPEAT), parser.parse("%%dot:5000000%%")); + assertEquals("❤".repeat(IconParser.MAX_REPEAT), parser.parse("%%icon:health:2000000000%%")); + assertEquals("", parser.parse("%%dot:-3%%")); + } + + @Test + void tooltipPaddingIsClamped() { + GeneratedObject padded = new GeneratorImageBuilder() + .addGenerator(new MinecraftTooltipGenerator.Builder().withName("x").withItemLore("hello").withPadding(8_000).build()) + .build(); + GeneratedObject plain = new GeneratorImageBuilder() + .addGenerator(new MinecraftTooltipGenerator.Builder().withName("x").withItemLore("hello").build()) + .build(); + + assertEquals(plain.getImage().getWidth() + 2 * MinecraftTooltip.MAX_PADDING, padded.getImage().getWidth()); + assertEquals(plain.getImage().getHeight() + 2 * MinecraftTooltip.MAX_PADDING, padded.getImage().getHeight()); + } + + @Test + void hugeIconRepeatInLoreStillRenders() { + GeneratedObject result = new GeneratorImageBuilder() + .addGenerator(new MinecraftTooltipGenerator.Builder().withName("x").withItemLore("%%dot:5000000%%").build()) + .build(); + assertTrue(result.getImage().getWidth() > 0); + } + + @Test + void oversizedInventoryIsRejected() { + assertThrows(IllegalArgumentException.class, () -> new MinecraftInventoryGenerator.Builder() + .withRows(120).withSlotsPerRow(120).withInventoryString("stone:[1]").build()); + // Within the per-axis cap, but 60x60 slots is still far over the canvas budget. + assertThrows(GeneratorException.class, () -> new MinecraftInventoryGenerator.Builder() + .withRows(60).withSlotsPerRow(60).withInventoryString("stone:[1]").build()); + assertThrows(GeneratorValidationException.class, () -> InventoryRequest.builder() + .rows(120).slotsPerRow(9).inventoryString("stone:[1]").build()); + } + + @Test + void hugeExponentNumberIsRejectedQuickly() { + IllegalArgumentException thrown = assertTimeoutPreemptively(Duration.ofSeconds(2), + () -> assertThrows(IllegalArgumentException.class, + () -> MinecraftSceneGenerator.fromScene("{\"schema_version\":1e400000000,\"regions\":[]}"))); + assertTrue(thrown.getMessage().length() < 200, "the error must not print the expanded number"); + + assertThrows(IllegalArgumentException.class, + () -> MinecraftSceneGenerator.fromScene("{\"schema_version\":1e-400000000,\"regions\":[]}")); + assertThrows(IllegalArgumentException.class, + () -> MinecraftSceneGenerator.fromScene("{\"schema_version\":1" + "0".repeat(100) + ",\"regions\":[]}")); + } + + @Test + void sceneOptionsHaveUpperBounds() { + String region = "\"regions\":[{\"name\":\"t\",\"type\":\"tooltip\",\"lore\":\"hi\"}]"; + assertThrows(IllegalArgumentException.class, + () -> MinecraftSceneGenerator.fromScene("{\"schema_version\":1,\"scale\":200," + region + "}")); + assertThrows(IllegalArgumentException.class, + () -> MinecraftSceneGenerator.fromScene("{\"schema_version\":1,\"margin\":50000," + region + "}")); + assertThrows(IllegalArgumentException.class, () -> MinecraftSceneGenerator.fromScene( + "{\"schema_version\":1,\"regions\":[{\"name\":\"t\",\"type\":\"tooltip\",\"lore\":\"hi\",\"at\":[100000,0]}]}")); + assertDoesNotThrow(() -> MinecraftSceneGenerator.fromScene("{\"schema_version\":1,\"scale\":2,\"margin\":8," + region + "}")); + } + + @Test + void templateFillOutputIsBounded() { + ContentTemplate template = ContentTemplate.parse( + "{\"schema_version\":1,\"placeholders\":{\"a\":{}},\"content\":{\"lore\":\"" + "{a}".repeat(1_000) + "\"}}"); + + assertDoesNotThrow(() -> template.fill(Map.of("a", "x".repeat(100)))); + IllegalArgumentException thrown = assertThrows(IllegalArgumentException.class, + () -> template.fill(Map.of("a", "x".repeat(2_000)))); + assertTrue(thrown.getMessage().contains("too large")); + } +}