/ 
HTML-FormHandler-0.40068
⭐ Starred 89 / HTML::FormHandler::Render::Simple
Security Advisories (1)
CVE-2022-4993 (2026-08-13)

HTML::FormHandler versions through 0.40068 for Perl allow attacker selected method dispatch and resource exhaustion because _apply_actions and add_error use error message text built from request data as a Locale::Maketext bracket notation template. add_error hands its first argument to the language handle as the Locale::Maketext message key, and the default handle's lexicon sets `_AUTO`, so a string that is not a lexicon entry is compiled as a bracket notation template instead of being looked up. In a bracket group the first token names a method called on the language handle and the remaining tokens are its arguments. Three kinds of text the library did not author reach that position. _apply_actions installs a `$SIG{__WARN__}` handler that stores the warning text in `$error_message`, and a captured warning survives a successful action, so a field carrying a numeric transform turns `Argument "[sprintf,%50000000d,0]" isn't numeric` into the template; a warning quotes the submitted value verbatim, so the group is well formed and dispatches. `$error_message ||= $tobj->validate($new_value)` takes a type constraint's own failure message, which renders the rejected value through a partial dumper in bracket and comma form (Devel::PartialDump when Moose can load it, Type::Tiny's own dumper always), so a field with `apply => [ Str ]` given a parameter sent more than once, which arrives as an array, gets `Reference ["a","b"] did not pass type constraint "Str"` as its template, from a request that carries no bracket character of its own. A coercion or transform exception reaches it the same way. Beyond those, a validator whose message contains the field value puts that value in the template directly, and add_error replaces the message list with the contents of an arrayref first argument (`@message = @{$message[0]} if ref $message[0] eq 'ARRAY'`), so a value arriving as an array fills the argument slots from the same request as well. A malformed group such as `[0]` makes the compile croak, and HTML::FormHandler::I18N::maketext and add_error each re-raise that as a die, so process() throws. A well formed group naming sprintf reaches CORE::sprintf with an attacker chosen field width. Any caller that applies a type constraint or a transform to an untrusted field, or whose validator passes an untrusted field value to add_error, can be made to throw an unhandled exception out of process(), or to allocate an arbitrary amount of memory in one request, and an application whose language handle subclass defines side effecting public methods makes those callable with attacker chosen arguments. The dumped type constraint message is bounded to the exception, because both dumpers quote non-numeric elements so the method slot is never an attacker chosen name. The built-in messages pass fixed templates with the value in an argument slot, where it stays inert, and the built-in field types attach explicit message callbacks, so neither is affected.

NAME

HTML::FormHandler::Render::Simple - simple rendering role

VERSION

version 0.40068

SYNOPSIS

This is a Moose role that is an example of a simple rendering routine for HTML::FormHandler. It's here as an example of how to write a custom renderer in one package, if you prefer that to using the widgets. It won't always be updated with improvements by default, because it was becoming a lot of work to update the rendering in multiple places.

For a 'MyApp::Form::Renderer' which you've created and modified, in your Form class:

package MyApp::Form::Silly;
use Moose;
extends 'HTML::FormHandler::Model::DBIC';
with 'MyApp::Form::Renderers';

In a template:

[% form.render %]

The widgets are rendered with $field->render; rendering routines from a class like this use $form->render_field('field_name') to render individual fields:

[% form.render_field( 'title' ) %]

DESCRIPTION

This role provides HTML output routines for the 'widget' types defined in the provided FormHandler fields. Each 'widget' name has a 'widget_$name' method here.

These widget routines output strings with HTML suitable for displaying form fields.

The widget for a particular field can be defined in the form. You can create additional widget routines in your form for custom widgets.

The fill-in-form values ('fif') are cleaned with the 'render_filter' method of the base field class. You can change the filter to suit your own needs: see HTML::FormHandler::Manual::Rendering

render

To render all the fields in a form in sorted order (using 'sorted_fields' method).

render_start, render_end

These use the methods in HTML::FormHandler::Widget::Form::Simple now. If you want to customize them, copy them to your own package.

Will render the beginning and ending <form> tags and fieldsets. Allows for easy splitting up of the form if you want to hand-render some of the fields.

[% form.render_start %]
[% form.render_field('title') %]
<insert specially rendered field>
[% form.render_field('some_field') %]
[% form.render_end %]

render_field

Render a field passing in a field object or a field name

$form->render_field( $field )
$form->render_field( 'title' )

render_text

Output an HTML string for a text widget

render_password

Output an HTML string for a password widget

render_hidden

Output an HTML string for a hidden input widget

render_select

Output an HTML string for a 'select' widget, single or multiple

render_checkbox

Output an HTML string for a 'checkbox' widget

render_radio_group

Output an HTML string for a 'radio_group' selection widget. This widget should be for a field that inherits from 'Select', since it requires the existence of an 'options' array.

render_textarea

Output an HTML string for a textarea widget

render_compound

Renders field with 'compound' widget

render_submit

Renders field with 'submit' widget

AUTHOR

FormHandler Contributors - see HTML::FormHandler

COPYRIGHT AND LICENSE

This software is copyright (c) 2017 by Gerda Shank.

This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself.