Finally Fixing Up the Guidance Tags (canada-ca#522)

* Updated Dmarc Tags

* small fix to the dmarc tags

* fix isintance checks

* Spf tags re-factor

* Dkim tags re-factor

* HTTPS tags are now actually here, again ...

* Removed comment

* First iteration of ssl tags

* Updated ssl tags

* Update dkim tags

* Update dmarc, and spf tags

* Created mock data for guidance tags tests

* Moved all mock data into separate dicts

* Fix missing checks

* switched guidance tag fields to fields

* Fixes to dkim tags, and testing for the majority of dkim tags

* Remove print debug statement

* Fixed guidance tag generation, and implemented tests

* Trimmed down data for dkim, and dmarc tests

* Updated dmarc and spf tags

* Updated dmarc tags, and added tests for dmarc14, and dmarc15

* Updated https, ssl objects

* Fix www scan objects

* HTTPS guidance tags fixed, and tested

* Updated error out messages

* Removed unused import

* Updated spf tags, and completed testing

* Updated ssl tags, and completed tests for ssl

* spf3 guidance tag implemented

* Black ran on files

* Refactored spf

* Refactored dmarc

* Refactored dkim

* Refactored https

* Refactored ssl

* Black re-ran on files

* Updated descriptions

* typo in description(s)

* Updated faker

Author: nsdeschenes

api/Pipfile.lock

@@ -25,6 +25,7 @@ class Meta:
             "organization",
             "scans",
             "slug",
+            "dmarc_reports"
         )
 
     url = URL(description="The domain the scan was run on")

api/schemas/domain/__init__.py

@@ -23,17 +23,17 @@ class Meta:
 
     domain = URL(description="The domain the scan was run on")
     timestamp = graphene.DateTime(description="The time the scan was initiated")
-    dmarc = graphene.List(
+    dmarc = graphene.Field(
         lambda: DMARC,
         description="Domain-based Message Authentication, Reporting, "
         "and Conformance (DMARC) ",
     )
-    spf = graphene.List(
+    spf = graphene.Field(
         lambda: SPF,
         description="Sender Policy Framework (SPF) for Authorizing Use of "
         "Domains in Email ",
     )
-    dkim = graphene.List(
+    dkim = graphene.Field(
         lambda: DKIM, description="DomainKeys Identified Mail (DKIM) Signatures"
     )
 
@@ -45,15 +45,15 @@ def resolve_timestamp(self: Scans, info):
 
     def resolve_dmarc(self: Scans, info):
         query = DMARC.get_query(info)
-        return query.filter(self.id == Dmarc_scans.id).all()
+        return query.filter(self.id == Dmarc_scans.id).first()
 
     def resolve_spf(self: Scans, info):
         query = SPF.get_query(info)
-        return query.filter(self.id == Spf_scans.id).all()
+        return query.filter(self.id == Spf_scans.id).first()
 
     def resolve_dkim(self: Scans, info):
         query = DKIM.get_query(info)
-        return query.filter(self.id == Dkim_scans.id).all()
+        return query.filter(self.id == Dkim_scans.id).first()
 
 
 class EmailScanConnection(relay.Connection):

api/schemas/domain/email_scan/__init__.py

@@ -0,0 +1,102 @@
+import graphene
+from graphene_sqlalchemy import SQLAlchemyObjectType
+
+from models import Dkim_scans
+from scalars.url import URL
+from functions.get_domain import get_domain
+from functions.get_timestamp import get_timestamp
+
+
+class DKIM(SQLAlchemyObjectType):
+    """
+    DomainKeys Identified Mail (DKIM) permits a person, role, or
+    organization that owns the signing domain to claim some
+    responsibility for a message by associating the domain with the
+    message.  This can be an author's organization, an operational relay,
+    or one of their agents.
+    """
+
+    class Meta:
+        model = Dkim_scans
+        exclude_fields = ("id", "dkim_scan")
+
+    id = graphene.ID(description="ID of the object")
+    domain = URL(description="The domain the scan was run on")
+    timestamp = graphene.DateTime(description="Time when scan was initiated")
+    record = graphene.String(
+        description="DKIM record retrieved during the scan of the " "given domain "
+    )
+    key_length = graphene.String(description="Length of DKIM public key")
+    dkim_guidance_tags = graphene.List(
+        lambda: graphene.String, description="Key tags found during scan"
+    )
+
+    def resolve_domain(self, info):
+        get_domain(self, info)
+
+    def resolve_timestamp(self, info):
+        get_timestamp(self, info)
+
+    def resolve_record(self, info):
+        return self.dkim_scan["dkim"]["txt_record"]
+
+    def resolve_key_length(self, info):
+        return self.dkim_scan["dkim"]["key_size"]
+
+    def resolve_dkim_guidance_tags(self, info):
+        tags = []
+
+        if self.dkim_scan.get("dkim", {}).get("missing", None) is not None:
+            tags.append("dkim2")
+            return tags
+
+        # Get Key Size, and Key Type
+        key_size = self.dkim_scan.get("dkim", {}).get("key_size", None)
+        key_type = self.dkim_scan.get("dkim", {}).get("key_type", None)
+
+        if key_size is None:
+            tags.append("dkim9")
+        elif key_type is None:
+            tags.append("dkim9")
+        else:
+            if key_size >= 4096 and key_type == "rsa":
+                tags.append("dkim8")
+            elif key_size >= 2048 and key_type == "rsa":
+                tags.append("dkim7")
+            elif key_size == 1024 and key_type == "rsa":
+                tags.append("dkim6")
+            elif key_size < 1024 and key_type == "rsa":
+                tags.append("dkim5")
+            else:
+                tags.append("dkim9")
+
+        # Update Recommended
+        key_invalid = self.dkim_scan.get("dkim", {}).get("update-recommend", None)
+
+        if key_invalid:
+            tags.append("dkim10")
+
+        # Invalid Crypto
+        invalid_crypto = (
+            self.dkim_scan.get("dkim", {}).get("txt_record", {}).get("k", None)
+        )
+        # if k != rsa
+        if invalid_crypto != "rsa":
+            tags.append("dkim11")
+
+        # Dkim value invalid
+        # Check if v, k, and p exist in txt_record
+        v_tag = self.dkim_scan.get("dkim", {}).get("txt_record", {}).get("v", None)
+        k_tag = self.dkim_scan.get("dkim", {}).get("txt_record", {}).get("k", None)
+        p_tag = self.dkim_scan.get("dkim", {}).get("txt_record", {}).get("p", None)
+
+        if v_tag is None and k_tag is None and p_tag is None:
+            if "dkim12" not in tags:
+                tags.append("dkim12")
+
+        # Testing Enabled
+        t_enabled = self.dkim_scan.get("dkim", {}).get("t_value")
+        if t_enabled is not None:
+            tags.append("dkim13")
+
+        return tags