sfa/trust/certificate.py

   1 #----------------------------------------------------------------------
   2 # Copyright (c) 2008 Board of Trustees, Princeton University
   3 #
   4 # Permission is hereby granted, free of charge, to any person obtaining
   5 # a copy of this software and/or hardware specification (the "Work") to
   6 # deal in the Work without restriction, including without limitation the
   7 # rights to use, copy, modify, merge, publish, distribute, sublicense,
   8 # and/or sell copies of the Work, and to permit persons to whom the Work
   9 # is furnished to do so, subject to the following conditions:
  10 #
  11 # The above copyright notice and this permission notice shall be
  12 # included in all copies or substantial portions of the Work.
  13 #
  14 # THE WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  15 # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  16 # MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  17 # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  18 # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  19 # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  20 # OUT OF OR IN CONNECTION WITH THE WORK OR THE USE OR OTHER DEALINGS
  21 # IN THE WORK.
  22 #----------------------------------------------------------------------
  23
  24 ##
  25 # SFA uses two crypto libraries: pyOpenSSL and M2Crypto to implement
  26 # the necessary crypto functionality. Ideally just one of these libraries
  27 # would be used, but unfortunately each of these libraries is independently
  28 # lacking. The pyOpenSSL library is missing many necessary functions, and
  29 # the M2Crypto library has crashed inside of some of the functions. The
  30 # design decision is to use pyOpenSSL whenever possible as it seems more
  31 # stable, and only use M2Crypto for those functions that are not possible
  32 # in pyOpenSSL.
  33 #
  34 # This module exports two classes: Keypair and Certificate.
  35 ##
  36 #
  37
  38 import os
  39 import tempfile
  40 import base64
  41 import traceback
  42 from tempfile import mkstemp
  43
  44 from OpenSSL import crypto
  45 import M2Crypto
  46 from M2Crypto import X509
  47
  48 from sfa.util.sfalogging import sfa_logger
  49 from sfa.util.namespace import urn_to_hrn
  50 from sfa.util.faults import *
  51
  52 def convert_public_key(key):
  53     keyconvert_path = "/usr/bin/keyconvert.py"
  54     if not os.path.isfile(keyconvert_path):
  55         raise IOError, "Could not find keyconvert in %s" % keyconvert_path
  56
  57     # we can only convert rsa keys
  58     if "ssh-dss" in key:
  59         return None
  60
  61     (ssh_f, ssh_fn) = tempfile.mkstemp()
  62     ssl_fn = tempfile.mktemp()
  63     os.write(ssh_f, key)
  64     os.close(ssh_f)
  65
  66     cmd = keyconvert_path + " " + ssh_fn + " " + ssl_fn
  67     os.system(cmd)
  68
  69     # this check leaves the temporary file containing the public key so
  70     # that it can be expected to see why it failed.
  71     # TODO: for production, cleanup the temporary files
  72     if not os.path.exists(ssl_fn):
  73         return None
  74
  75     k = Keypair()
  76     try:
  77         k.load_pubkey_from_file(ssl_fn)
  78     except:
  79         sfa_logger().log_exc("convert_public_key caught exception")
  80         k = None
  81
  82     # remove the temporary files
  83     os.remove(ssh_fn)
  84     os.remove(ssl_fn)
  85
  86     return k
  87
  88 ##
  89 # Public-private key pairs are implemented by the Keypair class.
  90 # A Keypair object may represent both a public and private key pair, or it
  91 # may represent only a public key (this usage is consistent with OpenSSL).
  92
  93 class Keypair:
  94     key = None       # public/private keypair
  95     m2key = None     # public key (m2crypto format)
  96
  97     ##
  98     # Creates a Keypair object
  99     # @param create If create==True, creates a new public/private key and
 100     #     stores it in the object
 101     # @param string If string!=None, load the keypair from the string (PEM)
 102     # @param filename If filename!=None, load the keypair from the file
 103
 104     def __init__(self, create=False, string=None, filename=None):
 105         if create:
 106             self.create()
 107         if string:
 108             self.load_from_string(string)
 109         if filename:
 110             self.load_from_file(filename)
 111
 112     ##
 113     # Create a RSA public/private key pair and store it inside the keypair object
 114
 115     def create(self):
 116         self.key = crypto.PKey()
 117         self.key.generate_key(crypto.TYPE_RSA, 1024)
 118
 119     ##
 120     # Save the private key to a file
 121     # @param filename name of file to store the keypair in
 122
 123     def save_to_file(self, filename):
 124         open(filename, 'w').write(self.as_pem())
 125         self.filename=filename
 126
 127     ##
 128     # Load the private key from a file. Implicity the private key includes the public key.
 129
 130     def load_from_file(self, filename):
 131         buffer = open(filename, 'r').read()
 132         self.load_from_string(buffer)
 133         self.filename=filename
 134
 135     ##
 136     # Load the private key from a string. Implicitly the private key includes the public key.
 137
 138     def load_from_string(self, string):
 139         self.key = crypto.load_privatekey(crypto.FILETYPE_PEM, string)
 140         self.m2key = M2Crypto.EVP.load_key_string(string)
 141
 142     ##
 143     #  Load the public key from a string. No private key is loaded.
 144
 145     def load_pubkey_from_file(self, filename):
 146         # load the m2 public key
 147         m2rsakey = M2Crypto.RSA.load_pub_key(filename)
 148         self.m2key = M2Crypto.EVP.PKey()
 149         self.m2key.assign_rsa(m2rsakey)
 150
 151         # create an m2 x509 cert
 152         m2name = M2Crypto.X509.X509_Name()
 153         m2name.add_entry_by_txt(field="CN", type=0x1001, entry="junk", len=-1, loc=-1, set=0)
 154         m2x509 = M2Crypto.X509.X509()
 155         m2x509.set_pubkey(self.m2key)
 156         m2x509.set_serial_number(0)
 157         m2x509.set_issuer_name(m2name)
 158         m2x509.set_subject_name(m2name)
 159         ASN1 = M2Crypto.ASN1.ASN1_UTCTIME()
 160         ASN1.set_time(500)
 161         m2x509.set_not_before(ASN1)
 162         m2x509.set_not_after(ASN1)
 163         junk_key = Keypair(create=True)
 164         m2x509.sign(pkey=junk_key.get_m2_pkey(), md="sha1")
 165
 166         # convert the m2 x509 cert to a pyopenssl x509
 167         m2pem = m2x509.as_pem()
 168         pyx509 = crypto.load_certificate(crypto.FILETYPE_PEM, m2pem)
 169
 170         # get the pyopenssl pkey from the pyopenssl x509
 171         self.key = pyx509.get_pubkey()
 172         self.filename=filename
 173
 174     ##
 175     # Load the public key from a string. No private key is loaded.
 176
 177     def load_pubkey_from_string(self, string):
 178         (f, fn) = tempfile.mkstemp()
 179         os.write(f, string)
 180         os.close(f)
 181         self.load_pubkey_from_file(fn)
 182         os.remove(fn)
 183
 184     ##
 185     # Return the private key in PEM format.
 186
 187     def as_pem(self):
 188         return crypto.dump_privatekey(crypto.FILETYPE_PEM, self.key)
 189
 190     ##
 191     # Return an M2Crypto key object
 192
 193     def get_m2_pkey(self):
 194         if not self.m2key:
 195             self.m2key = M2Crypto.EVP.load_key_string(self.as_pem())
 196         return self.m2key
 197
 198     ##
 199     # Returns a string containing the public key represented by this object.
 200
 201     def get_pubkey_string(self):
 202         m2pkey = self.get_m2_pkey()
 203         return base64.b64encode(m2pkey.as_der())
 204
 205     ##
 206     # Return an OpenSSL pkey object
 207
 208     def get_openssl_pkey(self):
 209         return self.key
 210
 211     ##
 212     # Given another Keypair object, return TRUE if the two keys are the same.
 213
 214     def is_same(self, pkey):
 215         return self.as_pem() == pkey.as_pem()
 216
 217     def sign_string(self, data):
 218         k = self.get_m2_pkey()
 219         k.sign_init()
 220         k.sign_update(data)
 221         return base64.b64encode(k.sign_final())
 222
 223     def verify_string(self, data, sig):
 224         k = self.get_m2_pkey()
 225         k.verify_init()
 226         k.verify_update(data)
 227         return M2Crypto.m2.verify_final(k.ctx, base64.b64decode(sig), k.pkey)
 228
 229     def compute_hash(self, value):
 230         return self.sign_string(str(value))
 231
 232     # only informative
 233     def get_filename(self):
 234         return getattr(self,'filename',None)
 235
 236     def dump (self, *args, **kwargs):
 237         print self.dump_string(*args, **kwargs)
 238
 239     def dump_string (self):
 240         result=""
 241         result += "KEYPAIR: pubkey=%40s..."%self.get_pubkey_string()
 242         filename=self.get_filename()
 243         if filename: result += "Filename %s\n"%filename
 244         return result
 245
 246 ##
 247 # The certificate class implements a general purpose X509 certificate, making
 248 # use of the appropriate pyOpenSSL or M2Crypto abstractions. It also adds
 249 # several addition features, such as the ability to maintain a chain of
 250 # parent certificates, and storage of application-specific data.
 251 #
 252 # Certificates include the ability to maintain a chain of parents. Each
 253 # certificate includes a pointer to it's parent certificate. When loaded
 254 # from a file or a string, the parent chain will be automatically loaded.
 255 # When saving a certificate to a file or a string, the caller can choose
 256 # whether to save the parent certificates as well.
 257
 258 class Certificate:
 259     digest = "md5"
 260
 261     cert = None
 262     issuerKey = None
 263     issuerSubject = None
 264     parent = None
 265
 266     separator="-----parent-----"
 267
 268     ##
 269     # Create a certificate object.
 270     #
 271     # @param create If create==True, then also create a blank X509 certificate.
 272     # @param subject If subject!=None, then create a blank certificate and set
 273     #     it's subject name.
 274     # @param string If string!=None, load the certficate from the string.
 275     # @param filename If filename!=None, load the certficiate from the file.
 276
 277     def __init__(self, create=False, subject=None, string=None, filename=None, intermediate=None):
 278         self.data = {}
 279         if create or subject:
 280             self.create()
 281         if subject:
 282             self.set_subject(subject)
 283         if string:
 284             self.load_from_string(string)
 285         if filename:
 286             self.load_from_file(filename)
 287
 288         if intermediate:
 289             self.set_intermediate_ca(intermediate)
 290
 291     ##
 292     # Create a blank X509 certificate and store it in this object.
 293
 294     def create(self):
 295         self.cert = crypto.X509()
 296         self.cert.set_serial_number(3)
 297         self.cert.gmtime_adj_notBefore(0)
 298         self.cert.gmtime_adj_notAfter(60*60*24*365*5) # five years
 299
 300     ##
 301     # Given a pyOpenSSL X509 object, store that object inside of this
 302     # certificate object.
 303
 304     def load_from_pyopenssl_x509(self, x509):
 305         self.cert = x509
 306
 307     ##
 308     # Load the certificate from a string
 309
 310     def load_from_string(self, string):
 311         # if it is a chain of multiple certs, then split off the first one and
 312         # load it (support for the ---parent--- tag as well as normal chained certs)
 313
 314         string = string.strip()
 315
 316         # If it's not in proper PEM format, wrap it
 317         if string.count('-----BEGIN CERTIFICATE') == 0:
 318             string = '-----BEGIN CERTIFICATE-----\n%s\n-----END CERTIFICATE-----' % string
 319
 320         # If there is a PEM cert in there, but there is some other text first
 321         # such as the text of the certificate, skip the text
 322         beg = string.find('-----BEGIN CERTIFICATE')
 323         if beg > 0:
 324             # skipping over non cert beginning
 325             string = string[beg:]
 326
 327         parts = []
 328
 329         if string.count('-----BEGIN CERTIFICATE-----') > 1 and \
 330                string.count(Certificate.separator) == 0:
 331             parts = string.split('-----END CERTIFICATE-----',1)
 332             parts[0] += '-----END CERTIFICATE-----'
 333         else:
 334             parts = string.split(Certificate.separator, 1)
 335
 336         self.cert = crypto.load_certificate(crypto.FILETYPE_PEM, parts[0])
 337
 338         # if there are more certs, then create a parent and let the parent load
 339         # itself from the remainder of the string
 340         if len(parts) > 1 and parts[1] != '':
 341             self.parent = self.__class__()
 342             self.parent.load_from_string(parts[1])
 343
 344     ##
 345     # Load the certificate from a file
 346
 347     def load_from_file(self, filename):
 348         file = open(filename)
 349         string = file.read()
 350         self.load_from_string(string)
 351         self.filename=filename
 352
 353     ##
 354     # Save the certificate to a string.
 355     #
 356     # @param save_parents If save_parents==True, then also save the parent certificates.
 357
 358     def save_to_string(self, save_parents=True):
 359         string = crypto.dump_certificate(crypto.FILETYPE_PEM, self.cert)
 360         if save_parents and self.parent:
 361             string = string + self.parent.save_to_string(save_parents)
 362         return string
 363
 364     ##
 365     # Save the certificate to a file.
 366     # @param save_parents If save_parents==True, then also save the parent certificates.
 367
 368     def save_to_file(self, filename, save_parents=True, filep=None):
 369         string = self.save_to_string(save_parents=save_parents)
 370         if filep:
 371             f = filep
 372         else:
 373             f = open(filename, 'w')
 374         f.write(string)
 375         f.close()
 376         self.filename=filename
 377
 378     ##
 379     # Save the certificate to a random file in /tmp/
 380     # @param save_parents If save_parents==True, then also save the parent certificates.
 381     def save_to_random_tmp_file(self, save_parents=True):
 382         fp, filename = mkstemp(suffix='cert', text=True)
 383         fp = os.fdopen(fp, "w")
 384         self.save_to_file(filename, save_parents=True, filep=fp)
 385         return filename
 386
 387     ##
 388     # Sets the issuer private key and name
 389     # @param key Keypair object containing the private key of the issuer
 390     # @param subject String containing the name of the issuer
 391     # @param cert (optional) Certificate object containing the name of the issuer
 392
 393     def set_issuer(self, key, subject=None, cert=None):
 394         self.issuerKey = key
 395         if subject:
 396             # it's a mistake to use subject and cert params at the same time
 397             assert(not cert)
 398             if isinstance(subject, dict) or isinstance(subject, str):
 399                 req = crypto.X509Req()
 400                 reqSubject = req.get_subject()
 401                 if (isinstance(subject, dict)):
 402                     for key in reqSubject.keys():
 403                         setattr(reqSubject, key, subject[key])
 404                 else:
 405                     setattr(reqSubject, "CN", subject)
 406                 subject = reqSubject
 407                 # subject is not valid once req is out of scope, so save req
 408                 self.issuerReq = req
 409         if cert:
 410             # if a cert was supplied, then get the subject from the cert
 411             subject = cert.cert.get_subject()
 412         assert(subject)
 413         self.issuerSubject = subject
 414
 415     ##
 416     # Get the issuer name
 417
 418     def get_issuer(self, which="CN"):
 419         x = self.cert.get_issuer()
 420         return getattr(x, which)
 421
 422     ##
 423     # Set the subject name of the certificate
 424
 425     def set_subject(self, name):
 426         req = crypto.X509Req()
 427         subj = req.get_subject()
 428         if (isinstance(name, dict)):
 429             for key in name.keys():
 430                 setattr(subj, key, name[key])
 431         else:
 432             setattr(subj, "CN", name)
 433         self.cert.set_subject(subj)
 434     ##
 435     # Get the subject name of the certificate
 436
 437     def get_subject(self, which="CN"):
 438         x = self.cert.get_subject()
 439         return getattr(x, which)
 440
 441     ##
 442     # Get the public key of the certificate.
 443     #
 444     # @param key Keypair object containing the public key
 445
 446     def set_pubkey(self, key):
 447         assert(isinstance(key, Keypair))
 448         self.cert.set_pubkey(key.get_openssl_pkey())
 449
 450     ##
 451     # Get the public key of the certificate.
 452     # It is returned in the form of a Keypair object.
 453
 454     def get_pubkey(self):
 455         m2x509 = X509.load_cert_string(self.save_to_string())
 456         pkey = Keypair()
 457         pkey.key = self.cert.get_pubkey()
 458         pkey.m2key = m2x509.get_pubkey()
 459         return pkey
 460
 461     def set_intermediate_ca(self, val):
 462         self.intermediate = val
 463         if val:
 464             self.add_extension('basicConstraints', 1, 'CA:TRUE')
 465
 466
 467
 468     ##
 469     # Add an X509 extension to the certificate. Add_extension can only be called
 470     # once for a particular extension name, due to limitations in the underlying
 471     # library.
 472     #
 473     # @param name string containing name of extension
 474     # @param value string containing value of the extension
 475
 476     def add_extension(self, name, critical, value):
 477         ext = crypto.X509Extension (name, critical, value)
 478         self.cert.add_extensions([ext])
 479
 480     ##
 481     # Get an X509 extension from the certificate
 482
 483     def get_extension(self, name):
 484
 485         # pyOpenSSL does not have a way to get extensions
 486         m2x509 = X509.load_cert_string(self.save_to_string())
 487         value = m2x509.get_ext(name).get_value()
 488
 489         return value
 490
 491     ##
 492     # Set_data is a wrapper around add_extension. It stores the parameter str in
 493     # the X509 subject_alt_name extension. Set_data can only be called once, due
 494     # to limitations in the underlying library.
 495
 496     def set_data(self, str, field='subjectAltName'):
 497         # pyOpenSSL only allows us to add extensions, so if we try to set the
 498         # same extension more than once, it will not work
 499         if self.data.has_key(field):
 500             raise "Cannot set ", field, " more than once"
 501         self.data[field] = str
 502         self.add_extension(field, 0, str)
 503
 504     ##
 505     # Return the data string that was previously set with set_data
 506
 507     def get_data(self, field='subjectAltName'):
 508         if self.data.has_key(field):
 509             return self.data[field]
 510
 511         try:
 512             uri = self.get_extension(field)
 513             self.data[field] = uri
 514         except LookupError:
 515             return None
 516
 517         return self.data[field]
 518
 519     ##
 520     # Sign the certificate using the issuer private key and issuer subject previous set with set_issuer().
 521
 522     def sign(self):
 523         sfa_logger().debug('certificate.sign')
 524         assert self.cert != None
 525         assert self.issuerSubject != None
 526         assert self.issuerKey != None
 527         self.cert.set_issuer(self.issuerSubject)
 528         self.cert.sign(self.issuerKey.get_openssl_pkey(), self.digest)
 529
 530     ##
 531     # Verify the authenticity of a certificate.
 532     # @param pkey is a Keypair object representing a public key. If Pkey
 533     #     did not sign the certificate, then an exception will be thrown.
 534
 535     def verify(self, pkey):
 536         # pyOpenSSL does not have a way to verify signatures
 537         m2x509 = X509.load_cert_string(self.save_to_string())
 538         m2pkey = pkey.get_m2_pkey()
 539         # verify it
 540         return m2x509.verify(m2pkey)
 541
 542         # XXX alternatively, if openssl has been patched, do the much simpler:
 543         # try:
 544         #   self.cert.verify(pkey.get_openssl_key())
 545         #   return 1
 546         # except:
 547         #   return 0
 548
 549     ##
 550     # Return True if pkey is identical to the public key that is contained in the certificate.
 551     # @param pkey Keypair object
 552
 553     def is_pubkey(self, pkey):
 554         return self.get_pubkey().is_same(pkey)
 555
 556     ##
 557     # Given a certificate cert, verify that this certificate was signed by the
 558     # public key contained in cert. Throw an exception otherwise.
 559     #
 560     # @param cert certificate object
 561
 562     def is_signed_by_cert(self, cert):
 563         print 'is_signed_by_cert'
 564         k = cert.get_pubkey()
 565         result = self.verify(k)
 566         return result
 567
 568     ##
 569     # Set the parent certficiate.
 570     #
 571     # @param p certificate object.
 572
 573     def set_parent(self, p):
 574         self.parent = p
 575
 576     ##
 577     # Return the certificate object of the parent of this certificate.
 578
 579     def get_parent(self):
 580         return self.parent
 581
 582     ##
 583     # Verification examines a chain of certificates to ensure that each parent
 584     # signs the child, and that some certificate in the chain is signed by a
 585     # trusted certificate.
 586     #
 587     # Verification is a basic recursion: <pre>
 588     #     if this_certificate was signed by trusted_certs:
 589     #         return
 590     #     else
 591     #         return verify_chain(parent, trusted_certs)
 592     # </pre>
 593     #
 594     # At each recursion, the parent is tested to ensure that it did sign the
 595     # child. If a parent did not sign a child, then an exception is thrown. If
 596     # the bottom of the recursion is reached and the certificate does not match
 597     # a trusted root, then an exception is thrown.
 598     #
 599     # @param Trusted_certs is a list of certificates that are trusted.
 600     #
 601
 602     def verify_chain(self, trusted_certs = None):
 603         # Verify a chain of certificates. Each certificate must be signed by
 604         # the public key contained in it's parent. The chain is recursed
 605         # until a certificate is found that is signed by a trusted root.
 606
 607         # verify expiration time
 608         if self.cert.has_expired():
 609             sfa_logger().debug("verify_chain: NO our certificate has expired")
 610             raise CertExpired(self.get_subject(), "client cert")
 611
 612         # if this cert is signed by a trusted_cert, then we are set
 613         for trusted_cert in trusted_certs:
 614             if self.is_signed_by_cert(trusted_cert):
 615                 # verify expiration of trusted_cert ?
 616                 if not trusted_cert.cert.has_expired():
 617                     sfa_logger().debug("verify_chain: YES cert %s signed by trusted cert %s"%(
 618                             self.get_subject(), trusted_cert.get_subject()))
 619                     return trusted_cert
 620                 else:
 621                     sfa_logger().debug("verify_chain: NO cert %s is signed by trusted_cert %s, but this is expired..."%(
 622                             self.get_subject(),trusted_cert.get_subject()))
 623                     raise CertExpired(self.get_subject(),"trusted_cert %s"%trusted_cert.get_subject())
 624
 625         # if there is no parent, then no way to verify the chain
 626         if not self.parent:
 627             sfa_logger().debug("verify_chain: NO %s has no parent and is not in trusted roots"%self.get_subject())
 628             raise CertMissingParent(self.get_subject())
 629
 630         # if it wasn't signed by the parent...
 631         if not self.is_signed_by_cert(self.parent):
 632             sfa_logger().debug("verify_chain: NO %s is not signed by parent"%self.get_subject())
 633             return CertNotSignedByParent(self.get_subject())
 634
 635         # if the parent isn't verified...
 636         sfa_logger().debug("verify_chain: .. %s, -> verifying parent %s",self.get_subject(),self.parent.get_subject())
 637         self.parent.verify_chain(trusted_certs)
 638
 639         return
 640
 641     ### more introspection
 642     def get_extensions(self):
 643         # pyOpenSSL does not have a way to get extensions
 644         triples=[]
 645         m2x509 = X509.load_cert_string(self.save_to_string())
 646         nb_extensions=m2x509.get_ext_count()
 647         sfa_logger().debug("X509 had %d extensions"%nb_extensions)
 648         for i in range(nb_extensions):
 649             ext=m2x509.get_ext_at(i)
 650             triples.append( (ext.get_name(), ext.get_value(), ext.get_critical(),) )
 651         return triples
 652
 653     def get_data_names(self):
 654         return self.data.keys()
 655
 656     def get_all_datas (self):
 657         triples=self.get_extensions()
 658         for name in self.get_data_names():
 659             triples.append( (name,self.get_data(name),'data',) )
 660         return triples
 661
 662     # only informative
 663     def get_filename(self):
 664         return getattr(self,'filename',None)
 665
 666     def dump (self, *args, **kwargs):
 667         print self.dump_string(*args, **kwargs)
 668
 669     def dump_string (self,show_extensions=False):
 670         result = ""
 671         result += "CERTIFICATE for %s\n"%self.get_subject()
 672         result += "Issued by %s\n"%self.get_issuer()
 673         filename=self.get_filename()
 674         if filename: result += "Filename %s\n"%filename
 675         if show_extensions:
 676             all_datas=self.get_all_datas()
 677             result += " has %d extensions/data attached"%len(all_datas)
 678             for (n,v,c) in all_datas:
 679                 if c=='data':
 680                     result += "   data: %s=%s\n"%(n,v)
 681                 else:
 682                     result += "    ext: %s (crit=%s)=<<<%s>>>\n"%(n,c,v)
 683         return result