Release 0.7.0

[florian-jaeger]

No description provided.

To fix the problem, we need to ensure that the next URL parameter is properly validated to prevent open redirects. We can achieve this by maintaining a list of allowed redirect URLs and checking the user-provided URL against this list. If the URL is not in the list, we should redirect to a default safe URL.

1. Define a list of allowed redirect URLs.
2. Modify the _validate_next_url method to check if the user-provided URL is in the list of allowed URLs.
3. If the URL is not in the list, return a default safe URL.

To fix the problem, we need to ensure that the _validate_next_url method in BaseHandler is robust enough to prevent any untrusted URL redirection. We will enhance the validation logic to ensure that only relative URLs are allowed and that any potentially dangerous URLs are rejected.

• Modify the _validate_next_url method in BaseHandler to include additional checks for URL safety.
• Ensure that the get_next_url method in BaseHandler uses the enhanced _validate_next_url method to validate the URL before redirecting.
• Update the LoginHandler class in grader_service/auth/login.py to use the validated URL for redirection.

To fix the problem, we need to ensure that the next_url is properly validated before being used in a redirect. We can enhance the _validate_next_url method to be more robust and ensure that only safe URLs are allowed. Additionally, we should update the get_next_url method to use this enhanced validation.

1. Enhance the _validate_next_url method to include stricter checks for allowed hosts and schemes.
2. Update the get_next_url method to use the enhanced _validate_next_url method.
3. Ensure that the redirect method in login.py uses the validated next_url.

To fix the problem, we need to ensure that the next_url is validated before it is used in the redirect function. We can achieve this by using the _validate_next_url method from the BaseHandler class to validate the next_url before redirecting.

1. Modify the redirect_to_next_url method in grader_service/auth/lti13/handlers.py to validate the next_url using the _validate_next_url method.
2. Ensure that the validated next_url is used in the redirect function.

To fix the problem, we need to enhance the validation of the next_url to ensure it is safe for redirection. We can achieve this by using the _validate_next_url method from BaseHandler in the OAuthCallbackHandler class to validate the next_url before using it for redirection. This will ensure that the URL is within the same host and protocol, mitigating the risk of URL redirection attacks.

1. Modify the get_next_url method in OAuthCallbackHandler to use _validate_next_url for validating the next_url.
2. Ensure that the next_url is validated before it is used in the redirect method.

To fix the problem, we need to ensure that the constructed file path is contained within a safe root folder. We can achieve this by normalizing the path using os.path.normpath and then checking that the normalized path starts with the expected base directory. This will prevent directory traversal attacks.

1. Normalize the git_repo_path and submission_repo_path using os.path.normpath.
2. Verify that the normalized paths start with the base directory (self.gitbase).

To fix the problem, we need to ensure that the constructed file paths are safe and do not allow path traversal attacks. We can achieve this by normalizing the paths and ensuring they are contained within a safe root directory. Specifically, we will:

1. Normalize the git_repo_path and submission_repo_path using os.path.normpath.
2. Ensure that the normalized paths start with the expected base directory (self.gitbase).

To fix the problem, we need to ensure that the constructed file paths are safe and do not allow directory traversal attacks. We can achieve this by normalizing the paths and ensuring they are contained within a designated root directory. Specifically, we will:

1. Normalize the constructed paths using os.path.normpath.
2. Verify that the normalized paths start with the expected base directory.

To fix the problem, we need to ensure that the constructed file paths are safe and do not allow directory traversal attacks. This can be achieved by normalizing the paths and ensuring they are within a designated safe directory.

1. Normalize the constructed paths using os.path.normpath.
2. Verify that the normalized paths start with the expected base directory.

We will apply these changes to the construction of git_repo_path, submission_repo_path, and tmp_path.

To fix the problem, we should bind the socket to the loopback interface (127.0.0.1) instead of all interfaces. This change will limit the socket's exposure to the local machine only, reducing the security risks associated with binding to all interfaces.

• Update the random_port function in the grader_service/utils.py file.
• Change the binding address from ('', 0) to ('127.0.0.1', 0).