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=C0103
  28
  29 # C0103: Invalid name, since pylint doesn't see that Dump points to a
  30 # function and not a constant
  31
  32 _OLD_SIMPLEJSON = False
  33
  34 try:
  35   import json
  36 except ImportError:
  37   # The "json" module was only added in Python 2.6. Earlier versions must use
  38   # the separate "simplejson" module.
  39   import simplejson as json
  40   _OLD_SIMPLEJSON = True
  41
  42 import re
  43 import logging
  44
  45 from ganeti import errors
  46 from ganeti import utils
  47
  48
  49 _JSON_INDENT = 2
  50
  51 _RE_EOLSP = re.compile("[ \t]+$", re.MULTILINE)
  52
  53
  54 class _CustomJsonEncoder(json.JSONEncoder):
  55   if __debug__ and not _OLD_SIMPLEJSON:
  56     try:
  57       _orig_fn = json.JSONEncoder._iterencode_dict
  58     except AttributeError:
  59       raise Exception("Can't override JSONEncoder's '_iterencode_dict'")
  60     else:
  61       def _iterencode_dict(self, data, *args, **kwargs):
  62         for key in data.keys():
  63           if not (key is None or isinstance(key, (basestring, bool))):
  64             raise ValueError("Key '%s' is of disallowed type '%s'" %
  65                              (key, type(key)))
  66
  67         return self._orig_fn(data, *args, **kwargs)
  68
  69
  70 def _GetJsonDumpers(_encoder_class=_CustomJsonEncoder):
  71   """Returns two JSON functions to serialize data.
  72
  73   @rtype: (callable, callable)
  74   @return: The function to generate a compact form of JSON and another one to
  75            generate a more readable, indented form of JSON (if supported)
  76
  77   """
  78   plain_encoder = _encoder_class(sort_keys=True)
  79
  80   # Check whether the simplejson module supports indentation
  81   try:
  82     indent_encoder = _encoder_class(indent=_JSON_INDENT, sort_keys=True)
  83   except TypeError:
  84     # Indentation not supported
  85     indent_encoder = plain_encoder
  86
  87   return (plain_encoder.encode, indent_encoder.encode)
  88
  89
  90 (_DumpJson, _DumpJsonIndent) = _GetJsonDumpers()
  91
  92
  93 def DumpJson(data, indent=True):
  94   """Serialize a given object.
  95
  96   @param data: the data to serialize
  97   @param indent: whether to indent output (depends on simplejson version)
  98
  99   @return: the string representation of data
 100
 101   """
 102   if indent:
 103     fn = _DumpJsonIndent
 104   else:
 105     fn = _DumpJson
 106
 107   txt = _RE_EOLSP.sub("", fn(data))
 108   if not txt.endswith("\n"):
 109     txt += "\n"
 110
 111   return txt
 112
 113
 114 def LoadJson(txt):
 115   """Unserialize data from a string.
 116
 117   @param txt: the json-encoded form
 118
 119   @return: the original data
 120
 121   """
 122   return json.loads(txt)
 123
 124
 125 def DumpSignedJson(data, key, salt=None, key_selector=None):
 126   """Serialize a given object and authenticate it.
 127
 128   @param data: the data to serialize
 129   @param key: shared hmac key
 130   @param key_selector: name/id that identifies the key (in case there are
 131     multiple keys in use, e.g. in a multi-cluster environment)
 132   @return: the string representation of data signed by the hmac key
 133
 134   """
 135   txt = DumpJson(data, indent=False)
 136   if salt is None:
 137     salt = ""
 138   signed_dict = {
 139     "msg": txt,
 140     "salt": salt,
 141     }
 142
 143   if key_selector:
 144     signed_dict["key_selector"] = key_selector
 145   else:
 146     key_selector = ""
 147
 148   signed_dict["hmac"] = utils.Sha1Hmac(key, txt, salt=salt + key_selector)
 149
 150   return DumpJson(signed_dict, indent=False)
 151
 152
 153 def LoadSignedJson(txt, key):
 154   """Verify that a given message was signed with the given key, and load it.
 155
 156   @param txt: json-encoded hmac-signed message
 157   @param key: the shared hmac key or a callable taking one argument (the key
 158     selector), which returns the hmac key belonging to the key selector.
 159     Typical usage is to pass a reference to the get method of a dict.
 160   @rtype: tuple of original data, string
 161   @return: original data, salt
 162   @raises errors.SignatureError: if the message signature doesn't verify
 163
 164   """
 165   signed_dict = LoadJson(txt)
 166   if not isinstance(signed_dict, dict):
 167     raise errors.SignatureError("Invalid external message")
 168   try:
 169     msg = signed_dict["msg"]
 170     salt = signed_dict["salt"]
 171     hmac_sign = signed_dict["hmac"]
 172   except KeyError:
 173     raise errors.SignatureError("Invalid external message")
 174
 175   if callable(key):
 176     # pylint: disable=E1103
 177     key_selector = signed_dict.get("key_selector", None)
 178     hmac_key = key(key_selector)
 179     if not hmac_key:
 180       raise errors.SignatureError("No key with key selector '%s' found" %
 181                                   key_selector)
 182   else:
 183     key_selector = ""
 184     hmac_key = key
 185
 186   if not utils.VerifySha1Hmac(hmac_key, msg, hmac_sign,
 187                               salt=salt + key_selector):
 188     raise errors.SignatureError("Invalid Signature")
 189
 190   return LoadJson(msg), salt
 191
 192
 193 Dump = DumpJson
 194 Load = LoadJson
 195 DumpSigned = DumpSignedJson
 196 LoadSigned = LoadSignedJson