Commit aa528377c for imagemagick.org

commit aa528377caa1734c51120cece3d852f89e15b40a
Author: Cristy <urban-warrior@imagemagick.org>
Date:   Fri Nov 20 18:59:02 2026 -0500

    AcquireKernelInfo() no longer leaks kernel_cache on a parse error

diff --git a/MagickCore/morphology.c b/MagickCore/morphology.c
index 3a626fcc5..a79447efa 100644
--- a/MagickCore/morphology.c
+++ b/MagickCore/morphology.c
@@ -43,7 +43,7 @@
 % This module provides not only a general morphology function, and the ability
 % to apply more advanced or iterative morphologies, but also functions for the
 % generation of many different types of kernel arrays from user supplied
-% arguments. Prehaps even the generation of a kernel from a small image.
+% arguments. Perhaps even the generation of a kernel from a small image.
 */

 /*
@@ -536,6 +536,8 @@ MagickExport KernelInfo *AcquireKernelInfo(const char *kernel_string,
           {
             if (kernel != (KernelInfo *) NULL)
               kernel=DestroyKernelInfo(kernel);
+            if (kernel_cache != (char *) NULL)
+              kernel_cache=DestroyString(kernel_cache);
             return((KernelInfo *) NULL);
           }

@@ -602,7 +604,7 @@ MagickExport KernelInfo *AcquireKernelInfo(const char *kernel_string,
 %       NOTE: that the 'radius' is optional, but if provided can limit (clip)
 %       the final size of the resulting kernel to a square 2*radius+1 in size.
 %       The radius should be at least 2 times that of the sigma value, or
-%       sever clipping and aliasing may result.  If not given or set to 0 the
+%       severe clipping and aliasing may result.  If not given or set to 0 the
 %       radius will be determined so as to produce the best minimal error
 %       result, which is usually much larger than is normally needed.
 %
@@ -788,7 +790,7 @@ MagickExport KernelInfo *AcquireKernelInfo(const char *kernel_string,
 %      the default FreiChen (type 0) kernel.  As such  FreiChen:45  will look
 %      like a  Sobel:45  but with 'sqrt(2)' instead of '2' values.
 %
-%      WARNING: The above was layed out as per
+%      WARNING: The above was laid out as per
 %          http://www.math.tau.ac.il/~turkel/notes/edge_detectors.pdf
 %      But rotated 90 degrees so direction is from left rather than the top.
 %      I have yet to find any secondary confirmation of the above. The only
@@ -816,7 +818,7 @@ MagickExport KernelInfo *AcquireKernelInfo(const char *kernel_string,
 %    Disk:[{radius}[,{scale}]]
 %       Generate a binary disk, thresholded at the radius given, the radius
 %       may be a float-point value. Final Kernel size is floor(radius)*2+1
-%       square. A radius of 5.3 is the default.
+%       square. The default is a radius of approximately 4.3 (a 9x9 kernel).
 %
 %       NOTE: That a low radii Disk kernels produce the same results as
 %       many of the previously defined kernels, but differ greatly at larger
@@ -1050,7 +1052,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
           AcquireAlignedMemory(1,sizeof(*kernel->values)));
         if (kernel->values == (MagickRealType *) NULL)
           return(DestroyKernelInfo(kernel));
-        kernel->maximum = kernel->values[0] = args->rho;
+        kernel->values[0] = args->rho;
+        CalcKernelMetaData(kernel);  /* ranges, minimum and maximum */
         break;
       }
       break;
@@ -1168,7 +1171,7 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
         ** It generates a gaussian 3 times the width, and compresses it into
         ** the expected range.  This produces a closer normalization of the
         ** resulting kernel, especially for very low sigma values.
-        ** As such while wierd it is prefered.
+        ** As such while weird it is preferred.
         **
         ** I am told this method originally came from Photoshop.
         **
@@ -1323,12 +1326,22 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
         /* set all kernel values within diamond area to scale given */
         for ( i=0, v=0; v < (ssize_t)kernel->height; v++)
           {
-            size_t
-              alpha = order_f / ( fact((size_t) v) * fact(kernel->height-(size_t) v-1) );
+            /* Each binomial coefficient fits in a size_t, but their product
+            ** times order_f did not (orders >= 18 on 64-bit, >= 11 on 32-bit).
+            ** Form the product in floating point instead.
+            */
+            const double
+              alpha = (double) (order_f / ( fact((size_t) v) *
+                fact(kernel->height-(size_t) v-1) ));

             for ( u=0; u < (ssize_t)kernel->width; u++, i++)
-              kernel->positive_range += kernel->values[i] = (double)
-                (alpha * order_f / ( fact((size_t) u) * fact(kernel->height-(size_t) u-1) ));
+              {
+                const double
+                  beta = (double) (order_f / ( fact((size_t) u) *
+                    fact(kernel->width-(size_t) u-1) ));
+
+                kernel->positive_range += kernel->values[i] = alpha*beta;
+              }
           }
         kernel->minimum = 1.0;
         kernel->maximum = kernel->values[kernel->x+kernel->y*(ssize_t) kernel->width];
