[xen master] xz: avoid overlapping memcpy() with invalid input with in-place decompression

[patchbot@xxxxxxx]

commit 10454f381f9157bce26d5db15e07e857b317b4af
Author:     Lasse Collin <lasse.collin@xxxxxxxxxxx>
AuthorDate: Mon Mar 7 09:08:08 2022 +0100
Commit:     Jan Beulich <jbeulich@xxxxxxxx>
CommitDate: Mon Mar 7 09:08:08 2022 +0100

    xz: avoid overlapping memcpy() with invalid input with in-place 
decompression
    
    From: Lasse Collin <lasse.collin@xxxxxxxxxxx>
    
    With valid files, the safety margin described in lib/decompress_unxz.c
    ensures that these buffers cannot overlap. But if the uncompressed size
    of the input is larger than the caller thought, which is possible when
    the input file is invalid/corrupt, the buffers can overlap. Obviously
    the result will then be garbage (and usually the decoder will return
    an error too) but no other harm will happen when such an over-run occurs.
    
    This change only affects uncompressed LZMA2 chunks and so this
    should have no effect on performance.
    
    Link: https://lore.kernel.org/r/20211010213145.17462-2-xiang@xxxxxxxxxx
    Signed-off-by: Lasse Collin <lasse.collin@xxxxxxxxxxx>
    Signed-off-by: Gao Xiang <hsiangkao@xxxxxxxxxxxxxxxxx>
    Origin: git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git 
83d3c4f22a36
    Signed-off-by: Jan Beulich <jbeulich@xxxxxxxx>
    Reviewed-by: Luca Fancellu <luca.fancellu@xxxxxxx>
    Acked-by: Andrew Cooper <andrew.cooper3@xxxxxxxxxx>
---
 xen/common/unxz.c         |  2 +-
 xen/common/xz/dec_lzma2.c | 21 +++++++++++++++++++--
 2 files changed, 20 insertions(+), 3 deletions(-)

diff --git a/xen/common/unxz.c b/xen/common/unxz.c
index 4f1b50cade..05e83e1ede 100644
--- a/xen/common/unxz.c
+++ b/xen/common/unxz.c
@@ -127,7 +127,7 @@
  * memeq and memzero are not used much and any remotely sane implementation
  * is fast enough. memcpy/memmove speed matters in multi-call mode, but
  * the kernel image is decompressed in single-call mode, in which only
- * memcpy speed can matter and only if there is a lot of uncompressible data
+ * memmove speed can matter and only if there is a lot of uncompressible data
  * (LZMA2 stores uncompressible chunks in uncompressed form). Thus, the
  * functions below should just be kept small; it's probably not worth
  * optimizing for speed.
diff --git a/xen/common/xz/dec_lzma2.c b/xen/common/xz/dec_lzma2.c
index 2748c8e18a..3b60191ee6 100644
--- a/xen/common/xz/dec_lzma2.c
+++ b/xen/common/xz/dec_lzma2.c
@@ -387,7 +387,14 @@ static void __init dict_uncompressed(struct dictionary 
*dict, struct xz_buf *b,
 
                *left -= copy_size;
 
-               memcpy(dict->buf + dict->pos, b->in + b->in_pos, copy_size);
+               /*
+                * If doing in-place decompression in single-call mode and the
+                * uncompressed size of the file is larger than the caller
+                * thought (i.e. it is invalid input!), the buffers below may
+                * overlap and cause undefined behavior with memcpy().
+                * With valid inputs memcpy() would be fine here.
+                */
+               memmove(dict->buf + dict->pos, b->in + b->in_pos, copy_size);
                dict->pos += copy_size;
 
                if (dict->full < dict->pos)
@@ -397,7 +404,11 @@ static void __init dict_uncompressed(struct dictionary 
*dict, struct xz_buf *b,
                        if (dict->pos == dict->end)
                                dict->pos = 0;
 
-                       memcpy(b->out + b->out_pos, b->in + b->in_pos,
+                       /*
+                        * Like above but for multi-call mode: use memmove()
+                        * to avoid undefined behavior with invalid input.
+                        */
+                       memmove(b->out + b->out_pos, b->in + b->in_pos,
                                        copy_size);
                }
 
@@ -421,6 +432,12 @@ static uint32_t __init dict_flush(struct dictionary *dict, 
struct xz_buf *b)
                if (dict->pos == dict->end)
                        dict->pos = 0;
 
+               /*
+                * These buffers cannot overlap even if doing in-place
+                * decompression because in multi-call mode dict->buf
+                * has been allocated by us in this file; it's not
+                * provided by the caller like in single-call mode.
+                */
                memcpy(b->out + b->out_pos, dict->buf + dict->start,
                                copy_size);
        }
--
generated by git-patchbot for /home/xen/git/xen.git#master