Merge pull request #27 from vesellov/master

testing clTRID field on EPP response to make sure stream sequence is not broken

Author: vesellov

setup.py

@@ -2,7 +2,7 @@
 
 setup_params = dict(
     name='epp-python-client',
-    version='0.0.13',
+    version='0.0.14',
     author='Veselin Penev',
     author_email='[email protected]',
     packages=find_packages(where='src'),

src/epp/epp_client.py

@@ -4,6 +4,7 @@
 import struct
 import hashlib
 import time
+import re
 
 from bs4 import BeautifulSoup
 
@@ -56,12 +57,20 @@ class EPPConnectionAlreadyClosedError(Exception):
 class EPPResponseEmptyError(Exception):
     pass
 
+
+class EPPRequestFailedError(Exception):
+    pass
+
+
+class EPPStreamSequenceBrokenError(Exception):
+    pass
+
 #------------------------------------------------------------------------------
 
 
 class EPPConnection:
 
-    def __init__(self, host, port, user, password, verbose=False, raise_errors=False, return_soup=None):
+    def __init__(self, host, port, user, password, verbose=False, raise_errors=True, return_soup=None):
         self.host = host
         self.port = int(port)
         self.user = user
@@ -73,6 +82,7 @@ def __init__(self, host, port, user, password, verbose=False, raise_errors=False
         self.verbose = verbose
         self.raise_errors = raise_errors
         self.return_soup = return_soup
+        self.cltrid_regexp = re.compile(r'<clTRID>(\w+?)</clTRID>')
 
     def open(self, timeout=15):
         self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -152,7 +162,7 @@ def read(self):
             if self.verbose:
                 logger.exception('failed to receive EPP response')
             return None
-        if ret is None:
+        if not ret:
             if self.verbose:
                 logger.error('nothing was received from EPP connection')
             raise EPPResponseEmptyError()
@@ -181,13 +191,30 @@ def write(self, xml):
         return ret
 
     def call(self, cmd, soup=None, quite=False):
+        cltrid_request = ''
+        r_req = self.cltrid_regexp.search(cmd)
+        if r_req:
+            cltrid_request = r_req.group(1)
         if self.write(cmd):
             if self.verbose and not quite:
-                logger.debug('sent %d bytes:\n%s\n', len(cmd), cmd)
+                logger.debug('sent %d bytes [%s]:\n%s\n', len(cmd), cltrid_request, cmd)
+        else:
+            if self.verbose:
+                logger.exception('failed to send EPP request')
+            raise EPPRequestFailedError()
         raw = self.read()
-        if raw:
-            if self.verbose and not quite:
-                logger.debug('received %d bytes:\n%s', len(raw), raw.decode())
+        if not raw:
+            if self.verbose:
+                logger.exception('received empty EPP response')
+            return ''
+        cltrid_response = ''
+        r_resp = self.cltrid_regexp.search(raw.decode())
+        if r_resp:
+            cltrid_response = r_resp.group(1)
+        if self.verbose and not quite:
+            logger.debug('received %d bytes [%s]:\n%s', len(raw), cltrid_response, raw.decode())
+        if cltrid_request and cltrid_response and cltrid_request != cltrid_response:
+            raise EPPStreamSequenceBrokenError()
         if soup is True or (self.return_soup is True and soup is not False):
             try:
                 soup = BeautifulSoup(raw, "lxml")

src/epp/rpc_server.py

@@ -257,20 +257,24 @@ def do_process_epp_command(self, request_json):
             cmd = request_json['cmd']
             args = request_json.get('args', {})
         except KeyError as exc:
-            logger.exception('failed processing epp command')
-            return {'error': 'failed reading epp request: %r' % exc, }
+            logger.exception('failed processing EPP command')
+            return {'error': 'failed reading EPP request: %r' % exc, }
 
         try:
             if self.verbose:
                 if self.verbose_poll or cmd not in ['poll_req', 'poll_ack', ]:
                     logger.debug('request: [%s]  %r', cmd, args)
             response_xml = self.do_epp_request(cmd, args)
-
-        except (epp_client.EPPConnectionAlreadyClosedError, epp_client.EPPResponseEmptyError, ) as exc:
+        except (
+            epp_client.EPPConnectionAlreadyClosedError,
+            epp_client.EPPResponseEmptyError,
+            epp_client.EPPRequestFailedError,
+            epp_client.EPPStreamSequenceBrokenError,
+        ) as exc:
             if not self.epp_reconnect:
                 if self.verbose:
                     logger.critical('EPP connection closed: %r', exc)
-                return {'error': 'failed processing epp command: %r' % exc, }
+                return {'error': 'failed processing EPP command: %r' % exc, }
             if self.verbose:
                 logger.critical('about to restart EPP connection, because of %r', exc)
             try:
@@ -281,16 +285,16 @@ def do_process_epp_command(self, request_json):
                 self.connect_epp()
                 response_xml = self.do_epp_request(cmd, args)
             except Exception as exc:
-                logger.exception('epp command retry failed')
-                return {'error': 'failed processing epp command: %r' % exc, }
+                logger.exception('EPP command retry failed')
+                return {'error': 'failed processing EPP command: %r' % exc, }
 
         except Exception as exc:
-            logger.exception('failed processing epp command')
-            return {'error': 'failed processing epp command: %r' % exc, }
+            logger.exception('failed processing EPP command')
+            return {'error': 'failed processing EPP command: %r' % exc, }
 
-        if response_xml is None:
-            logger.error('UNKNOWN COMMAND: %r', cmd)
-            return {'error': 'unknown command: %r' % cmd, }
+        if not response_xml:
+            logger.exception('unknown command or empty response received: %r', cmd)
+            return {'error': 'unknown command or empty response received: %r' % cmd, }
 
         try:
             response_json = json.loads(xml2json.xml2json(response_xml, XML2JsonOptions(), strip_ns=1, strip=1))
@@ -300,10 +304,10 @@ def do_process_epp_command(self, request_json):
                 response_json = json.loads(xml2json.xml2json(response_xml.encode('ascii', errors='ignore'), XML2JsonOptions(), strip_ns=1, strip=1))
             except Exception as exc:
                 logger.exception('xml2json failed')
-                return {'error': 'failed reading epp response: %r' % exc, }
+                return {'error': 'failed reading EPP response: %r' % exc, }
         except Exception as exc:
-            logger.exception('failed reading epp response')
-            return {'error': 'failed reading epp response: %r' % exc, }
+            logger.exception('failed reading EPP response')
+            return {'error': 'failed reading EPP response: %r' % exc, }
 
         try:
             code = response_json['epp']['response']['result']['@code']

tests/epp/test_epp_client.py

@@ -42,6 +42,18 @@
 <trID><svTRID>1618663648910</svTRID></trID></response></epp>'''
 
 
+sample_domain_check_command_response = b'''<?xml version="1.0" encoding="UTF-8"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd"><response><result code="1000">
+<msg>Command completed successfully</msg></result>
+<resData><domain:chkData xmlns:domain="urn:ietf:params:xml:ns:domain-1.0"
+xsi:schemaLocation="urn:ietf:params:xml:ns:domain-1.0 domain-1.0.xsd">
+<domain:cd><domain:name avail="0">test.com</domain:name><domain:reason>(00) The domain exists</domain:reason>
+</domain:cd></domain:chkData></resData><trID>
+<clTRID>bde35ab00a221ebc0e557c3d6fd6b693</clTRID><svTRID>1634623283678</svTRID></trID></response></epp>
+'''
+
+
 def conn():
     logging.getLogger('epp.client').setLevel(logging.DEBUG)
     return epp_client.EPPConnection(
@@ -188,3 +200,55 @@ def test_call_with_soup(self, mock_wrap_socket, mock_socket_connect):
         assert resp.find('result').get('code') == '2000'
         assert resp.find('msg').text == 'Unknown command'
         assert c.close() is True
+
+    @mock.patch('socket.socket.connect')
+    @mock.patch('ssl.wrap_socket')
+    def test_call_cltrid_is_matching(self, mock_wrap_socket, mock_socket_connect):
+        mock_socket_connect.return_value = True
+        fake_stream = io.BytesIO(
+            fake_response(sample_greeting) +
+            fake_response(sample_login_response) +
+            fake_response(sample_domain_check_command_response) +
+            fake_response(sample_logout_response))
+        setattr(fake_stream, 'send', lambda _: True)
+        mock_wrap_socket.return_value = fake_stream
+        c = conn()
+        assert c.open() is True
+        assert c.call(cmd='''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
+    <command>
+        <check>
+            <domain:check xmlns:domain="urn:ietf:params:xml:ns:domain-1.0">
+                <domain:name>test.com</domain:name>
+            </domain:check>
+        </check>
+        <clTRID>bde35ab00a221ebc0e557c3d6fd6b693</clTRID>
+    </command>
+</epp>''') == sample_domain_check_command_response
+        assert c.close() is True
+
+    @mock.patch('socket.socket.connect')
+    @mock.patch('ssl.wrap_socket')
+    def test_call_cltrid_missmatch(self, mock_wrap_socket, mock_socket_connect):
+        mock_socket_connect.return_value = True
+        fake_stream = io.BytesIO(
+            fake_response(sample_greeting) +
+            fake_response(sample_login_response) +
+            fake_response(sample_domain_check_command_response) +
+            fake_response(sample_logout_response))
+        setattr(fake_stream, 'send', lambda _: True)
+        mock_wrap_socket.return_value = fake_stream
+        c = conn()
+        assert c.open() is True
+        with pytest.raises(epp_client.EPPStreamSequenceBrokenError):
+            c.call(cmd='''<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<epp xmlns="urn:ietf:params:xml:ns:epp-1.0">
+    <command>
+        <check>
+            <domain:check xmlns:domain="urn:ietf:params:xml:ns:domain-1.0">
+                <domain:name>test.com</domain:name>
+            </domain:check>
+        </check>
+        <clTRID>bde35ab00a221ebc0e557c3d6fd6b693isdifferent</clTRID>
+    </command>
+</epp>''')

tests/epp/test_rpc_server.py

@@ -80,21 +80,21 @@ class TestEPP_RPC_Server(object):
     def test_bad_rpc_request(self):
         assert srv().do_process_epp_command(
             {'bad': 'request'}
-        )['error'] == "failed reading epp request: KeyError('cmd')"
+        )['error'] == "failed reading EPP request: KeyError('cmd')"
 
     def test_unknown_command(self):
         assert srv(
             xml_response='bad response'
         ).do_process_epp_command(
             {'cmd': 'something_crazy'}
-        )['error'] == "unknown command: 'something_crazy'"
+        )['error'] == "unknown command or empty response received: 'something_crazy'"
 
     def test_bad_rpc_response(self):
         assert srv(
             xml_response='bad response'
         ).do_process_epp_command(
             {'cmd': 'poll_req'}
-        )['error'] == "failed reading epp response: ParseError('syntax error: line 1, column 0')"
+        )['error'] == "failed reading EPP response: ParseError('syntax error: line 1, column 0')"
 
     def test_cmd_poll_req(self):
         verify_cmd(
@@ -514,12 +514,12 @@ def test_cmd_contact_delete(self):
             xml_response='''<?xml version="1.0" encoding="UTF-8"?><epp xmlns="urn:ietf:params:xml:ns:epp-1.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd">
 <response><result code="1000"><msg>Command completed successfully</msg></result><msgQ count="2" id="786"/>
-<trID><clTRID>13ed22ad5eea887a64688edf51db893b</clTRID><svTRID>1618921358722</svTRID></trID></response></epp>''',
+<trID><clTRID>c5bc8f94103f1a47019a09049dff5aec</clTRID><svTRID>1618921358722</svTRID></trID></response></epp>''',
             json_response={'epp': {
                 '@{http://www.w3.org/2001/XMLSchema-instance}schemaLocation': 'urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd',
                 'response': {'msgQ': {'@count': '2', '@id': '786'},
                      'result': {'@code': '1000', 'msg': 'Command completed successfully'},
-                     'trID': {'clTRID': '13ed22ad5eea887a64688edf51db893b', 'svTRID': '1618921358722'}, },
+                     'trID': {'clTRID': 'c5bc8f94103f1a47019a09049dff5aec', 'svTRID': '1618921358722'}, },
             }, },
         )
 
