Securing Endpoints with Simple Middleware
Securing Endpoints with Simple Middleware
Welcome to the next step in securing your Laravel applications! In this unit, we will explore an essential aspect of web development — securing endpoints using middleware. Previously, we learned how to authenticate users with Bcrypt to protect our application. Here, we will build on that knowledge to ensure that only authenticated users can access specific parts of our application. This lesson will help you incorporate a vital layer of security into your web applications.
What You'll Learn
In this section, we will dive into the exciting world of middleware and how it can be used to secure endpoints in Laravel applications. In the previous lesson we covered how to create registration and login functionalities for users. But authentication is only the first step in securing your application. In this lesson, you will learn how to use middleware to restrict access to specific routes based on user authentication. Specifically, you will learn how to secure the todos route so that only authenticated users can access it. Let's get started!
What are Sessions?
Before we dive into the code let's understand the concept of sessions.
A session is a way to store information about a user across multiple pages. When a user logs in, a session is created that stores the user's information. This information is then used to authenticate the user on subsequent requests. Sessions are stored on the server and are accessible across multiple pages.
Let's discuss the analaog of what sessions are in real life. Imagine you are at a party and you are given a wristband to wear. This wristband allows you to access different parts of the party. The wristband is like a session. It stores information about you and allows you to access different parts of the party. In the same way, a session stores information about a user and allows them to access different parts of a website.
As mentioned, the sessions are stored in the backend and they usually have a TTL (Time To Live) which is the time the session will be stored on the server. After the TTL expires, the session is destroyed.
Let's see the steps how this occurs:
- When the user logs ins, a new session is created for the user ID and the user is authenticated. This is usually achieved by creating a unique token for the user and storing it in the session.
- This token is then returned to the user and is used to authenticate the user on subsequent requests - this is usually done by storing the token in a cookie or in the local storage of the browser on the client side.
- When the user makes a request to the server, the server checks the token in the session to authenticate the user. If the token is valid, the user is authenticated and the request is processed. If the token is invalid, the user is redirected to the login page.
- When the user logs out, the session is destroyed and the user is logged out.
Authentication Middleware
Let's now see how we can implement this logic with a real example.
Let's start by the controller, where we will modify the login method to store the user's ID in the session. This will allow us to authenticate the user on subsequent requests.
Let's examine the code above thoroughly:
- We have added a new method
getSessionDatathat reads the session data from a file atstorage/app/session_data.json. This file will store the session data for all users. Each entry is a key-value pair where the key is the user ID and the value is the session data for that user (which includes the user ID and the token). - We have added a new method
saveSessionDatathat writes the session data to the file atstorage/app/session_data.json. - In the
loginmethod, we have added the logic to store the user ID in the session data. We generate a new token usingStr::uuid()and store the user ID and the token in the session data. We then save the session data to the file and return the token to the user.
Let's now examine how the client-side code will look like for login:
Notice that when user hits the Login button, the handleLogin function is called. This function sends a POST request to the /login endpoint with the username and password. If the login is successful, the token is stored in the local storage and an alert is shown to the user.
Let's now see how we secure the todos route using middleware. First let's note, that the controller does nothing for securing the todos route, it simply returns all the todos as before:
All the security logic will be implemented in the middleware. Let's create a new middleware called CheckToken:
Let's examine the code above step by step:
- We have created a new middleware called
CheckTokenthat checks if the user is authenticated based on the token and user ID passed in the request. - In the
handlemethod, we first check if the token and user ID are present in the request. If they are not present, we return a400error. - We then read the session data from the file and check if the user ID and token match the session data. If they match, we allow the request to proceed. If they do not match, we log a warning and return a
401error. - We have added a new method
getSessionDatathat reads the session data from the file atstorage/app/session_data.json.
Remember, the middleware is registered in the app/Http/Kernel.php file in the $routeMiddleware array:
Now, let's apply the middleware to the todos route in the routes/web.php file:
With this, when users try to access the /todos route, the CheckToken middleware will be executed first. If the user is not authenticated, the middleware will return a 401 error. If the user is authenticated, the middleware will allow the request to proceed, and the todos will be returned as before.
Let's also understand how the token and user ID are passed in the request.
Let's examine the code above:
- We have added a new function
fetchTodosthat fetches the todos from the/get-todosendpoint. The token and user ID are passed as query parameters in the request. - We have added a new
window.onloadevent listener that calls thefetchTodosfunction when the page loads. - When the
fetchTodosfunction is called, it first checks if the token and user ID are present in the local storage. If they are not present, it shows an alert to the user. - It then sends a
GETrequest to the/get-todosendpoint with the token and user ID as query parameters. If the request is successful, it populates the todos in thetodos-listelement. If the request fails, it shows an error message. - The todos are displayed as a list of items with the title and description of each todo.
With this setup, only authenticated users can access the /todos route. If a user is not authenticated, they will be redirected to the login page. This adds an extra layer of security to the application and ensures that sensitive data is protected.
Logging Out
Finally, let's see how we can implement a logout functionality. When a user logs out
Notice, that in this method we simply remove the user from the session data. This effectively logs the user out. The client-side code for logging out will look like this:
When the user clicks the Logout button, the logout function is called. This function removes the token from the local storage and sends a POST request to the /logout endpoint with the user ID. The user is then logged out and the session data is updated.
With this setup, you have implemented a complete authentication system with login, logout, and session management in your Laravel application. This adds an extra layer of security to your application and ensures that only authenticated users can access sensitive data.
Why It Matters
Securing endpoints is vital in web application development. Middleware acts as a security gate, ensuring that unauthorized users cannot access sensitive parts of your application. By implementing token-based authentication through middleware, you ensure that user data is protected, thereby enhancing your application's reliability and trustworthiness. Middleware not only helps maintain the security of your application but also enforces clean, organized code practices. Ready to strengthen your application's defenses? Let's start practicing!
