mm: fix use-after-free when anon vma name is used after vma is freed
Subsystems (4)
Suren Baghdasaryan
reviewerPATCH v2 1/1 mm: fix use-after-free when anon vma name is used after vma is freed
When adjacent vmas are being merged it can result in the vma that was originally passed to madvise_update_vma being destroyed. In the current implementation, the name parameter passed to madvise_update_vma points directly to vma->anon_name->name and it is used after the call to vma_merge. In the cases when vma_merge merges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior << passes vma->anon_name->name as name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free <-- frees the vma
replace_vma_anon_name(name) <-- UAF
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
---
changes in v2:
- Replaces name copying with refcounting and added vma_anon_name_{get/put} API, per Andrew Morton
include/linux/mm_inline.h | 13 +++++++++++++ mm/madvise.c | 28 ++++++++++++++++++++++++++-- 2 files changed, 39 insertions(+), 2 deletions(-)
include/linux/mm_inline.h +13 -0
@@ -145,6 +145,11 @@ static __always_inline void del_page_from_lru_list(struct page *page,*/ extern const char *vma_anon_name (struct vm_area_struct *vma); +/* mmap_lock should be read-locked */ +extern struct anon_vma_name *vma_anon_name_get (struct vm_area_struct *vma); + +extern void vma_anon_name_put (struct anon_vma_name *anon_name); +/* * mmap_lock should be read-locked for orig_vma->vm_mm. * mmap_lock should be write-locked for new_vma->vm_mm or new_vma should be
@@ -176,6 +181,14 @@ static inline const char *vma_anon_name(struct vm_area_struct *vma) {return NULL ; } + +static inline +struct anon_vma_name *vma_anon_name_get (struct vm_area_struct *vma) +{ +return NULL ; +} + +static inline void vma_anon_name_put (struct anon_vma_name *anon_name) {}static inline void dup_vma_anon_name (struct vm_area_struct *orig_vma,struct vm_area_struct *new_vma) {}static inline void free_vma_anon_name (struct vm_area_struct *vma) {}
mm/madvise.c +26 -2
@@ -103,6 +103,22 @@ const char *vma_anon_name(struct vm_area_struct *vma)return vma->anon_name->name; } +struct anon_vma_name *vma_anon_name_get (struct vm_area_struct *vma) +{ +if (!has_vma_anon_name (vma)) +return NULL ; + +mmap_assert_locked (vma->vm_mm); + +kref_get (&vma->anon_name->kref); +return vma->anon_name; +} + +void vma_anon_name_put (struct anon_vma_name *anon_name) +{ +kref_put (&anon_name->kref, vma_anon_name_free); +} +void dup_vma_anon_name (struct vm_area_struct *orig_vma,struct vm_area_struct *new_vma) {
@@ -976,6 +992,7 @@ static int madvise_vma_behavior(struct vm_area_struct *vma, {int error;unsigned long new_flags = vma->vm_flags; +struct anon_vma_name *anon_name;switch (behavior) {case MADV_REMOVE :
@@ -1040,8 +1057,15 @@ static int madvise_vma_behavior(struct vm_area_struct *vma,break ; } - error =madvise_update_vma (vma, prev, start, end, new_flags, -vma_anon_name (vma)); + anon_name =vma_anon_name_get (vma); +if (anon_name) { + error =madvise_update_vma (vma, prev, start, end, new_flags, + anon_name->name); +vma_anon_name_put (anon_name); + }else { + error =madvise_update_vma (vma, prev, start, end, new_flags, +NULL ); + } out:/*
Signature · 1 line
2.35.1.265.g69c8d7142f-goog
Michal Hocko
reviewerQuoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAF
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that madvise_update_vma uses the naked name rather than the encapsulated anon_vma_name? This really just begs for problems.
Signature · 2 lines
Michal Hocko SUSE Labs
Suren Baghdasaryan
reviewerQuoted 16 lines · Michal Hocko' via kernel-team
Quoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAF
Quoted 5 lines
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that
madvise_update_vmauses the naked name rather than the encapsulatedanon_vma_name? This really just begs for problems.
The reason for that is the second place it's being used from the prctl syscall:
prctl_set_vma
madvise_set_anon_name
madvise_vma_anon_name
madvise_update_vma
In that case the name parameter is not part of any anon_vma_name struct and therefore is stable. I can add a comment to madvise_update_vma indicating that the name parameter has to be stable if that helps.
Quoted 7 lines
--
Michal Hocko
SUSE Labs--
To unsubscribe from this group and stop receiving emails from it, send an email to [email protected].
Quoted 31 lines · Suren Baghdasaryan
Quoted 16 lines · Michal Hocko' via kernel-team
Quoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAFQuoted 5 lines
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that
madvise_update_vmauses the naked name rather than the encapsulatedanon_vma_name? This really just begs for problems.The reason for that is the second place it's being used from the prctl syscall:
prctl_set_vma
madvise_set_anon_name
madvise_vma_anon_name
madvise_update_vma
Quoted 4 lines
In that case the name parameter is not part of any
anon_vma_namestruct and therefore is stable. I can add a comment tomadvise_update_vmaindicating that the name parameter has to be stable if that helps.
Seems to me it'd simplify things if replace_vma_anon_name() and madvise_vma_anon_name() took a struct anon_vma_name instead of a bare char *. You could construct it in madvise_set_anon_name().
Suren Baghdasaryan
reviewerQuoted 33 lines · Matthew Wilcox
Quoted 31 lines · Suren Baghdasaryan
Quoted 16 lines · Michal Hocko' via kernel-team
Quoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAFQuoted 5 lines
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that
madvise_update_vmauses the naked name rather than the encapsulatedanon_vma_name? This really just begs for problems.The reason for that is the second place it's being used from the prctl syscall:
prctl_set_vma
madvise_set_anon_name
madvise_vma_anon_name
madvise_update_vma
Quoted 8 lines
Quoted 4 lines
In that case the name parameter is not part of any
anon_vma_namestruct and therefore is stable. I can add a comment tomadvise_update_vmaindicating that the name parameter has to be stable if that helps.Seems to me it'd simplify things if
replace_vma_anon_name()andmadvise_vma_anon_name()took a structanon_vma_nameinstead of a bare char *. You could construct it inmadvise_set_anon_name().
Ok, this can be done. However I don't think changing replace_vma_anon_name() to accept a struct anon_vma_name would be a good idea. Reader might think that the object being passed will become the vma->anon_name of the vma, while in reality that's not the case. Keeping it a char* makes it obvious that the function will construct a new anon_vma_name struct.
I'll post a v3 shortly implementing these suggestions. Thanks for the review folks!
Quoted 39 lines · Suren Baghdasaryan
Quoted 38 lines · Matthew Wilcox
Quoted 35 lines · Suren Baghdasaryan
Quoted 16 lines · Michal Hocko' via kernel-team
Quoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAFQuoted 5 lines
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that
madvise_update_vmauses the naked name rather than the encapsulatedanon_vma_name? This really just begs for problems.The reason for that is the second place it's being used from the prctl syscall:
prctl_set_vma
madvise_set_anon_name
madvise_vma_anon_name
madvise_update_vmaIn that case the name parameter is not part of any
anon_vma_namestruct and therefore is stable. I can add a comment tomadvise_update_vmaindicating that the name parameter has to be stable if that helps.
Quoted 8 lines
Quoted 3 lines
Seems to me it'd simplify things if
replace_vma_anon_name()andmadvise_vma_anon_name()took a structanon_vma_nameinstead of a bare char *. You could construct it inmadvise_set_anon_name().Ok, this can be done. However I don't think changing
replace_vma_anon_name()to accept a structanon_vma_namewould be a good idea. Reader might think that the object being passed will become thevma->anon_nameof the vma, while in reality that's not the case.
Why woud we not want that to be the case? It's a refcounted name. I don't see why it shouldn't be shared between multiple VMAs that have the same name?
Suren Baghdasaryan
reviewerQuoted 45 lines · Matthew Wilcox
Quoted 43 lines · Suren Baghdasaryan
Quoted 41 lines · Matthew Wilcox
Quoted 31 lines · Suren Baghdasaryan
Quoted 16 lines · Michal Hocko' via kernel-team
Quoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAFQuoted 5 lines
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that
madvise_update_vmauses the naked name rather than the encapsulatedanon_vma_name? This really just begs for problems.The reason for that is the second place it's being used from the prctl syscall:
prctl_set_vma
madvise_set_anon_name
madvise_vma_anon_name
madvise_update_vmaQuoted 4 lines
In that case the name parameter is not part of any
anon_vma_namestruct and therefore is stable. I can add a comment tomadvise_update_vmaindicating that the name parameter has to be stable if that helps.Seems to me it'd simplify things if
replace_vma_anon_name()andmadvise_vma_anon_name()took a structanon_vma_nameinstead of a bare char *. You could construct it inmadvise_set_anon_name().
Quoted 8 lines
Quoted 4 lines
Ok, this can be done. However I don't think changing
replace_vma_anon_name()to accept a structanon_vma_namewould be a good idea. Reader might think that the object being passed will become thevma->anon_nameof the vma, while in reality that's not the case.Why woud we not want that to be the case? It's a refcounted name. I don't see why it shouldn't be shared between multiple VMAs that have the same name?
You are right. After I reworked the code it became apparent that replace_vma_anon_name() should use anon_vma_name. I have made that change and am testing it now. Hopefully no new surprises pop up. Thanks,
Suren.
Quoted 1 line
Suren Baghdasaryan
reviewerQuoted 52 lines · Suren Baghdasaryan
Quoted 50 lines · Matthew Wilcox
Quoted 47 lines · Suren Baghdasaryan
Quoted 33 lines · Matthew Wilcox
Quoted 31 lines · Suren Baghdasaryan
Quoted 16 lines · Michal Hocko' via kernel-team
Quoted 14 lines · Suren Baghdasaryan
When adjacent vmas are being merged it can result in the vma that was originally passed to
madvise_update_vmabeing destroyed. In the current implementation, the name parameter passed tomadvise_update_vmapoints directly tovma->anon_name->nameand it is used after the call tovma_merge. In the cases whenvma_mergemerges the original vma and destroys it, this will result in use-after-free bug as shown below:
madvise_vma_behavior<< passesvma->anon_name->nameas name param
madvise_update_vma(name)
vma_merge
__vma_adjust
vm_area_free<-- frees the vma
replace_vma_anon_name(name)<-- UAFQuoted 5 lines
Quoted 2 lines
Fix this by raising the name refcount and stabilizing it. Introduce vma_anon_name_{get/put} API for this purpose.
What is the reason that
madvise_update_vmauses the naked name rather than the encapsulatedanon_vma_name? This really just begs for problems.The reason for that is the second place it's being used from the prctl syscall:
prctl_set_vma
madvise_set_anon_name
madvise_vma_anon_name
madvise_update_vmaQuoted 8 lines
Quoted 4 lines
In that case the name parameter is not part of any
anon_vma_namestruct and therefore is stable. I can add a comment tomadvise_update_vmaindicating that the name parameter has to be stable if that helps.Seems to me it'd simplify things if
replace_vma_anon_name()andmadvise_vma_anon_name()took a structanon_vma_nameinstead of a bare char *. You could construct it inmadvise_set_anon_name().Ok, this can be done. However I don't think changing
replace_vma_anon_name()to accept a structanon_vma_namewould be a good idea. Reader might think that the object being passed will become thevma->anon_nameof the vma, while in reality that's not the case.
Quoted 7 lines
Quoted 3 lines
Why woud we not want that to be the case? It's a refcounted name. I don't see why it shouldn't be shared between multiple VMAs that have the same name?
You are right. After I reworked the code it became apparent that
replace_vma_anon_name()should useanon_vma_name. I have made that change and am testing it now. Hopefully no new surprises pop up.
v3 is posted at
https://lore.kernel.org/all/[email protected]/
Quoted 4 lines
Thanks,
Suren.Quoted 1 line
mm/madvise.c const char *vma_anon_name(struct vm_area_struct *vma) · line 120
Quoted 4 lines · Suren Baghdasaryan
mm/madvise.c +4
-0+void vma_anon_name_put (struct anon_vma_name *anon_name) +{ +kref_put (&anon_name->kref, vma_anon_name_free); +}
To agree with Michal, make this:
if (anon_name) kref_put(&anon_name->kref, vma_anon_name_free);
mm/madvise.c static int madvise_vma_behavior(struct vm_area_struct *vma, · line 1068
Quoted 12 lines
mm/madvise.c +9
-2- error =madvise_update_vma (vma, prev, start, end, new_flags, -vma_anon_name (vma)); + anon_name =vma_anon_name_get (vma); +if (anon_name) { + error =madvise_update_vma (vma, prev, start, end, new_flags, + anon_name->name); +vma_anon_name_put (anon_name); + }else { + error =madvise_update_vma (vma, prev, start, end, new_flags, +NULL ); + }
And then this becomes:
anon_name = vma_anon_name_get(vma); error = madvise_update_vma(vma, prev, start, end, new_flags, anon_name); vma_anon_name_put(anon_name);
Suren Baghdasaryan
reviewerQuoted 11 lines · Matthew Wilcox
mm/madvise.c const char *vma_anon_name(struct vm_area_struct *vma) · line 120
Quoted 4 lines · Suren Baghdasaryan
mm/madvise.c +4
-0+void vma_anon_name_put (struct anon_vma_name *anon_name) +{ +kref_put (&anon_name->kref, vma_anon_name_free); +}To agree with Michal, make this:
if (anon_name) kref_put(&anon_name->kref, vma_anon_name_free);
Ack.
Quoted 14 lines
mm/madvise.c static int madvise_vma_behavior(struct vm_area_struct *vma, · line 1068
Quoted 13 lines
mm/madvise.c +9
-2- error =madvise_update_vma (vma, prev, start, end, new_flags, -vma_anon_name (vma)); + anon_name =vma_anon_name_get (vma); +if (anon_name) { + error =madvise_update_vma (vma, prev, start, end, new_flags, + anon_name->name); +vma_anon_name_put (anon_name); + }else { + error =madvise_update_vma (vma, prev, start, end, new_flags, +NULL ); + }
Quoted 5 lines
And then this becomes:
anon_name = vma_anon_name_get(vma); error = madvise_update_vma(vma, prev, start, end, new_flags, anon_name); vma_anon_name_put(anon_name);
As I indicated in the other reply, there is another madvise_update_vma user which has only the name string, not the anon_vma_name struct. So this can become:
anon_name = vma_anon_name_get(vma);
error = madvise_update_vma(vma, prev, start, end, new_flags,
anon_name ?anon_name->name : NULL);
vma_anon_name_put(anon_name);