VPN Connectivity Verification Tool in C: Complete Tutorial

#define PI 3.14
#define SQUARE(x) ((x) * (x))

#define MAX_BUFFER 2048   // Maximum buffer for network adapter info
#define IP_SIZE 100       // Buffer size for IP addresses
#define DNS_SIZE 1024     // Buffer size for DNS server information

int fetch_public_ip(char *ip_buffer);

int fetch_dns_servers(char *dns_buffer);

int detect_vpn_adapter(char *adapter_buffer);

void print_separator(char c, int length);

void safe_copy(char *dest, const char *src, size_t size);

int check_vpn_keywords_windows(const char *line);

int check_vpn_keywords_unix(const char *line);

int main() {
    // State storage variables
    char ip_before[IP_SIZE] = {0};           // Public IP before VPN
    char ip_after[IP_SIZE] = {0};            // Public IP after VPN
    char dns_before[DNS_SIZE] = {0};         // DNS servers before VPN
    char dns_after[DNS_SIZE] = {0};          // DNS servers after VPN
    char vpn_adapter_before[MAX_BUFFER] = {0};  // VPN adapters before
    char vpn_adapter_after[MAX_BUFFER] = {0};   // VPN adapters after
    
    // Analysis flags
    int ip_changed = 0;          // Flag: Did IP address change?
    int dns_changes = 0;         // Flag: Did DNS servers change?
    int vpn_adapter_detected = 0; // Flag: VPN adapter present?

print_separator('=', 65);
printf("        Advanced VPN Connectivity Verification Tool\n");
print_separator('=', 65);

#ifdef OS_WINDOWS
    printf("Operating System: Windows\n");
#elif defined(OS_LINUX)
    printf("Operating System: Linux\n");
#elif defined(OS_MAC)
    printf("Operating System: macOS\n");
#else
    printf("Operating System: Unknown\n");
#endif

print_separator('=', 65);

printf("\n[Step 1] Checking current public IP address...\n");
if (fetch_public_ip(ip_before) != 0) {
    printf("ERROR: Unable to fetch public IP address.\n");
    printf("Please check your internet connection.\n");
    return 1;  // Critical error - exit program
}
printf("Public IP before VPN: %s\n", ip_before);

printf("\n[Step 2] Checking current DNS Servers...\n");
if (fetch_dns_servers(dns_before) != 0) {
    printf("WARNING: Unable to fetch DNS information.\n");
} else {
    printf("DNS Servers (Before VPN): \n%s\n", dns_before);
}

printf("\n[Step 3] Scanning for VPN network adapters...\n");
detect_vpn_adapter(vpn_adapter_before);

if (strlen(vpn_adapter_before) > 0) {
    printf("VPN Adapters Found (Before VPN): \n%s\n", vpn_adapter_before);
} else {
    printf("No VPN adapters detected (before VPN).\n");
}

print_separator('=', 65);
printf("\n>>> NOW CONNECT TO YOUR VPN <<<\n");
printf(">>> Press ENTER when connected <<<\n");
getchar();  // Wait for user input
print_separator('=', 65);

// Step 4: Check IP After VPN
if (fetch_public_ip(ip_after) != 0) {
    printf("ERROR: Unable to fetch public IP address.\n");
    return 1;
}
printf("Public IP after VPN: %s\n", ip_after);

// Step 5: Check DNS After VPN
if (fetch_dns_servers(dns_after) != 0) {
    printf("WARNING: Unable to fetch DNS information.\n");
} else {
    printf("DNS Servers (After VPN): \n%s\n", dns_after);
}

// Step 6: Detect VPN Adapters After VPN
detect_vpn_adapter(vpn_adapter_after);
if (strlen(vpn_adapter_after) > 0) {
    printf("VPN Adapters Found (After VPN): \n%s\n", vpn_adapter_after);
    vpn_adapter_detected = 1;  // Set flag for analysis
} else {
    printf("No VPN adapters detected (After VPN).\n");
}

print_separator('=', 65);
printf("                    Verification Summary\n");
print_separator('=', 65);

printf("\n%-30s %s\n", "IP Address (Before): ", ip_before);
printf("%-30s %s\n", "IP Address (After): ", ip_after);

// Compare IPs
ip_changed = (strcmp(ip_before, ip_after) != 0);
printf("%-30s %s\n", "IP Changed:", ip_changed ? "YES" : "NO");

// Compare DNS
dns_changes = (strcmp(dns_before, dns_after) != 0);
printf("%-30s %s\n", "DNS Changed:", dns_changes ? "YES" : "NO");

// VPN Adapter Status
printf("%-30s %s\n", "VPN Adapter Detected:", 
       vpn_adapter_detected ? "YES" : "NO");

print_separator('*', 65);

if (ip_changed && vpn_adapter_detected) {
    printf("         VPN STATUS: ACTIVE\n");
    printf("         Your connection is successfully routed through VPN!\n");
}
else if (ip_changed && !vpn_adapter_detected) {
    printf("         VPN STATUS: LIKELY ACTIVE\n");
    printf("         IP changed but no VPN adapter detected. Verify manually.\n");
}
else if (!ip_changed && vpn_adapter_detected) {
    printf("         VPN STATUS: PARTIAL\n");
    printf("         VPN adapter found but IP did not change. Check routing.\n");
}
else {
    printf("         VPN STATUS: NOT ACTIVE\n");
    printf("         Your connection is NOT protected by VPN!\n");
}

print_separator('*', 65);

printf("\n[SECURITY NOTE] For complete security verification:\n");
printf(" 1. Check DNS leaks: https://dnsleaktest.com\n");
printf(" 2. Check WebRTC leaks: https://browserleaks.com/webrtc\n");
printf(" 3. Verify IPv6 is disabled or routed through VPN\n");

print_separator('=', 65);
return 0;

int fetch_public_ip(char *ip_buffer) {
    FILE *fp;
    char command[] = "curl -s --max-time 10 ifconfig.me";
    
    // Execute curl command
    fp = popen(command, "r");
    if (fp == NULL) {
        return 1;  // popen failed
    }
    
    // Read IP address from command output
    if (fgets(ip_buffer, IP_SIZE, fp) == NULL) {
        pclose(fp);
        return 1;  // fgets failed (no output)
    }
    
    pclose(fp);
    return 0;  // Success
}

#ifdef OS_WINDOWS
    fp = popen(DNS_COMMAND, "r");  // "ipconfig /all"
    if (fp == NULL) {
        return 1;
    }
    
    dns_buffer0] = '\0';  // Initialize buffer
    
    while (fgets(line, sizeof(line), fp) != NULL) {
        // Look for DNS server lines
        if (strstr(line, "DNS Servers") != NULL || 
            strstr(line, "DNS Server") != NULL) {
            strncat(dns_buffer, line, DNS_SIZE - strlen(dns_buffer) - 1);
            found = 1;
            
            // Read continuation lines (indented IP addresses)
            while (fgets(line, sizeof(line), fp) != NULL) {
                // Check if line is indented and contains IP-like text
                if (line[0] == ' ' && 
                    (strstr(line, ".") != NULL || strstr(line, ":") != NULL)) {
                    strncat(dns_buffer, line, DNS_SIZE - strlen(dns_buffer) - 1);
                } else {
                    break;  // End of DNS section
                }
            }
        }
    }
