Skip to main content

Insecure functionality


Secure functionality implementation


  • Usage of Python 3 for scripting and application development
  • Usage of Django for building web applications in Python


Non compliant code

from django.http import HttpResponse
from .models import User

def get_user(request):
user_id = request.GET['id']
user = User.objects.get(id=user_id)
return HttpResponse(user)

The function get_user in the above code is responsible for fetching a user from the database by their ID. The ID is obtained from the GET parameters of the request object. This function is vulnerable because it does not validate or sanitize the user input before using it to query the database.

This can lead to two major issues:

  1. Information Disclosure: If a malicious user knows the ID of other users, they can easily retrieve their information by simply sending a request with their ID. This can lead to unauthorized access to sensitive user information.

  2. SQL Injection: Although Django's ORM, which is used here, is designed to prevent SQL injection attacks, certain complex queries can still be susceptible. In this case, if the user input is not validated, a sophisticated attacker could potentially manipulate the query to retrieve information they are not supposed to have access to or perform actions on the database that they are not authorized to do.

To fix these vulnerabilities, we need to add appropriate access controls to ensure that users can only access data they are authorized for. We also need to validate and sanitize user inputs to protect against SQL injection attacks.


  • Validate and sanitize the input: Ensure that the user_id obtained from the request is valid and safe to use. This can be done by checking if it is a number and does not contain any special characters or SQL commands.
  • Use parameterized queries: Instead of directly inserting the user_id into the query, use a parameterized query. This way, the database knows exactly what data to expect, which reduces the risk of SQL injection.
  • Implement error handling: If the user_id does not exist in the database, the application should handle this gracefully. This can be done by checking if the user object is None and returning an appropriate error message.
  • Limit data exposure: Instead of returning the entire user object, only return the necessary information. This reduces the risk of exposing sensitive information.

Compliant code

from django.http import HttpResponse, JsonResponse
from django.core.exceptions import ObjectDoesNotExist
from .models import User
import re

def get_user(request):
user_id = request.GET.get('id', None)

# Validate and sanitize the input
if user_id is None or not re.match("^[0-9]+$", user_id):
return JsonResponse({'error': 'Invalid user ID.'}, status=400)

# Use parameterized queries and implement error handling
user = User.objects.get(id=user_id)
except ObjectDoesNotExist:
return JsonResponse({'error': 'User not found.'}, status=404)

# Limit data exposure
user_data = {
'username': user.username,
# add other necessary fields

return JsonResponse(user_data)

The code starts by getting the user_id from the request. If no user_id is provided or if it contains anything other than numbers, an error message is returned.

Next, a parameterized query is used to get the user from the database. This is done using Django's ORM, which automatically uses parameterized queries. If no user with the provided id exists, an error message is returned.

Finally, instead of returning the entire user object, a dictionary is created with only the necessary information. This dictionary is then returned as a JSON response. This limits data exposure by ensuring that only the necessary information is sent to the client.

This code fixes the vulnerability by validating and sanitizing the input, using parameterized queries, implementing error handling, and limiting data exposure.