code.grnet.gr Git - ganeti-local/blob - lib/serializer.py

   1 #
   2 #
   3
   4 # Copyright (C) 2007, 2008 Google Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful, but
  12 # WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 # General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20
  21 """Serializer abstraction module
  22
  23 This module introduces a simple abstraction over the serialization
  24 backend (currently json).
  25
  26 """
  27 # pylint: disable-msg=C0103
  28
  29 # C0103: Invalid name, since pylint doesn't see that Dump points to a
  30 # function and not a constant
  31
  32 import simplejson
  33 import re
  34
  35 from ganeti import errors
  36 from ganeti import utils
  37
  38
  39 _JSON_INDENT = 2
  40
  41 _RE_EOLSP = re.compile('[ \t]+$', re.MULTILINE)
  42
  43
  44 def _GetJsonDumpers(_encoder_class=simplejson.JSONEncoder):
  45   """Returns two JSON functions to serialize data.
  46
  47   @rtype: (callable, callable)
  48   @return: The function to generate a compact form of JSON and another one to
  49            generate a more readable, indented form of JSON (if supported)
  50
  51   """
  52   plain_encoder = _encoder_class(sort_keys=True)
  53
  54   # Check whether the simplejson module supports indentation
  55   try:
  56     indent_encoder = _encoder_class(indent=_JSON_INDENT, sort_keys=True)
  57   except TypeError:
  58     # Indentation not supported
  59     indent_encoder = plain_encoder
  60
  61   return (plain_encoder.encode, indent_encoder.encode)
  62
  63
  64 (_DumpJson, _DumpJsonIndent) = _GetJsonDumpers()
  65
  66
  67 def DumpJson(data, indent=True):
  68   """Serialize a given object.
  69
  70   @param data: the data to serialize
  71   @param indent: whether to indent output (depends on simplejson version)
  72
  73   @return: the string representation of data
  74
  75   """
  76   if indent:
  77     fn = _DumpJsonIndent
  78   else:
  79     fn = _DumpJson
  80
  81   txt = _RE_EOLSP.sub("", fn(data))
  82   if not txt.endswith('\n'):
  83     txt += '\n'
  84
  85   return txt
  86
  87
  88 def LoadJson(txt):
  89   """Unserialize data from a string.
  90
  91   @param txt: the json-encoded form
  92
  93   @return: the original data
  94
  95   """
  96   return simplejson.loads(txt)
  97
  98
  99 def DumpSignedJson(data, key, salt=None, key_selector=None):
 100   """Serialize a given object and authenticate it.
 101
 102   @param data: the data to serialize
 103   @param key: shared hmac key
 104   @param key_selector: name/id that identifies the key (in case there are
 105     multiple keys in use, e.g. in a multi-cluster environment)
 106   @return: the string representation of data signed by the hmac key
 107
 108   """
 109   txt = DumpJson(data, indent=False)
 110   if salt is None:
 111     salt = ''
 112   signed_dict = {
 113     'msg': txt,
 114     'salt': salt,
 115     }
 116
 117   if key_selector:
 118     signed_dict["key_selector"] = key_selector
 119   else:
 120     key_selector = ""
 121
 122   signed_dict["hmac"] = utils.Sha1Hmac(key, txt, salt=salt + key_selector)
 123
 124   return DumpJson(signed_dict, indent=False)
 125
 126
 127 def LoadSignedJson(txt, key):
 128   """Verify that a given message was signed with the given key, and load it.
 129
 130   @param txt: json-encoded hmac-signed message
 131   @param key: the shared hmac key or a callable taking one argument (the key
 132     selector), which returns the hmac key belonging to the key selector.
 133     Typical usage is to pass a reference to the get method of a dict.
 134   @rtype: tuple of original data, string
 135   @return: original data, salt
 136   @raises errors.SignatureError: if the message signature doesn't verify
 137
 138   """
 139   signed_dict = LoadJson(txt)
 140   if not isinstance(signed_dict, dict):
 141     raise errors.SignatureError('Invalid external message')
 142   try:
 143     msg = signed_dict['msg']
 144     salt = signed_dict['salt']
 145     hmac_sign = signed_dict['hmac']
 146   except KeyError:
 147     raise errors.SignatureError('Invalid external message')
 148
 149   if callable(key):
 150     # pylint: disable-msg=E1103
 151     key_selector = signed_dict.get("key_selector", None)
 152     hmac_key = key(key_selector)
 153     if not hmac_key:
 154       raise errors.SignatureError("No key with key selector '%s' found" %
 155                                   key_selector)
 156   else:
 157     key_selector = ""
 158     hmac_key = key
 159
 160   if not utils.VerifySha1Hmac(hmac_key, msg, hmac_sign,
 161                               salt=salt + key_selector):
 162     raise errors.SignatureError('Invalid Signature')
 163
 164   return LoadJson(msg), salt
 165
 166
 167 Dump = DumpJson
 168 Load = LoadJson
 169 DumpSigned = DumpSignedJson
 170 LoadSigned = LoadSignedJson