Hey there, fellow security enthusiasts! Today, we're going to discuss a recently-disclosed vulnerability, CVE-2022-3945, which affects the Kareadita/Kavita GitHub repository. Kareadita/Kavita is a popular self-hosted, open-source web-based reader for manga, comics, and books, which experienced a security issue due to improper restriction of excessive authentication attempts.

In this post, we'll explore the vulnerability in detail, including where in the code it was located, how potential attackers could exploit it, and what the maintainers of the repository did to fix it. Buckle up and get ready to dig deep into CVE-2022-3945!

Vulnerability Details

As mentioned before, CVE-2022-3945 is an improper restriction of excessive authentication attempts that affected Kareadita/Kavita's GitHub repository prior to version .6..3. This vulnerability allowed attackers to gain unauthorized access to accounts by performing a brute-force attack on user passwords.

Code Snippet

The affected code snippet can be found in the AuthenticationController.cs file, within the Login() method. Here's the original, vulnerable code:

[HttpPost("login"), AllowAnonymous]
public async Task<IActionResult> Login([FromBody] LoginDto loginDto)
    // Check if the user exists
    var user = await _userManager.FindByNameAsync(loginDto.Username);
    if (user == null)
        return BadRequest("Invalid username or password");

    // Verify password
    if (!await _userManager.CheckPasswordAsync(user, loginDto.Password))
        return BadRequest("Invalid username or password");

    // ... (code continues for generating JWT token and logging in the user)

As you can see from the code above, the application checks to see if a user exists based on the provided username and password. If either is incorrect, it returns a "Bad Request" message stating, "Invalid username or password." The issue lies in the absence of any mechanism or restriction to prevent continuous authentication attempts.


Given the lack of a robust defense mechanism, an attacker could exploit this vulnerability by using a brute-force method to try multiple combinations of usernames and passwords. Eventually, they might be successful in guessing the correct credentials, allowing them to gain unauthorized access to a victim's account.

Original References and Acknowledgments

The vulnerability was discovered and reported by GitHub user emreakayik (Emre Akayik) in this issue, and a subsequent pull request was provided to address this security issue.

Fixing the Vulnerability

Fortunately, the maintainers of the Kareadita/Kavita repository took quick action, and a patch was released in version .6..3. To remedy this issue, they implemented a rate-limiting feature using the AspNetCoreRateLimit library. This addition prevents excessive authentication attempts by setting restrictions on the number of requests allowed within a specified time window.

Here's the updated code

[HttpPost("login"), AllowAnonymous, EnableRateLimiting]
public async Task<IActionResult> Login([FromBody] LoginDto loginDto)
    // ... (same code as before)

By adding the EnableRateLimiting attribute to the Login() method, the developers ensure that rate limiting is enforced on authentication attempts. This puts an end to potential brute-force attacks.

Conclusion and Recommendations

CVE-2022-3945 highlights the importance of securing user authentication mechanisms in web applications. It's crucial for developers to consider implementing rate-limiting features and other defense mechanisms to prevent brute-force attacks.

To protect yourself from this vulnerability, make sure you're using Kareadita/Kavita version .6..3 or later, which contains the patch. Additionally, it's always a good idea for users to utilize strong, unique passwords for their accounts, enabling an extra layer of protection against unauthorized access.


Published on: 11/11/2022 12:15:00 UTC
Last modified on: 11/16/2022 15:34:00 UTC