FM / M2Crypto

/usr/lib64/python2.6/site-packages/M2Crypto/

/usr/lib64/python2.6/site-packages/M2Crypto

Name	Size	Mode	Actions
PGP/	-	0755	rm
SSL/	-	0755	rm
ASN1.py	5614	0644	edit dl rm
ASN1.pyc	9462	0644	edit dl rm
ASN1.pyo	9063	0644	edit dl rm
AuthCookie.py	3085	0644	edit dl rm
AuthCookie.pyc	5339	0644	edit dl rm
AuthCookie.pyo	5275	0644	edit dl rm
BIO.py	7389	0644	edit dl rm
BIO.pyc	12186	0644	edit dl rm
BIO.pyo	12186	0644	edit dl rm
BN.py	1330	0644	edit dl rm
BN.pyc	1873	0644	edit dl rm
BN.pyo	1873	0644	edit dl rm
callback.py	249	0644	edit dl rm
callback.pyc	475	0644	edit dl rm
callback.pyo	475	0644	edit dl rm
DH.py	2374	0644	edit dl rm
DH.pyc	4681	0644	edit dl rm
DH.pyo	4248	0644	edit dl rm
DSA.py	14019	0644	edit dl rm
DSA.pyc	17433	0644	edit dl rm
DSA.pyo	16845	0644	edit dl rm
EC.py	10916	0644	edit dl rm
EC.pyc	13287	0644	edit dl rm
EC.pyo	12683	0644	edit dl rm
Engine.py	3397	0644	edit dl rm
Engine.pyc	5492	0644	edit dl rm
Engine.pyo	5492	0644	edit dl rm
Err.py	1123	0644	edit dl rm
Err.pyc	2687	0644	edit dl rm
Err.pyo	2687	0644	edit dl rm
EVP.py	11810	0644	edit dl rm
EVP.pyc	16643	0644	edit dl rm
EVP.pyo	16643	0644	edit dl rm
ftpslib.py	2881	0644	edit dl rm
ftpslib.pyc	3946	0644	edit dl rm
ftpslib.pyo	3946	0644	edit dl rm
httpslib.py	7861	0644	edit dl rm
httpslib.pyc	7797	0644	edit dl rm
httpslib.pyo	7699	0644	edit dl rm
m2.py	785	0644	edit dl rm
m2.pyc	963	0644	edit dl rm
m2.pyo	963	0644	edit dl rm
m2urllib.py	2124	0644	edit dl rm
m2urllib.pyc	2177	0644	edit dl rm
m2urllib.pyo	2177	0644	edit dl rm
m2urllib2.py	5269	0644	edit dl rm
m2urllib2.pyc	5120	0644	edit dl rm
m2urllib2.pyo	5065	0644	edit dl rm
m2xmlrpclib.py	1928	0644	edit dl rm
m2xmlrpclib.pyc	2318	0644	edit dl rm
m2xmlrpclib.pyo	2318	0644	edit dl rm
Rand.py	488	0644	edit dl rm
Rand.pyc	583	0644	edit dl rm
Rand.pyo	583	0644	edit dl rm
RC4.py	692	0644	edit dl rm
RC4.pyc	1634	0644	edit dl rm
RC4.pyo	1634	0644	edit dl rm
RSA.py	13128	0644	edit dl rm
RSA.pyc	17393	0644	edit dl rm
RSA.pyo	16991	0644	edit dl rm
SMIME.py	7479	0644	edit dl rm
SMIME.pyc	10955	0644	edit dl rm
SMIME.pyo	10667	0644	edit dl rm
threading.py	347	0644	edit dl rm
threading.pyc	789	0644	edit dl rm
threading.pyo	789	0644	edit dl rm
util.py	1588	0644	edit dl rm
util.pyc	3081	0644	edit dl rm
util.pyo	3081	0644	edit dl rm
X509.py	34646	0644	edit dl rm
X509.pyc	47271	0644	edit dl rm
X509.pyo	44913	0644	edit dl rm
__init__.py	1421	0644	edit dl rm
__init__.pyc	1980	0644	edit dl rm
__init__.pyo	1980	0644	edit dl rm
__m2crypto.so	445064	0644	edit dl rm

Edit: /usr/lib64/python2.6/site-packages/M2Crypto/DSA.py (14019B)