#endif

int fetch_public_ipv6(char *ip_buffer);

int fetch_public_ipv6(char *ip_buffer)
{
    FILE *fp;
    char command[] = "curl -6 -s --max-time 10 ifconfig.me";

    fp = popen(command, "r");
    if (fp == NULL)
        return 1;
    if (fgets(ip_buffer, IP_SIZE, fp) == NULL)
    {
        pclose(fp);
        return 1;
    }

    pclose(fp);
    return 0;
}

# Windows (PowerShell as Admin)
Disable-NetAdapterBinding -Name "*" -ComponentID ms_tcpip6

# Linux
sudo sysctl -w net.ipv6.conf.all.disable_ipv6=1

# macOS
networksetup -setv6off Wi-Fi

int fetch_geolocation(char *country_buffer, char *region_buffer, char *city_buffer);

int fetch_geolocation(char *country_buffer, char *region_buffer, char *city_buffer)
{
    FILE *fp;

    // Fetch country
    char country_command[] = "curl -s ipinfo.io/country";
    fp = popen(country_command, "r");
    if (fp == NULL)
    {
        return 1;
    }
    if (fgets(country_buffer, COUNTRY_SIZE, fp) == NULL)
    {
        pclose(fp);
        return 1;
    }
    pclose(fp);

    // Remove newline character from country code
    size_t len = strlen(country_buffer);
    if (len > 0 && country_buffer[len - 1] == '\n')
    {
        country_buffer[len - 1] = '\0';
    }

    // Fetch region
    char region_command[] = "curl -s ipinfo.io/region";
    fp = popen(region_command, "r");
    if (fp == NULL)
    {
        return 1;
    }
    if (fgets(region_buffer, REGION_SIZE, fp) == NULL)
    {
        pclose(fp);
        return 1;
    }
    pclose(fp);

    // Remove newline character from region
    len = strlen(region_buffer);
    if (len > 0 && region_buffer[len - 1] == '\n')
    {
        region_buffer[len - 1] = '\0';
    }

    // Fetch city
    char city_command[] = "curl -s ipinfo.io/city";
    fp = popen(city_command, "r");
    if (fp == NULL)
    {
        return 1;
    }
    if (fgets(city_buffer, CITY_SIZE, fp) == NULL)
    {
        pclose(fp);
        return 1;
    }
    pclose(fp);

    // Remove newline character from city
    len = strlen(city_buffer);
    if (len > 0 && city_buffer[len - 1] == '\n')
    {
        city_buffer[len - 1] = '\0';
    }

    return 0;
}

