Source Code for Module openid.store.filestore

  1  """ 
  2  This module contains an C{L{OpenIDStore}} implementation backed by 
  3  flat files. 
  4  """ 
  5   
  6  import string 
  7  import os 
  8  import os.path 
  9  import time 
 10   
 11  from errno import EEXIST, ENOENT 
 12   
 13  try: 
 14      from tempfile import mkstemp 
 15  except ImportError: 
 16      # Python < 2.3 
 17      import warnings 
 18      warnings.filterwarnings("ignore", 
 19                              "tempnam is a potential security risk", 
 20                              RuntimeWarning, 
 21                              "openid.store.filestore") 
 22   
 23 -    def mkstemp(dir): 
 24          for _ in range(5): 
 25              name = os.tempnam(dir) 
 26              try: 
 27                  fd = os.open(name, os.O_CREAT | os.O_EXCL | os.O_RDWR, 0600) 
 28              except OSError, why: 
 29                  if why.errno != EEXIST: 
 30                      raise 
 31              else: 
 32                  return fd, name 
 33   
 34          raise RuntimeError('Failed to get temp file after 5 attempts') 
 35   
 36  from openid.association import Association 
 37  from openid.store.interface import OpenIDStore 
 38  from openid.store import nonce 
 39  from openid import cryptutil, oidutil 
 40   
 41  _filename_allowed = string.ascii_letters + string.digits + '.' 
 42  try: 
 43      # 2.4 
 44      set 
 45  except NameError: 
 46      try: 
 47          # 2.3 
 48          import sets 
 49      except ImportError: 
 50          # Python < 2.2 
 51          d = {} 
 52          for c in _filename_allowed: 
 53              d[c] = None 
 54          _isFilenameSafe = d.has_key 
 55          del d 
 56      else: 
 57          _isFilenameSafe = sets.Set(_filename_allowed).__contains__ 
 58  else: 
 59      _isFilenameSafe = set(_filename_allowed).__contains__ 
 60   
 61 -def _safe64(s): 
 62      h64 = oidutil.toBase64(cryptutil.sha1(s)) 
 63      h64 = h64.replace('+', '_') 
 64      h64 = h64.replace('/', '.') 
 65      h64 = h64.replace('=', '') 
 66      return h64 
 67   
 68 -def _filenameEscape(s): 
 69      filename_chunks = [] 
 70      for c in s: 
 71          if _isFilenameSafe(c): 
 72              filename_chunks.append(c) 
 73          else: 
 74              filename_chunks.append('_%02X' % ord(c)) 
 75      return ''.join(filename_chunks) 
 76   
 77 -def _removeIfPresent(filename): 
 78      """Attempt to remove a file, returning whether the file existed at 
 79      the time of the call. 
 80   
 81      str -> bool 
 82      """ 
 83      try: 
 84          os.unlink(filename) 
 85      except OSError, why: 
 86          if why.errno == ENOENT: 
 87              # Someone beat us to it, but it's gone, so that's OK 
 88              return 0 
 89          else: 
 90              raise 
 91      else: 
 92          # File was present 
 93          return 1 
 94   
 95 -def _ensureDir(dir_name): 
 96      """Create dir_name as a directory if it does not exist. If it 
 97      exists, make sure that it is, in fact, a directory. 
 98   
 99      Can raise OSError 
100   
101      str -> NoneType 
102      """ 
103      try: 
104          os.makedirs(dir_name) 
105      except OSError, why: 
106          if why.errno != EEXIST or not os.path.isdir(dir_name): 
107              raise 
108   
109 -class FileOpenIDStore(OpenIDStore): 
110      """ 
111      This is a filesystem-based store for OpenID associations and 
112      nonces.  This store should be safe for use in concurrent systems 
113      on both windows and unix (excluding NFS filesystems).  There are a 
114      couple race conditions in the system, but those failure cases have 
115      been set up in such a way that the worst-case behavior is someone 
116      having to try to log in a second time. 
117   
118      Most of the methods of this class are implementation details. 
119      People wishing to just use this store need only pay attention to 
120      the C{L{__init__}} method. 
121   
122      Methods of this object can raise OSError if unexpected filesystem 
123      conditions, such as bad permissions or missing directories, occur. 
124      """ 
125   
126 -    def __init__(self, directory): 
127          """ 
128          Initializes a new FileOpenIDStore.  This initializes the 
129          nonce and association directories, which are subdirectories of 
130          the directory passed in. 
131   
132          @param directory: This is the directory to put the store 
133              directories in. 
134   
135          @type directory: C{str} 
136          """ 
137          # Make absolute 
138          directory = os.path.normpath(os.path.abspath(directory)) 
139   
140          self.nonce_dir = os.path.join(directory, 'nonces') 
141   
142          self.association_dir = os.path.join(directory, 'associations') 
143   
144          # Temp dir must be on the same filesystem as the assciations 
145          # directory 
146          self.temp_dir = os.path.join(directory, 'temp') 
147   
148          self.max_nonce_age = 6 * 60 * 60 # Six hours, in seconds 
149   
150          self._setup() 
151   
152 -    def _setup(self): 
153          """Make sure that the directories in which we store our data 
154          exist. 
155   
156          () -> NoneType 
157          """ 
158          _ensureDir(self.nonce_dir) 
159          _ensureDir(self.association_dir) 
160          _ensureDir(self.temp_dir) 
161   
162 -    def _mktemp(self): 
163          """Create a temporary file on the same filesystem as 
164          self.association_dir. 
165   
166          The temporary directory should not be cleaned if there are any 
167          processes using the store. If there is no active process using 
168          the store, it is safe to remove all of the files in the 
169          temporary directory. 
170   
171          () -> (file, str) 
172          """ 
173          fd, name = mkstemp(dir=self.temp_dir) 
174          try: 
175              file_obj = os.fdopen(fd, 'wb') 
176              return file_obj, name 
177          except: 
178              _removeIfPresent(name) 
179              raise 
180   
181 -    def getAssociationFilename(self, server_url, handle): 
182          """Create a unique filename for a given server url and 
183          handle. This implementation does not assume anything about the 
184          format of the handle. The filename that is returned will 
185          contain the domain name from the server URL for ease of human 
186          inspection of the data directory. 
187   
188          (str, str) -> str 
189          """ 
190          if server_url.find('://') == -1: 
191              raise ValueError('Bad server URL: %r' % server_url) 
192   
193          proto, rest = server_url.split('://', 1) 
194          domain = _filenameEscape(rest.split('/', 1)[0]) 
195          url_hash = _safe64(server_url) 
196          if handle: 
197              handle_hash = _safe64(handle) 
198          else: 
199              handle_hash = '' 
200   
201          filename = '%s-%s-%s-%s' % (proto, domain, url_hash, handle_hash) 
202   
203          return os.path.join(self.association_dir, filename) 
204   
205 -    def storeAssociation(self, server_url, association): 
206          """Store an association in the association directory. 
207   
208          (str, Association) -> NoneType 
209          """ 
210          association_s = association.serialize() 
211          filename = self.getAssociationFilename(server_url, association.handle) 
212          tmp_file, tmp = self._mktemp() 
213   
214          try: 
215              try: 
216                  tmp_file.write(association_s) 
217                  os.fsync(tmp_file.fileno()) 
218              finally: 
219                  tmp_file.close() 
220   
221              try: 
222                  os.rename(tmp, filename) 
223              except OSError, why: 
224                  if why.errno != EEXIST: 
225                      raise 
226   
227                  # We only expect EEXIST to happen only on Windows. It's 
228                  # possible that we will succeed in unlinking the existing 
229                  # file, but not in putting the temporary file in place. 
230                  try: 
231                      os.unlink(filename) 
232                  except OSError, why: 
233                      if why.errno == ENOENT: 
234                          pass 
235                      else: 
236                          raise 
237   
238                  # Now the target should not exist. Try renaming again, 
239                  # giving up if it fails. 
240                  os.rename(tmp, filename) 
241          except: 
242              # If there was an error, don't leave the temporary file 
243              # around. 
244              _removeIfPresent(tmp) 
245              raise 
246   
247 -    def getAssociation(self, server_url, handle=None): 
248          """Retrieve an association. If no handle is specified, return 
249          the association with the latest expiration. 
250   
251          (str, str or NoneType) -> Association or NoneType 
252          """ 
253          if handle is None: 
254              handle = '' 
255   
256          # The filename with the empty handle is a prefix of all other 
257          # associations for the given server URL. 
258          filename = self.getAssociationFilename(server_url, handle) 
259   
260          if handle: 
261              return self._getAssociation(filename) 
262          else: 
263              association_files = os.listdir(self.association_dir) 
264              matching_files = [] 
265              # strip off the path to do the comparison 
266              name = os.path.basename(filename) 
267              for association_file in association_files: 
268                  if association_file.startswith(name): 
269                      matching_files.append(association_file) 
270   
271              matching_associations = [] 
272              # read the matching files and sort by time issued 
273              for name in matching_files: 
274                  full_name = os.path.join(self.association_dir, name) 
275                  association = self._getAssociation(full_name) 
276                  if association is not None: 
277                      matching_associations.append( 
278                          (association.issued, association)) 
279   
280              matching_associations.sort() 
281   
282              # return the most recently issued one. 
283              if matching_associations: 
284                  (_, assoc) = matching_associations[-1] 
285                  return assoc 
286              else: 
287                  return None 
288   
289 -    def _getAssociation(self, filename): 
290          try: 
291              assoc_file = file(filename, 'rb') 
292          except IOError, why: 
293              if why.errno == ENOENT: 
294                  # No association exists for that URL and handle 
295                  return None 
296              else: 
297                  raise 
298          else: 
299              try: 
300                  assoc_s = assoc_file.read() 
301              finally: 
302                  assoc_file.close() 
303   
304              try: 
305                  association = Association.deserialize(assoc_s) 
306              except ValueError: 
307                  _removeIfPresent(filename) 
308                  return None 
309   
310          # Clean up expired associations 
311          if association.getExpiresIn() == 0: 
312              _removeIfPresent(filename) 
313              return None 
314          else: 
315              return association 
316   
317 -    def removeAssociation(self, server_url, handle): 
318          """Remove an association if it exists. Do nothing if it does not. 
319   
320          (str, str) -> bool 
321          """ 
322          assoc = self.getAssociation(server_url, handle) 
323          if assoc is None: 
324              return 0 
325          else: 
326              filename = self.getAssociationFilename(server_url, handle) 
327              return _removeIfPresent(filename) 
328   
329 -    def useNonce(self, server_url, timestamp, salt): 
330          """Return whether this nonce is valid. 
331   
332          str -> bool 
333          """ 
334          if abs(timestamp - time.time()) > nonce.SKEW: 
335              return False 
336   
337          if server_url: 
338              proto, rest = server_url.split('://', 1) 
339          else: 
340              # Create empty proto / rest values for empty server_url, 
341              # which is part of a consumer-generated nonce. 
342              proto, rest = '', '' 
343   
344          domain = _filenameEscape(rest.split('/', 1)[0]) 
345          url_hash = _safe64(server_url) 
346          salt_hash = _safe64(salt) 
347   
348          filename = '%08x-%s-%s-%s-%s' % (timestamp, proto, domain, 
349                                           url_hash, salt_hash) 
350   
351          filename = os.path.join(self.nonce_dir, filename) 
352          try: 
353              fd = os.open(filename, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0200) 
354          except OSError, why: 
355              if why.errno == EEXIST: 
356                  return False 
357              else: 
358                  raise 
359          else: 
360              os.close(fd) 
361              return True 
362   
363 -    def _allAssocs(self): 
364          all_associations = [] 
365   
366          association_filenames = map( 
367              lambda filename: os.path.join(self.association_dir, filename), 
368              os.listdir(self.association_dir)) 
369          for association_filename in association_filenames: 
370              try: 
371                  association_file = file(association_filename, 'rb') 
372              except IOError, why: 
373                  if why.errno == ENOENT: 
374                      oidutil.log("%s disappeared during %s._allAssocs" % ( 
375                          association_filename, self.__class__.__name__)) 
376                  else: 
377                      raise 
378              else: 
379                  try: 
380                      assoc_s = association_file.read() 
381                  finally: 
382                      association_file.close() 
383   
384                  # Remove expired or corrupted associations 
385                  try: 
386                      association = Association.deserialize(assoc_s) 
387                  except ValueError: 
388                      _removeIfPresent(association_filename) 
389                  else: 
390                      all_associations.append( 
391                          (association_filename, association)) 
392   
393          return all_associations 
394   
395 -    def cleanup(self): 
396          """Remove expired entries from the database. This is 
397          potentially expensive, so only run when it is acceptable to 
398          take time. 
399   
400          () -> NoneType 
401          """ 
402          self.cleanupAssociations() 
403          self.cleanupNonces() 
404   
405 -    def cleanupAssociations(self): 
406          removed = 0 
407          for assoc_filename, assoc in self._allAssocs(): 
408              if assoc.getExpiresIn() == 0: 
409                  _removeIfPresent(assoc_filename) 
410                  removed += 1 
411          return removed 
412   
413 -    def cleanupNonces(self): 
414          nonces = os.listdir(self.nonce_dir) 
415          now = time.time() 
416   
417          removed = 0 
418          # Check all nonces for expiry 
419          for nonce_fname in nonces: 
420              timestamp = nonce_fname.split('-', 1)[0] 
421              timestamp = int(timestamp, 16) 
422              if abs(timestamp - now) > nonce.SKEW: 
423                  filename = os.path.join(self.nonce_dir, nonce_fname) 
424                  _removeIfPresent(filename) 
425                  removed += 1 
426          return removed 
427