ctypescrypto/digest.py

   1 """
   2         Implements interface to OpenSSL EVP_Digest* functions.
   3
   4         Interface  made as close to hashlib as possible.
   5
   6         This module is really an excess effort. Hashlib allows access to
   7         mostly same functionality except oids and nids of hashing
   8         algortithms (which might be needed for private key operations).
   9
  10         hashlib even allows to use engine-provided digests if it is build
  11         with dinamically linked libcrypto - so use
  12         ctypescrypto.engine.set_default("gost",xFFFF) and md_gost94
  13         algorithm would be available both to this module and hashlib.
  14
  15 """
  16 from ctypes import c_int, c_char_p, c_void_p, POINTER, c_long,c_longlong, create_string_buffer,byref
  17 from ctypescrypto import libcrypto
  18 from ctypescrypto.exception import LibCryptoError
  19 from ctypescrypto.oid import Oid
  20 DIGEST_ALGORITHMS = ("MD5", "SHA1", "SHA224", "SHA256", "SHA384", "SHA512")
  21
  22 __all__ = ['DigestError','Digest','DigestType','new']
  23
  24 class DigestError(LibCryptoError):
  25         pass
  26
  27 def new(algname):
  28         """
  29                 Behaves just like hashlib.new. Creates digest object by
  30                 algorithm name
  31         """
  32         md=DigestType(algname)
  33         return Digest(md)
  34
  35 class DigestType(object):
  36         """
  37
  38                 Represents EVP_MD object - constant structure which describes
  39                 digest algorithm
  40
  41         """
  42         def __init__(self,      digest_name):
  43                 """
  44                         Finds digest by its name. You can pass Oid object instead of
  45                         name.
  46
  47                         Special case is when None is passed as name. In this case
  48                         unitialized digest is created, and can be initalized later
  49                         by setting its digest attribute to pointer to EVP_MD
  50                 """
  51                 if digest_name is None:
  52                         return
  53                 if isinstance(digest_name,Oid):
  54                         self.digest_name=digest_name.longname()
  55                         self.digest=libcrypto.EVP_get_digestbyname(self.digest_name)
  56                 else:
  57                         self.digest_name = str(digest_name)
  58                         self.digest = libcrypto.EVP_get_digestbyname(self.digest_name)
  59                 if self.digest is None:
  60                         raise DigestError("Unknown digest: %s" % self.digest_name)
  61
  62         @property
  63         def name(self):
  64                 if not hasattr(self,'digest_name'):
  65                         self.digest_name=Oid(libcrypto.EVP_MD_type(self.digest)).longname()
  66                 return self.digest_name
  67         def __del__(self):
  68                 pass
  69         def digest_size(self):
  70                 return libcrypto.EVP_MD_size(self.digest)
  71         def block_size(self):
  72                 return libcrypto.EVP_MD_block_size(self.digest)
  73         def oid(self):
  74                 return Oid(libcrypto.EVP_MD_type(self.digest))
  75
  76 class Digest(object):
  77         """
  78                 Represents EVP_MD_CTX object which actually used to calculate
  79                 digests.
  80
  81         """
  82         def __init__(self,digest_type):
  83                 """
  84                         Initializes digest using given type.
  85                 """
  86                 self._clean_ctx()
  87                 self.ctx = libcrypto.EVP_MD_CTX_create()
  88                 if self.ctx is None:
  89                         raise DigestError("Unable to create digest context")
  90                 result = libcrypto.EVP_DigestInit_ex(self.ctx, digest_type.digest, None)
  91                 if result == 0:
  92                         self._clean_ctx()
  93                         raise DigestError("Unable to initialize digest")
  94                 self.digest_type = digest_type
  95                 self.digest_size = self.digest_type.digest_size()
  96                 self.block_size = self.digest_type.block_size()
  97
  98         def __del__(self):
  99                 self._clean_ctx()
 100
 101         def update(self, data, length=None):
 102                 """
 103                         Hashes given byte string
 104
 105                         @param data - string to hash
 106                         @param length - if not specifed, entire string is hashed,
 107                                         otherwise only first length bytes
 108                 """
 109                 if self.digest_finalized:
 110                         raise DigestError("No updates allowed")
 111                 if not isinstance(data,str):
 112                         raise TypeError("A string is expected")
 113                 if length is None:
 114                         length = len(data)
 115                 elif length > len(data):
 116                         raise ValueError("Specified length is greater than length of data")
 117                 result = libcrypto.EVP_DigestUpdate(self.ctx, c_char_p(data), length)
 118                 if result != 1:
 119                         raise DigestError, "Unable to update digest"
 120
 121         def digest(self, data=None):
 122                 """
 123                         Finalizes digest operation and return digest value
 124                         Optionally hashes more data before finalizing
 125                 """
 126                 if self.digest_finalized:
 127                         return self.digest_out.raw[:self.digest_size]
 128                 if data is not None:
 129                         self.update(data)
 130                 self.digest_out = create_string_buffer(256)
 131                 length = c_long(0)
 132                 result = libcrypto.EVP_DigestFinal_ex(self.ctx, self.digest_out, byref(length))
 133                 if result != 1 :
 134                         raise DigestError("Unable to finalize digest")
 135                 self.digest_finalized = True
 136                 return self.digest_out.raw[:self.digest_size]
 137         def copy(self):
 138                 """
 139                         Creates copy of the digest CTX to allow to compute digest
 140                         while being able to hash more data
 141                 """
 142                 new_digest=Digest(self.digest_type)
 143                 libcrypto.EVP_MD_CTX_copy(new_digest.ctx,self.ctx)
 144                 return new_digest
 145
 146         def _clean_ctx(self):
 147                 try:
 148                         if self.ctx is not None:
 149                                 libcrypto.EVP_MD_CTX_destroy(self.ctx)
 150                                 del(self.ctx)
 151                 except AttributeError:
 152                         pass
 153                 self.digest_out = None
 154                 self.digest_finalized = False
 155
 156         def hexdigest(self,data=None):
 157                 """
 158                         Returns digest in the hexadecimal form. For compatibility
 159                         with hashlib
 160                 """
 161                 from base64 import b16encode
 162                 return b16encode(self.digest(data))
 163
 164
 165 # Declare function result and argument types
 166 libcrypto.EVP_get_digestbyname.restype = c_void_p
 167 libcrypto.EVP_get_digestbyname.argtypes = (c_char_p,)
 168 libcrypto.EVP_MD_CTX_create.restype = c_void_p
 169 libcrypto.EVP_DigestInit_ex.argtypes = (c_void_p,c_void_p,c_void_p)
 170 libcrypto.EVP_DigestUpdate.argtypes = (c_void_p,c_char_p,c_longlong)
 171 libcrypto.EVP_DigestFinal_ex.argtypes = (c_void_p,c_char_p,POINTER(c_long))
 172 libcrypto.EVP_MD_CTX_destroy.argtypes = (c_void_p,)
 173 libcrypto.EVP_MD_CTX_copy.argtypes=(c_void_p, c_void_p)
 174 libcrypto.EVP_MD_type.argtypes=(c_void_p,)
 175 libcrypto.EVP_MD_size.argtypes=(c_void_p,)
 176 libcrypto.EVP_MD_block_size.argtypes=(c_void_p,)