Securing PHP scripts from unauthorized REST API requests

When developing web applications, it is crucial to ensure the security of our PHP scripts, especially when handling sensitive data. One common vulnerability is unauthorized REST API requests from external sources. In this blog post, we will explore some measures to protect PHP scripts from such attacks.

1. Verifying Request Origin:
To prevent unauthorized GET requests, we can verify the origin of the request. By comparing the HTTP Referer header with the expected URL, we can ensure that the request comes from the intended source.


$expectedReferer = '';
if (isset($_SERVER['HTTP_REFERER']) && $_SERVER['HTTP_REFERER'] === $expectedReferer) {
    // Process the data
} else {
    // Invalid request origin

However, it's important to note that the Referer header can be modified by the browser and is not completely reliable. Therefore, consider this as a helpful hint rather than an absolute truth.

2. CSRF Token Implementation:
Implementing CSRF (Cross-Site Request Forgery) tokens provides an effective defense against unauthorized requests. These tokens are unique identifiers tied to a user session. They are generated on the server and passed to forms or requests as hidden fields or headers. The server then checks if the token provided by the client is valid. This security measure makes it difficult for attackers to forge requests from external sources.

Implementing CSRF tokens is a widely adopted practice to protect against Cross-Site Request Forgery attacks. Let's dive deeper into this topic and explore a short example of how to implement CSRF tokens in PHP and JavaScript.

On the server side (PHP), we need to generate a CSRF token and associate it with the user's session. This token will be compared with the one received from the client to ensure its authenticity.

Example (server-side - PHP):


// Generate and store CSRF token in the user's session
if (!isset($_SESSION['csrf_token'])) {
    $_SESSION['csrf_token'] = bin2hex(random_bytes(32));

// Validate the received CSRF token
function validateCsrfToken($token) {
    return hash_equals($_SESSION['csrf_token'], $token);

// Process the request and verify CSRF token
    $receivedToken = $_POST['csrf_token'] ?? '';
    if (validateCsrfToken($receivedToken)) {
        // Token is valid, process the request
    } else {
        // Token is invalid, reject the request

On the client side (JavaScript), we need to include the CSRF token in each request sent to the server. This can be done by adding the token as a hidden input field in HTML forms or including it as a header in AJAX requests.

Example (client-side):

<form id="csrf-form" action="process.php" method="POST">
    <input type="hidden" name="csrf_token" id="csrf-token" value="<?php echo $_SESSION['csrf_token']; ?>">
    <!-- Other form fields -->
    <button type="submit">Submit</button>

In this example, we generate a CSRF token on the server side and store it in the user's session. On the client side, we retrieve the token value and set it as the value of the hidden input field. When the form is submitted, the CSRF token will be sent along with the other form data to the server.

Upon receiving the request on the server side, we validate the CSRF token by comparing the received token with the one stored in the user's session. If they match, the request is considered valid, and the server can proceed with processing the request. Otherwise, the request is rejected.

By implementing CSRF tokens, we add an extra layer of security to our PHP scripts, mitigating the risk of unauthorized requests and protecting the integrity of our web applications. Remember to regenerate and update the CSRF token periodically or with each new session to enhance security.

3. Encrypting Data:
If the data being transmitted is sensitive, encryption can be employed to prevent unauthorized access and interception. PHP provides functions like `openssl_encrypt()` and `openssl_decrypt()` for encrypting and decrypting data.


$key = "secret_key";
$data = "sensitive_data";

$encryptedData = openssl_encrypt($data, "AES-128-ECB", $key);
echo "Encrypted data: " . $encryptedData;

$decryptedData = openssl_decrypt($encryptedData, "AES-128-ECB", $key);
echo "Decrypted data: " . $decryptedData;

4. User Authentication:
If the data is accessible only to authenticated users, it is essential to require authentication before processing the request. Session management, cookies, or other authentication mechanisms can be utilized to verify if the user is authorized to submit the request.

Securing PHP scripts from unauthorized GET requests is crucial for protecting sensitive data and ensuring the integrity of web applications. By implementing measures such as verifying request origin, utilizing CSRF tokens, encrypting data, and enforcing user authentication, we can significantly enhance the security of our PHP scripts. However, it is important to regularly update and review our security measures to stay ahead of potential vulnerabilities.

Remember, security is a continuous process, and employing multiple layers of protection is key to building robust and resilient web applications.

0 Response to “Securing PHP scripts from unauthorized REST API requests”

  • No Comments

Leave a Reply