@@ -1691,7 +1704,9 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
         {
           ssize_t
             limit1,
-            limit2,
+            limit2;
+
+          double
             scale;

           if (args->rho < args->sigma)
@@ -1715,7 +1730,7 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
             return(DestroyKernelInfo(kernel));

           /* set a ring of points of 'scale' ( 0.0 for PeaksKernel ) */
-          scale = (ssize_t) (( type == PeaksKernel) ? 0.0 : args->xi);
+          scale = ( type == PeaksKernel) ? 0.0 : args->xi;
           for ( i=0, v= -kernel->y; v <= (ssize_t)kernel->y; v++)
             for ( u=-kernel->x; u <= (ssize_t)kernel->x; u++, i++)
               { ssize_t radius=u*u+v*v;
@@ -2155,6 +2170,8 @@ MagickExport KernelInfo *AcquireKernelBuiltIn(const KernelInfoType type,
     default:
       {
         /* No-Op Kernel - Basically just a single pixel on its own */
+        if (kernel != (KernelInfo *) NULL)
+          kernel=DestroyKernelInfo(kernel);  /* do not leak the base kernel */
         kernel=ParseKernelArray("1:1");
         if (kernel == (KernelInfo *) NULL)
           return(kernel);
@@ -2203,6 +2220,9 @@ MagickExport KernelInfo *CloneKernelInfo(const KernelInfo *kernel)
   if (new_kernel == (KernelInfo *) NULL)
     return(new_kernel);
   *new_kernel=(*kernel); /* copy values in structure */
+  new_kernel->values=(MagickRealType *) NULL;
+  new_kernel->next=(KernelInfo *) NULL;  /* must not alias the original list,
+    otherwise DestroyKernelInfo() below would free the caller's kernels */

   /* replace the values with a copy of the values */
   if (AcquireKernelValues(new_kernel) == MagickFalse)
@@ -2465,6 +2485,8 @@ static void CalcKernelMetaData(KernelInfo *kernel)
   kernel->negative_range = kernel->positive_range = 0.0;
   for (i=0; i < (kernel->width*kernel->height); i++)
     {
+      if (IsNaN(kernel->values[i]))
+        continue;   /* 'nan' marks a value that is not part of the kernel */
       if ( fabs(kernel->values[i]) < MagickEpsilon )
         kernel->values[i] = 0.0;
       ( kernel->values[i] < 0)
@@ -2615,7 +2637,9 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
     {
       (void) ThrowMagickException(exception,GetMagickModule(),OptionWarning,
         "InvalidOption","`%s'","not a primitive morphology method");
-      break;
+      morphology_view=DestroyCacheView(morphology_view);
+      image_view=DestroyCacheView(image_view);
+      return(-1);
     }
   }
   changed=0;
@@ -2777,7 +2801,7 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
       for (j=0; j < (ssize_t) GetOpenMPMaximumThreads(); j++)
         changed+=changes[j];
       changes=(size_t *) RelinquishMagickMemory(changes);
-      return(status ? (ssize_t) (changed/GetImageChannels(image)) : 0);
+      return(status ? (ssize_t) (changed/GetImageChannels(image)) : -1);
     }
   /*
     Normal handling of horizontal or rectangular kernels (row by row).
@@ -2874,7 +2898,6 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
             break;
           }
           case DilateMorphology:
-          case ErodeIntensityMorphology:
           {
             pixel=0.0;
             break;
@@ -3065,7 +3088,12 @@ static ssize_t MorphologyPrimitive(const Image *image,Image *morphology_image,
               Select pixel with minimum intensity within kernel neighbourhood.

               The kernel is not reflected for this operation.
+
+              Start above any possible intensity: a neighbourhood of pure
+              white has intensity == QuantumRange (give or take rounding) and
+              would otherwise never be selected, yielding black.
             */
+            minimum=MagickMaximumValue;
             k=kernel->values;
             for (v=0; v < (ssize_t) kernel->height; v++)
             {
@@ -3610,9 +3638,6 @@ MagickPrivate Image *MorphologyApply(const Image *image,
   const KernelInfo *kernel, const CompositeOperator compose,const double bias,
   ExceptionInfo *exception)
 {
-  CompositeOperator
-    curr_compose;
-
   Image
     *curr_image,    /* Image we are working with or iterating */
     *work_image,    /* secondary image for primitive iteration */
@@ -3672,8 +3697,6 @@ MagickPrivate Image *MorphologyApply(const Image *image,

   /* initialise for cleanup */
   curr_image = (Image *) image;
-  curr_compose = image->compose;
-  (void) curr_compose;
   work_image = save_image = rslt_image = (Image *) NULL;
   reflected_kernel = (KernelInfo *) NULL;

@@ -3729,7 +3752,7 @@ MagickPrivate Image *MorphologyApply(const Image *image,
       changed=MorphologyPrimitiveDirect(rslt_image,method,kernel,exception);

       if (verbose != MagickFalse)
-        (void) (void) FormatLocaleFile(stderr,
+        (void) FormatLocaleFile(stderr,
           "%s:%.17g.%.17g #%.17g => Changed %.17g\n",
           CommandOptionToMnemonic(MagickMorphologyOptions, method),
           1.0,0.0,1.0, (double) changed);
@@ -3913,7 +3936,7 @@ MagickPrivate Image *MorphologyApply(const Image *image,
           if (verbose != MagickFalse) {
             if ( kernel_loop > 1 )
               (void) FormatLocaleFile(stderr, "\n"); /* add end-of-line from previous */
-            (void) (void) FormatLocaleFile(stderr,
+            (void) FormatLocaleFile(stderr,
               "%s%s%s:%.17g.%.17g #%.17g => Changed %.17g",
               v_info,CommandOptionToMnemonic(MagickMorphologyOptions,
               primitive),(this_kernel == rflt_kernel ) ? "*" : "",
@@ -4156,7 +4179,12 @@ MagickExport Image *MorphologyImage(const Image *image,
           if ( curr_kernel == kernel )
             curr_kernel = CloneKernelInfo(kernel);
           if (curr_kernel == (KernelInfo *) NULL)
-            return((Image *) NULL);
+            {
+              (void) ThrowMagickException(exception,GetMagickModule(),
+                ResourceLimitError,"MemoryAllocationFailed","`%s'",
+                image->filename);
+              return((Image *) NULL);
+            }
           ScaleGeometryKernelInfo(curr_kernel, artifact);
         }
       }
@@ -4312,7 +4340,8 @@ static void RotateKernelInfo(KernelInfo *kernel, double angle)
           kernel->angle = fmod(kernel->angle+45.0, 360.0);
         }
       else
-        perror("Unable to rotate non-3x3 kernel by 45 degrees");
+        (void) FormatLocaleFile(stderr,
+          "Unable to rotate non-3x3 kernel by 45 degrees\n");
     }
   if ( 45.0 < fmod(angle, 180.0)  && fmod(angle,180.0) <= 135.0 )
     {
@@ -4365,7 +4394,8 @@ static void RotateKernelInfo(KernelInfo *kernel, double angle)
           kernel->angle = fmod(kernel->angle+90.0, 360.0);
         }
       else
-        perror("Unable to rotate a non-square, non-linear kernel 90 degrees");
+        (void) FormatLocaleFile(stderr,
+          "Unable to rotate a non-square, non-linear kernel 90 degrees\n");
     }
   if ( 135.0 < angle && angle <= 225.0 )
     {
@@ -4576,6 +4606,12 @@ MagickExport void ScaleKernelInfo(KernelInfo *kernel,
   else
     neg_scale = pos_scale;

+  /* guard against division by zero (for example an all-zero kernel) */
+  if ( fabs(pos_scale) < MagickEpsilon )
+    pos_scale = 1.0;
+  if ( fabs(neg_scale) < MagickEpsilon )
+    neg_scale = 1.0;
+
   /* finalize scaling_factor for positive and negative components */
   pos_scale = scaling_factor/pos_scale;
   neg_scale = scaling_factor/neg_scale;
@@ -4599,7 +4635,7 @@ MagickExport void ScaleKernelInfo(KernelInfo *kernel,
     kernel->negative_range = t;
     t = kernel->maximum;
     kernel->maximum = kernel->minimum;
-    kernel->minimum = 1;
+    kernel->minimum = t;
   }

   return;
@@ -4716,7 +4752,16 @@ MagickExport void UnityAddKernelInfo(KernelInfo *kernel,
     UnityAddKernelInfo(kernel->next, scale);

   /* Add the scaled unity kernel to the existing kernel */
-  kernel->values[kernel->x+kernel->y*(ssize_t) kernel->width] += scale;
+  {
+    MagickRealType
+      *origin;
+
+    origin=(&kernel->values[kernel->x+kernel->y*(ssize_t) kernel->width]);
+    if (IsNaN(*origin))
+      *origin=(MagickRealType) scale;  /* origin was not part of the kernel */
+    else
+      *origin+=(MagickRealType) scale;
+  }
   CalcKernelMetaData(kernel);  /* recalculate the meta-data */

   return;