Merge ~spitap/dkimpy:utf8-support into dkimpy:master

[Adrien]

Added UTF-8 support && ability to check message from CLI

Unmerged commits

9813d5b... by Adrien on 2022-08-04

UT8-Support

b446e70... by Scott Kitterman on 2022-08-01

WIP to support DNS data via text file and support for non-UTF-8 email addresses

diff --git a/.gitignore b/.gitignore
index debba34..589aff8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -4,3 +4,4 @@ dkim/*.pyc
 dkim/tests/*.pyc
 dkimpy.egg-info
 dist
+build/
diff --git a/dkim/asyncsupport.py b/dkim/asyncsupport.py
index 226cc42..e326827 100644
--- a/dkim/asyncsupport.py
+++ b/dkim/asyncsupport.py
@@ -50,13 +50,17 @@ async def get_txt_async(name, timeout=5):
     # Note: This will use the existing loop or create one if needed
     loop = asyncio.get_event_loop()
     resolver = aiodns.DNSResolver(loop=loop, timeout=timeout)
-
-    async def query(name, qtype):
-        return await resolver.query(name, qtype)
+    
+    try:
+        unicode_name = name.decode('utf-8')
+    except UnicodeDecodeError:
+        return None
+    async def query(unicode_name, qtype):
+        return await resolver.query(unicode_name, qtype)
 
     #q = query(name, 'TXT')
     try:
-        result = await query(name, 'TXT')
+        result = await query(unicode_name, 'TXT')
     except aiodns.error.DNSError:
         result = None
 
@@ -86,7 +90,7 @@ class DKIM(dkim.DKIM):
     name = sig[b's'] + b"._domainkey." + sig[b'd'] + b"."
     try:
       self.pk, self.keysize, self.ktag, self.seqtlsrpt = await load_pk_from_dns_async(name,
-              dnsfunc, timeout=self.timeout)
+            dnsfunc, timeout=self.timeout)
     except dkim.KeyFormatError as e:
       self.logger.error("%s" % e)
       return False
diff --git a/dkim/dkimverify.py b/dkim/dkimverify.py
index 2ca90d5..e1d6243 100644
--- a/dkim/dkimverify.py
+++ b/dkim/dkimverify.py
@@ -28,24 +28,54 @@ import argparse
 
 import dkim
 
+def filedns(datafile, tgtdomain, selector):
+
+    def dnsf(self, domain, timeout=5):
+        target = "{0}._domainkey.{1}.".format(selector, tgtdomain)
+        _dns_responses = {
+          target : read_test_data(datafile),
+        }
+        try:
+            domain = domain.decode('ascii')
+        except UnicodeDecodeError:
+            return None
+        self.assertTrue(domain in _dns_responses,domain)
+        return _dns_responses[domain]
+
+    return dnsf
+
 def main():
     parser = argparse.ArgumentParser(
         description='Verify DKIM signature for email messages.',
         epilog="message to be verified follows commands on stdin")
+    parser.add_argument('-v', '--verbose', action='store_true', default=False,
+        help='turn verbose mode on')
     parser.add_argument('--index', metavar='N', type=int, default=0,
         help='Index of DKIM signature header to verify: default=0')
+    parser.add_argument('-f', '--dnsfile', action="store", default=None,
+        help='File containing DKIM public key records' )
+    parser.add_argument('-d', '--domain', action="store", default=None,
+        help='Domain for DNS record in dnsfile.  Mandatory with -f.' )
+    parser.add_argument('-s', '--selector', action="store", default=None,
+        help='Selector for DNS record in dnsfile.  Mandatory with -f.' )
     args=parser.parse_args()
     if sys.version_info[0] >= 3:
         # Make sys.stdin a binary stream.
         sys.stdin = sys.stdin.detach()
 
     message = sys.stdin.read()
-    verbose = '-v' in sys.argv
-    if verbose:
+    if args.verbose:
         import logging
-        d = dkim.DKIM(message, logger=logging)
+        log=logging
+    else:
+        log=None
+    if args.dnsfile:
+        if not args.domain or not args.selector:
+            raise SyntaxError('Both --domain and --selector are required with --dnsfile')
+        dnsfc=filedns(args.dnsfile, args.domain, args.selector)
+        d = dkim.DKIM(message, logger=log, dnsfunc=dnsfc)
     else:
-        d = dkim.DKIM(message)
+        d = dkim.DKIM(message, logger=log)
     res = d.verify(args.index)
     if not res:
         print("signature verification failed")
diff --git a/dkim/dnsplug.py b/dkim/dnsplug.py
index 5ccf97c..4c75d34 100644
--- a/dkim/dnsplug.py
+++ b/dkim/dnsplug.py
@@ -24,7 +24,6 @@ __all__ = [
     'get_txt'
     ]
 
-
 def get_txt_dnspython(name, timeout=5):
     """Return a TXT record associated with a DNS name."""
     try:
@@ -78,11 +77,11 @@ except ImportError:
 def get_txt(name, timeout=5):
     """Return a TXT record associated with a DNS name.
 
-    @param name: The bytestring domain name to look up.
+    @param name: The string domain name to look up.
     """
     # pydns needs Unicode, but DKIM's d= is ASCII (already punycoded).
     try:
-        unicode_name = name.decode('UTF-8')
+        unicode_name = name.decode('utf-8')
     except UnicodeDecodeError:
         return None
     txt = _get_txt(unicode_name, timeout)
diff --git a/dkim/tests/__init__.py b/dkim/tests/__init__.py
index 4fb2926..50fe90f 100644
--- a/dkim/tests/__init__.py
+++ b/dkim/tests/__init__.py
@@ -24,6 +24,15 @@
 import unittest
 
 
+def utf8_decode(data):
+    """To decode utf-8 bytestring"""
+    try:
+        data = data.decode('utf-8')
+    except UnicodeDecodeError:
+        return None
+    return data
+
+
 def test_suite():
     from dkim.tests import (
         test_canonicalization,
diff --git a/dkim/tests/data/test_punnycode.message b/dkim/tests/data/test_punnycode.message
new file mode 100644
index 0000000..bece5cc
--- /dev/null
+++ b/dkim/tests/data/test_punnycode.message
@@ -0,0 +1,9 @@
+Authentication-Results: lists.example.org; arc=none; spf=pass smtp.mfrom=[e-mail]; dkim=pass (1024-bit key) header.i=@d1.example; dmarc=pass
+Received: from localhost
+Message-ID: <[e-mail]>
+Date: Mon, 01 Jan 2011 01:02:03 +0400
+From: UTF8 user <[e-mail]--qxa6a>
+To: [e-mail]
+Subject: Testing
+
+This is a test message.
diff --git a/dkim/tests/data/test_utf8.message b/dkim/tests/data/test_utf8.message
new file mode 100644
index 0000000..80b6543
--- /dev/null
+++ b/dkim/tests/data/test_utf8.message
@@ -0,0 +1,9 @@
+Authentication-Results: lists.example.org; arc=none; spf=pass smtp.mfrom=[e-mail]; dkim=pass (1024-bit key) header.i=@d1.example; dmarc=pass
+Received: from localhost
+Message-ID: <[e-mail]>
+Date: Mon, 01 Jan 2011 01:02:03 +0400
+From: UTF8 user <test@κλαρα-σωλις.ευ>
+To: [e-mail]
+Subject: Testing
+
+This is a test message.
diff --git a/dkim/tests/test_arc.py b/dkim/tests/test_arc.py
index a65c7c3..c07b9ce 100644
--- a/dkim/tests/test_arc.py
+++ b/dkim/tests/test_arc.py
@@ -23,7 +23,7 @@
 import os.path
 import unittest
 import time
-
+from . import utf8_decode
 import dkim
 
 
@@ -61,9 +61,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
diff --git a/dkim/tests/test_dkim.py b/dkim/tests/test_dkim.py
index dc589d6..3ce5379 100644
--- a/dkim/tests/test_dkim.py
+++ b/dkim/tests/test_dkim.py
@@ -22,7 +22,7 @@ import unittest
 import time
 
 import dkim
-
+from . import utf8_decode
 
 def read_test_data(filename):
     """Get the content of the given test data file.
@@ -61,6 +61,8 @@ class TestSignAndVerify(unittest.TestCase):
         self.message4 = read_test_data("rfc6376.signed.msg")
         self.message5 = read_test_data("rfc6376.signed.rsa.msg")
         self.message6 = read_test_data("test.message.baddomain")
+        self.messageutf8 = read_test_data("test_utf8.message")
+        self.messagepunycode = read_test_data("test_punnycode.message")
         self.key = read_test_data("test.private")
         self.rfckey = read_test_data("rfc8032_7_1.key")
 
@@ -81,9 +83,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -105,9 +106,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -129,9 +129,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -153,9 +152,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -172,9 +170,8 @@ b/mPfjC0QJTocVBq6Za/PlzfV+Py92VaCak19F4WrbVTK5Gg5tW220MCAwEAAQ=="""
           'brisbane._domainkey.football.example.com.': """v=DKIM1; k=ed25519; \
 p=11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo="""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -190,9 +187,8 @@ b/mPfjC0QJTocVBq6Za/PlzfV+Py92VaCak19F4WrbVTK5Gg5tW220MCAwEAAQ=="""
           'brisbane._domainkey.football.example.com.': """v=DKIM1; k=ed25519; \
 p=11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo="""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -206,13 +202,32 @@ b/mPfjC0QJTocVBq6Za/PlzfV+Py92VaCak19F4WrbVTK5Gg5tW220MCAwEAAQ=="""
         _dns_responses = {
           'test._domainkey.legitimate.com(.attacker.com.': read_test_data("test.txt"),
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
 
+    def dnsfuncutf8(self, domain, timeout=5):
+        _dns_responses = {
+          '2022._domainkey.κλαρα-σωλις.ευ.': read_test_data("2048_testkey_PKCS8.key.pub.txt"),
+          'test._domainkey.legitimate.com(.attacker.com.': read_test_data("test.txt"),
+        }
+        domain = utf8_decode(domain)
+        if not domain:
+            return None
+        self.assertTrue(domain in _dns_responses)
+        return _dns_responses[domain]
+
+    def dnsfuncpunycode(self, domain, timeout=5):
+        _dns_response = {
+            '2022._domainkey.xn----ylba7abgd9bnh0e.xn--qxa6a.' : read_test_data("2048_testkey_PKCS8.key.pub.txt")
+        }
+        domain = utf8_decode(domain)
+        if not domain:
+            return None
+        self.assertTrue(domain in _dns_response)
+        return _dns_response[domain]
 
     def test_verifies(self):
         # A message verifies after being signed.
@@ -499,6 +514,26 @@ b/mPfjC0QJTocVBq6Za/PlzfV+Py92VaCak19F4WrbVTK5Gg5tW220MCAwEAAQ==
             sigerror = True
         self.assertTrue(sigerror)
 
+    def test_utf_8_verifies(self):
+        # Attempt to verify message with UTF-8 domain.
+        key = read_test_data("2048_testkey_PKCS8.key")
+        for header_algo in (b"simple", b"relaxed"):
+            for body_algo in (b"simple", b"relaxed"):
+                sig = dkim.sign(self.messageutf8, b'2022', "κλαρα-σωλις.ευ".encode('utf-8'), key,
+                canonicalize=(header_algo, body_algo))
+                res = dkim.verify(sig + self.messageutf8, dnsfunc=self.dnsfuncutf8)
+                self.assertTrue(res)
+
+    def test_punnycode_verifies(self):
+        # Attempt to verify message with UTF-8 domain.
+        key = read_test_data("2048_testkey_PKCS8.key")
+        for header_algo in (b"simple", b"relaxed"):
+            for body_algo in (b"simple", b"relaxed"):
+                sig = dkim.sign(self.messagepunycode, b'2022', "xn----ylba7abgd9bnh0e.xn--qxa6a".encode('utf-8'), key,
+                canonicalize=(header_algo, body_algo))
+                res = dkim.verify(sig + self.messagepunycode, dnsfunc=self.dnsfuncpunycode)
+                self.assertTrue(res)
+
     def test_validate_signature_fields(self):
       sig = {b'v': b'1',
       b'a': b'rsa-sha256',
diff --git a/dkim/tests/test_dkim_ed25519.py b/dkim/tests/test_dkim_ed25519.py
index 5cf89e4..adeea99 100644
--- a/dkim/tests/test_dkim_ed25519.py
+++ b/dkim/tests/test_dkim_ed25519.py
@@ -22,6 +22,7 @@ import os.path
 import unittest
 import time
 
+from . import utf8_decode
 import dkim
 
 
@@ -72,9 +73,8 @@ p=yi50DjK5O9pqbFpNHklsv9lqaS0ArSYu02qp1S0DW1Y=""",
           'brisbane._domainkey.football.example.com.': """v=DKIM1; k=ed25519; \
 p=11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo="""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
diff --git a/dkim/tests/test_dkim_generate.py b/dkim/tests/test_dkim_generate.py
index 1649ab5..7063c5b 100644
--- a/dkim/tests/test_dkim_generate.py
+++ b/dkim/tests/test_dkim_generate.py
@@ -23,6 +23,7 @@ import unittest
 
 import dkim
 import dknewkey
+from . import utf8_decode
 
 def read_data(path):
     """Get the content of the given test data file."""
@@ -88,9 +89,8 @@ class TestSignAndVerify(unittest.TestCase):
         _dns_responses = {
             'test._domainkey.example.com.': read_data(self.rsa_dns_key_file),
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -99,9 +99,8 @@ class TestSignAndVerify(unittest.TestCase):
         _dns_responses = {
             'test1._domainkey.example.com.': read_data(self.ed25519_dns_key_file),
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
diff --git a/dkim/tests/test_dkim_rsavariants.py b/dkim/tests/test_dkim_rsavariants.py
index 992d466..a230b3a 100644
--- a/dkim/tests/test_dkim_rsavariants.py
+++ b/dkim/tests/test_dkim_rsavariants.py
@@ -22,6 +22,7 @@ import unittest
 import time
 
 import dkim
+from . import utf8_decode
 
 
 def read_test_data(filename):
@@ -51,9 +52,8 @@ class TestSignAndVerify(unittest.TestCase):
           'test4._domainkey.example.com.': read_test_data("2048_testkey_wo_markers.pub.rsa.txt"),
           'test5._domainkey.example.com.': read_test_data("2048_testkey_PKCS8.key.pub.txt")
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
diff --git a/dkim/tests/test_dkim_tlsrpt.py b/dkim/tests/test_dkim_tlsrpt.py
index 83b31b6..2684885 100644
--- a/dkim/tests/test_dkim_tlsrpt.py
+++ b/dkim/tests/test_dkim_tlsrpt.py
@@ -22,6 +22,7 @@ import unittest
 import time
 
 import dkim
+from . import utf8_decode
 
 
 def read_test_data(filename):
@@ -79,9 +80,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -103,9 +103,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -127,9 +126,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -151,9 +149,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -170,9 +167,8 @@ b/mPfjC0QJTocVBq6Za/PlzfV+Py92VaCak19F4WrbVTK5Gg5tW220MCAwEAAQ=="""
           'brisbane._domainkey.football.example.com.': """v=DKIM1; k=ed25519; \
 p=11qYAYKxCrfVS/7TyWQHOg7hcvPapiMlrwIaaPcHURo="""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]
@@ -194,9 +190,8 @@ hzY8i+RQ9DpSVpPbF7ykQxtKXkv/ahW3KjViiAH+ghvvIhkx4xYSIc9oSwVmAl5Oct\
 MEeWUwg8Istjqz8BZeTWbf41fbNhte7Y+YqZOwq1Sd0DbvYAD9NOZK9vlfuac0598H\
 Y+vtSBczUiKERHv1yRbcaQtZFh5wtiRrN04BLUTD21MycBX5jYchHjPY/wIDAQAB"""
         }
-        try:
-            domain = domain.decode('ascii')
-        except UnicodeDecodeError:
+        domain = utf8_decode(domain)
+        if not domain:
             return None
         self.assertTrue(domain in _dns_responses,domain)
         return _dns_responses[domain]