Python DNS Beispiele

Beispiel #1

Datei: challenges_test.py Projekt: tdfischer/lets-encrypt-preview

 def setUp(self):
     from acme.challenges import DNS
     self.msg = DNS(token='17817c66b60ce2e4012dfad92657527a')
     self.jmsg = {
         'type': 'dns',
         'token': '17817c66b60ce2e4012dfad92657527a'
     }

Beispiel #2

Datei: challenges_test.py Projekt: bsmr-misc-forks/letsencrypt

class DNSTest(unittest.TestCase):

    def setUp(self):
        from acme.challenges import DNS
        self.msg = DNS(token=jose.b64decode(
            b'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA'))
        self.jmsg = {
            'type': 'dns',
            'token': 'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA',
        }

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

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

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

    def test_gen_check_validation(self):
        self.assertTrue(self.msg.check_validation(
            self.msg.gen_validation(KEY), KEY.public_key()))

    def test_gen_check_validation_wrong_key(self):
        key2 = jose.JWKRSA.load(test_util.load_vector('rsa1024_key.pem'))
        self.assertFalse(self.msg.check_validation(
            self.msg.gen_validation(KEY), key2.public_key()))

    def test_check_validation_wrong_payload(self):
        validations = tuple(
            jose.JWS.sign(payload=payload, alg=jose.RS256, key=KEY)
            for payload in (b'', b'{}')
        )
        for validation in validations:
            self.assertFalse(self.msg.check_validation(
                validation, KEY.public_key()))

    def test_check_validation_wrong_fields(self):
        bad_validation = jose.JWS.sign(
            payload=self.msg.update(
                token=b'x' * 20).json_dumps().encode('utf-8'),
            alg=jose.RS256, key=KEY)
        self.assertFalse(self.msg.check_validation(
            bad_validation, KEY.public_key()))

    def test_gen_response(self):
        with mock.patch('acme.challenges.DNS.gen_validation') as mock_gen:
            mock_gen.return_value = mock.sentinel.validation
            response = self.msg.gen_response(KEY)
        from acme.challenges import DNSResponse
        self.assertTrue(isinstance(response, DNSResponse))
        self.assertEqual(response.validation, mock.sentinel.validation)

    def test_validation_domain_name(self):
        self.assertEqual(
            '_acme-challenge.le.wtf', self.msg.validation_domain_name('le.wtf'))

Beispiel #3

class DNSTest(unittest.TestCase):

    def setUp(self):
        from acme.challenges import DNS
        self.msg = DNS(token=jose.b64decode(
            b'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA'))
        self.jmsg = {
            'type': 'dns',
            'token': 'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA',
        }

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

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

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

    def test_gen_check_validation(self):
        self.assertTrue(self.msg.check_validation(
            self.msg.gen_validation(KEY), KEY.public_key()))

    def test_gen_check_validation_wrong_key(self):
        key2 = jose.JWKRSA.load(test_util.load_vector('rsa1024_key.pem'))
        self.assertFalse(self.msg.check_validation(
            self.msg.gen_validation(KEY), key2.public_key()))

    def test_check_validation_wrong_payload(self):
        validations = tuple(
            jose.JWS.sign(payload=payload, alg=jose.RS256, key=KEY)
            for payload in (b'', b'{}')
        )
        for validation in validations:
            self.assertFalse(self.msg.check_validation(
                validation, KEY.public_key()))

    def test_check_validation_wrong_fields(self):
        bad_validation = jose.JWS.sign(
            payload=self.msg.update(
                token=b'x' * 20).json_dumps().encode('utf-8'),
            alg=jose.RS256, key=KEY)
        self.assertFalse(self.msg.check_validation(
            bad_validation, KEY.public_key()))

    def test_gen_response(self):
        with mock.patch('acme.challenges.DNS.gen_validation') as mock_gen:
            mock_gen.return_value = mock.sentinel.validation
            response = self.msg.gen_response(KEY)
        from acme.challenges import DNSResponse
        self.assertTrue(isinstance(response, DNSResponse))
        self.assertEqual(response.validation, mock.sentinel.validation)

    def test_validation_domain_name(self):
        self.assertEqual(
            '_acme-challenge.le.wtf', self.msg.validation_domain_name('le.wtf'))

