Esempio n. 1
0
class DVSNIResponseTest(unittest.TestCase):

    def setUp(self):
        from acme.challenges import DVSNIResponse
        self.msg = DVSNIResponse(
            s='\xf5\xd6\xe3\xb2]\xe0L\x0bN\x9cKJ\x14I\xa1K\xa3#\xf9\xa8'
              '\xcd\x8c7\x0e\x99\x19)\xdc\xb7\xf3\x9bw')
        self.jmsg = {
            'type': 'dvsni',
            's': '9dbjsl3gTAtOnEtKFEmhS6Mj-ajNjDcOmRkp3Lfzm3c',
        }

    def test_z_and_domain(self):
        from acme.challenges import DVSNI
        challenge = DVSNI(
            r="O*\xb4-\xad\xec\x95>\xed\xa9\r0\x94\xe8\x97\x9c&6"
              "\xbf'\xb3\xed\x9a9nX\x0f'\\m\xe7\x12",
            nonce=long('439736375371401115242521957580409149254868992063'
                       '44333654741504362774620418661L'))
        # pylint: disable=invalid-name
        z = '38e612b0397cc2624a07d351d7ef50e46134c0213d9ed52f7d7c611acaeed41b'
        self.assertEqual(z, self.msg.z(challenge))
        self.assertEqual(
            '{0}.acme.invalid'.format(z), self.msg.z_domain(challenge))

    def test_to_partial_json(self):
        self.assertEqual(self.jmsg, self.msg.to_partial_json())

    def test_from_json(self):
        from acme.challenges import DVSNIResponse
        self.assertEqual(self.msg, DVSNIResponse.from_json(self.jmsg))

    def test_from_json_hashable(self):
        from acme.challenges import DVSNIResponse
        hash(DVSNIResponse.from_json(self.jmsg))
Esempio n. 2
0
class DVSNIResponseTest(unittest.TestCase):
    def setUp(self):
        from acme.challenges import DVSNIResponse
        self.msg = DVSNIResponse(
            s='\xf5\xd6\xe3\xb2]\xe0L\x0bN\x9cKJ\x14I\xa1K\xa3#\xf9\xa8'
            '\xcd\x8c7\x0e\x99\x19)\xdc\xb7\xf3\x9bw')
        self.jmsg = {
            'type': 'dvsni',
            's': '9dbjsl3gTAtOnEtKFEmhS6Mj-ajNjDcOmRkp3Lfzm3c',
        }

    def test_z_and_domain(self):
        from acme.challenges import DVSNI
        challenge = DVSNI(
            r="O*\xb4-\xad\xec\x95>\xed\xa9\r0\x94\xe8\x97\x9c&6"
            "\xbf'\xb3\xed\x9a9nX\x0f'\\m\xe7\x12",
            nonce=long('439736375371401115242521957580409149254868992063'
                       '44333654741504362774620418661L'))
        # pylint: disable=invalid-name
        z = '38e612b0397cc2624a07d351d7ef50e46134c0213d9ed52f7d7c611acaeed41b'
        self.assertEqual(z, self.msg.z(challenge))
        self.assertEqual('{0}.acme.invalid'.format(z),
                         self.msg.z_domain(challenge))

    def test_to_partial_json(self):
        self.assertEqual(self.jmsg, self.msg.to_partial_json())

    def test_from_json(self):
        from acme.challenges import DVSNIResponse
        self.assertEqual(self.msg, DVSNIResponse.from_json(self.jmsg))

    def test_from_json_hashable(self):
        from acme.challenges import DVSNIResponse
        hash(DVSNIResponse.from_json(self.jmsg))
class DVSNIResponseTest(unittest.TestCase):
    def setUp(self):
        from acme.challenges import DVSNIResponse
        # pylint: disable=invalid-name
        s = '9dbjsl3gTAtOnEtKFEmhS6Mj-ajNjDcOmRkp3Lfzm3c'
        self.msg = DVSNIResponse(s=jose.decode_b64jose(s))
        self.jmsg = {
            'resource': 'challenge',
            'type': 'dvsni',
            's': s,
        }

        from acme.challenges import DVSNI
        self.chall = DVSNI(
            r=jose.decode_b64jose(
                'Tyq0La3slT7tqQ0wlOiXnCY2vyez7Zo5blgPJ1xt5xI'),
            nonce=jose.decode_b64jose('a82d5ff8ef740d12881f6d3c2277ab2e'))
        self.z = (b'38e612b0397cc2624a07d351d7ef50e4'
                  b'6134c0213d9ed52f7d7c611acaeed41b')
        self.domain = 'foo.com'
        self.key = test_util.load_pyopenssl_private_key('rsa512_key.pem')
        self.public_key = test_util.load_rsa_private_key(
            'rsa512_key.pem').public_key()

    def test_z_and_domain(self):
        # pylint: disable=invalid-name
        self.assertEqual(self.z, self.msg.z(self.chall))
        self.assertEqual(self.z + b'.acme.invalid',
                         self.msg.z_domain(self.chall))

    def test_to_partial_json(self):
        self.assertEqual(self.jmsg, self.msg.to_partial_json())

    def test_from_json(self):
        from acme.challenges import DVSNIResponse
        self.assertEqual(self.msg, DVSNIResponse.from_json(self.jmsg))

    def test_from_json_hashable(self):
        from acme.challenges import DVSNIResponse
        hash(DVSNIResponse.from_json(self.jmsg))

    @mock.patch('acme.challenges.DVSNIResponse.verify_cert')
    def test_simple_verify(self, mock_verify_cert):
        chall = mock.Mock()
        chall.probe_cert.return_value = mock.sentinel.cert
        mock_verify_cert.return_value = 'x'
        self.assertEqual(
            'x',
            self.msg.simple_verify(chall, mock.sentinel.domain,
                                   mock.sentinel.key))
        chall.probe_cert.assert_called_once_with(domain=mock.sentinel.domain)
        self.msg.verify_cert.assert_called_once_with(chall,
                                                     mock.sentinel.domain,
                                                     mock.sentinel.key,
                                                     mock.sentinel.cert)

    def test_simple_verify_false_on_probe_error(self):
        chall = mock.Mock()
        chall.probe_cert.side_effect = errors.Error
        self.assertFalse(
            self.msg.simple_verify(chall=chall, domain=None, public_key=None))

    def test_gen_verify_cert_postive_no_key(self):
        cert = self.msg.gen_cert(self.chall, self.domain, self.key)
        self.assertTrue(
            self.msg.verify_cert(self.chall,
                                 self.domain,
                                 public_key=None,
                                 cert=cert))

    def test_gen_verify_cert_postive_with_key(self):
        cert = self.msg.gen_cert(self.chall, self.domain, self.key)
        self.assertTrue(
            self.msg.verify_cert(self.chall,
                                 self.domain,
                                 public_key=self.public_key,
                                 cert=cert))

    def test_gen_verify_cert_negative_with_wrong_key(self):
        cert = self.msg.gen_cert(self.chall, self.domain, self.key)
        key = test_util.load_rsa_private_key('rsa256_key.pem').public_key()
        self.assertFalse(
            self.msg.verify_cert(self.chall,
                                 self.domain,
                                 public_key=key,
                                 cert=cert))

    def test_gen_verify_cert_negative(self):
        cert = self.msg.gen_cert(self.chall, self.domain + 'x', self.key)
        self.assertFalse(
            self.msg.verify_cert(self.chall,
                                 self.domain,
                                 public_key=None,
                                 cert=cert))
