A Dotnet Core DNS Updater

April 21, 2020

TL;DR

I created a DNS Updater using Dotnet Core that lives on my CentOS VM on my QNAP which gets my external IP address from my Google Wi-Fi router, updates my GoDaddy DNS and sends me a push notification if changed...all controlled by a cron job.

It's a pretty bespoke solution that solves my issue of having a dynamic IP address, and was quite a fun little project.

Background

I, like I presume most software developers, have a very specific personal server setup.

It currently consists of:

A Dynamic IP from my ISP
Home network using Google Wi-Fi
Domain and DNS through GoDaddy
Multiple sub-domains for my personal sites
A QNAP running a CentOS VM

As I currently have a dynamic IP from my service provider it makes self-hosting a server for my basic personal sites a pain to maintain. This is because every time my IP address changes I need to update my DNS settings with my domain registrar.

There are services that allow you to keep your DNS up to date by updating for you (dyn, no-ip, afraid etc), however I found that my need to run multiple subdomains, hosted locally, meant that they weren't the right fit for me (due to cost, domain restrictions, hosting, or other limitations).

To be honest, I didn't really look into it that hard as I wanted to build something myself anyway. And so, to get around my limitations, I built a DNS Updater for my specific use case.

For it to work, I needed to be able to supply my DNS provider with my current external IP address, when it changes, to update my A-Records (i.e. sub-domains/servers). Luckily, GoDaddy has an accessible API that allows just that.

I went through a couple of iterations of this project before landing on the final implementation:

Using services like icanhazip to get my external IP address (seemed to fail more often than my DNS)
Using Firebase Firestore real-time updates to trigger manual update on the server as an API workaround (ran into some memory and timeout issues)
Using a console app with a timer job that re-called itself at an interval (memory/timing issues)

In my current implementation I have done away with the manual update requirement as I never really used it. I decided to go with a Web API as I can call an endpoint to trigger the sync. I also found that Google Wi-Fi has its own 'hidden' API that allows you to retrieve information about the network, including external IP address.

So now we have the tools needed to create a Dotnet Core Web API that we can host on a Linux virtual which we can trigger using a crontab job. This will retrieve the current external IP from out local router, check if it has changed, and then update our DNS with the current, if needed. As an added bonus I added in a call to a service call Pushover which will send us a notification when the DNS gets updated, or errors occur.

If, by any chance, this is similar to your setup, the following may be of use.

DNS Updater

Create a new Dotnet Core Web API.

Update appsettings.json to hold our service keys and endpoints for easy access:

appsettings.json

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft": "Warning",
      "Microsoft.Hosting.Lifetime": "Information"
    }
  },
  "AllowedHosts": "*",
  "GoDaddy": {
    "Key": "<GODADDY_KEY>",
    "Secret": "<GODADDY_SECRET>"
  },
  "Wan": {
    "IP": "192.168.86.1"
  },
  "AdminSafeList": "127.0.0.1;192.168.86.101;::1",
  "Domains": [ "domain.com" ],
  "Pushover": {
    "Url": "https://api.pushover.net/1/",
    "Token": "<PUSHOVER_APP_TOKEN>",
    "User": "<PUSHOVER_USER_KEY>"
  }
}

I added an authorization filter that only allows access to from localhost for some basic auth:

AuthorizeIPFilter.cs

public class AuthorizeIPFilter : ActionFilterAttribute
{
    private readonly string safelist;
    // AdminSafeList param passed in from Startup.cs consisting of allowed local ips
    public AuthorizeIPFilter(string _safelist)
    {
        safelist = _safelist;
    }
    public override void OnActionExecuting(ActionExecutingContext context)
    {
        // get the caller IP
        var remoteIp = context.HttpContext.Connection.RemoteIpAddress;
        string[] ip = safelist.Split(';');
        var badIp = true;
        foreach (var address in ip)
        {
            if (remoteIp.IsIPv4MappedToIPv6)
            {
                remoteIp = remoteIp.MapToIPv4();
            }
            var testIp = IPAddress.Parse(address);
            // if we match an IP, we are local
            if (testIp.Equals(remoteIp))
            {
                badIp = false;
                break;
            }
        }
        // throw forbidden if no match to local
        if (badIp)
        {
            context.Result = new StatusCodeResult(StatusCodes.Status403Forbidden);
            return;
        }
        base.OnActionExecuting(context);
    }
}

Add the following to ConfigureServices in Startup.cs (this passes our allowed values to the auth filter):

Startup.cs

public void ConfigureServices(IServiceCollection services)
{
    services.AddScoped(container =>
    {
        return new AuthorizeIPFilter(Configuration["AdminSafeList"]);
    });
}

And ensure we are using authorization in Configure:

Startup.cs

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseAuthorization();
}

The Web API consists of a single endpoint that is called by our cron job (authorized by our filter):

