MechanismDomainCidrSpec.cs

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
 
namespace Waher.Security.SPF.Mechanisms
{
    public abstract class MechanismDomainCidrSpec : MechanismDomainSpec
    {
        protected readonly int ip4Cidr = 32;
 
        protected readonly int ip6Cidr = 128;
 
        public MechanismDomainCidrSpec(Term Term, SpfQualifier Qualifier)
            : base(Term, Qualifier)
        {
            if (Term.PeekNextChar() == '/')
            {
                Term.NextChar();
 
                bool HasIp4;
 
                if (HasIp4 = char.IsDigit(Term.PeekNextChar()))
                {
                    this.ip4Cidr = Term.NextInteger();
                    if (this.ip4Cidr < 0 || this.ip4Cidr > 32)
                        throw new Exception("Invalid IP4 CIDR");
                }
 
                if (Term.PeekNextChar() == '/')
                {
                    Term.NextChar();
 
                    if (HasIp4 && Term.PeekNextChar() == '/')
                        Term.NextChar();
 
                    if (char.IsDigit(Term.PeekNextChar()))
                    {
                        this.ip6Cidr = Term.NextInteger();
                        if (this.ip6Cidr < 0 || this.ip4Cidr > 128)
                            throw new Exception("Invalid IP6 CIDR");
                    }
                    else if (!HasIp4)
                        throw new Exception("IP4 or IP6 CIDR expected.");
                }
            }
        }
 
        public override bool DomainRequired => false;
 
        internal static bool Matches(IPAddress[] Addresses, Term Term, int Cidr)
        {
            byte[] Bin1 = Term.ip.GetAddressBytes();
            int c = Bin1.Length;
 
            foreach (IPAddress Addr in Addresses)
            {
                byte[] Bin2 = Addr.GetAddressBytes();
                if (Bin2.Length != c)
                    continue;
 
                int BitsLeft = Cidr;
                int Pos = 0;
 
                while (BitsLeft > 0 && Pos < c)
                {
                    if (BitsLeft >= 8)
                    {
                        if (Bin1[Pos] != Bin2[Pos])
                            break;
 
                        BitsLeft -= 8;
                    }
                    else
                    {
                        byte Mask = (byte)(0xff << (8 - BitsLeft));
 
                        if ((Bin1[Pos] & Mask) != (Bin2[Pos] & Mask))
                            break;
 
                        BitsLeft = 0;
                    }
 
                    Pos++;
                }
 
                if (BitsLeft == 0)
                    return true;
            }
 
            return false;
        }
    }
}