Welcome back to our “Code of the Week” series! This is the third installment where we continue our deep dive into the less obvious, but equally critical, vulnerabilities hidden within our code. Today, we’re going to uncover another sneaky issue that, much like our previous episodes, might be sitting unnoticed, ready to cause havoc under the right circumstances.

This time around, we’re examining a scenario that’s commonplace in many applications but contains a subtle flaw that could lead to significant vulnerabilities, especially when handling user input and array indexing.

The code

The rule of the game is straightforward: spot the bug! Keep in mind, for this snippet and any others in the series, if something isn’t explicitly shown, you can assume it’s either not within the user’s control or it’s not a source of vulnerability.

#include <stdio.h>
#include <stdlib.h>

int main() {
    int lower, upper;
    int tally[2] = {0};
    char *buffer = (char *)malloc(sizeof(char) * 128);

    while(1) {
        fgets(buffer, 128, stdin);
        if (sscanf(buffer, "%d %d", &lower, &upper) != 2) {
            printf("Invalid input\n");

        for(int num = lower; num <= upper; num++) {
            int index = (num % 2);

        printf("==========\nEvens: %d\nOdds: %d\n==========\n", tally[0], tally[1]);

    return 0;

The bug

Did you spot it? The issue lies in the line int index = (num % 2);! For some reason, if you give modulo a negative number (in C, Python doesn’t behave like that?!) it can return -1. If our index is minus one, we are on the buffer pointer, meaning we can change what it points to and write just about anywhere (assuming we are on 32 bits, 64 bits would allow us to write only half of the address, which is still fairly good as it is the lower half) since once the for-loop ended we end up in a fgets() with the buffer. Impressive how just one little detail can lead to such a dangerous primitive, right?

Of course, most of the time it probably is not exploitable, but it can lead to undefined behavior, and we all know too well how they can be annoying and dangerous.

The fix

In this case, its really straightforward: before using the index, we can simply add a check that it is within the expected range.

The detection

Identifying this kind of bug requires a nuanced understanding of both the programming language in question and the context in which it’s used. Unlike our previous focus on thread safety and authentication, this issue demands vigilance in input validation and memory access patterns.

While static analysis tools can catch a wide range of vulnerabilities, this particular scenario highlights the need for tailored checks, especially for languages that allow direct memory manipulation. Incorporating custom linting rules or enhancing existing tools to flag when array indices could potentially be negative can help in early detection.

However, the cornerstone of detection lies within rigorous code review processes and a keen eye for the unexpected. Developers should be particularly wary of operations leading to array indices, ensuring they account for all possible values, especially when user input is involved.

The conclusion

As we wrap up this episode, we’re reminded once again of the subtleties and dangers lurking in our codebases. This array indexing issue, especially in a language like C, underscores the need for meticulous validation, understanding of language-specific idiosyncrasies, and the crucial role of defensive programming.

Through these explorations, we aim not just to solve individual puzzles but to foster a culture of security and attentiveness in software development. As we move forward, let’s carry the lessons learned into our daily practices, ensuring that the bugs we uncover today don’t become the vulnerabilities of tomorrow.

Stay tuned for more adventures in coding, and remember, the quest for secure, clean code is a journey, not a destination.