Skip to content

Commit 56323ab

Browse files
farindkfarindk
committed
pass security limits down into image allocation and color conversion (#1389)
1 parent cac74f9 commit 56323ab

30 files changed

+344
-240
lines changed

‎fuzzing/color_conversion_fuzzer.cc

+4-3
Original file line numberDiff line numberDiff line change
@@ -70,7 +70,7 @@ static bool read_plane(BitstreamRange* range,
7070
if (!range->prepare_read(static_cast<size_t>(width) * height)) {
7171
return false;
7272
}
73-
if (auto err = image->add_plane2(channel, width, height, bit_depth)) {
73+
if (auto err = image->add_plane(channel, width, height, bit_depth, heif_get_disabled_security_limits())) {
7474
return false;
7575
}
7676
uint32_t stride;
@@ -96,7 +96,7 @@ static bool read_plane_interleaved(BitstreamRange* range,
9696
if (!range->prepare_read(static_cast<size_t>(width) * height * comps)) {
9797
return false;
9898
}
99-
if (auto err = image->add_plane2(channel, width, height, bit_depth)) {
99+
if (auto err = image->add_plane(channel, width, height, bit_depth, heif_get_disabled_security_limits())) {
100100
return false;
101101
}
102102
uint32_t stride;
@@ -255,7 +255,8 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
255255
static_cast<heif_chroma>(out_chroma),
256256
nullptr,
257257
output_bpp,
258-
options->color_conversion_options);
258+
options->color_conversion_options,
259+
heif_get_disabled_security_limits());
259260

260261
heif_encoding_options_free(options);
261262

‎libheif/api/libheif/heif.cc

+7-6
Original file line numberDiff line numberDiff line change
@@ -1774,7 +1774,7 @@ heif_error heif_image_crop(struct heif_image* img,
17741774
"Image size exceeds maximum supported size"};
17751775
}
17761776

1777-
auto cropResult = img->image->crop(left, static_cast<int>(w) - 1 - right, top, static_cast<int>(h) - 1 - bottom);
1777+
auto cropResult = img->image->crop(left, static_cast<int>(w) - 1 - right, top, static_cast<int>(h) - 1 - bottom, nullptr);
17781778
if (cropResult.error) {
17791779
return cropResult.error.error_struct(img->image.get());
17801780
}
@@ -1806,7 +1806,8 @@ int heif_image_has_channel(const struct heif_image* img, enum heif_channel chann
18061806
struct heif_error heif_image_add_plane(struct heif_image* image,
18071807
heif_channel channel, int width, int height, int bit_depth)
18081808
{
1809-
if (auto err = image->image->add_plane2(channel, width, height, bit_depth)) {
1809+
// Note: no security limit, because this is explicitly requested by the user.
1810+
if (auto err = image->image->add_plane(channel, width, height, bit_depth, nullptr)) {
18101811
return err.error_struct(image->image.get());
18111812
}
18121813
else {
@@ -1820,7 +1821,7 @@ struct heif_error heif_image_add_channel(struct heif_image* image,
18201821
int width, int height,
18211822
heif_channel_datatype datatype, int bit_depth)
18221823
{
1823-
if (!image->image->add_channel(channel, width, height, datatype, bit_depth)) {
1824+
if (!image->image->add_channel(channel, width, height, datatype, bit_depth, nullptr)) {
18241825
struct heif_error err = {heif_error_Memory_allocation_error,
18251826
heif_suberror_Unspecified,
18261827
"Cannot allocate memory for image plane"};
@@ -1994,7 +1995,7 @@ int heif_image_is_premultiplied_alpha(struct heif_image* image)
19941995

19951996
struct heif_error heif_image_extend_padding_to_size(struct heif_image* image, int min_physical_width, int min_physical_height)
19961997
{
1997-
Error err = image->image->extend_padding_to_size2(min_physical_width, min_physical_height);
1998+
Error err = image->image->extend_padding_to_size(min_physical_width, min_physical_height, false, nullptr);
19981999
if (err) {
19992000
return err.error_struct(image->image.get());
20002001
}
@@ -2011,7 +2012,7 @@ struct heif_error heif_image_scale_image(const struct heif_image* input,
20112012
{
20122013
std::shared_ptr<HeifPixelImage> out_img;
20132014

2014-
Error err = input->image->scale_nearest_neighbor(out_img, width, height);
2015+
Error err = input->image->scale_nearest_neighbor(out_img, width, height, nullptr);
20152016
if (err) {
20162017
return err.error_struct(input->image.get());
20172018
}
@@ -2026,7 +2027,7 @@ struct heif_error heif_image_scale_image(const struct heif_image* input,
20262027
struct heif_error heif_image_extend_to_size_fill_with_zero(struct heif_image* image,
20272028
uint32_t width, uint32_t height)
20282029
{
2029-
Error err = image->image->extend_to_size_with_zero2(width, height);
2030+
Error err = image->image->extend_to_size_with_zero(width, height, nullptr);
20302031
if (err) {
20312032
return err.error_struct(image->image.get());
20322033
}

‎libheif/codecs/uncompressed/unc_codec.cc

+7-5
Original file line numberDiff line numberDiff line change
@@ -441,7 +441,8 @@ static AbstractDecoder* makeDecoder(uint32_t width, uint32_t height, const std::
441441
Result<std::shared_ptr<HeifPixelImage>> UncompressedImageCodec::create_image(const std::shared_ptr<const Box_cmpd> cmpd,
442442
const std::shared_ptr<const Box_uncC> uncC,
443443
uint32_t width,
444-
uint32_t height)
444+
uint32_t height,
445+
const heif_security_limits* limits)
445446
{
446447
auto img = std::make_shared<HeifPixelImage>();
447448
heif_chroma chroma = heif_chroma_undefined;
@@ -465,12 +466,13 @@ Result<std::shared_ptr<HeifPixelImage>> UncompressedImageCodec::create_image(con
465466
}
466467

467468
if ((channel == heif_channel_Cb) || (channel == heif_channel_Cr)) {
468-
if (auto err = img->add_plane2(channel, (width / chroma_h_subsampling(chroma)), (height / chroma_v_subsampling(chroma)), component.component_bit_depth)) {
469+
if (auto err = img->add_plane(channel, (width / chroma_h_subsampling(chroma)), (height / chroma_v_subsampling(chroma)), component.component_bit_depth,
470+
limits)) {
469471
return err;
470472
}
471473
}
472474
else {
473-
if (auto err = img->add_plane2(channel, width, height, component.component_bit_depth)) {
475+
if (auto err = img->add_plane(channel, width, height, component.component_bit_depth, limits)) {
474476
return err;
475477
}
476478
}
@@ -505,7 +507,7 @@ Error UncompressedImageCodec::decode_uncompressed_image_tile(const HeifContext*
505507
uint32_t tile_width = ispe->get_width() / uncC->get_number_of_tile_columns();
506508
uint32_t tile_height = ispe->get_height() / uncC->get_number_of_tile_rows();
507509

508-
Result<std::shared_ptr<HeifPixelImage>> createImgResult = create_image(cmpd, uncC, tile_width, tile_height);
510+
Result<std::shared_ptr<HeifPixelImage>> createImgResult = create_image(cmpd, uncC, tile_width, tile_height, context->get_security_limits());
509511
if (createImgResult.error) {
510512
return createImgResult.error;
511513
}
@@ -629,7 +631,7 @@ Error UncompressedImageCodec::decode_uncompressed_image(const HeifContext* conte
629631
return error;
630632
}
631633

632-
Result<std::shared_ptr<HeifPixelImage>> createImgResult = create_image(cmpd, uncC, width, height);
634+
Result<std::shared_ptr<HeifPixelImage>> createImgResult = create_image(cmpd, uncC, width, height, context->get_security_limits());
633635
if (createImgResult.error) {
634636
return createImgResult.error;
635637
}

‎libheif/codecs/uncompressed/unc_codec.h

+2-1
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,8 @@ class UncompressedImageCodec
6868
static Result<std::shared_ptr<HeifPixelImage>> create_image(std::shared_ptr<const Box_cmpd>,
6969
std::shared_ptr<const Box_uncC>,
7070
uint32_t width,
71-
uint32_t height);
71+
uint32_t height,
72+
const heif_security_limits* limits);
7273

7374
static Error check_header_validity(std::optional<const std::shared_ptr<const Box_ispe>>,
7475
const std::shared_ptr<const Box_cmpd>&,

‎libheif/color-conversion/alpha.cc

+3-2
Original file line numberDiff line numberDiff line change
@@ -56,7 +56,8 @@ Result<std::shared_ptr<HeifPixelImage>>
5656
Op_drop_alpha_plane::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
5757
const ColorState& input_state,
5858
const ColorState& target_state,
59-
const heif_color_conversion_options& options) const
59+
const heif_color_conversion_options& options,
60+
const heif_security_limits* limits) const
6061
{
6162
uint32_t width = input->get_width();
6263
uint32_t height = input->get_height();
@@ -74,7 +75,7 @@ Op_drop_alpha_plane::convert_colorspace(const std::shared_ptr<const HeifPixelIma
7475
heif_channel_G,
7576
heif_channel_B}) {
7677
if (input->has_channel(channel)) {
77-
outimg->copy_new_plane_from(input, channel, channel);
78+
outimg->copy_new_plane_from(input, channel, channel, limits);
7879
}
7980
}
8081

‎libheif/color-conversion/alpha.h

+2-1
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,8 @@ class Op_drop_alpha_plane : public ColorConversionOperation
3838
convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
3939
const ColorState& input_state,
4040
const ColorState& target_state,
41-
const heif_color_conversion_options& options) const override;
41+
const heif_color_conversion_options& options,
42+
const heif_security_limits* limits) const override;
4243
};
4344

4445
#endif //LIBHEIF_COLORCONVERSION_ALPHA_H

‎libheif/color-conversion/chroma_sampling.cc

+24-20
Original file line numberDiff line numberDiff line change
@@ -79,7 +79,8 @@ Result<std::shared_ptr<HeifPixelImage>>
7979
Op_YCbCr444_to_YCbCr420_average<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
8080
const ColorState& input_state,
8181
const ColorState& target_state,
82-
const heif_color_conversion_options& options) const
82+
const heif_color_conversion_options& options,
83+
const heif_security_limits* limits) const
8384
{
8485
bool hdr = !std::is_same<Pixel, uint8_t>::value;
8586

@@ -129,14 +130,14 @@ Op_YCbCr444_to_YCbCr420_average<Pixel>::convert_colorspace(const std::shared_ptr
129130
uint32_t cwidth = (width + 1) / 2;
130131
uint32_t cheight = (height + 1) / 2;
131132

132-
if (auto err = outimg->add_plane2(heif_channel_Y, width, height, bpp_y) ||
133-
outimg->add_plane2(heif_channel_Cb, cwidth, cheight, bpp_cb) ||
134-
outimg->add_plane2(heif_channel_Cr, cwidth, cheight, bpp_cr)) {
133+
if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
134+
outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp_cb, limits) ||
135+
outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp_cr, limits)) {
135136
return err;
136137
}
137138

138139
if (has_alpha) {
139-
if (auto err = outimg->add_plane2(heif_channel_Alpha, width, height, bpp_a)) {
140+
if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
140141
return err;
141142
}
142143
}
@@ -297,7 +298,8 @@ Result<std::shared_ptr<HeifPixelImage>>
297298
Op_YCbCr444_to_YCbCr422_average<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
298299
const ColorState& input_state,
299300
const ColorState& target_state,
300-
const heif_color_conversion_options& options) const
301+
const heif_color_conversion_options& options,
302+
const heif_security_limits* limits) const
301303
{
302304
bool hdr = !std::is_same<Pixel, uint8_t>::value;
303305

@@ -347,14 +349,14 @@ Op_YCbCr444_to_YCbCr422_average<Pixel>::convert_colorspace(const std::shared_ptr
347349
uint32_t cwidth = (width + 1) / 2;
348350
uint32_t cheight = height;
349351

350-
if (auto err = outimg->add_plane2(heif_channel_Y, width, height, bpp_y) ||
351-
outimg->add_plane2(heif_channel_Cb, cwidth, cheight, bpp_cb) ||
352-
outimg->add_plane2(heif_channel_Cr, cwidth, cheight, bpp_cr)) {
352+
if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
353+
outimg->add_plane(heif_channel_Cb, cwidth, cheight, bpp_cb, limits) ||
354+
outimg->add_plane(heif_channel_Cr, cwidth, cheight, bpp_cr, limits)) {
353355
return err;
354356
}
355357

356358
if (has_alpha) {
357-
if (auto err = outimg->add_plane2(heif_channel_Alpha, width, height, bpp_a)) {
359+
if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
358360
return err;
359361
}
360362
}
@@ -491,7 +493,8 @@ Result<std::shared_ptr<HeifPixelImage>>
491493
Op_YCbCr420_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
492494
const ColorState& input_state,
493495
const ColorState& target_state,
494-
const heif_color_conversion_options& options) const
496+
const heif_color_conversion_options& options,
497+
const heif_security_limits* limits) const
495498
{
496499
bool hdr = !std::is_same<Pixel, uint8_t>::value;
497500

@@ -538,14 +541,14 @@ Op_YCbCr420_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_pt
538541

539542
outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_444);
540543

541-
if (auto err = outimg->add_plane2(heif_channel_Y, width, height, bpp_y) ||
542-
outimg->add_plane2(heif_channel_Cb, width, height, bpp_cb) ||
543-
outimg->add_plane2(heif_channel_Cr, width, height, bpp_cr)) {
544+
if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
545+
outimg->add_plane(heif_channel_Cb, width, height, bpp_cb, limits) ||
546+
outimg->add_plane(heif_channel_Cr, width, height, bpp_cr, limits)) {
544547
return err;
545548
}
546549

547550
if (has_alpha) {
548-
if (auto err = outimg->add_plane2(heif_channel_Alpha, width, height, bpp_a)) {
551+
if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
549552
return err;
550553
}
551554
}
@@ -768,7 +771,8 @@ Result<std::shared_ptr<HeifPixelImage>>
768771
Op_YCbCr422_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
769772
const ColorState& input_state,
770773
const ColorState& target_state,
771-
const heif_color_conversion_options& options) const
774+
const heif_color_conversion_options& options,
775+
const heif_security_limits* limits) const
772776
{
773777
bool hdr = !std::is_same<Pixel, uint8_t>::value;
774778

@@ -815,14 +819,14 @@ Op_YCbCr422_bilinear_to_YCbCr444<Pixel>::convert_colorspace(const std::shared_pt
815819

816820
outimg->create(width, height, heif_colorspace_YCbCr, heif_chroma_444);
817821

818-
if (auto err = outimg->add_plane2(heif_channel_Y, width, height, bpp_y) ||
819-
outimg->add_plane2(heif_channel_Cb, width, height, bpp_cb) ||
820-
outimg->add_plane2(heif_channel_Cr, width, height, bpp_cr)) {
822+
if (auto err = outimg->add_plane(heif_channel_Y, width, height, bpp_y, limits) ||
823+
outimg->add_plane(heif_channel_Cb, width, height, bpp_cb, limits) ||
824+
outimg->add_plane(heif_channel_Cr, width, height, bpp_cr, limits)) {
821825
return err;
822826
}
823827

824828
if (has_alpha) {
825-
if (auto err = outimg->add_plane2(heif_channel_Alpha, width, height, bpp_a)) {
829+
if (auto err = outimg->add_plane(heif_channel_Alpha, width, height, bpp_a, limits)) {
826830
return err;
827831
}
828832
}

‎libheif/color-conversion/chroma_sampling.h

+8-4
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,8 @@ class Op_YCbCr444_to_YCbCr420_average : public ColorConversionOperation
4141
convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
4242
const ColorState& input_state,
4343
const ColorState& target_state,
44-
const heif_color_conversion_options& options) const override;
44+
const heif_color_conversion_options& options,
45+
const heif_security_limits* limits) const override;
4546
};
4647

4748

@@ -58,7 +59,8 @@ class Op_YCbCr444_to_YCbCr422_average : public ColorConversionOperation
5859
convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
5960
const ColorState& input_state,
6061
const ColorState& target_state,
61-
const heif_color_conversion_options& options) const override;
62+
const heif_color_conversion_options& options,
63+
const heif_security_limits* limits) const override;
6264
};
6365

6466

@@ -77,7 +79,8 @@ class Op_YCbCr420_bilinear_to_YCbCr444 : public ColorConversionOperation
7779
convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
7880
const ColorState& input_state,
7981
const ColorState& target_state,
80-
const heif_color_conversion_options& options) const override;
82+
const heif_color_conversion_options& options,
83+
const heif_security_limits* limits) const override;
8184
};
8285

8386
template <class Pixel>
@@ -93,7 +96,8 @@ class Op_YCbCr422_bilinear_to_YCbCr444 : public ColorConversionOperation
9396
convert_colorspace(const std::shared_ptr<const HeifPixelImage>& input,
9497
const ColorState& input_state,
9598
const ColorState& target_state,
96-
const heif_color_conversion_options& options) const override;
99+
const heif_color_conversion_options& options,
100+
const heif_security_limits* limits) const override;
97101
};
98102

99103
#endif //LIBHEIF_CHROMA_SAMPLING_H

0 commit comments

Comments
 (0)