diff --git a/ndn-cpp/util/blob.hpp b/ndn-cpp/util/blob.hpp
index 0572301..d71808d 100644
--- a/ndn-cpp/util/blob.hpp
+++ b/ndn-cpp/util/blob.hpp
@@ -12,16 +12,16 @@
 namespace ndn {
 
 /**
- * A Blob holds a pointer to an immutable byte array implemented as const std::vector<unsigned char>.  
+ * A Blob holds a pointer to an immutable byte array implemented as const std::vector<uint8_t>.  
  * This is like a JavaScript string which is a pointer to an immutable string.  
  * It is OK to pass a pointer to the string because the new owner can't change the bytes
  * of the string.  However, like a JavaScript string, it is possible to change the pointer, and so this does allow
  * the copy constructor and assignment to change the pointer.  Also remember that the pointer can be null.
- * (Note that we could have made Blob derive directly from vector<unsigned char> and then explicitly use
+ * (Note that we could have made Blob derive directly from vector<uint8_t> and then explicitly use
  * a pointer to it like shared_ptr<Blob>, but this does not enforce immutability because we can't declare
- * Blob as derived from const vector<unsigned char>.)
+ * Blob as derived from const vector<uint8_t>.)
  */
-class Blob : public ptr_lib::shared_ptr<const std::vector<unsigned char> > {
+class Blob : public ptr_lib::shared_ptr<const std::vector<uint8_t> > {
 public:
   /**
    * Create a new Blob with a null pointer.
@@ -35,19 +35,19 @@
    * @param value A pointer to the byte array which is copied.
    * @param valueLength The length of value.
    */
-  Blob(const unsigned char* value, unsigned int valueLength)
-  : ptr_lib::shared_ptr<const std::vector<unsigned char> >(new std::vector<unsigned char>(value, value + valueLength))
+  Blob(const uint8_t* value, unsigned int valueLength)
+  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(new std::vector<uint8_t>(value, value + valueLength))
   {
   }
   
   /**
    * Create a new Blob with an immutable copy of the array in the given vector.
    * If you want to transfer the array without copying, the the vector has to start as a 
-   * ptr_lib::shared_ptr<std::vector<unsigned char> > and you can use the Blob constructor with this type.
+   * ptr_lib::shared_ptr<std::vector<uint8_t> > and you can use the Blob constructor with this type.
    * @param value A reference to a vector which is copied.
    */
-  Blob(const std::vector<unsigned char> &value)
-  : ptr_lib::shared_ptr<const std::vector<unsigned char> >(new std::vector<unsigned char>(value))
+  Blob(const std::vector<uint8_t> &value)
+  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(new std::vector<uint8_t>(value))
   {
   }
   
@@ -56,12 +56,12 @@
    * if you keep a pointer to the array then you must treat the array as immutable and promise not to change it.
    * @param value A pointer to a vector with the byte array.  This takes another reference and does not copy the bytes.
    */
-  Blob(const ptr_lib::shared_ptr<std::vector<unsigned char> > &value)
-  : ptr_lib::shared_ptr<const std::vector<unsigned char> >(value)
+  Blob(const ptr_lib::shared_ptr<std::vector<uint8_t> > &value)
+  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(value)
   {
   }
-  Blob(const ptr_lib::shared_ptr<const std::vector<unsigned char> > &value)
-  : ptr_lib::shared_ptr<const std::vector<unsigned char> >(value)
+  Blob(const ptr_lib::shared_ptr<const std::vector<uint8_t> > &value)
+  : ptr_lib::shared_ptr<const std::vector<uint8_t> >(value)
   {
   }
   
@@ -80,7 +80,7 @@
   /**
    * Return a const pointer to the first byte of the immutable byte array, or 0 if the pointer is null.
    */
-  const unsigned char* 
+  const uint8_t* 
   buf() const
   {
     if (*this)