Source Code for Module dns.rdtypes.ANY.CERT

  1  # Copyright (C) 2003-2007, 2009-2011 Nominum, Inc. 
  2  # 
  3  # Permission to use, copy, modify, and distribute this software and its 
  4  # documentation for any purpose with or without fee is hereby granted, 
  5  # provided that the above copyright notice and this permission notice 
  6  # appear in all copies. 
  7  # 
  8  # THE SOFTWARE IS PROVIDED "AS IS" AND NOMINUM DISCLAIMS ALL WARRANTIES 
  9  # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
 10  # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL NOMINUM BE LIABLE FOR 
 11  # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
 12  # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
 13  # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 
 14  # OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 
 15   
 16  import cStringIO 
 17  import struct 
 18   
 19  import dns.exception 
 20  import dns.dnssec 
 21  import dns.rdata 
 22  import dns.tokenizer 
 23   
 24  _ctype_by_value = { 
 25      1 : 'PKIX', 
 26      2 : 'SPKI', 
 27      3 : 'PGP', 
 28      253 : 'URI', 
 29      254 : 'OID', 
 30      } 
 31   
 32  _ctype_by_name = { 
 33      'PKIX' : 1, 
 34      'SPKI' : 2, 
 35      'PGP' : 3, 
 36      'URI' : 253, 
 37      'OID' : 254, 
 38      } 
 39   
 40 -def _ctype_from_text(what): 
 41      v = _ctype_by_name.get(what) 
 42      if not v is None: 
 43          return v 
 44      return int(what) 
 45   
 46 -def _ctype_to_text(what): 
 47      v = _ctype_by_value.get(what) 
 48      if not v is None: 
 49          return v 
 50      return str(what) 
 51   
 52 -class CERT(dns.rdata.Rdata): 
 53      """CERT record 
 54   
 55      @ivar certificate_type: certificate type 
 56      @type certificate_type: int 
 57      @ivar key_tag: key tag 
 58      @type key_tag: int 
 59      @ivar algorithm: algorithm 
 60      @type algorithm: int 
 61      @ivar certificate: the certificate or CRL 
 62      @type certificate: string 
 63      @see: RFC 2538""" 
 64   
 65      __slots__ = ['certificate_type', 'key_tag', 'algorithm', 'certificate'] 
 66   
 67 -    def __init__(self, rdclass, rdtype, certificate_type, key_tag, algorithm, 
 68                   certificate): 
 69          super(CERT, self).__init__(rdclass, rdtype) 
 70          self.certificate_type = certificate_type 
 71          self.key_tag = key_tag 
 72          self.algorithm = algorithm 
 73          self.certificate = certificate 
 74   
 75 -    def to_text(self, origin=None, relativize=True, **kw): 
 76          certificate_type = _ctype_to_text(self.certificate_type) 
 77          return "%s %d %s %s" % (certificate_type, self.key_tag, 
 78                                  dns.dnssec.algorithm_to_text(self.algorithm), 
 79                                  dns.rdata._base64ify(self.certificate)) 
 80   
 81 -    def from_text(cls, rdclass, rdtype, tok, origin = None, relativize = True): 
 82          certificate_type = _ctype_from_text(tok.get_string()) 
 83          key_tag = tok.get_uint16() 
 84          algorithm = dns.dnssec.algorithm_from_text(tok.get_string()) 
 85          if algorithm < 0 or algorithm > 255: 
 86              raise dns.exception.SyntaxError("bad algorithm type") 
 87          chunks = [] 
 88          while 1: 
 89              t = tok.get().unescape() 
 90              if t.is_eol_or_eof(): 
 91                  break 
 92              if not t.is_identifier(): 
 93                  raise dns.exception.SyntaxError 
 94              chunks.append(t.value) 
 95          b64 = ''.join(chunks) 
 96          certificate = b64.decode('base64_codec') 
 97          return cls(rdclass, rdtype, certificate_type, key_tag, 
 98                     algorithm, certificate) 
 99   
100      from_text = classmethod(from_text) 
101   
102 -    def to_wire(self, file, compress = None, origin = None): 
103          prefix = struct.pack("!HHB", self.certificate_type, self.key_tag, 
104                               self.algorithm) 
105          file.write(prefix) 
106          file.write(self.certificate) 
107   
108 -    def from_wire(cls, rdclass, rdtype, wire, current, rdlen, origin = None): 
109          prefix = wire[current : current + 5].unwrap() 
110          current += 5 
111          rdlen -= 5 
112          if rdlen < 0: 
113              raise dns.exception.FormError 
114          (certificate_type, key_tag, algorithm) = struct.unpack("!HHB", prefix) 
115          certificate = wire[current : current + rdlen].unwrap() 
116          return cls(rdclass, rdtype, certificate_type, key_tag, algorithm, 
117                     certificate) 
118   
119      from_wire = classmethod(from_wire) 
120