"""
    M2Crypto wrapper for OpenSSL DSA API.

Portions created by Open Source Applications Foundation (OSAF) are
    Copyright (C) 2004 OSAF. All Rights Reserved.
"""

import sys
import util, BIO, m2

class DSAError(Exception): pass

m2.dsa_init(DSAError)

class DSA:

"""
    This class is a context supporting DSA key and parameter
    values, signing and verifying.
    
    Simple example::
    
        from M2Crypto import EVP, DSA, util
        
        message = 'Kilroy was here!'
        md = EVP.MessageDigest('sha1')
        md.update(message)        
        digest = md.final()
        
        dsa = DSA.gen_params(1024)
        dsa.gen_key()
        r, s = dsa.sign(digest)
        good = dsa.verify(digest, r, s)
        if good:
            print '  ** success **'
        else:
            print '  ** verification failed **'
    """

m2_dsa_free = m2.dsa_free

def __init__(self, dsa, _pyfree=0):
        """
        Use one of the factory functions to create an instance.
        """
        assert m2.dsa_type_check(dsa), "'dsa' type error"
        self.dsa = dsa
        self._pyfree = _pyfree
        
    def __del__(self):
        if getattr(self, '_pyfree', 0):
            self.m2_dsa_free(self.dsa)

def __len__(self):
        """
        Return the key length.
    
        @rtype:   int
        @return:  the DSA key length in bits
        """
        assert m2.dsa_type_check(self.dsa), "'dsa' type error"
        return m2.dsa_keylen(self.dsa)

def __getattr__(self, name):
        """
        Return specified DSA parameters and key values.
    
        @type  name: str
        @param name: name of variable to be returned.  Must be 
                     one of 'p', 'q', 'g', 'pub', 'priv'.
        @rtype:      str
        @return:     value of specified variable (a "byte string")
        """
        if name in ['p', 'q', 'g', 'pub', 'priv']:
            method = getattr(m2, 'dsa_get_%s' % (name,))
            assert m2.dsa_type_check(self.dsa), "'dsa' type error"
            return method(self.dsa)
        else:
            raise AttributeError

def __setattr__(self, name, value):
        if name in ['p', 'q', 'g']:
            raise DSAError('set (p, q, g) via set_params()')
        elif name in ['pub','priv']:
            raise DSAError('generate (pub, priv) via gen_key()')
        else:
            self.__dict__[name] = value

def set_params(self, p, q, g):
        """
        Set new parameters.
        
        @warning: This does not change the private key, so it may be
                  unsafe to use this method. It is better to use
                  gen_params function to create a new DSA object.
        """
        m2.dsa_set_p(self.dsa, p)
        m2.dsa_set_q(self.dsa, q)
        m2.dsa_set_g(self.dsa, g)

def gen_key(self):
        """
        Generate a key pair.
        """
        assert m2.dsa_type_check(self.dsa), "'dsa' type error"
        m2.dsa_gen_key(self.dsa)

def save_params(self, filename):
        """
        Save the DSA parameters to a file.
    
        @type  filename: str
        @param filename: Save the DSA parameters to this file.
        @return:         1 (true) if successful
        """
        bio = BIO.openfile(filename, 'wb')
        ret = m2.dsa_write_params_bio(self.dsa, bio._ptr())
        bio.close()
        return ret

def save_params_bio(self, bio):
        """
        Save DSA parameters to a BIO object.
    
        @type  bio: M2Crypto.BIO object
        @param bio: Save DSA parameters to this object.
        @return:    1 (true) if successful
        """
        return m2.dsa_write_params_bio(self.dsa, bio._ptr())

def save_key(self, filename, cipher='aes_128_cbc', 
                 callback=util.passphrase_callback):
        """
        Save the DSA key pair to a file.
    
        @type  filename: str
        @param filename: Save the DSA key pair to this file.
        @type  cipher:   str
        @param cipher:   name of symmetric key algorithm and mode
                         to encrypt the private key.
        @return:         1 (true) if successful
        """
        bio = BIO.openfile(filename, 'wb')
        ret = self.save_key_bio(bio, cipher, callback)
        bio.close()
        return ret

