diff --git a/lib/util.py b/lib/util.py
new file mode 100644
index 0000000..71fc36b
--- /dev/null
+++ b/lib/util.py
@@ -0,0 +1,198 @@
+#
+#   Copyright 2017 CNIT - Consorzio Nazionale Interuniversitario per le Telecomunicazioni
+#
+#   Licensed under the Apache License, Version 2.0 (the "License");
+#   you may not use this file except in compliance with the License.
+#   You may obtain a copy of the License at
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#   Unless required by applicable law or agreed to in writing, software
+#   distributed under the License is distributed on an  BASIS,
+#   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#   See the License for the specific language governing permissions and
+#   limitations under the License.
+#
+
+import json
+import yaml
+import pyaml
+import logging
+import jsonschema
+import uuid 
+
+_lib_name = 'Util'
+
+
+logging.basicConfig(level=logging.DEBUG)
+log = logging.getLogger('lib/util.py')
+
+
+class Util(object):
+
+    def __init__(self):
+        # logging.basicConfig(level=logging.DEBUG)
+        # self.log = logging.getLogger('UtilLogger')
+        pass
+
+
+    @classmethod
+    def json_load_byteified(cls, file_handle):
+        return cls._byteify(
+            json.load(file_handle, object_hook=cls._byteify),
+            ignore_dicts=True
+        )
+
+    @classmethod
+    def json_loads_byteified(cls, json_text):
+        return cls._byteify(
+            json.loads(json_text, object_hook=cls._byteify),
+            ignore_dicts=True
+        )
+
+    @classmethod
+    def _byteify(cls, data, ignore_dicts = False):
+        # if this is a unicode string, return its string representation
+        if isinstance(data, unicode):
+            return data.encode('utf-8')
+        # if this is a list of values, return list of byteified values
+        if isinstance(data, list):
+            return [ cls._byteify(item, ignore_dicts=True) for item in data ]
+        # if this is a dictionary, return dictionary of byteified keys and values
+        # but only if we haven't already byteified it
+        if isinstance(data, dict) and not ignore_dicts:
+            return {
+                cls._byteify(key, ignore_dicts=True): cls._byteify(value, ignore_dicts=True)
+                for key, value in data.iteritems()
+            }
+        # if it's anything else, return it in its original form
+        return data
+
+    @classmethod
+    def yaml2json(cls, object_yaml):
+        """Converts a yaml object into a json representation"""
+        log.debug('yaml2json')
+        return json.dumps(object_yaml, sort_keys=True, indent=2) if not object_yaml is None else None
+
+    @classmethod
+    def json2yaml(cls, object_json):
+        """Converts a json object into a yaml representation"""
+        log.debug('json2yaml')
+        return yaml.safe_dump(object_json, default_flow_style=False) if not object_json is None else None
+
+    @classmethod
+    def openfile(cls, filepath, mode='r', buffering=1):
+        """Returns an open file given a filepath
+
+        If the filepath is already an open file, returns into
+        Raises Exception
+        """
+
+        log.debug('reading file ' + filepath)
+        try:
+            if isinstance(filepath, file):
+                return filepath
+            else:
+                return open(filepath, mode, buffering)
+
+        except IOError as e:
+            log.exception('openfile', e)
+            raise
+
+    @classmethod
+    def loadyamlfile(cls, name):
+        """Returns a yaml object from a filename or an open file
+
+        Raises Exception
+        """
+
+        yaml_object = None
+        try:
+            if isinstance(name, file):
+                yaml_object = yaml.load(name)
+            else:
+                yaml_file = cls.openfile(name)
+                yaml_object = yaml.load(yaml_file)
+
+            return yaml_object
+        except Exception as e:
+            log.exception('Exception loadYamlFile', e)
+            raise
+
+    @classmethod
+    def loadjsonfile(cls, name):
+        """Returns a json object from a filename or an open file
+
+        Raises Exception
+        """
+
+        json_object = None
+        try:
+            #raise IOError('error from throws')
+            if isinstance(name, file):
+                json_object = json.load(name)
+            else:
+                # json_file = self.openfile(name)
+                json_file = cls.openfile(name)
+                json_object = json.load(json_file)
+
+            return json_object
+        except Exception as e:
+            log.exception('Exception loadJsonFile', e)
+            raise
+
+    @classmethod
+    def writejsonfile(cls, name, json_object):
+        """Writes the dump of a json obj to a filename or an open file
+
+        Raises Exception
+        """
+
+        try:
+            log.debug('writejsonfile ' + name)
+            if isinstance(name, file):
+                json_object = json.dump(json_object, name)
+            else:
+                json_file = cls.openfile(name, 'w')
+                json_object = json.dump(json_object, json_file,separators=(',',': '), indent=4)
+        except Exception as e:
+            log.exception('Exception writejsonfile', e)
+            raise
+
+    @classmethod
+    def writeyamlfile(cls, name, yaml_object):
+        """Writes the dump of a yaml obj to a filename or an open file
+
+        Raises Exception
+        """
+
+        try:
+            log.debug('writeyamlfile ' + name)
+            if isinstance(name, file):
+                yaml_object = pyaml.dump(yaml_object, name, safe=True)
+            else:
+                yaml_file = cls.openfile(name, 'w')
+                yaml_object = pyaml.dump(yaml_object, yaml_file, safe=True)
+        except Exception as e:
+            log.exception('Exception writeyamlfile')
+            raise
+
+    @classmethod
+    def validate_json_schema(cls, reference_schema, data):
+        """Validates a json data against a json schema
+
+        Raises Exception
+        """
+
+        try:
+            # schema = cls.loadjsonfile("lib/etsi/schemas/"+type_descriptor+".json")
+             #print 'type_descriptor : '+type_descriptor
+            jsonschema.validate(data, reference_schema)
+            return True
+        except Exception as e:
+            log.exception('Exception validate json schema', e)
+            return False
+
+    @classmethod
+    def get_unique_id(cls):
+        return uuid.uuid4().hex[:6].upper()