Add spf data fragment parser

Author: tinohager

src/Nager.EmailAuthentication.UnitTest/SpfRecordParserTest/FragmentParser/BasicTest.cs

@@ -0,0 +1,44 @@
+using Nager.EmailAuthentication.FragmentParsers;
+
+namespace Nager.EmailAuthentication.UnitTest.SpfRecordParserTest.FragmentParser
+{
+    [TestClass]
+    public sealed class BasicTest
+    {
+        [TestMethod]
+        public void Should_Parse_Spf_With_Include_And_All()
+        {
+            var spf = "v=spf1 include:spf.protection.outlook.com -all";
+            var isSuccessful = SpfRecordDataFragmentParserV1.TryParse(spf, out var spfDataFragment);
+
+            Assert.IsTrue(isSuccessful);
+            Assert.IsNotNull(spfDataFragment);
+            Assert.IsNotNull(spfDataFragment.SpfTerms);
+            Assert.AreEqual(2, spfDataFragment.SpfTerms.Length);
+        }
+
+        [TestMethod]
+        public void Should_Parse_Spf_With_Redirect()
+        {
+            var spf = "v=spf1 redirect=spf.provider.com";
+            var isSuccessful = SpfRecordDataFragmentParserV1.TryParse(spf, out var spfDataFragment);
+
+            Assert.IsTrue(isSuccessful);
+            Assert.IsNotNull(spfDataFragment);
+            Assert.IsNotNull(spfDataFragment.SpfTerms);
+            Assert.AreEqual(1, spfDataFragment.SpfTerms.Length);
+        }
+
+        [TestMethod]
+        public void Should_Parse_Spf_With_Multiple_Ip4_And_Include()
+        {
+            var spf = "v=spf1 ip4:155.56.66.96/30 ip4:155.56.66.102/31 ip4:155.56.66.104/32 ip4:155.56.66.106/32 ip4:155.56.68.128/26 include:spf.protection.outlook.com -all";
+            var isSuccessful = SpfRecordDataFragmentParserV1.TryParse(spf, out var spfDataFragment);
+
+            Assert.IsTrue(isSuccessful);
+            Assert.IsNotNull(spfDataFragment);
+            Assert.IsNotNull(spfDataFragment.SpfTerms);
+            Assert.AreEqual(7, spfDataFragment.SpfTerms.Length);
+        }
+    }
+}

src/Nager.EmailAuthentication/FragmentParsers/SpfRecordDataFragmentParserV1.cs