def save_key_bio(self, bio, cipher='aes_128_cbc', 
                     callback=util.passphrase_callback):
        """
        Save DSA key pair to a BIO object.
    
        @type  bio:    M2Crypto.BIO object
        @param bio:    Save DSA parameters to this object.
        @type  cipher: str
        @param cipher: name of symmetric key algorithm and mode
                       to encrypt the private key.
        @return:       1 (true) if successful
        """
        if cipher is None:
            return m2.dsa_write_key_bio_no_cipher(self.dsa, 
                                                 bio._ptr(), callback)
        else:
            ciph = getattr(m2, cipher, None)
            if ciph is None:
                raise DSAError('no such cipher: %s' % cipher)
            else:
                ciph = ciph()
            return m2.dsa_write_key_bio(self.dsa, bio._ptr(), ciph, callback)

def save_pub_key(self, filename):
        """
        Save the DSA public key (with parameters) to a file.
    
        @type  filename: str
        @param filename: Save DSA public key (with parameters) 
                         to this file.
        @return:         1 (true) if successful
        """
        bio = BIO.openfile(filename, 'wb')
        ret = self.save_pub_key_bio(bio)
        bio.close()
        return ret

def save_pub_key_bio(self, bio):
        """
        Save DSA public key (with parameters) to a BIO object.
    
        @type  bio: M2Crypto.BIO object
        @param bio: Save DSA public key (with parameters) 
                    to this object.
        @return:  1 (true) if successful
        """
        return m2.dsa_write_pub_key_bio(self.dsa, bio._ptr())

def sign(self, digest):
        """
        Sign the digest.
    
        @type  digest: str
        @param digest: SHA-1 hash of message (same as output 
                       from MessageDigest, a "byte string")
        @rtype:        tuple
        @return:       DSA signature, a tuple of two values, r and s,
                       both "byte strings".
        """
        assert self.check_key(), 'key is not initialised'
        return m2.dsa_sign(self.dsa, digest)
    
    def verify(self, digest, r, s):
        """
        Verify a newly calculated digest against the signature 
        values r and s.
    
        @type  digest: str
        @param digest: SHA-1 hash of message (same as output 
                       from MessageDigest, a "byte string")
        @type  r:      str
        @param r:      r value of the signature, a "byte string"
        @type  s:      str
        @param s:      s value of the signature, a "byte string"
        @rtype:        int
        @return:       1 (true) if verify succeeded, 0 if failed
        """
        assert self.check_key(), 'key is not initialised'
        return m2.dsa_verify(self.dsa, digest, r, s)

def sign_asn1(self, digest):
        assert self.check_key(), 'key is not initialised'
        return m2.dsa_sign_asn1(self.dsa, digest)
    
    def verify_asn1(self, digest, blob):
        assert self.check_key(), 'key is not initialised'
        return m2.dsa_verify_asn1(self.dsa, digest, blob)

def check_key(self):
        """
        Check to be sure the DSA object has a valid private key.
    
        @rtype:   int
        @return:  1 (true) if a valid private key
        """
        assert m2.dsa_type_check(self.dsa), "'dsa' type error"
        return m2.dsa_check_key(self.dsa)

class DSA_pub(DSA):

"""
    This class is a DSA context that only supports a public key 
    and verification.  It does NOT support a private key or 
    signing.
    
    """

def sign(self, *argv):
        raise DSAError('DSA_pub object has no private key')

sign_asn1 = sign

def check_key(self):
        return m2.dsa_check_pub_key(self.dsa)
    
    save_key = DSA.save_pub_key

save_key_bio = DSA.save_pub_key_bio

#---------------------------------------------------------------
# factories and other functions

def gen_params(bits, callback=util.genparam_callback):
    """
    Factory function that generates DSA parameters and 
    instantiates a DSA object from the output.

@type  bits: int
    @param bits: The length of the prime to be generated. If 
                 'bits' < 512, it is set to 512.
    @type  callback: function
    @param callback: A Python callback object that will be 
                 invoked during parameter generation; it usual 
                 purpose is to provide visual feedback.
    @rtype:   DSA
    @return:  instance of DSA.
    """
    dsa = m2.dsa_generate_parameters(bits, callback)
    if dsa is None:
        raise DSAError('problem generating DSA parameters')
    return DSA(dsa, 1)