@@ -802,13 +802,13 @@ def test_cmd_domain_update(self):
             xml_response='''<?xml version="1.0" encoding="UTF-8"?><epp xmlns="urn:ietf:params:xml:ns:epp-1.0"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd">
 <response><result code="1000"><msg>Command completed successfully</msg></result><msgQ count="2" id="786"/>
-<trID><clTRID>dd8f602b0de383fcf4a63ee89f8bc3ca</clTRID><svTRID>1619202519557</svTRID></trID></response></epp>''',
+<trID><clTRID>c5bc8f94103f1a47019a09049dff5aec</clTRID><svTRID>1619202519557</svTRID></trID></response></epp>''',
             json_response={'epp': {
                 '@{http://www.w3.org/2001/XMLSchema-instance}schemaLocation': 'urn:ietf:params:xml:ns:epp-1.0 epp-1.0.xsd',
                 'response': {'msgQ': {
                     '@count': '2', '@id': '786'},
                 'result': {'@code': '1000', 'msg': 'Command completed successfully'},
-                'trID': {'clTRID': 'dd8f602b0de383fcf4a63ee89f8bc3ca', 'svTRID': '1619202519557'}, },
+                'trID': {'clTRID': 'c5bc8f94103f1a47019a09049dff5aec', 'svTRID': '1619202519557'}, },
             }, },
         )