I was reading several articles about the new NemID system in Denmark, and concerns around how organized groups might generate valid CPR numbers and brute-force passwords. This could lead to account lockouts—potentially paralyzing major parts of the country’s digital infrastructure.

To test this, I created code to generate valid CPR numbers based on known rules.

The Rules

The original rules were based on a textbook I no longer have, but I found newer ones via this blog post, official article, and PDF document from the CPR register.

Note: My code uses the old rules (pre-2007) because I couldn’t verify new CPR numbers.

Summary of Rules

  • 10 digits long
  • First 6 digits are the birthdate:
    • DDMMYY format
    • Must be a valid date
  • 7th digit indicates the century:
    • Even centuries: digit 5–9
    • Odd centuries: digit 0–4
  • Digits 8–9 are arbitrary
  • 10th digit determines sex:
    • Even = female, Odd = male

A modulus test is used: Each digit is multiplied by a predefined factor (4,3,2,7,6,5,4,3,2,1). If the total sum mod 11 is 0, the CPR is valid.

The Code

CPR Check

I tested three versions of a modulus check:

static bool CheckCPR(int[] Input)
{
    int[] factors = { 4, 3, 2, 7, 6, 5, 4, 3, 2, 1 };
    int sum = 0;
    for (int x = 0; x < factors.Length; x++)
        sum += Input[x] * factors[x];
    return sum % 11 == 0;
}

Int arrays performed slightly better than byte arrays or strings.

CPR Generator – Date Generation

Two methods were compared:

  • Using DateTime (valid dates only)
  • Using nested loops (all combinations)

DateTime was slower (~70ms vs. ~5ms) but avoids invalid dates. I chose this method for accuracy.

static int[][] GenerateDates_DateObject()
{
    DateTime tDate = new DateTime(1900, 1, 1);
    DateTime tMax = new DateTime(2010, 1, 1);

    var results = new List<int[]>();
    while (tDate < tMax)
    {
        tDate = tDate.AddDays(1);
        var day = tDate.Day.ToString("D2");
        var month = tDate.Month.ToString("D2");
        var year = tDate.Year;
        results.Add(new int[] {
            int.Parse(day[0].ToString()),
            int.Parse(day[1].ToString()),
            int.Parse(month[0].ToString()),
            int.Parse(month[1].ToString()),
            year });
    }
    return results.ToArray();
}

Control Digit Generator

static int[] ControlDigits(int[] InputDate)
{
    var result = new List<int>();
    int[] valids = (InputDate[4] / 100) % 2 == 0 ?
        new[] { 5, 6, 7, 8, 9 } : new[] { 0, 1, 2, 3, 4 };

    foreach (int x in valids)
        for (int y = 0; y <= 999; y++)
            result.Add(int.Parse($"{x}{y:D3}"));

    return result.ToArray();
}

Takes ~7ms to generate 5000 possibilities.

Final CPR Generator

static void Main()
{
    using var writer = new StreamWriter("output.txt");
    var dates = GenerateDates_DateObject();

    foreach (var date in dates)
    {
        var controlCodes = ControlDigits(date);
        foreach (var code in controlCodes)
        {
            var year = date[4].ToString().Substring(2);
            var control = code.ToString("D4");
            int[] cpr = {
                date[0], date[1], date[2], date[3],
                int.Parse(year[0].ToString()), int.Parse(year[1].ToString()),
                int.Parse(control[0].ToString()), int.Parse(control[1].ToString()),
                int.Parse(control[2].ToString()), int.Parse(control[3].ToString()) };

            if (CheckCPR(cpr))
                writer.WriteLine(string.Join("", cpr));
        }
    }
}

The Result

After ~19.5 minutes, I generated a 219 MB file with 18,262,698 valid CPR numbers from 1900 to 2010.

This list can be used for analysis, e.g., estimating valid CPRs per day/year.

And yes—my own CPR number is valid! 😄