Skip to content

armgit / wger

Public Imported from GitHub
0

Self hosted FLOSS fitness/workout, nutrition and weight tracker

Check slot_entry, next_log and day ownership on workout log/session APIs

Roland Geiderb29cf178651b
diff --git a/wger/manager/api/views.py b/wger/manager/api/views.py
index 136e94a70..99e4b7b11 100644
--- a/wger/manager/api/views.py
+++ b/wger/manager/api/views.py
@@ -280,7 +280,7 @@ class WorkoutSessionViewSet(WgerOwnerObjectModelViewSet):
"""
Return objects to check for ownership permission
"""
- return [(Routine, 'routine')]
+ return [(Routine, 'routine'), (Day, 'day')]
class WorkoutLogViewSet(WgerOwnerObjectModelViewSet):
@@ -313,7 +313,12 @@ class WorkoutLogViewSet(WgerOwnerObjectModelViewSet):
"""
Return objects to check for ownership permission
"""
- return [(Routine, 'routine'), (WorkoutSession, 'session')]
+ return [
+ (Routine, 'routine'),
+ (WorkoutSession, 'session'),
+ (SlotEntry, 'slot_entry'),
+ (WorkoutLog, 'next_log'),
+ ]
class RoutineDayViewSet(WgerOwnerObjectModelViewSet):
diff --git a/wger/manager/models/log.py b/wger/manager/models/log.py
index bd0c94f3c..6688eec82 100644
--- a/wger/manager/models/log.py
+++ b/wger/manager/models/log.py
@@ -252,6 +252,10 @@ class WorkoutLog(models.Model):
if self.routine and self.routine.user != self.user:
return
+ # Same check for slot_entry's owning routine
+ if self.slot_entry and self.slot_entry.slot.day.routine.user != self.user:
+ return
+
# If there is no session for this date and routine, create one
self.session = WorkoutSession.objects.get_or_create(
user=self.user,
diff --git a/wger/manager/models/slot_entry.py b/wger/manager/models/slot_entry.py
index 3eda33714..f46748ce9 100644
--- a/wger/manager/models/slot_entry.py
+++ b/wger/manager/models/slot_entry.py
@@ -364,7 +364,11 @@ class SlotEntry(models.Model):
if result and not self.has_progression:
return result
- logs = list(self.workoutlog_set.all())
+ # Defence-in-depth: ignore any log rows that don't belong to the
+ # routine's owner. The API ownership check should already prevent
+ # cross-user logs from being attached to a slot entry, but this
+ # filter ensures progression calculations stay user-scoped.
+ logs = list(self.workoutlog_set.filter(user=self.slot.day.routine.user))
# If there is a custom class set, pass all responsibilities to it
if self.class_name:
diff --git a/wger/manager/tests/test_api_ownership_checks.py b/wger/manager/tests/test_api_ownership_checks.py
new file mode 100644
index 000000000..f14d4b1a2
--- /dev/null
+++ b/wger/manager/tests/test_api_ownership_checks.py
@@ -0,0 +1,183 @@
+# This file is part of wger Workout Manager.
+#
+# wger Workout Manager is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# wger Workout Manager is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+
+# Django
+from django.urls import reverse
+
+# Third Party
+from rest_framework import status
+
+# wger
+from wger.core.tests.base_testcase import WgerTestCase
+from wger.manager.models import (
+ Day,
+ SlotEntry,
+ WorkoutLog,
+ WorkoutSession,
+)
+
+
+class WorkoutLogSlotEntryOwnershipTestCase(WgerTestCase):
+ """
+ Make sure the API rejects cross-user references on the ``slot_entry``
+ foreign key when creating or updating a WorkoutLog.
+
+ Slot entry pk=1 belongs to routine pk=1 (user 'admin', pk=1).
+ Routine pk=2 belongs to user 'test' (pk=2).
+ """
+
+ def test_create_with_foreign_slot_entry_is_forbidden(self):
+ """
+ POST /api/v2/workoutlog/ from user 'test' must not be able to attach
+ a log to admin's slot_entry, even if the request's ``routine`` is
+ owned by user 'test'.
+ """
+ self.user_login('test')
+
+ victim_slot_entry = SlotEntry.objects.get(pk=1)
+ self.assertEqual(victim_slot_entry.slot.day.routine.user_id, 1)
+
+ response = self.client.post(
+ reverse('workoutlog-list'),
+ data={
+ 'routine': 2,
+ 'slot_entry': victim_slot_entry.pk,
+ 'exercise': 1,
+ 'repetitions': 999,
+ 'repetitions_unit': 1,
+ 'weight': 999,
+ 'weight_unit': 1,
+ 'date': '2024-01-01',
+ 'iteration': 1,
+ },
+ )
+
+ self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+ self.assertFalse(
+ WorkoutLog.objects.filter(slot_entry=victim_slot_entry, weight=999).exists()
+ )
+
+ def test_create_with_own_slot_entry_is_allowed(self):
+ """
+ Ensure the new ownership check does not break the legitimate case.
+ """
+ self.user_login()
+
+ own_slot_entry = SlotEntry.objects.get(pk=1)
+ self.assertEqual(own_slot_entry.slot.day.routine.user_id, 1)
+
+ response = self.client.post(
+ reverse('workoutlog-list'),
+ data={
+ 'routine': 1,
+ 'slot_entry': own_slot_entry.pk,
+ 'exercise': 1,
+ 'repetitions': 5,
+ 'repetitions_unit': 1,
+ 'weight': 50,
+ 'weight_unit': 1,
+ 'date': '2024-01-01',
+ 'iteration': 1,
+ },
+ )
+
+ self.assertEqual(response.status_code, status.HTTP_201_CREATED)
+
+
+class WorkoutLogNextLogOwnershipTestCase(WgerTestCase):
+ """
+ Make sure the API rejects cross-user references on the ``next_log``
+ foreign key. Without the ownership check the model save() silently
+ nulls the field, but the API should respond with 403 for consistency
+ with the other foreign keys on this resource.
+
+ WorkoutLog pk=1 belongs to user 'admin' (pk=1).
+ Routine pk=3 belongs to user 'test' (pk=2).
+ """
+
+ def test_create_with_foreign_next_log_is_forbidden(self):
+ self.user_login('test')
+
+ victim_log = WorkoutLog.objects.get(pk=1)
+ self.assertEqual(victim_log.user_id, 1)
+
+ response = self.client.post(
+ reverse('workoutlog-list'),
+ data={
+ 'routine': 3,
+ 'next_log': victim_log.pk,
+ 'exercise': 1,
+ 'repetitions': 5,
+ 'repetitions_unit': 1,
+ 'weight': 50,
+ 'weight_unit': 1,
+ 'date': '2024-01-01',
+ 'iteration': 1,
+ },
+ )
+
+ self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+
+
+class WorkoutSessionDayOwnershipTestCase(WgerTestCase):
+ """
+ Make sure the API rejects cross-user references on the ``day``
+ foreign key when creating a WorkoutSession.
+
+ Day pk=1 belongs to routine pk=1 (user 'admin', pk=1).
+ Routine pk=3 belongs to user 'test' (pk=2).
+ """
+
+ def test_create_with_foreign_day_is_forbidden(self):
+ self.user_login('test')
+
+ victim_day = Day.objects.get(pk=1)
+ self.assertEqual(victim_day.routine.user_id, 1)
+
+ response = self.client.post(
+ reverse('workoutsession-list'),
+ data={
+ 'routine': 3,
+ 'day': victim_day.pk,
+ 'date': '2024-02-01',
+ 'notes': '',
+ 'impression': '2',
+ },
+ )
+
+ self.assertEqual(response.status_code, status.HTTP_403_FORBIDDEN)
+ self.assertFalse(WorkoutSession.objects.filter(day=victim_day, routine_id=3).exists())
+
+ def test_create_with_own_day_is_allowed(self):
+ """
+ Smoke test: the legitimate case (own routine + own day) still works.
+ Day pk=1 belongs to user 'admin'.
+ """
+ self.user_login()
+
+ own_day = Day.objects.get(pk=1)
+ self.assertEqual(own_day.routine.user_id, 1)
+
+ response = self.client.post(
+ reverse('workoutsession-list'),
+ data={
+ 'routine': 1,
+ 'day': own_day.pk,
+ 'date': '2024-02-15',
+ 'notes': '',
+ 'impression': '2',
+ },
+ )
+
+ self.assertEqual(response.status_code, status.HTTP_201_CREATED)
diff --git a/wger/manager/tests/test_log_model.py b/wger/manager/tests/test_log_model.py
index 4f6be5f4e..8b5210e64 100644
--- a/wger/manager/tests/test_log_model.py
+++ b/wger/manager/tests/test_log_model.py
@@ -92,6 +92,28 @@ class LogModelTestCase(WgerTestCase):
self.assertEqual(log.routine_id, 1)
+ def test_slot_entry_ownership(self):
+ """
+ Test that the slot_entry foreign key checks ownership at the
+ model layer, parallel to the existing routine guard.
+
+ SlotEntry pk=1 belongs to user 1; the new log is for user 2 with
+ no routine. Without a guard, super().save() persists a row; with
+ the guard, save() returns early and nothing is written.
+ """
+
+ log = WorkoutLog(
+ user_id=2,
+ exercise_id=1,
+ slot_entry_id=1,
+ repetitions=5,
+ weight=50,
+ )
+ log.save()
+
+ self.assertIsNone(log.pk)
+ self.assertFalse(WorkoutLog.objects.filter(user_id=2, slot_entry_id=1).exists())
+
def test_next_log_user_check_fail(self):
"""
Test that the next log foreign key checks ownership