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