Beispiel #4

 def setUp(self):
     from acme.challenges import DNS
     self.msg = DNS(token=jose.b64decode(
         b'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA'))
     self.jmsg = {
         'type': 'dns',
         'token': 'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA',
     }

Beispiel #5

 def setUp(self):
     self.account_key = jose.JWKRSA.load(
         test_util.load_vector('rsa512_key.pem'))
     from acme.challenges import DNS
     self.msg = DNS(token=jose.b64decode(
         b'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA'))
     self.jmsg = {
         'type': 'dns',
         'token': 'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA',
     }

Beispiel #6

Datei: challenges_test.py Projekt: NEOatNHNG/letsencrypt

class DNSResponseTest(unittest.TestCase):
    def setUp(self):
        from acme.challenges import DNS

        self.chall = DNS(token=jose.b64decode(b"evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"))
        self.validation = jose.JWS.sign(payload=self.chall.json_dumps(sort_keys=True).encode(), key=KEY, alg=jose.RS256)

        from acme.challenges import DNSResponse

        self.msg = DNSResponse(validation=self.validation)
        self.jmsg_to = {"resource": "challenge", "type": "dns", "validation": self.validation}
        self.jmsg_from = {"resource": "challenge", "type": "dns", "validation": self.validation.to_json()}

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

    def test_from_json(self):
        from acme.challenges import DNSResponse

        self.assertEqual(self.msg, DNSResponse.from_json(self.jmsg_from))

    def test_from_json_hashable(self):
        from acme.challenges import DNSResponse

        hash(DNSResponse.from_json(self.jmsg_from))

    def test_check_validation(self):
        self.assertTrue(self.msg.check_validation(self.chall, KEY.public_key()))

Beispiel #7

Datei: challenges_test.py Projekt: bsmr-misc-forks/letsencrypt

 def setUp(self):
     from acme.challenges import DNS
     self.msg = DNS(token=jose.b64decode(
         b'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA'))
     self.jmsg = {
         'type': 'dns',
         'token': 'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA',
     }

Beispiel #8

Datei: challenges_test.py Projekt: fmarier/letsencrypt

 def setUp(self):
     self.account_key = jose.JWKRSA.load(
         test_util.load_vector('rsa512_key.pem'))
     from acme.challenges import DNS
     self.msg = DNS(token=jose.b64decode(
         b'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA'))
     self.jmsg = {
         'type': 'dns',
         'token': 'evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA',
     }

Beispiel #9

    def setUp(self):
        from acme.challenges import DNS
        self.chall = DNS(token=jose.b64decode(
            b"evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"))
        self.validation = jose.JWS.sign(
            payload=self.chall.json_dumps(sort_keys=True).encode(),
            key=KEY, alg=jose.RS256)

        from acme.challenges import DNSResponse
        self.msg = DNSResponse(validation=self.validation)
        self.jmsg_to = {
            'resource': 'challenge',
            'type': 'dns',
            'validation': self.validation,
        }
        self.jmsg_from = {
            'resource': 'challenge',
            'type': 'dns',
            'validation': self.validation.to_json(),
        }

Beispiel #10

Datei: challenges_test.py Projekt: NEOatNHNG/letsencrypt

    def setUp(self):
        from acme.challenges import DNS

        self.chall = DNS(token=jose.b64decode(b"evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"))
        self.validation = jose.JWS.sign(payload=self.chall.json_dumps(sort_keys=True).encode(), key=KEY, alg=jose.RS256)

        from acme.challenges import DNSResponse

        self.msg = DNSResponse(validation=self.validation)
        self.jmsg_to = {"resource": "challenge", "type": "dns", "validation": self.validation}
        self.jmsg_from = {"resource": "challenge", "type": "dns", "validation": self.validation.to_json()}

