safe_string.h

Go to the documentation of this file.

/* Libmacro - A multi-platform, extendable macro and hotkey C library
  Copyright (C) 2013 Jonathan Pelletier, New Paradigm Software

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
*/

#ifndef MCR_EXTRAS_SAFE_STRING_H_
#define MCR_EXTRAS_SAFE_STRING_H_

#include "mcr/extras/util/string.h"
#include <cstring>

/* 256 / 8, 256 bits => 32 bytes */
#define MCR_AES_BLOCK_SIZE 32

#define MCR_AES_IV_SIZE 16

#define MCR_AES_TAG_SIZE 16

namespace mcr
{
class MCR_API IKeyProvider
{
public:
    MCR_DECL_INTERFACE(IKeyProvider)

    
    virtual void key(const void *obj,
                     const unsigned char *keyOut[MCR_AES_BLOCK_SIZE]) = 0;
    virtual void deregister(const void *obj) = 0;
};

class MCR_API SafeString
{
public:
    SafeString(IKeyProvider *keyProvider = nullptr,
               const String &str = String(),
               bool cryptic = true)
        : _cryptic(cryptic
                   && keyProvider), _encrypted(nullptr), _encryptedBufferSize(0),
          _encryptedBytes(0), _keyProvider(keyProvider), _iv {0}, _lenMem(0),
          _plain(nullptr), _plainBufferSize(0), _stateless(false), _tag {0}
    {
        if (_cryptic)
            resetIv();
        setText(str);
    }
    SafeString(const SafeString &copytron);
    virtual ~SafeString();
    SafeString &operator =(const SafeString &copytron)
    {
        if (&copytron != this)
            setText(copytron.text());
        return *this;
    }
    inline SafeString &operator =(const String &str)
    {
        setText(str);
        return *this;
    }
    inline SafeString &operator =(const char *str)
    {
        if (!str)
            str = "";
        setText(str, strlen(str));
        return *this;
    }

    static inline int encrypt(const String &plainText,
                              const unsigned char key[MCR_AES_BLOCK_SIZE],
                              const unsigned char iv[MCR_AES_IV_SIZE],
                              unsigned char tagOut[MCR_AES_TAG_SIZE], unsigned char *bufferOut)
    {
        return encrypt(*plainText, plainText.length(), key, iv, tagOut, bufferOut);
    }
    static int encrypt(const char *plain, size_t plainLen,
                       const unsigned char key[MCR_AES_BLOCK_SIZE],
                       const unsigned char iv[MCR_AES_IV_SIZE],
                       unsigned char tagOut[MCR_AES_TAG_SIZE], unsigned char *bufferOut);
    static inline String decrypt(const unsigned char *encrypted,
                                 int encryptedLength,
                                 const unsigned char key[MCR_AES_BLOCK_SIZE],
                                 const unsigned char iv[MCR_AES_IV_SIZE],
                                 const unsigned char tag[])
    {
        String ret;
        size_t decLen = 0;
        if (!encrypted || !encryptedLength)
            return ret ? ret : nullptr;
        ret.resize(encryptedLength);
        /* May throw, string will delete self */
        decLen = decrypt(encrypted, encryptedLength, key, iv, tag, ret.string());
        if (static_cast<int>(decLen) != -1)
            ret.setLength(decLen);
        return ret;
    }
    static size_t decrypt(const unsigned char *encrypted, int encryptedLength,
                          const unsigned char key[MCR_AES_BLOCK_SIZE],
                          const unsigned char iv[MCR_AES_IV_SIZE],
                          const unsigned char tag[], char *bufferOut);
    static void randomize(unsigned char *bufferOut, int bufferSize);
    static inline void sha(const String &text,
                           unsigned char bufferOut[MCR_AES_BLOCK_SIZE])
    {
        sha(*text, text.length(), bufferOut);
    }
    static void sha(const char *text, size_t textLen,
                    unsigned char bufferOut[MCR_AES_BLOCK_SIZE]);
    static void initialize();
    static void deinitialize();
    static inline void generateKey(unsigned char keyOut[MCR_AES_BLOCK_SIZE])
    {
        if (keyOut)
            randomize(keyOut, MCR_AES_BLOCK_SIZE);
    }
    static inline void initializer(unsigned char ivOut[MCR_AES_IV_SIZE])
    {
        if (ivOut)
            randomize(ivOut, MCR_AES_IV_SIZE);
    }

    int compare(const SafeString &rhs) const;

    inline bool cryptic() const
    {
        return _cryptic;
    }
    void setCryptic(bool val);
    inline IKeyProvider *keyProvider() const
    {
        return _keyProvider;
    }
    void setKeyProvider(IKeyProvider *provider);
    inline const unsigned char *iv() const
    {
        return _iv;
    }
    void setIv(unsigned char *iv);
    void resetIv();
    inline bool stateless() const
    {
        return _stateless;
    }
    void setStateless(bool val);

    inline size_t length() const
    {
        return _lenMem;
    }
    inline String text() const
    {
        String ret;
        if (!_cryptic)
            return _plain ? _plain : "";
        if (!_lenMem)
            return "";
        ret.resize(_lenMem);
        text(ret.string());
        ret.setLength(_lenMem);
        return ret;
    }
    size_t text(char *bufferOut) const;
    inline void setText(const String &str = String())
    {
        setText(*str, str.length());
    }
    void setText(const char *str, size_t len);
    inline void setText(const String &str, bool cryptic)
    {
        setText(*str, str.length(), cryptic);
    }
    void setText(const char *str, size_t len, bool cryptic);

    void clear();
private:
    bool _cryptic;
    unsigned char *_encrypted;
    int _encryptedBufferSize;
    int _encryptedBytes;
    IKeyProvider *_keyProvider;
    unsigned char _iv[MCR_AES_IV_SIZE];
    size_t _lenMem;
    char *_plain;
    size_t _plainBufferSize;
    bool _stateless;
    unsigned char _tag[MCR_AES_TAG_SIZE];
};
}

#endif