home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 February / maximum-cd-2011-02.iso / DiscContents / digsby_setup85.exe / lib / oauth / oauth.pyo (.txt) < prev   
Encoding:
Python Compiled Bytecode  |  2010-11-24  |  17.8 KB  |  562 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. import cgi
  5. import urllib
  6. import time
  7. import random
  8. import urlparse
  9. import hmac
  10. import base64
  11. VERSION = '1.0'
  12. HTTP_METHOD = 'GET'
  13. SIGNATURE_METHOD = 'PLAINTEXT'
  14.  
  15. class OAuthError(RuntimeError):
  16.     
  17.     def __init__(self, message = 'OAuth error occured.', oauth_data = None):
  18.         if not oauth_data:
  19.             pass
  20.         self.oauth_data = { }
  21.         self.message = message
  22.  
  23.     
  24.     def __repr__(self):
  25.         return RuntimeError.__repr__(self) + ': ' + self.message
  26.  
  27.  
  28.  
  29. def build_authenticate_header(realm = ''):
  30.     return {
  31.         'WWW-Authenticate': 'OAuth realm="%s"' % realm }
  32.  
  33.  
  34. def escape(s):
  35.     return urllib.quote(s, safe = '~')
  36.  
  37.  
  38. def generate_timestamp():
  39.     return int(time.time())
  40.  
  41.  
  42. def generate_nonce(length = 8):
  43.     return ''.join((lambda .0: for i in .0:
  44. str(random.randint(0, 9)))(range(length)))
  45.  
  46.  
  47. class OAuthConsumer(object):
  48.     key = None
  49.     secret = None
  50.     
  51.     def __init__(self, key, secret):
  52.         self.key = key
  53.         self.secret = secret
  54.  
  55.  
  56.  
  57. class OAuthToken(object):
  58.     key = None
  59.     secret = None
  60.     
  61.     def __init__(self, key, secret):
  62.         self.key = key
  63.         self.secret = secret
  64.  
  65.     
  66.     def to_string(self):
  67.         return urllib.urlencode({
  68.             'oauth_token': self.key,
  69.             'oauth_token_secret': self.secret })
  70.  
  71.     
  72.     def from_string(cls, s):
  73.         params = cgi.parse_qs(s, keep_blank_values = False)
  74.         key = params.get('oauth_token', [
  75.             None])[0]
  76.         secret = params.get('oauth_token_secret', [
  77.             None])[0]
  78.         if None in (key, secret):
  79.             raise OAuthError('No token found: %r' % s, s)
  80.         None in (key, secret)
  81.         return cls(key, secret)
  82.  
  83.     from_string = classmethod(from_string)
  84.     
  85.     def __str__(self):
  86.         return self.to_string()
  87.  
  88.     
  89.     def __repr__(self):
  90.         return '{self.__class__.__name__}(key = {self.key!r}, secret = {self.secret!r})'.format(self = self)
  91.  
  92.  
  93.  
  94. class OAuthRequest(object):
  95.     parameters = None
  96.     http_method = HTTP_METHOD
  97.     http_url = None
  98.     version = VERSION
  99.     
  100.     def __init__(self, http_method = HTTP_METHOD, http_url = None, parameters = None):
  101.         self.http_method = http_method
  102.         self.http_url = http_url
  103.         if not parameters:
  104.             pass
  105.         self.parameters = { }
  106.  
  107.     
  108.     def set_parameter(self, parameter, value):
  109.         self.parameters[parameter] = value
  110.  
  111.     
  112.     def get_parameter(self, parameter):
  113.         
  114.         try:
  115.             return self.parameters[parameter]
  116.         except:
  117.             raise OAuthError('Parameter not found: %s' % parameter)
  118.  
  119.  
  120.     
  121.     def _get_timestamp_nonce(self):
  122.         return (self.get_parameter('oauth_timestamp'), self.get_parameter('oauth_nonce'))
  123.  
  124.     
  125.     def get_nonoauth_parameters(self):
  126.         parameters = { }
  127.         for k, v in self.parameters.iteritems():
  128.             if k.find('oauth_') < 0:
  129.                 parameters[k] = v
  130.                 continue
  131.         
  132.         return parameters
  133.  
  134.     
  135.     def to_header(self, realm = ''):
  136.         auth_header = 'OAuth realm="%s"' % realm
  137.         if self.parameters:
  138.             for k, v in self.parameters.iteritems():
  139.                 if k.startswith('oauth_'):
  140.                     auth_header += ', %s="%s"' % (k, escape(str(v)))
  141.                     continue
  142.             
  143.         
  144.         return {
  145.             'Authorization': auth_header }
  146.  
  147.     
  148.     def to_postdata(self):
  149.         return '&'.join((lambda .0: for k, v in .0:
  150. '%s=%s' % (escape(str(k)), escape(str(v))))(self.parameters.iteritems()))
  151.  
  152.     
  153.     def to_url(self):
  154.         return '%s?%s' % (self.get_normalized_http_url(), self.to_postdata())
  155.  
  156.     
  157.     def get_normalized_parameters(self):
  158.         params = self.parameters
  159.         
  160.         try:
  161.             del params['oauth_signature']
  162.         except:
  163.             pass
  164.  
  165.         key_values = params.items()
  166.         key_values.sort()
  167.         return '&'.join((lambda .0: for k, v in .0:
  168. '%s=%s' % (escape(str(k)), escape(str(v))))(key_values))
  169.  
  170.     
  171.     def get_normalized_http_method(self):
  172.         return self.http_method.upper()
  173.  
  174.     
  175.     def get_normalized_http_url(self):
  176.         parts = urlparse.urlparse(self.http_url)
  177.         url_string = '%s://%s%s' % (parts[0], parts[1], parts[2])
  178.         return url_string
  179.  
  180.     
  181.     def sign_request(self, signature_method, consumer, token):
  182.         self.set_parameter('oauth_signature_method', signature_method.get_name())
  183.         self.set_parameter('oauth_signature', self.build_signature(signature_method, consumer, token))
  184.  
  185.     
  186.     def build_signature(self, signature_method, consumer, token):
  187.         return signature_method.build_signature(self, consumer, token)
  188.  
  189.     
  190.     def from_request(cls, http_method, http_url, headers = None, parameters = None, query_string = None):
  191.         if parameters is None:
  192.             parameters = { }
  193.         
  194.         if headers and 'Authorization' in headers:
  195.             auth_header = headers['Authorization']
  196.             if auth_header.index('OAuth') > -1:
  197.                 
  198.                 try:
  199.                     header_params = cls._split_header(auth_header)
  200.                     parameters.update(header_params)
  201.                 raise OAuthError('Unable to parse OAuth parameters from Authorization header.')
  202.  
  203.             
  204.         
  205.         if query_string:
  206.             query_params = cls._split_url_string(query_string)
  207.             parameters.update(query_params)
  208.         
  209.         param_str = urlparse.urlparse(http_url)[4]
  210.         url_params = cls._split_url_string(param_str)
  211.         parameters.update(url_params)
  212.         if parameters:
  213.             return cls(http_method, http_url, parameters)
  214.  
  215.     from_request = classmethod(from_request)
  216.     
  217.     def from_consumer_and_token(cls, oauth_consumer, token = None, http_method = None, http_url = None, parameters = None):
  218.         if http_method is None:
  219.             http_method = HTTP_METHOD
  220.         
  221.         if not parameters:
  222.             parameters = { }
  223.         
  224.         defaults = {
  225.             'oauth_consumer_key': oauth_consumer.key,
  226.             'oauth_timestamp': generate_timestamp(),
  227.             'oauth_nonce': generate_nonce(),
  228.             'oauth_version': cls.version }
  229.         defaults.update(parameters)
  230.         parameters = defaults
  231.         if token:
  232.             parameters['oauth_token'] = token.key
  233.         
  234.         return cls(http_method, http_url, parameters)
  235.  
  236.     from_consumer_and_token = classmethod(from_consumer_and_token)
  237.     
  238.     def from_token_and_callback(cls, token, callback = None, http_method = None, http_url = None, parameters = None):
  239.         if http_method is None:
  240.             http_method = HTTP_METHOD
  241.         
  242.         if not parameters:
  243.             parameters = { }
  244.         
  245.         if token and token.key:
  246.             parameters['oauth_token'] = token.key
  247.         
  248.         if callback:
  249.             parameters['oauth_callback'] = callback
  250.         
  251.         return cls(http_method, http_url, parameters)
  252.  
  253.     from_token_and_callback = classmethod(from_token_and_callback)
  254.     
  255.     def _split_header(header):
  256.         params = { }
  257.         parts = header.split(',')
  258.         for param in parts:
  259.             if param.find('OAuth realm') > -1:
  260.                 continue
  261.             
  262.             param = param.strip()
  263.             param_parts = param.split('=', 1)
  264.             params[param_parts[0]] = urllib.unquote(param_parts[1].strip('"'))
  265.         
  266.         return params
  267.  
  268.     _split_header = staticmethod(_split_header)
  269.     
  270.     def _split_url_string(param_str):
  271.         parameters = cgi.parse_qs(param_str, keep_blank_values = False)
  272.         for k, v in parameters.iteritems():
  273.             parameters[k] = urllib.unquote(v[0])
  274.         
  275.         return parameters
  276.  
  277.     _split_url_string = staticmethod(_split_url_string)
  278.  
  279.  
  280. class OAuthServer(object):
  281.     timestamp_threshold = 300
  282.     version = VERSION
  283.     signature_methods = None
  284.     data_store = None
  285.     
  286.     def __init__(self, data_store = None, signature_methods = None):
  287.         self.data_store = data_store
  288.         if not signature_methods:
  289.             pass
  290.         self.signature_methods = { }
  291.  
  292.     
  293.     def set_data_store(self, oauth_data_store):
  294.         self.data_store = data_store
  295.  
  296.     
  297.     def get_data_store(self):
  298.         return self.data_store
  299.  
  300.     
  301.     def add_signature_method(self, signature_method):
  302.         self.signature_methods[signature_method.get_name()] = signature_method
  303.         return self.signature_methods
  304.  
  305.     
  306.     def fetch_request_token(self, oauth_request):
  307.         
  308.         try:
  309.             token = self._get_token(oauth_request, 'request')
  310.         except OAuthError:
  311.             version = self._get_version(oauth_request)
  312.             consumer = self._get_consumer(oauth_request)
  313.             self._check_signature(oauth_request, consumer, None)
  314.             token = self.data_store.fetch_request_token(consumer)
  315.  
  316.         return token
  317.  
  318.     
  319.     def fetch_access_token(self, oauth_request):
  320.         version = self._get_version(oauth_request)
  321.         consumer = self._get_consumer(oauth_request)
  322.         token = self._get_token(oauth_request, 'request')
  323.         self._check_signature(oauth_request, consumer, token)
  324.         new_token = self.data_store.fetch_access_token(consumer, token)
  325.         return new_token
  326.  
  327.     
  328.     def verify_request(self, oauth_request):
  329.         version = self._get_version(oauth_request)
  330.         consumer = self._get_consumer(oauth_request)
  331.         token = self._get_token(oauth_request, 'access')
  332.         self._check_signature(oauth_request, consumer, token)
  333.         parameters = oauth_request.get_nonoauth_parameters()
  334.         return (consumer, token, parameters)
  335.  
  336.     
  337.     def authorize_token(self, token, user):
  338.         return self.data_store.authorize_request_token(token, user)
  339.  
  340.     
  341.     def get_callback(self, oauth_request):
  342.         return oauth_request.get_parameter('oauth_callback')
  343.  
  344.     
  345.     def build_authenticate_header(self, realm = ''):
  346.         return {
  347.             'WWW-Authenticate': 'OAuth realm="%s"' % realm }
  348.  
  349.     
  350.     def _get_version(self, oauth_request):
  351.         
  352.         try:
  353.             version = oauth_request.get_parameter('oauth_version')
  354.         except:
  355.             version = VERSION
  356.  
  357.         if version and version != self.version:
  358.             raise OAuthError('OAuth version %s not supported.' % str(version))
  359.         version != self.version
  360.         return version
  361.  
  362.     
  363.     def _get_signature_method(self, oauth_request):
  364.         
  365.         try:
  366.             signature_method = oauth_request.get_parameter('oauth_signature_method')
  367.         except:
  368.             signature_method = SIGNATURE_METHOD
  369.  
  370.         
  371.         try:
  372.             signature_method = self.signature_methods[signature_method]
  373.         except:
  374.             signature_method_names = ', '.join(self.signature_methods.keys())
  375.             raise OAuthError('Signature method %s not supported try one of the following: %s' % (signature_method, signature_method_names))
  376.  
  377.         return signature_method
  378.  
  379.     
  380.     def _get_consumer(self, oauth_request):
  381.         consumer_key = oauth_request.get_parameter('oauth_consumer_key')
  382.         if not consumer_key:
  383.             raise OAuthError('Invalid consumer key.')
  384.         consumer_key
  385.         consumer = self.data_store.lookup_consumer(consumer_key)
  386.         if not consumer:
  387.             raise OAuthError('Invalid consumer.')
  388.         consumer
  389.         return consumer
  390.  
  391.     
  392.     def _get_token(self, oauth_request, token_type = 'access'):
  393.         token_field = oauth_request.get_parameter('oauth_token')
  394.         token = self.data_store.lookup_token(token_type, token_field)
  395.         if not token:
  396.             raise OAuthError('Invalid %s token: %s' % (token_type, token_field))
  397.         token
  398.         return token
  399.  
  400.     
  401.     def _check_signature(self, oauth_request, consumer, token):
  402.         (timestamp, nonce) = oauth_request._get_timestamp_nonce()
  403.         self._check_timestamp(timestamp)
  404.         self._check_nonce(consumer, token, nonce)
  405.         signature_method = self._get_signature_method(oauth_request)
  406.         
  407.         try:
  408.             signature = oauth_request.get_parameter('oauth_signature')
  409.         except:
  410.             raise OAuthError('Missing signature.')
  411.  
  412.         valid_sig = signature_method.check_signature(oauth_request, consumer, token, signature)
  413.         if not valid_sig:
  414.             (key, base) = signature_method.build_signature_base_string(oauth_request, consumer, token)
  415.             raise OAuthError('Invalid signature. Expected signature base string: %s' % base)
  416.         valid_sig
  417.         built = signature_method.build_signature(oauth_request, consumer, token)
  418.  
  419.     
  420.     def _check_timestamp(self, timestamp):
  421.         timestamp = int(timestamp)
  422.         now = int(time.time())
  423.         lapsed = now - timestamp
  424.         if lapsed > self.timestamp_threshold:
  425.             raise OAuthError('Expired timestamp: given %d and now %s has a greater difference than threshold %d' % (timestamp, now, self.timestamp_threshold))
  426.         lapsed > self.timestamp_threshold
  427.  
  428.     
  429.     def _check_nonce(self, consumer, token, nonce):
  430.         nonce = self.data_store.lookup_nonce(consumer, token, nonce)
  431.         if nonce:
  432.             raise OAuthError('Nonce already used: %s' % str(nonce))
  433.         nonce
  434.  
  435.  
  436.  
  437. class OAuthClient(object):
  438.     consumer = None
  439.     token = None
  440.     
  441.     def __init__(self, oauth_consumer, oauth_token):
  442.         self.consumer = oauth_consumer
  443.         self.token = oauth_token
  444.  
  445.     
  446.     def get_consumer(self):
  447.         return self.consumer
  448.  
  449.     
  450.     def get_token(self):
  451.         return self.token
  452.  
  453.     
  454.     def fetch_request_token(self, oauth_request):
  455.         raise NotImplementedError
  456.  
  457.     
  458.     def fetch_access_token(self, oauth_request):
  459.         raise NotImplementedError
  460.  
  461.     
  462.     def access_resource(self, oauth_request):
  463.         raise NotImplementedError
  464.  
  465.  
  466.  
  467. class OAuthDataStore(object):
  468.     
  469.     def lookup_consumer(self, key):
  470.         raise NotImplementedError
  471.  
  472.     
  473.     def lookup_token(self, oauth_consumer, token_type, token_token):
  474.         raise NotImplementedError
  475.  
  476.     
  477.     def lookup_nonce(self, oauth_consumer, oauth_token, nonce, timestamp):
  478.         raise NotImplementedError
  479.  
  480.     
  481.     def fetch_request_token(self, oauth_consumer):
  482.         raise NotImplementedError
  483.  
  484.     
  485.     def fetch_access_token(self, oauth_consumer, oauth_token):
  486.         raise NotImplementedError
  487.  
  488.     
  489.     def authorize_request_token(self, oauth_token, user):
  490.         raise NotImplementedError
  491.  
  492.  
  493.  
  494. class OAuthSignatureMethod(object):
  495.     
  496.     def get_name(self):
  497.         raise NotImplementedError
  498.  
  499.     
  500.     def build_signature_base_string(self, oauth_request, oauth_consumer, oauth_token):
  501.         raise NotImplementedError
  502.  
  503.     
  504.     def build_signature(self, oauth_request, oauth_consumer, oauth_token):
  505.         raise NotImplementedError
  506.  
  507.     
  508.     def check_signature(self, oauth_request, consumer, token, signature):
  509.         built = self.build_signature(oauth_request, consumer, token)
  510.         return built == signature
  511.  
  512.  
  513.  
  514. class OAuthSignatureMethod_HMAC_SHA1(OAuthSignatureMethod):
  515.     
  516.     def get_name(self):
  517.         return 'HMAC-SHA1'
  518.  
  519.     
  520.     def build_signature_base_string(self, oauth_request, consumer, token):
  521.         sig = (escape(oauth_request.get_normalized_http_method()), escape(oauth_request.get_normalized_http_url()), escape(oauth_request.get_normalized_parameters()))
  522.         key = '%s&' % escape(consumer.secret)
  523.         if token:
  524.             key += escape(token.secret)
  525.         
  526.         raw = '&'.join(sig)
  527.         return (key, raw)
  528.  
  529.     
  530.     def build_signature(self, oauth_request, consumer, token):
  531.         (key, raw) = self.build_signature_base_string(oauth_request, consumer, token)
  532.         
  533.         try:
  534.             import hashlib
  535.             hashed = hmac.new(key, raw, hashlib.sha1)
  536.         except:
  537.             import sha
  538.             hashed = hmac.new(key, raw, sha)
  539.  
  540.         return base64.b64encode(hashed.digest())
  541.  
  542.  
  543.  
  544. class OAuthSignatureMethod_PLAINTEXT(OAuthSignatureMethod):
  545.     
  546.     def get_name(self):
  547.         return 'PLAINTEXT'
  548.  
  549.     
  550.     def build_signature_base_string(self, oauth_request, consumer, token):
  551.         sig = escape(consumer.secret) + '&'
  552.         if token:
  553.             sig = sig + escape(token.secret)
  554.         
  555.         return sig
  556.  
  557.     
  558.     def build_signature(self, oauth_request, consumer, token):
  559.         return self.build_signature_base_string(oauth_request, consumer, token)
  560.  
  561.  
  562.