Strings of unsigned chars

Question

Here's an interesting one. I'm writing an AES encryption algorithm, and have managed to get it making accurate encryptions. The trouble comes when I attempt to write the result to a file. I was getting files with incorrect output. Hex values would be mangled and it was just generally nonsensical (even by encrypted standards).

I did some debugging by sampling my encryption output before sending it to the file. What I found was that I was getting some type of overflow somewhere. When the correct hex value was supposed to be 9e, I would get ffffff9e. It would do this only to hex values above 7F, i.e. characters in the "extended" character set weren't being handled properly. This had happened to me earlier in my project as well, and the problem then had been using a char[][] container instead of an unsigned char[][] container.

My code uses strings to pass the encrypted data between the user interface and AES encryption class. I'm guessing that std::strings don't support the extended character set. So my question is: is there a way to instantiate an unsigned string, or will I have to find a way to replace all of my usage of strings?

Answer 1

std::string is really just a typedef, something like:

namespace std { 
   typedef basic_string<char> string;
}

It's fairly easy to create a variant for unsigned char:

typedef basic_string<unsigned char> ustring;

You will, however, have to change your code to use a ustring (or whatever name you prefer) instead of std::string though.

Depending on how you've written your code, that may not require editing all the code though. In particular, if you have something like:

namespace crypto { 
   using std::string;

   class AES { 
      string data;
      // ..
    };
}

You can change the string type by changing only the using declaration:

namespace unsigned_types { 
    typedef std::basic_string<unsigned char> string;
}

// ...

namespace crypto {
    using unsigned_types::string;

    class AES {
        string data;
    };
}

Also note that different instantiations of a template are entirely separate types, even when the types over which they're intantiated are related, so the fact that you can convert implicitly between char and unsigned char doesn't mean you'll get a matching implicit conversion between basic_string<char> and basic_string<unsigned char>.