def set_params(p, q, g):
    """
    Factory function that instantiates a DSA object with DSA
    parameters.

@type  p: str
    @param p: value of p, a "byte string"
    @type  q: str
    @param q: value of q, a "byte string"
    @type  g: str
    @param g: value of g, a "byte string"
    @rtype:   DSA
    @return:  instance of DSA.
    """
    dsa = m2.dsa_new()
    m2.dsa_set_p(dsa, p)
    m2.dsa_set_q(dsa, q)
    m2.dsa_set_g(dsa, g)
    return DSA(dsa, 1)

def load_params(file, callback=util.passphrase_callback):
    """
    Factory function that instantiates a DSA object with DSA 
    parameters from a file.

@type  file:     str
    @param file:     Names the file (a path) that contains the PEM 
                     representation of the DSA parameters. 
    @type  callback: A Python callable
    @param callback: A Python callback object that will be 
                     invoked if the DSA parameters file is 
                     passphrase-protected.
    @rtype:          DSA
    @return:         instance of DSA.
    """
    bio = BIO.openfile(file)
    ret = load_params_bio(bio, callback)
    bio.close()
    return ret

def load_params_bio(bio, callback=util.passphrase_callback):
    """
    Factory function that instantiates a DSA object with DSA
    parameters from a M2Crypto.BIO object.

@type  bio:      M2Crypto.BIO object
    @param bio:      Contains the PEM representation of the DSA 
                     parameters. 
    @type  callback: A Python callable
    @param callback: A Python callback object that will be 
                     invoked if the DSA parameters file is 
                     passphrase-protected.
    @rtype:          DSA
    @return:         instance of DSA.
    """
    dsa = m2.dsa_read_params(bio._ptr(), callback)
    if dsa is None:
        raise DSAError('problem loading DSA parameters')
    return DSA(dsa, 1)

def load_key(file, callback=util.passphrase_callback):
    """
    Factory function that instantiates a DSA object from a
    PEM encoded DSA key pair.

@type  file:     str
    @param file:     Names the file (a path) that contains the PEM 
                     representation of the DSA key pair. 
    @type  callback: A Python callable
    @param callback: A Python callback object that will be 
                     invoked if the DSA key pair is 
                     passphrase-protected.
    @rtype:          DSA
    @return:         instance of DSA.
    """
    bio = BIO.openfile(file)
    ret = load_key_bio(bio, callback)
    bio.close()
    return ret

def load_key_bio(bio, callback=util.passphrase_callback):
    """
    Factory function that instantiates a DSA object from a
    PEM encoded DSA key pair.

@type  bio:      M2Crypto.BIO object
    @param bio:      Contains the PEM representation of the DSA 
                     key pair. 
    @type  callback: A Python callable
    @param callback: A Python callback object that will be 
                     invoked if the DSA key pair is 
                     passphrase-protected.
    @rtype:          DSA
    @return:         instance of DSA.
    """
    dsa = m2.dsa_read_key(bio._ptr(), callback)
    if not dsa:
        raise DSAError('problem loading DSA key pair')
    return DSA(dsa, 1)

def load_pub_key(file, callback=util.passphrase_callback):
    """
    Factory function that instantiates a DSA_pub object using
    a DSA public key contained in PEM file.  The PEM file 
    must contain the parameters in addition to the public key.

@type  file:     str
    @param file:     Names the file (a path) that contains the PEM 
                     representation of the DSA public key. 
    @type  callback: A Python callable
    @param callback: A Python callback object that will be 
                     invoked should the DSA public key be 
                     passphrase-protected.
    @rtype:          DSA_pub
    @return:         instance of DSA_pub.
    """
    bio = BIO.openfile(file)
    ret = load_pub_key_bio(bio, callback)
    bio.close()
    return ret

def load_pub_key_bio(bio, callback=util.passphrase_callback):
    """
    Factory function that instantiates a DSA_pub object using
    a DSA public key contained in PEM format.  The PEM 
    must contain the parameters in addition to the public key.

@type  bio:      M2Crypto.BIO object
    @param bio:      Contains the PEM representation of the DSA 
                     public key (with params). 
    @type  callback: A Python callable
    @param callback: A Python callback object that will be 
                     invoked should the DSA public key be 
                     passphrase-protected.
    @rtype:          DSA_pub
    @return:         instance of DSA_pub.
    """
    dsapub = m2.dsa_read_pub_key(bio._ptr(), callback)
    if not dsapub:
        raise DSAError('problem loading DSA public key')
    return DSA_pub(dsapub, 1)

cmd: