Hello,

I've prepared ghostscript 10.0.0~dfsg-11+deb12u9 for bookworm-security, and 
it's ready for review.

It follows the Trixie updates DSA-6516-1 (10.05.1~dfsg-1+deb13u2) and 
DSA-6550-1 (10.05.1~dfsg-1+deb13u3); Sid has the same fixes in 10.08.0~dfsg-1. 
The debdiff against deb12u8 and the draft DLA are attached.

- CVE-2026-39919 (JPEG 2000 output): 
https://security-tracker.debian.org/tracker/CVE-2026-39919
- CVE-2026-125396 (.putgstringcopy): 
https://security-tracker.debian.org/tracker/CVE-2026-125396
- CVE-2026-101258 (procedure-source filter, shading function arrays): 
https://security-tracker.debian.org/tracker/CVE-2026-101258
- CVE-2026-103226 (pdfwrite Type 1 control stack): 
https://security-tracker.debian.org/tracker/CVE-2026-103226
- DSA-6516-1: https://security-tracker.debian.org/tracker/DSA-6516-1
- DSA-6550-1: https://security-tracker.debian.org/tracker/DSA-6550-1

The patches are upstream 8ddaa67d (same diff as 0a8bf88e), 1484854e, 9d8b70ad, 3d8a1db6 
and cbdc86cc. Three needed context tweaks for 10.0.0: the JPEG 2000 loop keeps the 
existing index formula in base/sjpx_openjpeg.c, .putgstringcopy keeps its ".bind 
executeonly odef" ending, and the pdfwrite check sits on the callsubr case just 
before type1_callsubr(). Otherwise the changes match the Trixie patches.

CVE-2026-110133 and CVE-2026-112922 stay open, as they are in Trixie's deb13u3. 
They can follow once Trixie gets them.

It builds in a Bookworm schroot, and the build-time smoke test, the bug 700317 
-dSAFER checks and the autopkgtest all pass. Lintian only shows the three 
existing source-is-missing tags on the language-binding HTML. I compared 
deb12u8 and deb12u9 in a Bookworm VM (kernel 6.1.190-1, AppArmor loaded):

- CVE-2026-101258: the public PoC created /tmp/gs_proof and segfaulted gs on deb12u8 
(pbmraw, png16m and forced clist). On deb12u9 it prints "leak-scan-failed", 
exits 0 and leaves no file.
- CVE-2026-103226: a self-recursive Type 1 subroutine crashed pdfwrite on 
deb12u8, with a 4-byte invalid write under valgrind. deb12u9 exits 0 and 
valgrind is clean. Rendered output is identical on both.
- Shadings: single-output functions render identically in Gray, RGB and CMYK. 
Multi-output functions are now rejected (exit 1), as intended.
- -dSAFER: .putgstringcopy and .forceput stay hidden, gs_fonts.ps has the new 
type check, and the usual file and pipe escapes return invalidfileaccess on 
both versions.
- CVE-2026-39919: single-component JPEG 2000 at 1 to 16 bits, plus 8-bit mixed 
subsampling, decodes identically. A 1-bit mixed-subsampling file aborted 
deb12u8 and decodes fine on deb12u9. So does a larger one wrapped in a PDF, 
which also showed an 8-byte invalid read on deb12u8. 4-bit mixed subsampling 
decodes on both with different packed bytes. Precisions 3 and 6 decode empty on 
deb12u9.

I also ran some general regression checks and can share details if anyone wants 
them.

Here is my Salsa fork: 
https://salsa.debian.org/tsimonq2/ghostscript/-/tree/debian/bookworm

Here is the Debusine work request: 
https://debusine.debian.net/debian/developers/work-request/1615153/

Feedback is welcome. If nothing showstopping comes up, I'll upload this and 
issue the DLA on Tuesday afternoon (November 17th, 2026).

Best regards,
Simon Quigley
[email protected]
diff -Nru ghostscript-10.0.0~dfsg/debian/changelog 
ghostscript-10.0.0~dfsg/debian/changelog
--- ghostscript-10.0.0~dfsg/debian/changelog    2025-10-05 03:11:09.000000000 
-0500
+++ ghostscript-10.0.0~dfsg/debian/changelog    2026-11-13 11:06:53.000000000 
-0600
@@ -1,3 +1,18 @@
+ghostscript (10.0.0~dfsg-11+deb12u9) bookworm-security; urgency=high
+
+  * Non-maintainer upload by the LTS Team.
+  * CVE-2026-39919: Stop the JPEG 2000 output adapter from reading
+    past a component when the subsampling factors differ.
+  * CVE-2026-125396: Check that .putgstringcopy is given a dictionary,
+    a name, and a string before it calls .forceput.
+  * CVE-2026-101258: Copy a local procedure-source string into the VM
+    that owns the file, and reject a shading function array whose
+    members are not one-output functions.
+  * CVE-2026-103226: Reject a Type 1 callsubr that would run off the
+    pdfwrite control stack.
+
+ -- Simon Quigley <[email protected]>  Fri, 13 Nov 2026 11:06:53 -0600
+
 ghostscript (10.0.0~dfsg-11+deb12u8) bookworm-security; urgency=high
 
   * Non-maintainer upload by the Security Team.
diff -Nru 
ghostscript-10.0.0~dfsg/debian/patches/0042-OpenJPEG-Fix-overreading-bytes-in-some-conditions.patch
 
ghostscript-10.0.0~dfsg/debian/patches/0042-OpenJPEG-Fix-overreading-bytes-in-some-conditions.patch
--- 
ghostscript-10.0.0~dfsg/debian/patches/0042-OpenJPEG-Fix-overreading-bytes-in-some-conditions.patch
 1969-12-31 18:00:00.000000000 -0600
+++ 
ghostscript-10.0.0~dfsg/debian/patches/0042-OpenJPEG-Fix-overreading-bytes-in-some-conditions.patch
 2026-11-13 11:06:53.000000000 -0600
@@ -0,0 +1,73 @@
+Origin: backport, 
https://github.com/ArtifexSoftware/ghostpdl/commit/8ddaa67d13daeca55aa13e9e3262172fa93b72f7
+Origin: backport, 
https://github.com/ArtifexSoftware/ghostpdl/commit/0a8bf88e39db07b0751a58d6ec1cf992073e4dc1
+Reviewed-by: Simon Quigley <[email protected]>
+Last-Update: 2026-11-12
+
+Backported to 10.0.0. The bits-per-sample allow-list is unchanged.
+The subsampled loop keeps 10.0.0's in_offset_scaled formula. The
+sample index advances in the inner loop, and a read past the width
+is skipped.
+
+From 8ddaa67d13daeca55aa13e9e3262172fa93b72f7 Mon Sep 17 00:00:00 2001
+From: Ken Sharp <[email protected]>
+Date: Mon, 24 Aug 2026 16:07:23 +0100
+Subject: OpenJPEG - Fix overreading bytes in some conditions.
+
+Bug #709666 "Heap buffer overflow in the JPEG 2000 (JPXDecode) output adapter 
via component subsampling mismatch (base/sjpx_openjpeg.c)"
+
+If we have more than one component, and the components are not the
+same scale factor, and the number of bits is less than 8, then we would
+run round a loop reading 'state->width' samples of data to the output.
+
+The problem, of course, is that if the BPS is less than 8, we don't
+want to read that many bytes, just that many samples.
+
+Fixed here by incrementing the sample count in the inner loop, so that
+we correctly count the number of samples.
+
+For completeness, also check the number of samples in side the inner
+loop so that we don't overread. We do need to run round the loop as
+many times as there are samples in a byte, because that pushes the
+data read so far to the left so that any unread data is at the right of
+the byte.
+
+This exposed an interesting bug in a regression file. It hits the
+same scale loop, but has bps equal to 10. This resulted in us reading
+no data in the old code, but in the new code reading way too much.
+
+Added a guard in decode_image to error out on images which have BPS
+which we don't support.
+
+The original issue was reported by Alex Thomas <[email protected]>
+of Wordfence Argus (AI).
+---
+--- a/base/sjpx_openjpeg.c
++++ b/base/sjpx_openjpeg.c
+@@ -490,6 +490,9 @@ static int decode_image(stream_jpxd_state * const state)
+     if (state->bpp == 12)
+         state->bpp = 16;
+ 
++    if (state->bpp != 1 && state->bpp != 2 && state->bpp != 4 && state->bpp 
!= 8 && state->bpp != 16)
++        return ERRC;
++
+     /* calculate  total data */
+     rowbytes =  (state->width*state->bpp*state->out_numcomps+7)/8;
+     state->totalbytes = (ulong)rowbytes*state->height;
+@@ -648,13 +651,14 @@ static int process_one_trunk(stream_jpxd_state * const 
state, stream_cursor_write * pw)
+                 int ppbyte1 = 8/state->bpp;
+                 /* sampling required */
+                 /* only grayscale can have such bit-depth, also shift_bit = 
0, bpp < 8 */
+-                for (i = 0; i < state->width; i++)
++                for (i = 0; i < state->width; )
+                 {
+-                    for (b=0; b<ppbyte1; b++)
++                    for (b=0; b<ppbyte1; b++, i++)
+                     {
+                         int in_offset_scaled = 
(y_offset/state->image->comps[compno].dy*state->width + 
i)/state->image->comps[compno].dx;
+                         bt = bt<<state->bpp;
+-                        bt += 
state->image->comps[compno].data[in_offset_scaled] + state->sign_comps[compno];
++                        if (i < state->width)
++                            bt += 
state->image->comps[compno].data[in_offset_scaled] + state->sign_comps[compno];
+                     }
+                     *row++ = bt;
+                 }
diff -Nru 
ghostscript-10.0.0~dfsg/debian/patches/0043-PS-interpreter-validate-operands-to-.putgstringcopy.patch
 
ghostscript-10.0.0~dfsg/debian/patches/0043-PS-interpreter-validate-operands-to-.putgstringcopy.patch
--- 
ghostscript-10.0.0~dfsg/debian/patches/0043-PS-interpreter-validate-operands-to-.putgstringcopy.patch
       1969-12-31 18:00:00.000000000 -0600
+++ 
ghostscript-10.0.0~dfsg/debian/patches/0043-PS-interpreter-validate-operands-to-.putgstringcopy.patch
       2026-11-13 11:06:53.000000000 -0600
@@ -0,0 +1,62 @@
+Origin: backport, 
https://github.com/ArtifexSoftware/ghostpdl/commit/1484854e0c8ddfda1baa4ad4cd965b8a9790aa81
+Reviewed-by: Simon Quigley <[email protected]>
+Last-Update: 2026-11-12
+
+Backported to 10.0.0. The closing line stays ".bind executeonly
+odef", which is the line this version already has. The operand
+type check is the upstream change.
+
+From 1484854e0c8ddfda1baa4ad4cd965b8a9790aa81 Mon Sep 17 00:00:00 2001
+From: Ken Sharp <[email protected]>
+Date: Wed, 2 Sep 2026 12:04:15 +0100
+Subject: PS interpreter - validate operands to .putgstringcopy
+
+Bug #709684 "Type 1 font-loader `.forceput` save/restore UAF yields native 
read/write and controlled dispatch/RCE under `-dSAFER`"
+
+Effectively another case of recovering .forceput, in this case by
+causing an error and then having the error handler use it.
+
+We are in the process of eliminating, or at least absolutely minimising,
+the use of .forceput. Ideally we want to remove it completely precisely
+to avoid this sort of thing. Unfortunately that's still a work in
+progress; it isn't easy to undo 30 years worth of assumptions in the
+code.
+
+For now this prevents the problem by ensuring that the operands are the
+correct types, which prevents the error executing 'copy' and so avoids
+the custom error handler managing to execute .forceput.
+
+This issue was reported by Paulos Yibelo <[email protected]>
+---
+--- a/Resource/Init/gs_fonts.ps
++++ b/Resource/Init/gs_fonts.ps
+@@ -1021,14 +1021,21 @@ $error /SubstituteFont { } put
+ 
+ % any user of .putgstringcopy must use bind and executeonly
+ /.putgstringcopy  %   <dict> <name> <string> .putgstringcopy -
+-{ 2 index gcheck currentglobal
+-  2 copy eq {
+-    pop pop .forceput
+-  } executeonly {
+-    5 1 roll setglobal
+-    dup length string copy
+-    .forceput setglobal
+-  } executeonly ifelse
++{
++  % Check operand types
++  dup type /stringtype eq 2 index type /nametype eq and 3 index type 
/dicttype eq and {
++    2 index gcheck currentglobal
++    2 copy eq {
++      pop pop .forceput
++    } executeonly {
++      5 1 roll setglobal
++      dup length string copy
++      .forceput setglobal
++    } executeonly ifelse
++  }
++  {
++      /.putgstringcopy cvx /typecheck signalerror
++  } ifelse
+ } .bind executeonly odef % must be bound and hidden for .forceput
+ 
+ /.loadfontloop {        % <fontname> <filename> <libflag> .loadfontloop
diff -Nru 
ghostscript-10.0.0~dfsg/debian/patches/0044-PostScript-interpreter-don-t-permit-local-inside-glo.patch
 
ghostscript-10.0.0~dfsg/debian/patches/0044-PostScript-interpreter-don-t-permit-local-inside-glo.patch
--- 
ghostscript-10.0.0~dfsg/debian/patches/0044-PostScript-interpreter-don-t-permit-local-inside-glo.patch
      1969-12-31 18:00:00.000000000 -0600
+++ 
ghostscript-10.0.0~dfsg/debian/patches/0044-PostScript-interpreter-don-t-permit-local-inside-glo.patch
      2026-11-13 11:06:53.000000000 -0600
@@ -0,0 +1,113 @@
+Origin: backport, 
https://github.com/ArtifexSoftware/ghostpdl/commit/9d8b70ad1301c9993155dcf53401df3eac14fa4f
+Reviewed-by: Simon Quigley <[email protected]>
+Last-Update: 2026-11-12
+
+Backported to 10.0.0. The copyright-year hunk is outside this
+update. The copy of a local string into the file's VM is the
+upstream change.
+
+From 9d8b70ad1301c9993155dcf53401df3eac14fa4f Mon Sep 17 00:00:00 2001
+From: Ken Sharp <[email protected]>
+Date: Wed, 24 Jun 2026 09:28:01 +0100
+Subject: PostScript interpreter - don't permit local inside global storage
+
+Bug #709461 "Use-after-free in procedure-source filter state across `restore` 
(`psi/zfproc.c`)"
+
+The problem is that the C code stores a reference to a PostScript
+string object, but does not check the allocation space. If the owner of
+the C structure is allocated in global VM, and the string is allocated
+in local VM, then the string can be restored away while the structure
+stil holds a pointer to it. When we reclaim memory this causes a crash.
+
+From a spec perspective there's no reason to retain a pointer to a local
+object in a global object, its just an implementation detail. Just to
+be sure I ran the file on Distiller and that has no problems.
+
+So in this commit; if the 'file' object (which owns the structure) is
+not in local VM, and the string returned by the procedural data source
+is in local VM, then make a copy of the string in global VM. This
+avoids any potential problems at the cost of using extra memory.
+
+This issue was reported by 'Rick de Jager <[email protected]>'.
+---
+ psi/zfproc.c | 47 ++++++++++++++++++++++++++++++++++++++++++++++-
+ 1 file changed, 46 insertions(+), 1 deletion(-)
+
+diff --git a/psi/zfproc.c b/psi/zfproc.c
+index 4917236a5bb7..259c1aa7e7fd 100644
+--- a/psi/zfproc.c
++++ b/psi/zfproc.c
+@@ -124,6 +124,30 @@ s_proc_set_defaults(stream_state * st)
+     make_null(&ss->data);
+ }
+ 
++static int s_proc_copy_string(i_ctx_t * i_ctx_p, ref *dest, ref *src, uint 
mem)
++{
++    int code = 0;
++    uint saved_space = avm_local;
++
++    saved_space = imemory_space(iimemory);
++
++    if (imemory_space(iimemory) != mem)
++        ialloc_set_space(idmemory, mem);
++
++    code = gs_alloc_string_ref(iimemory, dest, 0, r_size(src), 
"copy_cspace_string");
++
++    if (imemory_space(iimemory) != saved_space)
++        ialloc_set_space(idmemory, saved_space);
++
++    if (code < 0)
++        return code;
++
++    r_copy_attrs(dest, a_all, src);
++
++    memcpy(dest->value.bytes, src->value.bytes, r_size(src));
++    return 0;
++}
++
+ /* ---------------- Read streams ---------------- */
+ 
+ /* Forward references */
+@@ -220,11 +244,23 @@ s_proc_read_continue(i_ctx_t *i_ctx_p)
+     os_ptr opbuf = op - 1;
+     stream *ps;
+     stream_proc_state *ss;
++    uint s1, s2;
+ 
+     check_file(ps, op);
+     check_read_type(*opbuf, t_string);
+     while ((ps->end_status = 0, ps->strm) != 0)
+         ps = ps->strm;
++    s1 = r_space(op);
++    s2 = r_space(opbuf);
++    if (!r_is_local(op) && r_is_local(opbuf)) {
++        ref copy;
++        int code = 0;
++
++        code = s_proc_copy_string(i_ctx_p, &copy, opbuf, r_space(op));
++        if (code < 0)
++            return code;
++        *opbuf = copy;
++    }
+     ss = (stream_proc_state *) ps->state;
+     ss->data = *opbuf;
+     ss->index = 0;
+@@ -359,6 +395,15 @@ s_proc_write_continue(i_ctx_t *i_ctx_p)
+         ps = ps->strm;
+     }
+     ps->end_status = 0;
++    if (!r_is_local(op) && r_is_local(opbuf)) {
++        ref copy;
++        int code = 0;
++
++        code = s_proc_copy_string(i_ctx_p, &copy, opbuf, r_space(op));
++        if (code < 0)
++            return code;
++        *opbuf = copy;
++    }
+     ss = (stream_proc_state *) ps->state;
+     ss->data = *opbuf;
+     ss->index = 0;
+-- 
+2.55.0
+
diff -Nru 
ghostscript-10.0.0~dfsg/debian/patches/0045-graphics-library-Shadings-with-arrays-of-Functions-v.patch
 
ghostscript-10.0.0~dfsg/debian/patches/0045-graphics-library-Shadings-with-arrays-of-Functions-v.patch
--- 
ghostscript-10.0.0~dfsg/debian/patches/0045-graphics-library-Shadings-with-arrays-of-Functions-v.patch
      1969-12-31 18:00:00.000000000 -0600
+++ 
ghostscript-10.0.0~dfsg/debian/patches/0045-graphics-library-Shadings-with-arrays-of-Functions-v.patch
      2026-11-13 11:06:53.000000000 -0600
@@ -0,0 +1,70 @@
+Origin: backport, 
https://github.com/ArtifexSoftware/ghostpdl/commit/3d8a1db60895493d73aeef89903d34da9837bc0a
+Reviewed-by: Simon Quigley <[email protected]>
+Last-Update: 2026-11-12
+
+Backported to 10.0.0. The copyright-year hunk is outside this
+update. The one-output check on each function in the array is
+the upstream change.
+
+From 3d8a1db60895493d73aeef89903d34da9837bc0a Mon Sep 17 00:00:00 2001
+From: Ken Sharp <[email protected]>
+Date: Thu, 25 Jun 2026 13:51:51 +0100
+Subject: graphics library - Shadings with arrays of Functions, validate 1-out
+
+Bug #709462 "Ghostscript: Heap buffer overflow (OOB write) via array-wrapped 
shading `/Function` (`base/gsfunc3.c`)"
+
+The basic problem is that the shading checks for arrays of functions are
+only checking to see if the number of functions in the array matches
+the number of colour space ocmponents. If the functions are not 1-in,
+1 out (or for type 1 shadings only; 2-in, 1 out) then the evaluation
+of the function could overrun the output buffer.
+
+We don't actually need to check the total number of output components,
+because the only valid values are 'n' 1-in, 1-out (or 2-in, 1 out)
+functions; the 1-in (or 2-in) n-out case is always a single function.
+
+We already check (in effect) that the number of functions in the array
+matches the colour space so all we need to add is a check that the
+number of input components matches (1 or 2) and the number of output
+components is always 1, for each function.
+
+This bug was reported by 'Rick de Jager <[email protected]>'
+---
+ base/gsshade.c | 16 +++++++++++++++-
+ 1 file changed, 15 insertions(+), 1 deletion(-)
+
+diff --git a/base/gsshade.c b/base/gsshade.c
+index b4379f96bd35..436dc627d08e 100644
+--- a/base/gsshade.c
++++ b/base/gsshade.c
+@@ -31,6 +31,7 @@
+ #include "gxshade4.h"
+ #include "gzpath.h"
+ #include "gzcpath.h"
++#include "gsfunc3.h"
+ 
+ /* ================ Initialize shadings ================ */
+ 
+@@ -78,6 +79,19 @@ check_CBFD(const gs_shading_params_t * params,
+     if (function != 0) {
+         if (function->params.m != m || function->params.n != ncomp)
+             return_error(gs_error_rangecheck);
++        if (function->head.type == function_type_ArrayedOutput) {
++            /* If the Function member is an array it must contain either n 
1-in, 1-out function dictionaries
++             * or (type 1, function-based shadings) n 2-in, 1-out function 
dictionaries. Either way all the
++             * functions have to have a single output, so we need to check 
that.
++             */
++            int i = 0;
++            gs_function_AdOt_params_t *a_params = (gs_function_AdOt_params_t 
*)&function->params;
++
++            for (i = 0; i < a_params->n;i++) {
++                if (a_params->Functions[i]->params.m != m || 
a_params->Functions[i]->params.n != 1)
++                    return_error(gs_error_rangecheck);
++            }
++        }
+         /*
+          * The Adobe documentation says that the function's domain must
+          * be a superset of the domain defined in the shading dictionary.
+-- 
+2.55.0
+
diff -Nru 
ghostscript-10.0.0~dfsg/debian/patches/0046-pdfwrite-bound-check-control-stack-in-type-1-2-font-.patch
 
ghostscript-10.0.0~dfsg/debian/patches/0046-pdfwrite-bound-check-control-stack-in-type-1-2-font-.patch
--- 
ghostscript-10.0.0~dfsg/debian/patches/0046-pdfwrite-bound-check-control-stack-in-type-1-2-font-.patch
      1969-12-31 18:00:00.000000000 -0600
+++ 
ghostscript-10.0.0~dfsg/debian/patches/0046-pdfwrite-bound-check-control-stack-in-type-1-2-font-.patch
      2026-11-13 11:06:53.000000000 -0600
@@ -0,0 +1,39 @@
+Origin: backport, 
https://github.com/ArtifexSoftware/ghostpdl/commit/cbdc86cc7a95c792baae3a15c7acf59b95fbcd5c
+Reviewed-by: Simon Quigley <[email protected]>
+Last-Update: 2026-11-12
+
+Backported to 10.0.0. The control-stack check is placed before
+the call to type1_callsubr(). The operand-stack guard from a
+later commit is outside this update.
+
+From cbdc86cc7a95c792baae3a15c7acf59b95fbcd5c Mon Sep 17 00:00:00 2001
+From: Ken Sharp <[email protected]>
+Date: Tue, 25 Aug 2026 14:33:48 +0100
+Subject: pdfwrite - bound check control stack in type 1->2 font conversion
+
+Bug #709672 "Stack buffer overflow in gdevpsfx.c type1_callsubr(): unbounded 
ipstack push in pdfwrite Type 1->2 font converter (all versions since 8.00, 
unfixed in master)"
+
+A deeply nested subr could fall off the end of the control stack. Check
+the control stack before handling the subr by using the defined macro.
+
+Reported by lanlanwhh <[email protected]>
+
+This differs from the suggested fix in the bug report by doing the check
+in the main interpreter control loop, not the callsubr function. Which
+is why the commit is not attributed to lanlanwh, if the fix is wrong
+then its my responsibility, not theirs.
+
+There is nothing wrong per se with the proposed patch, but this matches
+the 'normal' pattern for font parsing in our code.
+---
+--- a/devices/vector/gdevpsfx.c
++++ b/devices/vector/gdevpsfx.c
+@@ -230,6 +230,8 @@ type1_next(gs_type1_state *pcis)
+         case c_undef17:
+             return_error(gs_error_invalidfont);
+         case c_callsubr:
++            /* Check there is space available on the control stack */
++            CS_CHECK_IPSTACK(ipsp + 1, pcis->ipstack);
+             code = type1_callsubr(pcis, fixed2int_var(*csp) +
+                                   pcis->pfont->data.subroutineNumberBias);
+             if (code < 0)
diff -Nru ghostscript-10.0.0~dfsg/debian/patches/series 
ghostscript-10.0.0~dfsg/debian/patches/series
--- ghostscript-10.0.0~dfsg/debian/patches/series       2025-10-05 
03:10:10.000000000 -0500
+++ ghostscript-10.0.0~dfsg/debian/patches/series       2026-11-13 
11:06:53.000000000 -0600
@@ -39,6 +39,11 @@
 0039-Bug-708606-Catch-a-null-file-pointer-closing-pdfwrit.patch
 0040-pdfwrite-bounds-check-some-strings.patch
 0041-pdfwrite-avoid-buffer-overrun.patch
+0042-OpenJPEG-Fix-overreading-bytes-in-some-conditions.patch
+0043-PS-interpreter-validate-operands-to-.putgstringcopy.patch
+0044-PostScript-interpreter-don-t-permit-local-inside-glo.patch
+0045-graphics-library-Shadings-with-arrays-of-Functions-v.patch
+0046-pdfwrite-bound-check-control-stack-in-type-1-2-font-.patch
 1004_enable_spot_devices.patch
 2001_docdir_fix_for_debian.patch
 2002_gs_man_fix_debian.patch
-------------------------------------------------------------------------
Debian LTS Advisory DLA-XXXX-1                [email protected]
https://www.debian.org/lts/security/                        Simon Quigley
November 17, 2026                             https://wiki.debian.org/LTS
-------------------------------------------------------------------------

Package        : ghostscript
Version        : 10.0.0~dfsg-11+deb12u9
CVE ID         : CVE-2026-39919 CVE-2026-125396 CVE-2026-101258 CVE-2026-103226

Ghostscript is an interpreter for the PostScript language and for PDFs.

An attacker who supplies a document can overflow a buffer in the
interpreter, escape the -dSAFER sandbox, and run a shell command when
that document is rendered.

CVE-2026-39919

    The JPEG 2000 output adapter packed several samples into one byte
    and still walked the row once per sample. When image components
    used different subsampling factors and the depth was under 8 bits,
    that walk wrote past the end of the output row.

CVE-2026-125396

    The hidden .putgstringcopy procedure called the privileged
    .forceput operator on whatever operands it was given. A document
    could force a type error on that path and then use the operator
    from an error handler, which bypasses -dSAFER.

CVE-2026-101258

    A procedure-source filter kept a pointer to a string in local VM
    from a structure owned by global VM, so a restore could free the
    string while the filter still used it. A shading whose Function
    was an array of functions was accepted when those functions had
    more than one output, and evaluating them wrote past the output
    buffer. The two defects can be chained to turn -dSAFER off and
    run a shell command.

CVE-2026-103226

    Converting a Type 1 font to Type 2 in the pdfwrite device pushed a
    nested callsubr onto a fixed control stack. A charstring that
    nested deeper than that stack ran off the end of it.

For Debian 12 bookworm, these problems have been fixed in version
10.0.0~dfsg-11+deb12u9.

We recommend that you upgrade your ghostscript packages.

For the detailed security status of ghostscript please refer to
its security tracker page at:
https://security-tracker.debian.org/tracker/ghostscript

Further information about Debian LTS security advisories, how to apply
these updates to your system, and frequently asked questions can be
found at: https://wiki.debian.org/LTS

Attachment: OpenPGP_signature.asc
Description: OpenPGP digital signature

Reply via email to