int measure_latency(const char *host);

int measure_latency(const char *host)
{
    char cmd[256];
    snprintf(cmd, sizeof(cmd), PING_COMMAND, host);
    
    FILE *fp = popen(cmd, "r");
    if (fp == NULL)
    {
        printf("ERROR: Unable to execute ping command.\n");
        return 1;
    }
    
    char line[256];
    int found = 0;
    
    printf("Pinging %s...\n", host);
    
    while (fgets(line, sizeof(line), fp) != NULL)
    {
#ifdef OS_WINDOWS
        if (strstr(line, "Average") != NULL || strstr(line, "Minimum") != NULL)
        {
            printf("   %s", line);
            found = 1;
        }
#else
        if (strstr(line, "avg") != NULL || strstr(line, "min") != NULL || 
            strstr(line, "rtt") != NULL)
        {
            printf("   %s", line);
            found = 1;
        }
#endif
    }
    
    if (!found)
    {
        printf("   Unable to extract latency statistics.\n");
    }
    
    pclose(fp);
    return 0;
}

#ifdef _WIN32
    #define PING_COMMAND "ping -n 4 %s"
#else
    #define PING_COMMAND "ping -c 4 %s"
#endif

int check_dns_leak(const char *dns_servers, const char *isp_dns);

int extract_first_dns_ip(const char *dns_buffer, char *ip_output)
{
    if (dns_buffer == NULL || ip_output == NULL)
        return 1;

    ip_output[0] = '\0';

#ifdef OS_WINDOWS
    const char *line = dns_buffer;

    while (*line != '\0')
    {
        if (strstr(line, "DNS Server") != NULL)
        {
            const char *ip_start = strchr(line, ':');
            if (ip_start != NULL)
            {
                ip_start++;

                // Skip whitespace and dots
                while (*ip_start == ' ' || *ip_start == '.')
                    ip_start++;

                // Extract IP address
                int i = 0;
                while (*ip_start != '\0' && *ip_start != '\n' && i < IP_SIZE - 1)
                {
                    if ((*ip_start >= '0' && *ip_start <= '9') || *ip_start == '.')
                    {
                        ip_output[i++] = *ip_start;
                    }
                    else if (ip_output[0] != '\0')
                    {
                        break;
                    }
                    ip_start++;
                }
                ip_output[i] = '\0';

                // Validate IP (must have at least 7 chars like "1.1.1.1")
                if (strlen(ip_output) > 6)
                    return 0; // Success
            }
        }

        // Move to next line
        line = strchr(line, '\n');
        if (line == NULL)
            break;
        line++;
    }
#else
    // Linux/macOS: Extract from nameserver line
    const char *nameserver = strstr(dns_buffer, "nameserver");
    if (nameserver != NULL)
    {
        if (sscanf(nameserver, "nameserver %s", ip_output) == 1)
        {
            return 0; // Success
        }
    }
#endif

    return 1; // Failed to extract
}

int check_dns_leak(const char *dns_servers, const char *isp_dns)
{
    if (dns_servers == NULL || isp_dns == NULL)
    {
        return 0;
    }

    // Extract the First DNS IP from the dns_servers buffer
    char first_dns_after_vpn[IP_SIZE] = {0};

    if (extract_first_dns_ip(dns_servers, first_dns_after_vpn) != 0)
    {
        return 0; // Could not extract DNS assume no leak
    }

    // Remove newline if present
    size_t len = strlen(first_dns_after_vpn);
    if (len > 0 && first_dns_after_vpn[len - 1] == '\n')
    {
        first_dns_after_vpn[len - 1] = '\0';
    }

    // Check if PRIMARY DNS changes from ISP DNS
    if (strlen(first_dns_after_vpn) > 0)
    {
        // If first DNS is still the ISP DNS = LEAK
        if (strcmp(first_dns_after_vpn, isp_dns) == 0)
        {
            printf("     WARNING: DNS Leak Detected!\n");
            printf("   Primary DNS is still ISP DNS: %s\n", isp_dns);
            return 1; // Leak detected
        }
        else
        {
            // First DNS is different (VPN DNS) = No Leak
            printf("      DNS Protection Active\n");
            printf("   Primary DNS changed to: %s\n", first_dns_after_vpn);
            return 0; // No leak
        }
    }
    return 0; // No leak
}

