Skip to main content

Traceability loss - Server's clock

Need​

Ensuring accurate time synchronization with NTP servers

Context​

  • Usage of Go 1.16 for developing high-performance and concurrent applications
  • Usage of gin-gonic/gin for building web applications and APIs in Go

Description​

Non compliant code​

package main

import (
    "github.com/gin-gonic/gin"
    "time"
)

func main() {
    router := gin.Default()

    router.GET("/time", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "time": time.Now().String(),
        })
    })

    router.Run(":8080")
}

The above code is a simple Gin server with a single endpoint /time, which returns the current time according to the server's internal clock.

The vulnerability here is that the server is using its own internal clock to determine the current time, which is not synced with any Network Time Protocol (NTP) servers. This could lead to a loss of traceability, as the timestamps generated by this server may not match the actual time, especially if the server's internal clock drifts or is set incorrectly.

This could cause major issues in a production environment, where accurate timekeeping is crucial for tasks like logging, event ordering, and synchronization between different systems.

Without NTP synchronization, the server's clock could easily drift by several seconds or even minutes over time, causing timestamps to become increasingly inaccurate. This could lead to confusion when trying to analyze logs or trace the sequence of events, and could potentially even have legal implications if accurate timekeeping is required by regulations or contracts.

In a worst-case scenario, if the server's clock is set far enough in the future, it could even cause events to appear to happen "in the future", which could break systems that rely on timestamps to order events or calculate durations.

Steps​

  • Synchronize the server's clock with a reliable time source, such as NTP (Network Time Protocol) servers.
  • Install and configure an NTP client on the server to automatically sync the clock at regular intervals.
  • Ensure that the server's firewall allows outgoing connections to NTP servers.
  • Monitor the server's clock synchronization status regularly to detect any issues or drift.
  • Implement proper error handling and logging mechanisms to capture any errors related to clock synchronization.
  • Consider using a library or framework that provides built-in clock synchronization functionality to simplify the process.
  • Test the application thoroughly after implementing the clock synchronization to ensure it functions correctly.

Compliant code​

package main

import (
    "github.com/beevik/ntp"
    "github.com/gin-gonic/gin"
    "log"
)

func main() {
    router := gin.Default()

    router.GET("/time", func(c *gin.Context) {
        ntpTime, err := ntp.Time("pool.ntp.org")
        if err != nil {
            log.Println("Error syncing with NTP server:", err)
            c.JSON(500, gin.H{
                "error": "Internal Server Error",
            })
            return
        }

        c.JSON(200, gin.H{
            "time": ntpTime.String(),
        })
    })

    router.Run(":8080")
}

The original code was vulnerable because it was using the system's internal clock, which was not synchronized with an NTP server. This could lead to traceability loss if the system's clock drifts or is manipulated.

The fixed code uses the github.com/beevik/ntp package to fetch the current time from an NTP server (pool.ntp.org in this case). This ensures that the time returned by the /time endpoint is always synchronized with a reliable external source.

If there is an error while fetching the time from the NTP server (for example, if the server is unreachable), the error is logged and a 500 Internal Server Error response is returned. This is an improvement over the original code, which would have returned potentially incorrect time data without any indication of an error.

Please note that this code assumes that the server's firewall allows outgoing connections to NTP servers. If this is not the case, you will need to adjust your firewall settings accordingly.

After implementing this fix, you should monitor the server's clock synchronization status regularly to detect any issues or drift. You should also implement proper error handling and logging mechanisms to capture any errors related to clock synchronization.

Finally, you should test the application thoroughly after implementing the clock synchronization to ensure it functions correctly.

References​

Last updated on