SyncController.cs

// auth filter implementation from above
[ServiceFilter(typeof(AuthorizeIPFilter))]
[ApiController]
[Route("api/[controller]")]
public class SyncController : ControllerBase
{
    // configure dependency injection of our sync service
    private readonly ISyncService service;
    public SyncController(ISyncService _service)
    {
        service = _service;
    }
    // GET https://localhost/api/sync
    public IActionResult Index()
    {
        var result = service.Sync();
        return Ok(result);
    }
}

The sync service consists of a single public method that runs through our order of operations. On call, it retrieves the current IP from the router, gets any previously saved IP from storage, compares the two and updates GoDaddy if they are different. If a change is made, it serializes the new IP to disk for next time and sends us an update notification through Pushover. If any errors occur during this process, it tries to send us a notification about it if possible.

SyncService.cs

public class SyncService : ISyncService
{
    // configure dependency injection of our services
    private readonly string FileName = "ip";
    private readonly IGoDaddyService goDaddy;
    private readonly IGoogleWiFiService wan;
    private readonly IPushoverService pushover;
    public SyncService(IGoogleWiFiService _wan, IGoDaddyService _goDaddy, IPushoverService _pushover)
    {
        wan = _wan;
        goDaddy = _goDaddy;
        pushover = _pushover;
    }
    // our sync method that returns a basic object of previous and current IP strings
    public IPResult Sync()
    {
        try
        {
            var ipResult = new IPResult();
            // from router
            ipResult.Current = GetCurrentIP();
            // from storage
            ipResult.Previous = GetPreviousIP();
			
            // if true we have a changed IP or no saved value (first run)
            if (ipResult.Current != ipResult.Previous || 			
                string.IsNullOrWhiteSpace(ipResult.Previous))
            {
                // update the dns
                goDaddy.UpdateDomains(ipResult.Current);
                // serialize new value to disk
                SaveIP(ipResult.Current);
                // notify of change
                pushover.SendPush("DNS Updated: " + ipResult.Current);
            }
            return ipResult;
        }
        catch (Exception e)
        {
            // try to notify on any errors
            pushover.SendPush(e.Message);
            throw e;
        }
    }
    private string GetCurrentIP()
    {
        var currentIP = wan.GetIP().Result;
        // we should always get a value back, otherwise something is wrong
        if (currentIP == null)
        {
            // most likely won't get a notification on this, as it probably
            // means that the internet is down
            throw new Exception("No IP returned from router");
        }
        return currentIP;
    }
    // retrieve previous ip from a serialized binary file saved to disk
    private string GetPreviousIP()
    {
        var previousIP = "";
        if (File.Exists(FileName))
        {
            var openFileStream = File.OpenRead(FileName);
            var deserializer = new BinaryFormatter();
            previousIP = (string)deserializer.Deserialize(openFileStream);
            openFileStream.Close();
        }
        return previousIP;
    }
    // serialize the string value and save to file on disk for next time
    private void SaveIP(string currentIP)
    {
        Stream SaveFileStream = File.Create(FileName);
        BinaryFormatter serializer = new BinaryFormatter();
        serializer.Serialize(SaveFileStream, currentIP);
        SaveFileStream.Close();
    }
}

Our GoogleWiFiService makes a simple GET request to the router to retrieve the current external IP value:

GoogleWiFiService.cs

public class GoogleWiFiService : IGoogleWiFiService
{
    // configure dependency injection for service
    private readonly IConfiguration config;
    public GoogleWiFiService(IConfiguration _config)
    {
        config = _config;
    }
    // make a GET request to router
    public async Task<string> GetIP()
    {
        var status = new GoogleWiFi();
        var client = new HttpClient();
        client.BaseAddress = new Uri("http://" + config["Wan:IP"] + "/api/v1/");
        var request = new HttpRequestMessage(HttpMethod.Get, "status?type=wan");
        var response = await client.SendAsync(request);
        response.EnsureSuccessStatusCode();
        var json = await response.Content.ReadAsStringAsync();
        status = JsonConvert.DeserializeObject<GoogleWiFi>(json);
        // return the IP value only
        return status.wan.localIpAddress;
    }
}

The GoogleWificlass has many values, but we can just deserialize for the localIpAddress value:

GoogleWiFi.cs

public class GoogleWiFi
{
    public Wan wan { get; set; }
}    
public class Wan
{
    // even though it says local, it is the external IP
    public string localIpAddress { get; set; }
}

The GoDaddyService makes the required calls to update the DNS for each value within the Domains string array in appsettings.json:

GoDaddyService.cs

