How to secure a REST API?
Tags: applicationsecurity, codesecurity, opensourcesecurity
Published: 2024-06-28 02:00:28

As developers, we often have to work with REST APIs when we integrate with third-party systems or connect between frontend and backend systems at work. APIs, and REST APIs in particular, are a fundamental part of modern web applications, allowing us to create, read, update, and delete data over HTTP. However, as with any technology, they come with their own set of security challenges. Let's break these challenges down and understand how to secure REST API applications.


What is a REST API?
-------------------


REST (representational state transfer) APIs are a set of conventions for designing networked applications. They use HTTP protocols to send and receive data and can be used with any programming language that can send HTTP requests. This makes them incredibly versatile and widely used in web development.


However, this versatility also makes them a target for cyber threats, and you should always prioritize developing secure software, such as [implementing the OWASP top 10 proactive controls](https://snyk.io/blog/owasp-top-10-proactive-controls-2020). Without proper security measures in place, REST APIs can expose sensitive data or even provide an entry point for attackers to compromise your system.


Common security threats to REST APIs
------------------------------------


There are several common security threats to REST APIs that developers should be aware of:


1. **Injection attacks**: These occur when an attacker sends malicious data as part of a command or query that tricks the interpreter into executing unintended commands or accessing unauthorized data. For instance, a SQL injection attack can manipulate your API's database queries, leading to data leaks or unauthorized data modifications.
2. **Broken authentication**: If your API's authentication mechanisms are implemented incorrectly, attackers can impersonate other users or even gain administrative privileges. This was the case in the 2018 [Reddit breach](https://www.reddit.com/r/announcements/comments/93qnm5/we_had_a_security_incident_heres_what_you_need_to/), where hackers were able to bypass SMS-based two-factor authentication.
3. **Sensitive data exposure**: APIs often handle sensitive data, such as user credentials or personal information. If this data is not properly protected, it can be intercepted or leaked, leading to serious privacy violations.
4. **Lack of rate limiting**: Without rate limiting, your API is vulnerable to brute force attacks, where an attacker makes repeated requests in an attempt to guess user credentials or overload your system. This was a key factor in the 2016 Dyn attack, which brought down major websites like Twitter and Netflix. Rate limiting is often implemented as part of middleware and considered a [best practice for API gateway security](https://snyk.io/blog/best-practices-for-api-gateway-security/).
5. **Insecure dependencies**: If your API relies on third-party libraries or frameworks that have known vulnerabilities, attackers can exploit them. This is a common issue in open-source software, as seen in the [2017 Equifax breach](https://snyk.io/blog/the-cost-of-a-security-breach/), where a vulnerability in Apache Struts was exploited.


These threats can be mitigated by following best practices for REST API security, such as using secure coding techniques, implementing robust authentication and authorization mechanisms, encrypting sensitive data, and using tools like [Snyk Code](https://snyk.io/product/snyk-code/) and [Snyk Open Source](https://snyk.io/product/snyk-open-source/) to detect and fix vulnerabilities in your code and dependencies.


In the following chapters, we'll explore these best practices and how you can implement them to secure your REST API applications.


1. Implement robust authentication and authorization mechanisms
---------------------------------------------------------------


When it comes to securing a REST API, implementing robust authentication and authorization mechanisms is the first line of defense. This ensures that only authenticated and authorized users can access the API endpoints.


Secure authentication is the process of confirming that a user is who they claim to be. In the context of how to secure a REST API, it's crucial to ensure that the authentication process is secure to prevent unauthorized access. For instance, in 2019, a data breach at Facebook exposed the personal information of nearly 50 million users. The breach was due to an issue in the authentication mechanism, highlighting the importance of secure authentication.


[Snyk Code](https://snyk.io/product/snyk-code/) can help you detect potential authentication vulnerabilities in your codebase, such as hard-coded credentials or lack of rate limiting, which could lead to brute-force attacks.


### Using OAuth 2.0 and JSON Web Tokens (JWT)


OAuth 2.0 is a protocol that allows a user to grant a third-party website or application access to their information without sharing their credentials. It's widely used due to its scalability and simplicity.


In the context of authentication, JSON Web Tokens (JWT) is a popular mechanism used for secure exchange of information between parties as a JSON object. The information within a JWT can be verified and trusted because it is digitally signed.


Here's an example of how to use JWT for authentication in a Node.js REST API:



```
const jwt = require("jsonwebtoken");

// User login
app.post("/login", (req, res) => {
  // Authenticate user
  // ...

  // Generate JWT
  const token = jwt.sign({ userID: user.id }, "your-secret-key");

  // Return token
  res.json({ token });
});

// Secure endpoint
app.get("/secure", (req, res) => {
  // Get token from headers
  const token = req.headers["x-access-token"];

  // Verify token
  jwt.verify(token, "your-secret-key", (err, decoded) => {
    if (err) {
      return res.sendStatus(403);
    }

    // Access granted
    // ...
  });
});
```

### Best practices in managing access tokens


Access tokens are the keys to your API and need to be managed securely. Here are some best practices:


* **Token expiration**: Access tokens should have a short lifespan. This reduces the impact if a token is compromised.
* **Token storage**: Avoid storing access tokens in local storage, as they can be easily accessed by attackers if the application is vulnerable to cross-site scripting (XSS). Instead, use secure storage mechanisms like HTTP-only cookies with security properties enabled (same site, secure flag, and HTTP only, as some best practices to follow).
* **Token transmission**: Always transmit tokens over secure channels. Use HTTPS instead of HTTP to prevent man-in-the-middle attacks.


[Snyk Open Source](https://snyk.io/product/snyk-open-source/) can help you detect vulnerabilities in your open source dependencies used for token management, ensuring your access tokens are managed by a library that is not known to have security vulnerabilities. For more insights on application security and to stay ahead of threats, [create a free Snyk account](https://app.snyk.io/login).


2. Secure data in transit and at rest
-------------------------------------


Securing data, both in transit and at rest, is a critical aspect of securing a REST API. This section will provide you with best practices on how to secure data in transit and at rest.


HTTPS (Hypertext Transfer Protocol Secure) is an essential security measure for any API. It ensures that data transferred between the client and the server is encrypted and cannot be intercepted by attackers.


Most cloud vendors and hosting infrastructure services will provide you with a free SSL certificate, which you can use to enable HTTPS on your REST API. However, if you need to resort to performing SSL termination in your own application code for internal microservices communication or other reasons, here's an example of how to enforce HTTPS in a Flask application using the Python package Flask-SSLify extension:



```
from flask import Flask, request
from flask_sslify import SSLify

app = Flask(__name__)
sslify = SSLify(app)

@app.route('/')
def index():
    return "Hello, World!"

if __name__ == '__main__':
    app.run()
```

In the above Python code snippet, we use the Flask-SSLify extension to enforce HTTPS in a Flask application. This is one of the ways you can secure your REST API with HTTPS.


### Data encryption methodologies


Data encryption is another crucial aspect of securing a REST API. It ensures that even if an attacker manages to access your data, they cannot read it without the decryption key.


One popular method of data encryption is AES (Advanced Encryption Standard). AES is a symmetric encryption algorithm that is widely used due to its security and efficiency.



```
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes

key = get_random_bytes(16)
cipher = AES.new(key, AES.MODE_GCM)
plaintext = b'This is a test.'
ciphertext = cipher.encrypt(plaintext)

print('Ciphertext:', ciphertext)
```

In the above Python code snippet, we use the PyCryptoDome library to encrypt data using AES with a 128-bit key and GCM (Galois/Counter Mode) mode of operation.


### Leveraging HTTP headers for security


HTTP headers can be used to enhance the security of your REST API. Headers like Content Security Policy (CSP) and `X-Content-Type-Options` can help prevent common web vulnerabilities.


CSP is a security header that helps prevent cross-site scripting (XSS) attacks by controlling the resources that a webpage is allowed to load.


`X-Content-Type-Options` is another security header that prevents MIME-type sniffing, a technique used by attackers to trick the browser into executing malicious scripts.



```
@app.after_request
def apply_caching(response):
    response.headers["X-Content-Type-Options"] = "nosniff"
    response.headers["Content-Security-Policy"] = "default-src 'self'"
    return response
```

In the above Python code snippet, we set the `X-Content-Type-Options` and CSP headers in a Flask application.


I highly recommend reading up on [how can a Content Security Policy prevent XSS and other vulnerabilities](https://snyk.io/blog/how-can-a-content-security-policy-prevent-xss-and-other-vulnerabilities/).


3. Validate and sanitize input data
-----------------------------------


One of the most critical steps in securing a REST API is to validate and sanitize input data. This step is crucial in preventing attacks such as SQL Injection.


SQL injection is a common security threat that exploits vulnerabilities in an application's data input fields. In this scenario, an attacker can manipulate SQL queries by injecting malicious SQL code through the application's input fields, leading to unauthorized access to or manipulation of data. In a similar scenario, NoSQL injection attacks can occur when an attacker manipulates a NoSQL database query by injecting malicious code through the application's input fields.


The Snyk Security Research team previously published security disclosures that found the popular [Squelize ORM library to be vulnerable to SQL injection](https://snyk.io/blog/sequelize-orm-npm-library-found-vulnerable-to-sql-injection-attacks/) attacks. This further highlights the importance of validating and sanitizing input data and monitoring your open source libraries for vulnerabilities (you can use [Snyk Open Source](https://snyk.io/product/snyk-open-source/) for free to help with this).


### Implementing input validation techniques


To mitigate these risks, it's essential to implement input validation techniques. Input validation ensures that only properly formatted data enters your system. For instance, if a user's age is expected to be a number, the system should reject any input that isn't a number.


Here's a simple example of input validation in JavaScript:



```
function validateAge(age) {
  if (isNaN(age)) {
    throw new Error("Invalid input: age must be a number");
  }
}
```

Better yet, you should use a library like Zod or Joi to handle input validation in a more robust and maintainable way. These libraries define an expected schema for your input data and validate it against that schema. They're faster and more reliable than writing your own validation logic. For you TypeScript fans, Zod is a great choice as it's built with TypeScript in mind.


In addition to input validation, you should also sanitize your data to ensure that any harmful effects from potentially malicious input are negated. Data sanitization removes or modifies data to prevent it from being used in harmful ways.


Here's a simple example of data sanitization in JavaScript:



```
function sanitizeString(str) {
  return str.replace(/<[^>]*>?/gm, "");
}
```

However, don't take RegEx sanitization too far. It's not a silver bullet and can be bypassed by attackers. Instead, use utility libraries like validator.js on the npm ecosystem, which provides a wide range of validation methods for different types of data. When you write a RegEx, you are likely to miss edge cases and could potentially introduce a security vulnerability known as regular expression denial of service (ReDoS). Snyk previously published a detailed write-up on the popular [UAParser.js ReDOS vulnerability](https://snyk.io/blog/regular-expression-denial-of-service-redos-in-uaparser-js/).


Manually validating and sanitizing every piece of data can be tedious. Thankfully, there are tools available that can automate these tasks. One such tool is [Snyk Code](https://snyk.io/product/snyk-code/). Snyk Code is a static application security testing (SAST) solution that can help you identify and fix vulnerabilities in your code, including those related to input validation and sanitization.


4. Use secure dependencies
--------------------------


When considering how to secure a REST API, it's crucial to pay attention to the dependencies your application relies on. In previous sections, we mentioned several popular libraries and frameworks that have been found to be vulnerable to security threats.


In this section, we'll further highlight the potential dangers of using vulnerable libraries, how to leverage [Snyk Open Source](https://snyk.io/product/snyk-open-source/) to detect these vulnerabilities, and strategies for keeping your dependencies up-to-date.


### The danger of using vulnerable libraries


Dependencies are like the building blocks of your application. However, just like a weak brick can compromise the integrity of a building, a vulnerable library can pose serious security risks to your REST API.


For instance, the infamous Equifax data breach in 2017 was traced back to a vulnerability in Apache Struts, an open source framework for creating Java web applications. The breach exposed the personal data of 147 million people, emphasizing the critical importance of using secure dependencies.



```
// Example of a vulnerable Apache Struts configuration

 

```

In the above example, the `struts.devMode` is set to `true`, which can expose sensitive information and should be avoided in a production environment.


Development mode (`devMode`) in Apache Struts is intended for development and debugging purposes. When `devMode` is enabled, the framework provides more detailed logging, error reporting, and configuration reloading features. These features are helpful during development but can expose sensitive information and potentially open security vulnerabilities if enabled in a production environment.


For instance, enabling `devMode` can lead to:


* Detailed error messages being displayed to users, potentially revealing information about the application structure, underlying technology, or even specific code lines and paths that can be exploited.
* Automatic reloading of configurations, which can be abused to alter the behavior of the application without needing to restart it.
* Increased resource usage due to additional logging and processing, which could impact performance and stability.


Therefore, it's considered a security best practice to ensure that `devMode` is set to `false` in production environments to mitigate these risks.


### Utilizing Snyk Open Source to detect vulnerable dependencies


To mitigate the risk of using vulnerable libraries, it's essential to have a robust system in place to detect and manage these vulnerabilities. This is where Snyk Open Source comes into play.


[Snyk Open Source](https://snyk.io/product/snyk-open-source/) is a tool that helps you identify and fix vulnerabilities in your open source dependencies. It provides a comprehensive database of known vulnerabilities and continuously monitors your dependencies to alert you of any new risks.



```
# Example of using Snyk Open Source to scan your project for vulnerabilities
snyk test
```

In the above example, the `snyk test` command scans your project for vulnerabilities and provides actionable advice on how to remediate them. The scan results are displayed in your terminal (or in the Snyk dashboard if you're using the Snyk web interface) and include details about the vulnerabilities, their severity, and suggested fixes. Example output for a Spring Java application that is using a vulnerable version of Apache Struts:



```
Testing /path/to/your/project...

✗ High severity vulnerability found in org.apache.struts:struts2-core@2.3.20
  Description: Remote Code Execution
  Info: https://snyk.io/vuln/SNYK-JAVA-ORGAPACHESTRUTS-31560
  Introduced through: org.apache.struts:struts2-core@2.3.20
  From: org.apache.struts:struts2-core@2.3.20 > org.apache.struts:struts2-core@2.3.20
  Remediation:
    Upgrade direct dependency org.apache.struts:struts2-core@2.3.20 to org.apache.struts:struts2-core@2.3.24

Tested 123 dependencies for known vulnerabilities, found 1 vulnerabilities, 1 vulnerable paths.
```

Strategies for keeping dependencies up-to-date
----------------------------------------------


Keeping your dependencies up-to-date is a key part of securing your REST API. Here are a few strategies to help you manage your dependencies effectively:


1. **Regularly check for updates:** Make it a habit to check for updates to your dependencies regularly. This can be done manually or by using tools like Snyk that automate the process.
2. **Use a versioning strategy:** Adopt a versioning strategy that balances the need for the latest features with the stability of your application. Semantic versioning is a popular approach that uses version numbers to communicate the type and scale of changes.
3. **Automate updates where possible:** Automating dependency updates can save you a lot of time and reduce the risk of human error. Snyk can be configured to automatically open pull requests for safe upgrades and patches.



```
# Example of using Snyk to automate dependency updates
snyk monitor
```

In the above example, the `snyk monitor` command continuously monitors your project and automatically opens pull requests for safe upgrades and patches. By following these best practices, you can ensure that your dependencies don't become the weak link in your REST API's security. Remember, when it comes to "how to secure REST API", every detail matters and secure dependencies are a crucial part of the puzzle.


Remember, securing your REST API involves more than just validating and sanitizing input data. It's a continuous process that requires regular monitoring and updating. By following these best practices and using tools like Snyk, you can significantly improve the security of your REST API.


Ready to start securing your REST API? [Sign up for Snyk](https://app.snyk.io/login) today.