Beispiel #11

Datei: challenges_test.py Projekt: kepstin/letsencrypt

class DNSTest(unittest.TestCase):

    def setUp(self):
        from acme.challenges import DNS
        self.msg = DNS(token='17817c66b60ce2e4012dfad92657527a')
        self.jmsg = {'type': 'dns', 'token': '17817c66b60ce2e4012dfad92657527a'}

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

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

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

Beispiel #12

Datei: challenges_test.py Projekt: tdfischer/lets-encrypt-preview

class DNSTest(unittest.TestCase):
    def setUp(self):
        from acme.challenges import DNS
        self.msg = DNS(token='17817c66b60ce2e4012dfad92657527a')
        self.jmsg = {
            'type': 'dns',
            'token': '17817c66b60ce2e4012dfad92657527a'
        }

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

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

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

Beispiel #13

Datei: challenges_test.py Projekt: fmarier/letsencrypt

    def setUp(self):
        self.key = jose.JWKRSA(key=KEY)

        from acme.challenges import DNS
        self.chall = DNS(token=jose.b64decode(
            b"evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"))
        self.validation = jose.JWS.sign(
            payload=self.chall.json_dumps(sort_keys=True).encode(),
            key=self.key, alg=jose.RS256)

        from acme.challenges import DNSResponse
        self.msg = DNSResponse(validation=self.validation)
        self.jmsg_to = {
            'resource': 'challenge',
            'type': 'dns',
            'validation': self.validation,
        }
        self.jmsg_from = {
            'resource': 'challenge',
            'type': 'dns',
            'validation': self.validation.to_json(),
        }

Beispiel #14

class DNSResponseTest(unittest.TestCase):
    def setUp(self):
        self.key = jose.JWKRSA(key=KEY)

        from acme.challenges import DNS
        self.chall = DNS(token=jose.b64decode(
            b"evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"))
        self.validation = jose.JWS.sign(
            payload=self.chall.json_dumps(sort_keys=True).encode(),
            key=self.key,
            alg=jose.RS256)

        from acme.challenges import DNSResponse
        self.msg = DNSResponse(validation=self.validation)
        self.jmsg_to = {
            'resource': 'challenge',
            'type': 'dns',
            'validation': self.validation,
        }
        self.jmsg_from = {
            'resource': 'challenge',
            'type': 'dns',
            'validation': self.validation.to_json(),
        }

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

    def test_from_json(self):
        from acme.challenges import DNSResponse
        self.assertEqual(self.msg, DNSResponse.from_json(self.jmsg_from))

    def test_from_json_hashable(self):
        from acme.challenges import DNSResponse
        hash(DNSResponse.from_json(self.jmsg_from))

    def test_check_validation(self):
        self.assertTrue(
            self.msg.check_validation(self.chall, self.key.public_key()))

Beispiel #15

Datei: challenges_test.py Projekt: kepstin/letsencrypt

 def setUp(self):
     from acme.challenges import DNS
     self.msg = DNS(token='17817c66b60ce2e4012dfad92657527a')
     self.jmsg = {'type': 'dns', 'token': '17817c66b60ce2e4012dfad92657527a'}

Beispiel #16

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

Beispiel #17

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

Beispiel #18

Datei: challenges_test.py Projekt: kepstin/letsencrypt

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

Beispiel #19

Datei: challenges_test.py Projekt: kepstin/letsencrypt

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

Beispiel #20

Datei: challenges_test.py Projekt: NEOatNHNG/letsencrypt

    def setUp(self):
        from acme.challenges import DNS

        self.msg = DNS(token=jose.b64decode(b"evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"))
        self.jmsg = {"type": "dns", "token": "evaGxfADs6pSRb2LAv9IZf17Dt3juxGJ-PCt92wr-oA"}