Windows

# Set VPN DNS to Cloudflare
netsh interface ipv4 set dns "VPN Connection Name" static 1.1.1.1
netsh interface ipv4 add dns "VPN Connection Name" 1.0.0.1 index=2

Linux

# Edit /etc/resolv.conf
sudo nano /etc/resolv.conf

# Add VPN DNS
nameserver 1.1.1.1
nameserver 1.0.0.1

# Make immutable (prevent overwrites)
sudo chattr +i /etc/resolv.conf

int monitor_vpn_connection(int interval_seconds, int duration_seconds);

int monitor_vpn_connection(int interval_seconds, int duration_seconds)
{
    int elapsed = 0;
    char ip_current[IP_SIZE];
    char ip_first[IP_SIZE] = {0};
    
    printf("\n");
    print_separator('=', 65);
    printf("        Real-Time VPN Connection Monitor\n");
    printf("        Monitoring for %d seconds...\n", duration_seconds);
    print_separator('=', 65);
    printf("\n");
    
    while (elapsed < duration_seconds)
    {
        // Check current IP
        if (fetch_public_ip(ip_current) == 0)
        {
            // Store first IP as baseline
            if (ip_first[0] == '\0')
            {
                strcpy(ip_first, ip_current);
            }
            
            // Remove newline from current IP
            size_t len = strlen(ip_current);
            if (len > 0 && ip_current[len - 1] == '\n')
                ip_current[len - 1] = '\0';
            
            // Remove newline from first IP for comparison
            len = strlen(ip_first);
            if (len > 0 && ip_first[len - 1] == '\n')
                ip_first[len - 1] = '\0';
            
            // Check for IP change
            int ip_changed = (strcmp(ip_first, ip_current) != 0);
            
            printf("[%4ds] IP: %-15s ", elapsed, ip_current);
            
            if (ip_changed)
            {
                printf("⚠️  WARNING [IP CHANGED!]\n");
            }
            else
            {
                printf("✓ OK [Stable]\n");
            }
        }
        else
        {
            printf("[%4ds] ❌ ERROR: Unable to fetch IP\n", elapsed);
        }
        
        sleep(interval_seconds);
        elapsed += interval_seconds;
    }
    
    print_separator('=', 65);
    printf("Monitoring complete.\n");
    print_separator('=', 65);
    
    return 0;
} 

int main()
{
    int monitor_mode = 0;
    
    print_separator('=', 65);
    printf("        Advanced VPN Connectivity Verification Tool\n");
    print_separator('=', 65);
    
    printf("\nSelect Mode:\n");
    printf(" 1. Standard VPN Verification (Before/After)\n");
    printf(" 2. Real-Time Monitor Mode\n");
    printf("\nEnter choice (1 or 2): ");
    
    int choice;
    scanf("%d", &choice);
    getchar();  // Consume newline
    
    if (choice == 2)
    {
        monitor_mode = 1;
        
        printf("\nReal-Time Monitor Configuration:\n");
        printf("Enter check interval (seconds, default 5): ");
        int interval = 5;
        scanf("%d", &interval);
        getchar();
        
        printf("Enter monitoring duration (seconds, default 60): ");
        int duration = 60;
        scanf("%d", &duration);
        getchar();
        
        printf("\n>>> Connect to your VPN NOW <<<\n");
        printf(">>> Press ENTER to start monitoring <<<\n");
        getchar();
        
        monitor_vpn_connection(interval, duration);
        return 0;
    }
    
    // Continue with standard mode...
}

#ifdef _WIN32
    #include 
    #define sleep(x) Sleep((x) * 1000)  // Convert seconds to milliseconds
#else
    #include   // Native sleep() on Unix/Linux/macOS
#endif

# Clone the repository
git clone https://github.com/YourUsername/vpn-connectivity-tool.git

# Navigate to directory
cd vpn-connectivity-tool

# Compile
gcc main.c -o vpn_check

# Run
./vpn_check