public class GoDaddyService : IGoDaddyService
{
    private readonly string url = "https://api.godaddy.com/v1/domains/";
    private readonly string endpoint = "/records/A";
    // configure dependency injection for service
    private readonly IConfiguration _config;
    public GoDaddyService(IConfiguration config)
    {
        _config = config;
    }
    public ARecord GetDomainARecord(string domain)
    {
        var result = new ARecord();
        var client = new HttpClient();
        client.BaseAddress = new Uri(url);
        var request = new HttpRequestMessage(HttpMethod.Get, domain + endpoint);
        request.Headers.Add(
            "Authorization", "sso-key " + _config["GoDaddy:Key"] + ":" + 
            _config["GoDaddy:Secret"]
        );
        request.Headers.Add("Accept", "application/json");
        var response = client.SendAsync(request).Result;
        response.EnsureSuccessStatusCode();
        var content = response.Content.ReadAsStringAsync().Result;
        // get the first A Record returned for the domain
        // depending on configuration you may need to change this to reflect
        // your needs
        if (JsonConvert.DeserializeObject<List<ARecord>>(content).Count > 0)
        {
            result = JsonConvert.DeserializeObject<List<ARecord>>(content)[0];
        }
        else
        {
            result.type = "A";
            result.name = "@";
            result.ttl = 3600;
        }
        return result;
    }
    private void UpdateARecord(string domain, ARecord record, string ip)
    {
        // dont needlessly update the record
        if (record.data == ip)
        {
            return;
        }
        record.data = ip;
        ARecord[] recordArray = { record };
        var client = new HttpClient();
        client.BaseAddress = new Uri(url);
        client.DefaultRequestHeaders.Accept.Clear();
        client.DefaultRequestHeaders.Accept.Add(
            new MediaTypeWithQualityHeaderValue("application/json")
        );
        client.DefaultRequestHeaders.Add(
            "Authorization", "sso-key " + _config["GoDaddy:Key"] + ":" + 
            _config["GoDaddy:Secret"]
        );
        var body = JsonConvert.SerializeObject(recordArray);
        var response = client.PutAsync(
            domain + endpoint, 
            new StringContent(body, Encoding.UTF8, "application/json")
        ).Result;
        response.EnsureSuccessStatusCode();
    }
    public void UpdateDomains(string ip)
    {
        // get our domains as a list
        var domains = _config.GetSection("Domains").Get<List<string>>();
        foreach (var domain in domains)
        {
            // get each domain A Record
            var aRecord = GetDomainARecord(domain);
            // and update with new IP value
            UpdateARecord(domain, aRecord, ip);
        }
    }
}

The ARecord class has some required values that we populate above:

ARecord.cs

public class ARecord
{
    // "A"
    public string type { get; set; }
    // i use "@" as my A Record name to point my CNAME values to
    public string name { get; set; }
    // the IP
    public string data { get; set; }
    // 3600 (godaddy default: 60 * 60 = 1 hour)
    public int ttl { get; set; }
}

At this point our service has updated the A Record, now we can send ourselves a notification about it, so we know it has been changed:

PushoverService.cs

public class PushoverService : IPushoverService
{
    // configure dependency injection for service
    private readonly IConfiguration config;
    public PushoverService(IConfiguration _config)
    {
        config = _config;
    }
    // pass a message string to be sent to the server (ip or error message in our case)
    public void SendPush(string message)
    {
        var client = new HttpClient();
        var url = config["Pushover:Url"];
        var token = config["Pushover:Token"];
        var user = config["Pushover:User"];
        client.BaseAddress = new Uri(url);
        var response = client.PostAsync($"messages.json?message={message}&token={token}&user={user}", null).Result;
        response.EnsureSuccessStatusCode();
    }
}

Publishing

We can now publish the API and deploy it to the Linux server.

For this we publish as a framework-dependant deployment (dotnet core 3.1), as I know I only want it on my linux-x64 box. To deploy, I simply used WinSCP to SSH my CentOS server and dropped the files in my home directory.

Make sure you have the latest runtimes installed.

To make sure the server maintained uptime, I used a package called Supervisor to make sure it gets restarted if it falls over.

/etc/supervisord.conf

[program:<PROJECT_NAME>]
command=/usr/bin/dotnet <FULL_PATH_TO_DLL>.dll
directory=<DIRECTORY_OF_FILES>
autostart=true
autorestart=true
stderr_logfile=/var/log/<PROJECT_NAME>.err.log
stdout_logfile=/var/log/<PROJECT_NAME>.out.log
environment=ASPNETCORE__ENVIRONMENT=Production
user=<SU_USER>
stopsignal=INT

Crontab

To kick off the sync process I added a cron job to my root user that cURL's into the API endpoint every 5 minutes.

/var/spool/cron/root

*/5 * * * * /home/andrew/checkdns.sh

It runs a shell script that just calls a cURL command:

checkdns.sh

#!/bin/bash
curl http://localhost:5000/api/sync

The result is a GET request to our endpoint from localhost, which satisfies our authorization filter, and kicks off the sync process to check for a change in IP address.