@@ -0,0 +1,155 @@
+using Nager.EmailAuthentication.Models.Spf;
+using Nager.EmailAuthentication.Models.Spf.Mechanisms;
+using Nager.EmailAuthentication.Models.Spf.Modifiers;
+using System.Diagnostics.CodeAnalysis;
+
+namespace Nager.EmailAuthentication.FragmentParsers
+{
+    /// <summary>
+    /// Spf Record Data Fragment Parser
+    /// </summary>
+    public static class SpfRecordDataFragmentParserV1
+    {
+        /// <summary>
+        /// Try Parse
+        /// </summary>
+        /// <param name="spf"></param>
+        /// <param name="spfDataFragment"></param>
+        /// <returns></returns>
+        public static bool TryParse(
+            string spf,
+            [NotNullWhen(true)] out SpfRecordDataFragmentV1? spfDataFragment)
+        {
+            var spfPrefix = "v=spf1 ";
+
+            if (!spf.StartsWith(spfPrefix, StringComparison.OrdinalIgnoreCase))
+            {
+                spfDataFragment = null;
+                return false;
+            }
+
+            var spfTerms = new List<SpfTerm>();
+            var mechanismTypes = new Dictionary<string, Type>
+            {
+                { AllMechanism.MechanismKey,      typeof(AllMechanism) },
+                { Ip4Mechanism.MechanismKey,      typeof(Ip4Mechanism) },
+                { Ip6Mechanism.MechanismKey,      typeof(Ip6Mechanism) },
+                { IncludeMechanism.MechanismKey,  typeof(IncludeMechanism) },
+                { ExistsMechanism.MechanismKey,   typeof(ExistsMechanism) },
+                { AMechanism.MechanismKey,        typeof(AMechanism) },
+                { MxMechanism.MechanismKey,       typeof(MxMechanism) },
+                { PtrMechanism.MechanismKey,      typeof(PtrMechanism) },
+            };
+
+            var modifierTypes = new Dictionary<string, Type>
+            {
+                { RedirectModifier.ModifierKey,   typeof(RedirectModifier) },
+                { ExpModifier.ModifierKey,        typeof(ExpModifier) }
+            };
+
+            var spfTermDelimiter = ' ';
+            var allowedQualifiers = new char[] { '+', '?', '~', '-' };
+            var inputSpan = spf.AsSpan()[spfPrefix.Length..];
+            var nextIndexOfDelimiter = 0;
+            var termIndex = 0;
+
+            while (nextIndexOfDelimiter != -1)
+            {
+                termIndex++;
+
+                nextIndexOfDelimiter = inputSpan.IndexOf(spfTermDelimiter);
+                if (nextIndexOfDelimiter == 0)
+                {
+                    inputSpan = inputSpan[1..];
+                    continue;
+                }
+
+                ReadOnlySpan<char> value;
+                if (nextIndexOfDelimiter == -1)
+                {
+                    value = inputSpan.Trim();
+                }
+                else
+                {
+                    value = inputSpan[..nextIndexOfDelimiter].Trim();
+                }
+
+                var qualifier = '+';
+                var indexOfQualifier = Array.IndexOf(allowedQualifiers, value[0]);
+                if (indexOfQualifier != -1)
+                {
+                    qualifier = allowedQualifiers[indexOfQualifier];
+                    value = value[1..];
+                }
+
+                foreach (var mechanismType in mechanismTypes)
+                {
+                    if (!value.StartsWith(mechanismType.Key))
+                    {
+                        continue;
+                    }
+
+                    var term = Activator.CreateInstance(mechanismType.Value) as SpfTerm;
+                    if (term is null)
+                    {
+                        continue;
+                    }
+
+                    term.Index = termIndex;
+
+                    if (term is SpfMechanismBase spfMechanism)
+                    {
+                        spfMechanism.SetQualifier(qualifier);
+
+                        value = value[mechanismType.Key.Length..];
+                        if (value.Length > 0)
+                        {
+                            spfMechanism.GetDataPart(value);
+                        }
+
+                        spfTerms.Add(spfMechanism);
+                        break;
+                    }
+                }
+
+                foreach (var modifierType in modifierTypes)
+                {
+                    if (!value.StartsWith(modifierType.Key))
+                    {
+                        continue;
+                    }
+
+                    var term = Activator.CreateInstance(modifierType.Value) as SpfTerm;
+                    if (term is null)
+                    {
+                        continue;
+                    }
+
+                    term.Index = termIndex;
+
+                    if (term is SpfModifierBase spfModifier)
+                    {
+                        value = value[modifierType.Key.Length..];
+                        if (value.Length > 0)
+                        {
+                            spfModifier.GetDataPart(value);
+                        }
+
+                        spfTerms.Add(spfModifier);
+                        break;
+                    }
+                }
+
+                inputSpan = inputSpan[(nextIndexOfDelimiter + 1)..];
+            }
+
+            spfDataFragment = new SpfRecordDataFragmentV1
+            {
+                Version = "1",
+                SpfTerms = [.. spfTerms]
+            };
+
+            return true;
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/MechanismType.cs

@@ -0,0 +1,49 @@
+namespace Nager.EmailAuthentication.Models.Spf
+{
+    /// <summary>
+    /// Represents the different types of mechanisms used in SPF (Sender Policy Framework) records.
+    /// These mechanisms define the rules for which servers are authorized to send emails on behalf of a domain.
+    /// </summary>
+    public enum MechanismType
+    {
+        /// <summary>
+        /// Represents an IPv4 address mechanism (`ip4`).
+        /// </summary>
+        Ip4,
+
+        /// <summary>
+        /// Represents an IPv6 address mechanism (`ip6`).
+        /// </summary>
+        Ip6,
+
+        /// <summary>
+        /// Represents an "A" record mechanism (`a`), used to authorize servers based on the domain's A or AAAA records.
+        /// </summary>
+        A,
+
+        /// <summary>
+        /// Represents a Mail Exchange (MX) record mechanism (`mx`), used to authorize servers based on the domain's MX records.
+        /// </summary>
+        Mx,
+
+        /// <summary>
+        /// Represents a PTR record mechanism (`ptr`), used to authorize servers based on reverse DNS lookups.
+        /// </summary>
+        Ptr,
+
+        /// <summary>
+        /// Represents an `include` mechanism, used to include the SPF record of another domain.
+        /// </summary>
+        Include,
+
+        /// <summary>
+        /// Represents the `exists` mechanism, used to authorize servers based on the existence of a DNS record for a domain.
+        /// </summary>
+        Exists,
+
+        /// <summary>
+        /// Represents the `all` mechanism, typically used at the end of the SPF record to define a catch-all rule for all other IPs.
+        /// </summary>
+        All
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/AMechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class AMechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "a";
+
+        public AMechanism() : base(MechanismType.A)
+        {
+
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/AllMechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class AllMechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "all";
+
+        public AllMechanism() : base(MechanismType.All)
+        {
+
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/ExistsMechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class ExistsMechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "exists";
+
+        public ExistsMechanism() : base(MechanismType.Exists)
+        {
+
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/IncludeMechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class IncludeMechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "include";
+
+        public IncludeMechanism() : base(MechanismType.Include)
+        {
+
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/Ip4Mechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class Ip4Mechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "ip4";
+
+        public Ip4Mechanism() : base(MechanismType.Ip4)
+        {
+
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/Ip6Mechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class Ip6Mechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "ip6";
+
+        public Ip6Mechanism() : base(MechanismType.Ip6)
+        {
+
+        }
+    }
+}

src/Nager.EmailAuthentication/Models/Spf/Mechanisms/MxMechanism.cs

@@ -0,0 +1,12 @@
+namespace Nager.EmailAuthentication.Models.Spf.Mechanisms
+{
+    public class MxMechanism : SpfMechanismBase
+    {
+        public const string MechanismKey = "mx";
+
+        public MxMechanism() : base(MechanismType.Mx)
+        {
+
+        }
+    }
+}