Esempio n. 4
0
class DVSNIResponseTest(unittest.TestCase):

    def setUp(self):
        from acme.challenges import DVSNIResponse
        # pylint: disable=invalid-name
        s = '9dbjsl3gTAtOnEtKFEmhS6Mj-ajNjDcOmRkp3Lfzm3c'
        self.msg = DVSNIResponse(s=jose.decode_b64jose(s))
        self.jmsg = {
            'resource': 'challenge',
            'type': 'dvsni',
            's': s,
        }

        from acme.challenges import DVSNI
        self.chall = DVSNI(
            r=jose.decode_b64jose('Tyq0La3slT7tqQ0wlOiXnCY2vyez7Zo5blgPJ1xt5xI'),
            nonce=jose.decode_b64jose('a82d5ff8ef740d12881f6d3c2277ab2e'))
        self.z = (b'38e612b0397cc2624a07d351d7ef50e4'
                  b'6134c0213d9ed52f7d7c611acaeed41b')
        self.domain = 'foo.com'
        self.key = test_util.load_pyopenssl_private_key('rsa512_key.pem')
        self.public_key = test_util.load_rsa_private_key(
            'rsa512_key.pem').public_key()

    def test_z_and_domain(self):
        # pylint: disable=invalid-name
        self.assertEqual(self.z, self.msg.z(self.chall))
        self.assertEqual(
            self.z + b'.acme.invalid', self.msg.z_domain(self.chall))

    def test_to_partial_json(self):
        self.assertEqual(self.jmsg, self.msg.to_partial_json())

    def test_from_json(self):
        from acme.challenges import DVSNIResponse
        self.assertEqual(self.msg, DVSNIResponse.from_json(self.jmsg))

    def test_from_json_hashable(self):
        from acme.challenges import DVSNIResponse
        hash(DVSNIResponse.from_json(self.jmsg))

    @mock.patch('acme.challenges.DVSNIResponse.verify_cert')
    def test_simple_verify(self, mock_verify_cert):
        chall = mock.Mock()
        chall.probe_cert.return_value = mock.sentinel.cert
        mock_verify_cert.return_value = 'x'
        self.assertEqual('x', self.msg.simple_verify(
            chall, mock.sentinel.domain, mock.sentinel.key))
        chall.probe_cert.assert_called_once_with(domain=mock.sentinel.domain)
        self.msg.verify_cert.assert_called_once_with(
            chall, mock.sentinel.domain, mock.sentinel.key,
            mock.sentinel.cert)

    def test_simple_verify_false_on_probe_error(self):
        chall = mock.Mock()
        chall.probe_cert.side_effect = errors.Error
        self.assertFalse(self.msg.simple_verify(
            chall=chall, domain=None, public_key=None))

    def test_gen_verify_cert_postive_no_key(self):
        cert = self.msg.gen_cert(self.chall, self.domain, self.key)
        self.assertTrue(self.msg.verify_cert(
            self.chall, self.domain, public_key=None, cert=cert))

    def test_gen_verify_cert_postive_with_key(self):
        cert = self.msg.gen_cert(self.chall, self.domain, self.key)
        self.assertTrue(self.msg.verify_cert(
            self.chall, self.domain, public_key=self.public_key, cert=cert))

    def test_gen_verify_cert_negative_with_wrong_key(self):
        cert = self.msg.gen_cert(self.chall, self.domain, self.key)
        key = test_util.load_rsa_private_key('rsa256_key.pem').public_key()
        self.assertFalse(self.msg.verify_cert(
            self.chall, self.domain, public_key=key, cert=cert))

    def test_gen_verify_cert_negative(self):
        cert = self.msg.gen_cert(self.chall, self.domain + 'x', self.key)
        self.assertFalse(self.msg.verify_cert(
            self.chall, self.domain, public_key=None, cert=cert))