home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / M2Crypto / X509.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  28.3 KB  |  774 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from M2Crypto import ASN1, BIO, Err, EVP, util
  5. import m2
  6. FORMAT_DER = 0
  7. FORMAT_PEM = 1
  8.  
  9. class X509Error(Exception):
  10.     pass
  11.  
  12. m2.x509_init(X509Error)
  13. V_OK = m2.X509_V_OK
  14.  
  15. def new_extension(name, value, critical = 0, _pyfree = 1):
  16.     if name == 'subjectKeyIdentifier' and value.strip('0123456789abcdefABCDEF:') is not '':
  17.         raise ValueError('value must be precomputed hash')
  18.     
  19.     lhash = m2.x509v3_lhash()
  20.     ctx = m2.x509v3_set_conf_lhash(lhash)
  21.     x509_ext_ptr = m2.x509v3_ext_conf(lhash, ctx, name, value)
  22.     x509_ext = X509_Extension(x509_ext_ptr, _pyfree)
  23.     x509_ext.set_critical(critical)
  24.     return x509_ext
  25.  
  26.  
  27. class X509_Extension:
  28.     m2_x509_extension_free = m2.x509_extension_free
  29.     
  30.     def __init__(self, x509_ext_ptr = None, _pyfree = 1):
  31.         self.x509_ext = x509_ext_ptr
  32.         self._pyfree = _pyfree
  33.  
  34.     
  35.     def __del__(self):
  36.         if getattr(self, '_pyfree', 0) and self.x509_ext:
  37.             self.m2_x509_extension_free(self.x509_ext)
  38.         
  39.  
  40.     
  41.     def _ptr(self):
  42.         return self.x509_ext
  43.  
  44.     
  45.     def set_critical(self, critical = 1):
  46.         return m2.x509_extension_set_critical(self.x509_ext, critical)
  47.  
  48.     
  49.     def get_critical(self):
  50.         return m2.x509_extension_get_critical(self.x509_ext)
  51.  
  52.     
  53.     def get_name(self):
  54.         return m2.x509_extension_get_name(self.x509_ext)
  55.  
  56.     
  57.     def get_value(self, flag = 0, indent = 0):
  58.         buf = BIO.MemoryBuffer()
  59.         m2.x509_ext_print(buf.bio_ptr(), self.x509_ext, flag, indent)
  60.         return buf.read_all()
  61.  
  62.  
  63.  
  64. class X509_Extension_Stack:
  65.     m2_sk_x509_extension_free = m2.sk_x509_extension_free
  66.     
  67.     def __init__(self, stack = None, _pyfree = 0):
  68.         if stack is not None:
  69.             self.stack = stack
  70.             self._pyfree = _pyfree
  71.             num = m2.sk_x509_extension_num(self.stack)
  72.             for i in range(num):
  73.                 self.pystack.append(X509_Extension(m2.sk_x509_extension_value(self.stack, i), _pyfree = _pyfree))
  74.             
  75.         else:
  76.             self.stack = m2.sk_x509_extension_new_null()
  77.             self._pyfree = 1
  78.             self.pystack = []
  79.  
  80.     
  81.     def __del__(self):
  82.         if getattr(self, '_pyfree', 0):
  83.             self.m2_sk_x509_extension_free(self.stack)
  84.         
  85.  
  86.     
  87.     def __len__(self):
  88.         return len(self.pystack)
  89.  
  90.     
  91.     def __getitem__(self, idx):
  92.         return self.pystack[idx]
  93.  
  94.     
  95.     def __iter__(self):
  96.         return iter(self.pystack)
  97.  
  98.     
  99.     def _ptr(self):
  100.         return self.stack
  101.  
  102.     
  103.     def push(self, x509_ext):
  104.         self.pystack.append(x509_ext)
  105.         ret = m2.sk_x509_extension_push(self.stack, x509_ext._ptr())
  106.         return ret
  107.  
  108.     
  109.     def pop(self):
  110.         x509_ext_ptr = m2.sk_x509_extension_pop(self.stack)
  111.         if x509_ext_ptr is None:
  112.             return None
  113.         
  114.         return self.pystack.pop()
  115.  
  116.  
  117.  
  118. class X509_Name_Entry:
  119.     m2_x509_name_entry_free = m2.x509_name_entry_free
  120.     
  121.     def __init__(self, x509_name_entry, _pyfree = 0):
  122.         self.x509_name_entry = x509_name_entry
  123.         self._pyfree = _pyfree
  124.  
  125.     
  126.     def __del__(self):
  127.         if getattr(self, '_pyfree', 0):
  128.             self.m2_x509_name_entry_free(self.x509_name_entry)
  129.         
  130.  
  131.     
  132.     def _ptr(self):
  133.         return self.x509_name_entry
  134.  
  135.     
  136.     def set_object(self, asn1obj):
  137.         return m2.x509_name_entry_set_object(self.x509_name_entry, asn1obj._ptr())
  138.  
  139.     
  140.     def set_data(self, data, type = ASN1.MBSTRING_ASC):
  141.         return m2.x509_name_entry_set_data(self.x509_name_entry, type, data)
  142.  
  143.     
  144.     def get_object(self):
  145.         return ASN1.ASN1_Object(m2.x509_name_entry_get_object(self.x509_name_entry))
  146.  
  147.     
  148.     def get_data(self):
  149.         return ASN1.ASN1_String(m2.x509_name_entry_get_data(self.x509_name_entry))
  150.  
  151.     
  152.     def create_by_txt(self, field, type, entry, len):
  153.         return m2.x509_name_entry_create_by_txt(self.x509_name_entry._ptr(), field, type, entry, len)
  154.  
  155.  
  156.  
  157. class X509_Name:
  158.     nid = {
  159.         'C': m2.NID_countryName,
  160.         'SP': m2.NID_stateOrProvinceName,
  161.         'ST': m2.NID_stateOrProvinceName,
  162.         'stateOrProvinceName': m2.NID_stateOrProvinceName,
  163.         'L': m2.NID_localityName,
  164.         'localityName': m2.NID_localityName,
  165.         'O': m2.NID_organizationName,
  166.         'organizationName': m2.NID_organizationName,
  167.         'OU': m2.NID_organizationalUnitName,
  168.         'organizationUnitName': m2.NID_organizationalUnitName,
  169.         'CN': m2.NID_commonName,
  170.         'commonName': m2.NID_commonName,
  171.         'Email': m2.NID_pkcs9_emailAddress,
  172.         'emailAddress': m2.NID_pkcs9_emailAddress,
  173.         'serialNumber': m2.NID_serialNumber,
  174.         'SN': m2.NID_surname,
  175.         'surname': m2.NID_surname,
  176.         'GN': m2.NID_givenName,
  177.         'givenName': m2.NID_givenName }
  178.     m2_x509_name_free = m2.x509_name_free
  179.     
  180.     def __init__(self, x509_name = None, _pyfree = 0):
  181.         if x509_name is not None:
  182.             self.x509_name = x509_name
  183.             self._pyfree = _pyfree
  184.         else:
  185.             self.x509_name = m2.x509_name_new()
  186.             self._pyfree = 1
  187.  
  188.     
  189.     def __del__(self):
  190.         if getattr(self, '_pyfree', 0):
  191.             self.m2_x509_name_free(self.x509_name)
  192.         
  193.  
  194.     
  195.     def __str__(self):
  196.         return m2.x509_name_oneline(self.x509_name)
  197.  
  198.     
  199.     def __getattr__(self, attr):
  200.         if attr in self.nid:
  201.             return m2.x509_name_by_nid(self.x509_name, self.nid[attr])
  202.         
  203.         if attr in self.__dict__:
  204.             return self.__dict__[attr]
  205.         
  206.         raise AttributeError, (self, attr)
  207.  
  208.     
  209.     def __setattr__(self, attr, value):
  210.         if attr in self.nid:
  211.             return m2.x509_name_set_by_nid(self.x509_name, self.nid[attr], value)
  212.         
  213.         self.__dict__[attr] = value
  214.  
  215.     
  216.     def __len__(self):
  217.         return m2.x509_name_entry_count(self.x509_name)
  218.  
  219.     
  220.     def __getitem__(self, idx):
  221.         if idx <= idx:
  222.             pass
  223.         elif not idx < self.entry_count():
  224.             raise IndexError('index out of range')
  225.         
  226.         return X509_Name_Entry(m2.x509_name_get_entry(self.x509_name, idx))
  227.  
  228.     
  229.     def __iter__(self):
  230.         for i in xrange(self.entry_count()):
  231.             yield self[i]
  232.         
  233.  
  234.     
  235.     def _ptr(self):
  236.         return self.x509_name
  237.  
  238.     
  239.     def add_entry_by_txt(self, field, type, entry, len, loc, set):
  240.         return m2.x509_name_add_entry_by_txt(self.x509_name, field, type, entry, len, loc, set)
  241.  
  242.     
  243.     def entry_count(self):
  244.         return m2.x509_name_entry_count(self.x509_name)
  245.  
  246.     
  247.     def get_entries_by_nid(self, nid):
  248.         ret = []
  249.         lastpos = -1
  250.         while True:
  251.             lastpos = m2.x509_name_get_index_by_nid(self.x509_name, nid, lastpos)
  252.             if lastpos == -1:
  253.                 break
  254.             
  255.             ret.append(self[lastpos])
  256.         return ret
  257.  
  258.     
  259.     def as_text(self, indent = 0, flags = m2.XN_FLAG_COMPAT):
  260.         buf = BIO.MemoryBuffer()
  261.         m2.x509_name_print_ex(buf.bio_ptr(), self.x509_name, indent, flags)
  262.         return buf.read_all()
  263.  
  264.     
  265.     def as_der(self):
  266.         return m2.x509_name_get_der(self.x509_name)
  267.  
  268.     
  269.     def as_hash(self):
  270.         return m2.x509_name_hash(self.x509_name)
  271.  
  272.  
  273.  
  274. class X509:
  275.     m2_x509_free = m2.x509_free
  276.     
  277.     def __init__(self, x509 = None, _pyfree = 0):
  278.         if x509 is not None:
  279.             self.x509 = x509
  280.             self._pyfree = _pyfree
  281.         else:
  282.             self.x509 = m2.x509_new()
  283.             self._pyfree = 1
  284.  
  285.     
  286.     def __del__(self):
  287.         if getattr(self, '_pyfree', 0):
  288.             self.m2_x509_free(self.x509)
  289.         
  290.  
  291.     
  292.     def _ptr(self):
  293.         return self.x509
  294.  
  295.     
  296.     def as_text(self):
  297.         buf = BIO.MemoryBuffer()
  298.         m2.x509_print(buf.bio_ptr(), self.x509)
  299.         return buf.read_all()
  300.  
  301.     
  302.     def as_der(self):
  303.         return m2.i2d_x509(self.x509)
  304.  
  305.     
  306.     def as_pem(self):
  307.         buf = BIO.MemoryBuffer()
  308.         m2.x509_write_pem(buf.bio_ptr(), self.x509)
  309.         return buf.read_all()
  310.  
  311.     
  312.     def save_pem(self, filename):
  313.         bio = BIO.openfile(filename, 'wb')
  314.         return m2.x509_write_pem(bio.bio_ptr(), self.x509)
  315.  
  316.     
  317.     def save(self, filename, format = FORMAT_PEM):
  318.         bio = BIO.openfile(filename, 'wb')
  319.         if format == FORMAT_PEM:
  320.             return m2.x509_write_pem(bio.bio_ptr(), self.x509)
  321.         elif format == FORMAT_DER:
  322.             return m2.i2d_x509_bio(bio.bio_ptr(), self.x509)
  323.         else:
  324.             raise ValueError('Unknown filetype. Must be either FORMAT_PEM or FORMAT_DER')
  325.  
  326.     
  327.     def set_version(self, version):
  328.         return m2.x509_set_version(self.x509, version)
  329.  
  330.     
  331.     def set_not_before(self, asn1_utctime):
  332.         return m2.x509_set_not_before(self.x509, asn1_utctime._ptr())
  333.  
  334.     
  335.     def set_not_after(self, asn1_utctime):
  336.         return m2.x509_set_not_after(self.x509, asn1_utctime._ptr())
  337.  
  338.     
  339.     def set_subject_name(self, name):
  340.         return m2.x509_set_subject_name(self.x509, name.x509_name)
  341.  
  342.     
  343.     def set_issuer_name(self, name):
  344.         return m2.x509_set_issuer_name(self.x509, name.x509_name)
  345.  
  346.     
  347.     def get_version(self):
  348.         return m2.x509_get_version(self.x509)
  349.  
  350.     
  351.     def get_serial_number(self):
  352.         asn1_integer = m2.x509_get_serial_number(self.x509)
  353.         return m2.asn1_integer_get(asn1_integer)
  354.  
  355.     
  356.     def set_serial_number(self, serial):
  357.         asn1_integer = m2.x509_get_serial_number(self.x509)
  358.         return m2.asn1_integer_set(asn1_integer, serial)
  359.  
  360.     
  361.     def get_not_before(self):
  362.         return ASN1.ASN1_UTCTIME(m2.x509_get_not_before(self.x509))
  363.  
  364.     
  365.     def get_not_after(self):
  366.         return ASN1.ASN1_UTCTIME(m2.x509_get_not_after(self.x509))
  367.  
  368.     
  369.     def get_pubkey(self):
  370.         return EVP.PKey(m2.x509_get_pubkey(self.x509), _pyfree = 1)
  371.  
  372.     
  373.     def set_pubkey(self, pkey):
  374.         return m2.x509_set_pubkey(self.x509, pkey.pkey)
  375.  
  376.     
  377.     def get_issuer(self):
  378.         return X509_Name(m2.x509_get_issuer_name(self.x509))
  379.  
  380.     
  381.     def set_issuer(self, name):
  382.         return m2.x509_set_issuer_name(self.x509, name.x509_name)
  383.  
  384.     
  385.     def get_subject(self):
  386.         return X509_Name(m2.x509_get_subject_name(self.x509))
  387.  
  388.     
  389.     def set_subject(self, name):
  390.         return m2.x509_set_subject_name(self.x509, name.x509_name)
  391.  
  392.     
  393.     def add_ext(self, ext):
  394.         return m2.x509_add_ext(self.x509, ext.x509_ext, -1)
  395.  
  396.     
  397.     def get_ext(self, name):
  398.         m2x509_get_ext = m2.x509_get_ext
  399.         m2x509_extension_get_name = m2.x509_extension_get_name
  400.         x509 = self.x509
  401.         for i in range(m2.x509_get_ext_count(x509)):
  402.             extPtr = m2x509_get_ext(x509, i)
  403.             if m2x509_extension_get_name(extPtr) == name:
  404.                 return X509_Extension(extPtr, _pyfree = 0)
  405.                 continue
  406.         
  407.         raise LookupError
  408.  
  409.     
  410.     def get_ext_at(self, index):
  411.         if index < 0 or index >= self.get_ext_count():
  412.             raise IndexError
  413.         
  414.         return X509_Extension(m2.x509_get_ext(self.x509, index), _pyfree = 0)
  415.  
  416.     
  417.     def get_ext_count(self):
  418.         return m2.x509_get_ext_count(self.x509)
  419.  
  420.     
  421.     def sign(self, pkey, md):
  422.         mda = getattr(m2, md, None)
  423.         if mda is None:
  424.             raise ValueError, ('unknown message digest', md)
  425.         
  426.         return m2.x509_sign(self.x509, pkey.pkey, mda())
  427.  
  428.     
  429.     def verify(self, pkey = None):
  430.         if pkey:
  431.             return m2.x509_verify(self.x509, pkey.pkey)
  432.         else:
  433.             return m2.x509_verify(self.x509, self.get_pubkey().pkey)
  434.  
  435.     
  436.     def check_ca(self):
  437.         return m2.x509_check_ca(self.x509)
  438.  
  439.     
  440.     def check_purpose(self, id, ca):
  441.         return m2.x509_check_purpose(self.x509, id, ca)
  442.  
  443.     
  444.     def get_fingerprint(self, md = 'md5'):
  445.         der = self.as_der()
  446.         md = EVP.MessageDigest(md)
  447.         md.update(der)
  448.         digest = md.final()
  449.         return hex(util.octx_to_num(digest))[2:-1].upper()
  450.  
  451.  
  452.  
  453. def load_cert(file, format = FORMAT_PEM):
  454.     bio = BIO.openfile(file)
  455.     if format == FORMAT_PEM:
  456.         return load_cert_bio(bio)
  457.     elif format == FORMAT_DER:
  458.         cptr = m2.d2i_x509(bio._ptr())
  459.         if cptr is None:
  460.             raise X509Error(Err.get_error())
  461.         
  462.         return X509(cptr, _pyfree = 1)
  463.     else:
  464.         raise ValueError('Unknown format. Must be either FORMAT_DER or FORMAT_PEM')
  465.  
  466.  
  467. def load_cert_bio(bio, format = FORMAT_PEM):
  468.     if format == FORMAT_PEM:
  469.         cptr = m2.x509_read_pem(bio._ptr())
  470.     elif format == FORMAT_DER:
  471.         cptr = m2.d2i_x509(bio._ptr())
  472.     else:
  473.         raise ValueError('Unknown format. Must be either FORMAT_DER or FORMAT_PEM')
  474.     if cptr is None:
  475.         raise X509Error(Err.get_error())
  476.     
  477.     return X509(cptr, _pyfree = 1)
  478.  
  479.  
  480. def load_cert_string(string, format = FORMAT_PEM):
  481.     bio = BIO.MemoryBuffer(string)
  482.     return load_cert_bio(bio, format)
  483.  
  484.  
  485. def load_cert_der_string(string):
  486.     bio = BIO.MemoryBuffer(string)
  487.     cptr = m2.d2i_x509(bio._ptr())
  488.     if cptr is None:
  489.         raise X509Error(Err.get_error())
  490.     
  491.     return X509(cptr, _pyfree = 1)
  492.  
  493.  
  494. class X509_Store_Context:
  495.     m2_x509_store_ctx_free = m2.x509_store_ctx_free
  496.     
  497.     def __init__(self, x509_store_ctx, _pyfree = 0):
  498.         self.ctx = x509_store_ctx
  499.         self._pyfree = _pyfree
  500.  
  501.     
  502.     def __del__(self):
  503.         if self._pyfree:
  504.             self.m2_x509_store_ctx_free(self.ctx)
  505.         
  506.  
  507.     
  508.     def _ptr(self):
  509.         return self.ctx
  510.  
  511.     
  512.     def get_current_cert(self):
  513.         return X509(m2.x509_store_ctx_get_current_cert(self.ctx), _pyfree = 0)
  514.  
  515.     
  516.     def get_error(self):
  517.         return m2.x509_store_ctx_get_error(self.ctx)
  518.  
  519.     
  520.     def get_error_depth(self):
  521.         return m2.x509_store_ctx_get_error_depth(self.ctx)
  522.  
  523.     
  524.     def get1_chain(self):
  525.         return X509_Stack(m2.x509_store_ctx_get1_chain(self.ctx), 1, 1)
  526.  
  527.  
  528.  
  529. class X509_Store:
  530.     m2_x509_store_free = m2.x509_store_free
  531.     
  532.     def __init__(self, store = None, _pyfree = 0):
  533.         if store is not None:
  534.             self.store = store
  535.             self._pyfree = _pyfree
  536.         else:
  537.             self.store = m2.x509_store_new()
  538.             self._pyfree = 1
  539.  
  540.     
  541.     def __del__(self):
  542.         if getattr(self, '_pyfree', 0):
  543.             self.m2_x509_store_free(self.store)
  544.         
  545.  
  546.     
  547.     def _ptr(self):
  548.         return self.store
  549.  
  550.     
  551.     def load_info(self, file):
  552.         ret = m2.x509_store_load_locations(self.store, file)
  553.         if ret < 1:
  554.             raise X509Error(Err.get_error())
  555.         
  556.         return ret
  557.  
  558.     load_locations = load_info
  559.     
  560.     def add_x509(self, x509):
  561.         return m2.x509_store_add_cert(self.store, x509._ptr())
  562.  
  563.     add_cert = add_x509
  564.  
  565.  
  566. class X509_Stack:
  567.     m2_sk_x509_free = m2.sk_x509_free
  568.     
  569.     def __init__(self, stack = None, _pyfree = 0, _pyfree_x509 = 0):
  570.         if stack is not None:
  571.             self.stack = stack
  572.             self._pyfree = _pyfree
  573.             self.pystack = []
  574.             num = m2.sk_x509_num(self.stack)
  575.             for i in range(num):
  576.                 self.pystack.append(X509(m2.sk_x509_value(self.stack, i), _pyfree = _pyfree_x509))
  577.             
  578.         else:
  579.             self.stack = m2.sk_x509_new_null()
  580.             self._pyfree = 1
  581.             self.pystack = []
  582.  
  583.     
  584.     def __del__(self):
  585.         if getattr(self, '_pyfree', 0):
  586.             self.m2_sk_x509_free(self.stack)
  587.         
  588.  
  589.     
  590.     def __len__(self):
  591.         return len(self.pystack)
  592.  
  593.     
  594.     def __getitem__(self, idx):
  595.         return self.pystack[idx]
  596.  
  597.     
  598.     def __iter__(self):
  599.         return iter(self.pystack)
  600.  
  601.     
  602.     def _ptr(self):
  603.         return self.stack
  604.  
  605.     
  606.     def push(self, x509):
  607.         self.pystack.append(x509)
  608.         ret = m2.sk_x509_push(self.stack, x509._ptr())
  609.         return ret
  610.  
  611.     
  612.     def pop(self):
  613.         x509_ptr = m2.sk_x509_pop(self.stack)
  614.         if x509_ptr is None:
  615.             return None
  616.         
  617.         return self.pystack.pop()
  618.  
  619.     
  620.     def as_der(self):
  621.         return m2.get_der_encoding_stack(self.stack)
  622.  
  623.  
  624.  
  625. def new_stack_from_der(der_string):
  626.     stack_ptr = m2.make_stack_from_der_sequence(der_string)
  627.     if stack_ptr is None:
  628.         raise X509Error(Err.get_error())
  629.     
  630.     return X509_Stack(stack_ptr, 1, 1)
  631.  
  632.  
  633. class Request:
  634.     m2_x509_req_free = m2.x509_req_free
  635.     
  636.     def __init__(self, req = None, _pyfree = 0):
  637.         if req is not None:
  638.             self.req = req
  639.             self._pyfree = _pyfree
  640.         else:
  641.             self.req = m2.x509_req_new()
  642.             self._pyfree = 1
  643.  
  644.     
  645.     def __del__(self):
  646.         if getattr(self, '_pyfree', 0):
  647.             self.m2_x509_req_free(self.req)
  648.         
  649.  
  650.     
  651.     def as_text(self):
  652.         buf = BIO.MemoryBuffer()
  653.         m2.x509_req_print(buf.bio_ptr(), self.req)
  654.         return buf.read_all()
  655.  
  656.     
  657.     def as_pem(self):
  658.         buf = BIO.MemoryBuffer()
  659.         m2.x509_req_write_pem(buf.bio_ptr(), self.req)
  660.         return buf.read_all()
  661.  
  662.     
  663.     def as_der(self):
  664.         buf = BIO.MemoryBuffer()
  665.         m2.i2d_x509_req_bio(buf.bio_ptr(), self.req)
  666.         return buf.read_all()
  667.  
  668.     
  669.     def save_pem(self, filename):
  670.         bio = BIO.openfile(filename, 'wb')
  671.         return m2.x509_req_write_pem(bio.bio_ptr(), self.req)
  672.  
  673.     
  674.     def save(self, filename, format = FORMAT_PEM):
  675.         bio = BIO.openfile(filename, 'wb')
  676.         if format == FORMAT_PEM:
  677.             return m2.x509_req_write_pem(bio.bio_ptr(), self.req)
  678.         elif format == FORMAT_DER:
  679.             return m2.i2d_x509_req_bio(bio.bio_ptr(), self.req)
  680.         else:
  681.             raise ValueError('Unknown filetype. Must be either FORMAT_DER or FORMAT_PEM')
  682.  
  683.     
  684.     def get_pubkey(self):
  685.         return EVP.PKey(m2.x509_req_get_pubkey(self.req), _pyfree = 1)
  686.  
  687.     
  688.     def set_pubkey(self, pkey):
  689.         return m2.x509_req_set_pubkey(self.req, pkey.pkey)
  690.  
  691.     
  692.     def get_version(self):
  693.         return m2.x509_req_get_version(self.req)
  694.  
  695.     
  696.     def set_version(self, version):
  697.         return m2.x509_req_set_version(self.req, version)
  698.  
  699.     
  700.     def get_subject(self):
  701.         return X509_Name(m2.x509_req_get_subject_name(self.req))
  702.  
  703.     
  704.     def set_subject_name(self, name):
  705.         return m2.x509_req_set_subject_name(self.req, name.x509_name)
  706.  
  707.     
  708.     def add_extensions(self, ext_stack):
  709.         return m2.x509_req_add_extensions(self.req, ext_stack._ptr())
  710.  
  711.     
  712.     def verify(self, pkey):
  713.         return m2.x509_req_verify(self.req, pkey.pkey)
  714.  
  715.     
  716.     def sign(self, pkey, md):
  717.         mda = getattr(m2, md, None)
  718.         if mda is None:
  719.             raise ValueError, ('unknown message digest', md)
  720.         
  721.         return m2.x509_req_sign(self.req, pkey.pkey, mda())
  722.  
  723.  
  724.  
  725. def load_request(file, format = FORMAT_PEM):
  726.     f = BIO.openfile(file)
  727.     if format == FORMAT_PEM:
  728.         cptr = m2.x509_req_read_pem(f.bio_ptr())
  729.     elif format == FORMAT_DER:
  730.         cptr = m2.d2i_x509_req(f.bio_ptr())
  731.     else:
  732.         raise ValueError('Unknown filetype. Must be either FORMAT_PEM or FORMAT_DER')
  733.     f.close()
  734.     if cptr is None:
  735.         raise X509Error(Err.get_error())
  736.     
  737.     return Request(cptr, 1)
  738.  
  739.  
  740. class CRL:
  741.     m2_x509_crl_free = m2.x509_crl_free
  742.     
  743.     def __init__(self, crl = None, _pyfree = 0):
  744.         if crl is not None:
  745.             self.crl = crl
  746.             self._pyfree = _pyfree
  747.         else:
  748.             self.crl = m2.x509_crl_new()
  749.             self._pyfree = 1
  750.  
  751.     
  752.     def __del__(self):
  753.         if getattr(self, '_pyfree', 0):
  754.             self.m2_x509_crl_free(self.crl)
  755.         
  756.  
  757.     
  758.     def as_text(self):
  759.         buf = BIO.MemoryBuffer()
  760.         m2.x509_crl_print(buf.bio_ptr(), self.crl)
  761.         return buf.read_all()
  762.  
  763.  
  764.  
  765. def load_crl(file):
  766.     f = BIO.openfile(file)
  767.     cptr = m2.x509_crl_read_pem(f.bio_ptr())
  768.     f.close()
  769.     if cptr is None:
  770.         raise X509Error(Err.get_error())
  771.     
  772.     return CRL(cptr, 1)
  773.  
  774.