Skip to contentSkip to conversation

mm: fix use-after-free when anon vma name is used after vma is freed

PATCH Superseded Suren Baghdasaryan 3 participants 10 messages Feb 10, 2022 – Feb 11, 2022

Subsystems (4)

v2 of 6 Superseded Latest is v6 →

lore
Share & tools
lore

Suren Baghdasaryan

author reviewer
#0 lore raw

PATCH 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.

Fixes 9a10064f5625 ("mm: add a field to store names for private anonymous memory")
Reported-by [email protected]

---
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
index b725839dfe71..2ad9b28499b1 100644
@@ -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
index 5604064df464..9cf069e574c0 100644
@@ -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
reviewer
#1 lore raw
Quoted 14 lines · Suren Baghdasaryan

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

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
author reviewer
#2 lore raw
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_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

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_vma uses the naked name rather than the encapsulated anon_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].

#3 lore raw
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_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

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_vma uses the naked name rather than the encapsulated anon_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_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.

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().

author reviewer
#4 lore raw
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_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

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_vma uses the naked name rather than the encapsulated anon_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_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.

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().

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!

#5 lore raw
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_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

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_vma uses the naked name rather than the encapsulated anon_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 8 lines
Quoted 3 lines

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().

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.

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?

author reviewer
#6 lore raw
Quoted 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_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

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_vma uses the naked name rather than the encapsulated anon_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_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.

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().

Quoted 8 lines
Quoted 4 lines

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.

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
author reviewer
#7 lore raw
Quoted 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_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

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_vma uses the naked name rather than the encapsulated anon_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_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.

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().

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.

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 use anon_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
#8 lore raw
In reply to Suren Baghdasaryan

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);
author reviewer
#9 lore raw
Quoted 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);