Protecting Art Assets With Encryption

Download Code File

Why protect assets
Your art is just as valuable as your code, and in some cases, more valuable. Putting all your art out for people to look at, rip off, or modify may not be something you want to do. This will help give you an idea about how to protect your art resources.

CryptoStream
Almost all I/O in the engine is done through the Stream class. This is an optimal entry point for the encryption. The first thing I did was to create a subclass of Stream called CryptoStream.

class CryptoStream : public Stream
{
   typedef Stream Parent;

protected:
   Stream *mWrappedStream;

   virtual bool _read( const U32 in_numBytes, void *out_pBuffer );
   virtual bool _write( const U32 in_numBytes, const void *in_pBuffer );

   virtual bool encrypt( const U32 size, const void *in, void *out ) = 0;
   virtual bool decrypt( const U32 size, const void *in, void *out ) = 0;

public:
   CryptoStream( Stream *wrapstream ) : mWrappedStream( wrapstream ) { setStatus( mWrappedStream->getStatus() ); };
   virtual Stream::Status getStatus() const { return mWrappedStream->getStatus(); };

   virtual bool hasCapability( const Capability caps ) const { return mWrappedStream->hasCapability( caps ); };
   virtual U32 getPosition() const { return mWrappedStream->getPosition(); };
   virtual bool setPosition( const U32 position ) { return mWrappedStream->setPosition( position ); };
   virtual U32 getStreamSize() { return mWrappedStream->getStreamSize(); };
};

Overview of CryptoStream
The goal of this class is to take another Stream, and wrap around it, providing encrypted I/O regardless of what kind of stream it is. Memory stream, file stream, network stream, it doesn't matter. As you can see there were a few methods overridden to point at the wrapped stream, and two pure-virtual methods added, 'encrypt' and 'decrypt'. This is a pure-virtual class, and so we need to subclass it to make use of it.

XOR Encryption
The encryption I chose to use for the purposes of this document is a very, very, simple 8-bit XOR encryption. This is not something you want to use to protect your assets. This is an example only. It will work against the casual user, but if someone says, "Oh I bet they just used that encryption resource," and an 8-bit key can be brute forced in less than a second. Now that that is out of the way, the XORStream class:

class XORStream : public CryptoStream
{
   typedef CryptoStream Parent;

protected:
   U8 mKey;

   virtual bool encrypt( const U32 size, const void *in, void *out );
   virtual bool decrypt( const U32 size, const void *in, void *out );

public:
   XORStream( Stream *stream, U8 key ) : mKey( key ), Parent( stream ) {};
};

//------------------------------------------------------------------------------

bool XORStream::encrypt( const U32 size, const void *in, void *out )
{
   for( int i = 0; i < size; i++ )
      ((U8 *)out)[i] = ((U8 *)in)[i] ^ mKey;

   return true;
}

//------------------------------------------------------------------------------


bool XORStream::decrypt( const U32 size, const void *in, void *out )
{
   return encrypt( size, in, out );
}

Using a CryptoStream
Now, how to go about using this class? I chose to add encryption to PNG files because it is very easy and will demonstrate the basics of how to use this in other parts of the engine. The general format for adding it to somewhere in the engine is this:

1. Read the header of a file. If the header is ok, continue like normal.
2. If the header is not ok, create the appropriate CryptoStream, re-read the header.
3. If the header is now ok, you have an encrypted asset, since the de-crypted header was ok.
4. Assign the CryptoStream pointer to the default pointer, so the rest of the read function will read out of the CryptoStream instead.

And that's about it. How does this translate into reading PNGs? Look at GBitmap::readPNG()

First store the starting stream position

#ifdef PNGCRYPT
   U32 startStreamPos = io_rStream.getPosition();
#endif

Next test the PNG header

bool isPng = png_check_sig(header, cs_headerBytesChecked) != 0;

#ifdef PNGCRYPT
   XORStream *xstream = NULL;

   if( !isPng )
   {
      // Check to see if it's encrypted
      io_rStream.setPosition( startStreamPos );

      xstream = new XORStream( &io_rStream, PNGCRYPT_KEY );

      // Re-read and re-check the header now
      xstream->read(cs_headerBytesChecked, header);
      isPng = png_check_sig(header, cs_headerBytesChecked) != 0;

      if( !isPng )
      {
         // Guess not
         delete xstream;
         xstream = NULL;
      }
   }
#endif

A bit later in the PNG code it will set a global PNG read stream, if this is a encrypted PNG, we should set it to the XORStream instead:

sg_pStream = &io_rStream;

#ifdef PNGCRYPT
   if( xstream != NULL )
      sg_pStream = xstream;
#endif

Finally, before the function returns, but after all reading is done, clean up memory

sg_pStream = NULL;

#ifdef PNGCRYPT
   if( xstream != NULL )
      delete xstream;
#endif

Finishing Up
So you may be asking, "Well that's all well and good, but how do I MAKE an encrypted PNG?" I included a very small console app for encrypting/decrypting files in the zip file with the code. Just compile that and you should be good to go. You can also write encrypted streams from inside Torque with a CryptoStream should you want to do that, as well.