diff --git a/KeePit/aes.cpp b/KeePit/aes.cpp
index 9e6467d..dcdc0ac 100644
--- a/KeePit/aes.cpp
+++ b/KeePit/aes.cpp
@@ -33,6 +33,14 @@ Aes::Aes()
 {
 }
 
+/// \brief Aes::decrypt
+///        Decrypts an AES byte array using CryptoPP
+/// \param pbAesKey The Aes key used to decrypt the file
+/// \param keysize The size of the key
+/// \param pbEncryptionIV The encryption IV
+/// \param pbFileContent The pointer to a byte array containing the Aes encrypted content
+/// \param contentSize The size of the content
+/// \return A string containing the decrypted file content
 string Aes::decrypt(byte * pbAesKey, uint keysize, byte* pbEncryptionIV, byte* pbFileContent, uint contentSize) {
 
     string recovered;
diff --git a/KeePit/arrayextensions.cpp b/KeePit/arrayextensions.cpp
index f3990f3..cbea536 100644
--- a/KeePit/arrayextensions.cpp
+++ b/KeePit/arrayextensions.cpp
@@ -24,6 +24,11 @@ ArrayExtensions::ArrayExtensions()
 {
 }
 
+/// \brief ArrayExtensions::toVector
+///        Converts a pointer to a char array into a Vector
+/// \param source The source pointer to a char array
+/// \param size The size of the array
+/// \return A vector containing the contents of the char array
 vector<char> ArrayExtensions::toVector(char* source, unsigned int size)
 {
     vector<char> destination;
diff --git a/KeePit/base64.cpp b/KeePit/base64.cpp
index 6c08095..8736e55 100644
--- a/KeePit/base64.cpp
+++ b/KeePit/base64.cpp
@@ -35,6 +35,11 @@ Base64::Base64()
 {
 }
 
+/// \brief Base64::base64_encode
+///        Base64 encodes the given pointer to the char array
+/// \param buf The buffer to encode
+/// \param bufLen The length of the buffer
+/// \return A string containing the base64 encoded content
 std::string Base64::base64_encode(char const* buf, unsigned int bufLen) {
   std::string ret;
   int i = 0;
@@ -76,6 +81,10 @@ std::string Base64::base64_encode(char const* buf, unsigned int bufLen) {
   return ret;
 }
 
+/// \brief Base64::base64_decode
+///        Decodes a base64 string
+/// \param encoded_string The encoded string
+/// \return A vector of char containing the encoded content
 std::vector<char> Base64::base64_decode(std::string const& encoded_string) {
   int in_len = encoded_string.size();
   int i = 0;
diff --git a/KeePit/bytestream.cpp b/KeePit/bytestream.cpp
index d552fdb..dcd6bb2 100644
--- a/KeePit/bytestream.cpp
+++ b/KeePit/bytestream.cpp
@@ -7,6 +7,10 @@ typedef unsigned char byte;
 #define BYTESIZE 4
 #define SHORTSIZE 2
 
+/// \brief ByteStream::ByteStream
+///        A container for a byte array
+/// \param memblock The array to stream
+/// \param size The size of the array
 ByteStream::ByteStream(char* memblock, uint size)
 {
     vector<char> b(memblock, memblock + size);
@@ -14,6 +18,8 @@ ByteStream::ByteStream(char* memblock, uint size)
     pos = 0;
 }
 
+/// \brief ByteStream::~ByteStream
+///        ByteStream destructor
 ByteStream::~ByteStream()
 {
     for(uint i = 0; i<buffer.size(); i++)
@@ -24,7 +30,10 @@ ByteStream::~ByteStream()
     ArrayExtensions::Reset(buffer);
 }
 
-// Static method that reads only a byte from the given memblock array
+/// \brief ByteStream::ReadByte
+///        Static method that reads only a byte from the given memblock array
+/// \param memblock The char array to read from
+/// \return A uint containing the byte read
 uint ByteStream::ReadByte(char* memblock)
 {
     int tmpPos = 0;
@@ -45,7 +54,11 @@ uint ByteStream::ReadByte(char* memblock)
     return result;
 }
 
-// Reads a byte from the array given in the ctor and advances the pos
+///
+/// \brief ByteStream::ReadByte
+///        Reads a byte from the array given in the ctor and advances the pos
+/// \return
+///
 uint ByteStream::ReadByte()
 {
     uint result = 0;
@@ -64,7 +77,11 @@ uint ByteStream::ReadByte()
     return result;
 }
 
-// Reads a ushort from the array given in the ctor and advances the pos
+///
+/// \brief ByteStream::ReadShort
+///        Reads a ushort from the array given in the ctor and advances the pos
+/// \return
+///
 ushort ByteStream::ReadShort()
 {
     ushort result = 0;
@@ -83,7 +100,11 @@ ushort ByteStream::ReadShort()
     return result;
 }
 
-// Reads 1 byte at a time from the array given in the ctor
+///
+/// \brief ByteStream::Read
+///        Reads 1 byte at a time from the array given in the ctor
+/// \return
+///
 char ByteStream::Read()
 {
     char result = buffer[pos];
@@ -92,7 +113,11 @@ char ByteStream::Read()
     return result;
 }
 
-// Returns the current position in the array we have read to
+///
+/// \brief ByteStream::GetPosition
+///        Returns the current position in the array we have read to
+/// \return
+///
 int ByteStream::GetPosition()
 {
     return pos;
diff --git a/KeePit/compositekey.cpp b/KeePit/compositekey.cpp
index f7c8946..b95a543 100644
--- a/KeePit/compositekey.cpp
+++ b/KeePit/compositekey.cpp
@@ -41,6 +41,11 @@ struct String {
     size_t length;
 };
 
+///
+/// \brief CompositeKey::CompositeKey
+/// \param pbKey
+/// \param pbKeyFile
+///
 CompositeKey::CompositeKey(vector<char> pbKey, vector<char> pbKeyFile)
 {
     m_pbKey = pbKey;
@@ -51,6 +56,12 @@ CompositeKey::CompositeKey(vector<char> pbKey, vector<char> pbKeyFile)
     }
 }
 
+///
+/// \brief CompositeKey::generateKey32
+/// \param pbKeySeed32
+/// \param uNumRounds
+/// \return
+///
 vector<char> CompositeKey::generateKey32(vector<char> pbKeySeed32, ulong uNumRounds) {
     assert(pbKeySeed32.size() == MASTER_KEY_SIZE);
     if(pbKeySeed32.size() != MASTER_KEY_SIZE) {
@@ -85,6 +96,11 @@ vector<char> CompositeKey::generateKey32(vector<char> pbKeySeed32, ulong uNumRou
     return pbTrf32;
 }
 
+///
+/// \brief CompositeKey::createRawCompositeKey
+/// \param key
+/// \return
+///
 vector<char> CompositeKey::createRawCompositeKey(vector<char> key) {
 
     SHA256 sha256;
@@ -93,6 +109,13 @@ vector<char> CompositeKey::createRawCompositeKey(vector<char> key) {
     return hash;
 }
 
+///
+/// \brief CompositeKey::transformKey
+/// \param pbOriginalKey32
+/// \param pbKeySeed32
+/// \param uNumRounds
+/// \return
+///
 vector<char> CompositeKey::transformKey(vector<char> pbOriginalKey32, vector<char> pbKeySeed32, ulong uNumRounds) {
     if(pbOriginalKey32.size() != MASTER_KEY_SIZE) throw new std::exception();
     assert((pbKeySeed32.size() == MASTER_KEY_SIZE));
diff --git a/KeePit/database.cpp b/KeePit/database.cpp
index 2b15a7e..f73c0b8 100644
--- a/KeePit/database.cpp
+++ b/KeePit/database.cpp
@@ -89,18 +89,32 @@ const uint FileVersionCriticalMask = 0xFFFF0000;
 const uint FileVersion32 = 0x00030001;
 PasswordEntryModel* model;
 
+///
+/// \brief Database::Database
+/// \param parent
+///
 Database::Database(QObject *parent) :
     QObject(parent)
 {    
 }
 
+///
+/// \brief Database::~Database
+///
 Database::~Database() {
 }
 
+///
+/// \brief Database::deleteFile
+/// \param filePath
+///
 void Database::deleteFile(QString filePath) {
     FileHandler::deleteFile(filePath);
 }
 
+///
+/// \brief Database::loadHome
+///
 void Database::loadHome() {
     model->removeRows(0, model->rowCount());
     for(uint i=0;i<dataTree.size();i++) {
@@ -108,11 +122,20 @@ void Database::loadHome() {
     }
 }
 
+///
+/// \brief Database::search
+/// \param name
+///
 void Database::search(QString name) {
     foundAny = false;
     searchInternal(name, dataTree);
 }
 
+///
+/// \brief Database::searchInternal
+/// \param name
+/// \param node
+///
 void Database::searchInternal(QString name, vector<TreeNode*> node) {
     for(uint i=0;i<node.size();i++) {
         QString strTitle = node[i]->passwordEntry().title();
@@ -130,6 +153,12 @@ void Database::searchInternal(QString name, vector<TreeNode*> node) {
     }
 }
 
+///
+/// \brief Database::reloadBranch
+/// \param uuid
+/// \param entryType
+/// \return
+///
 QString Database::reloadBranch(QString uuid, int entryType)
 {
     QString retVal;
@@ -162,6 +191,10 @@ QString Database::reloadBranch(QString uuid, int entryType)
     return retVal;
 }
 
+///
+/// \brief Database::selectBranch
+/// \param uuid
+///
 void Database::selectBranch(QString uuid)
 {
     if(getChildBranch(uuid, dataTree)) {
@@ -172,6 +205,12 @@ void Database::selectBranch(QString uuid)
     }
 }
 
+///
+/// \brief Database::getChildBranch
+/// \param uuid
+/// \param currentBranch
+/// \return
+///
 bool Database::getChildBranch(QString uuid, vector<TreeNode*> currentBranch)
 {
     TreeNode* node;
@@ -192,6 +231,12 @@ bool Database::getChildBranch(QString uuid, vector<TreeNode*> currentBranch)
     return false;
 }
 
+///
+/// \brief Database::getMyBranch
+/// \param uuid
+/// \param currentBranch
+/// \return
+///
 bool Database::getMyBranch(QString uuid, vector<TreeNode*> currentBranch)
 {
     TreeNode* node;
@@ -212,6 +257,10 @@ bool Database::getMyBranch(QString uuid, vector<TreeNode*> currentBranch)
     return false;
 }
 
+///
+/// \brief Database::createModel
+/// \return
+///
 PasswordEntryModel* Database::createModel()
 {
     model = new PasswordEntryModel();    
@@ -219,6 +268,9 @@ PasswordEntryModel* Database::createModel()
     return model;
 }
 
+///
+/// \brief Database::closeFile
+///
 void Database::closeFile() {
     if(m_dbState != open) {
         return;
@@ -232,6 +284,12 @@ void Database::closeFile() {
     m_dbState = closed;
 }
 
+///
+/// \brief Database::openFile
+/// \param url
+/// \param password
+/// \param passKey
+///
 void Database::openFile(QString url, QString password, QString passKey) {
 
     if(m_dbState == open) {
@@ -444,6 +502,11 @@ void Database::openFile(QString url, QString password, QString passKey) {
     return;
 }
 
+///
+/// \brief Database::readPayload
+/// \param read
+/// \param payload
+///
 void Database::readPayload(vector<char>* read, vector<char> payload) {
 
     HashedBlockStream *hashedStream = new HashedBlockStream(payload, false, 0, true);
@@ -462,7 +525,13 @@ void Database::readPayload(vector<char>* read, vector<char> payload) {
     assert (hashedStream == 0);
 }
 
-// Read the header information from the stream
+///
+/// \brief Database::readHeaderField
+///        Read the header information from the stream
+/// \param byteStream
+/// \param endOfHeaderReached
+/// \param readError
+///
 void Database::readHeaderField(ByteStream* byteStream, bool* endOfHeaderReached, bool *readError)
 {    
     char btFieldID = byteStream->Read();
diff --git a/KeePit/filehandler.cpp b/KeePit/filehandler.cpp
index c542aff..ae61b07 100644
--- a/KeePit/filehandler.cpp
+++ b/KeePit/filehandler.cpp
@@ -25,15 +25,28 @@
 
 using namespace std;
 
+///
+/// \brief FileHandler::FileHandler
+///
 FileHandler::FileHandler()
 {
 }
 
+///
+/// \brief FileHandler::deleteFile
+/// \param filePath
+///
 void FileHandler::deleteFile(QString filePath)
 {
     remove(filePath.toStdString().c_str());
 }
 
+///
+/// \brief FileHandler::readFile
+/// \param filePath
+/// \param size
+/// \return
+///
 char* FileHandler::readFile(QString filePath, std::streampos &size)
 {
     ifstream file;
@@ -61,6 +74,11 @@ char* FileHandler::readFile(QString filePath, std::streampos &size)
 
 }*/
 
+///
+/// \brief FileHandler::fileExists
+/// \param fileName
+/// \return
+///
 bool FileHandler::fileExists(const char* fileName)
 {
     ifstream infile(fileName);
diff --git a/KeePit/hashedblockstream.cpp b/KeePit/hashedblockstream.cpp
index 3ec8f13..56be764 100644
--- a/KeePit/hashedblockstream.cpp
+++ b/KeePit/hashedblockstream.cpp
@@ -31,26 +31,54 @@ using namespace std;
 
 const int m_nDefaultBufferSize = 1024 * 1024; // 1 MB
 
+///
+/// \brief HashedBlockStream::~HashedBlockStream
+///
 HashedBlockStream::~HashedBlockStream()
 {
     this->Reset();
 }
 
+///
+/// \brief HashedBlockStream::HashedBlockStream
+/// \param sBaseStream
+/// \param bWriting
+///
 HashedBlockStream::HashedBlockStream(vector<char> sBaseStream, bool bWriting)
 {
     Initialize(sBaseStream, bWriting, 0, true);
 }
 
+///
+/// \brief HashedBlockStream::HashedBlockStream
+/// \param sBaseStream
+/// \param bWriting
+/// \param nBuffersize
+///
 HashedBlockStream::HashedBlockStream(vector<char> sBaseStream, bool bWriting, int nBuffersize)
 {
     Initialize(sBaseStream, bWriting, nBuffersize, true);
 }
 
+///
+/// \brief HashedBlockStream::HashedBlockStream
+/// \param sBaseStream
+/// \param bWriting
+/// \param nBuffersize
+/// \param bVerify
+///
 HashedBlockStream::HashedBlockStream(vector<char> sBaseStream, bool bWriting, int nBuffersize, bool bVerify)
 {
     Initialize(sBaseStream, bWriting, nBuffersize, bVerify);
 }
 
+///
+/// \brief HashedBlockStream::Initialize
+/// \param sBaseStream
+/// \param bWriting
+/// \param nBufferSize
+/// \param bVerify
+///
 void HashedBlockStream::Initialize(vector<char> sBaseStream, bool bWriting, int nBufferSize, bool bVerify) {
     //if(sBaseStream == NULL) throw exception();
     if(nBufferSize < 0) throw exception();
@@ -65,6 +93,13 @@ void HashedBlockStream::Initialize(vector<char> sBaseStream, bool bWriting, int
     m_bVerify = bVerify;
 }
 
+///
+/// \brief HashedBlockStream::Read
+/// \param pbBuffer
+/// \param nOffset
+/// \param nCount
+/// \return
+///
 int HashedBlockStream::Read(vector<char>* pbBuffer, int nOffset, int nCount)
 {
     if(m_bWriting) throw exception();
@@ -97,6 +132,10 @@ int HashedBlockStream::Read(vector<char>* pbBuffer, int nOffset, int nCount)
     return nCount;
 }
 
+///
+/// \brief HashedBlockStream::ReadHashedBlock
+/// \return
+///
 bool HashedBlockStream::ReadHashedBlock()
 {
     if(m_bEos) return false; // End of stream reached already
@@ -177,6 +216,13 @@ bool HashedBlockStream::ReadHashedBlock()
     return true;
 }
 
+///
+/// \brief HashedBlockStream::readBytes
+/// \param memblock
+/// \param offset
+/// \param size
+/// \return
+///
 int HashedBlockStream::readBytes(vector<char> memblock, int offset, uint size)
 {
     int result = 0;
@@ -193,6 +239,9 @@ int HashedBlockStream::readBytes(vector<char> memblock, int offset, uint size)
     return result;
 }
 
+///
+/// \brief HashedBlockStream::Reset
+///
 void HashedBlockStream::Reset()
 {
     for(uint i = 0; i<m_pbBuffer.size() ;i++) {
diff --git a/KeePit/main.cpp b/KeePit/main.cpp
index 591b481..d5b7bcb 100644
--- a/KeePit/main.cpp
+++ b/KeePit/main.cpp
@@ -26,6 +26,12 @@
 #include "database.h"
 #include "passwordentry.h"
 
+///
+/// \brief main
+/// \param argc
+/// \param argv
+/// \return
+///
 int main(int argc, char *argv[])
 {
     QGuiApplication app(argc, argv);
diff --git a/KeePit/passwordentry.cpp b/KeePit/passwordentry.cpp
index d805f8e..33d4e1b 100644
--- a/KeePit/passwordentry.cpp
+++ b/KeePit/passwordentry.cpp
@@ -20,60 +20,109 @@
 
 #include "passwordentry.h"
 
+///
+/// \brief PasswordEntry::PasswordEntry
+///
 PasswordEntry::PasswordEntry()
 {
 }
 
+///
+/// \brief PasswordEntry::PasswordEntry
+/// \param title
+/// \param password
+/// \param entryType
+///
 PasswordEntry::PasswordEntry(const QString &title, const QString &password, PasswordEntryType entryType)
     : m_title(title), m_password(password), m_entryType(entryType)
 {
 }
 
+///
+/// \brief PasswordEntry::title
+/// \return
+///
 QString PasswordEntry::title() const
 {
     return m_title;
 }
 
+///
+/// \brief PasswordEntry::password
+/// \return
+///
 QString PasswordEntry::password() const
 {
     return m_password;
 }
 
+///
+/// \brief PasswordEntry::passwordProtected
+/// \return
+///
 bool PasswordEntry::passwordProtected() const
 {
     return m_passwordProtected;
 }
 
+///
+/// \brief PasswordEntry::entryType
+/// \return
+///
 PasswordEntryType PasswordEntry::entryType() const
 {
     return m_entryType;
 }
 
+///
+/// \brief PasswordEntry::uuid
+/// \return
+///
 QString PasswordEntry::uuid() const
 {
     return m_uuid;
 }
 
+///
+/// \brief PasswordEntry::username
+/// \return
+///
 QString PasswordEntry::username() const
 {
     return m_username;
 }
 
+///
+/// \brief PasswordEntry::url
+/// \return
+///
 QString PasswordEntry::url() const
 {
     return m_url;
 }
 
+///
+/// \brief PasswordEntry::notes
+/// \return
+///
 QString PasswordEntry::notes() const
 {
     return m_notes;
 }
 
+///
+/// \brief PasswordEntryModel::PasswordEntryModel
+/// \param parent
+///
 PasswordEntryModel::PasswordEntryModel(QObject *parent)
     : QAbstractListModel(parent)
 {
 }
 
+///
+/// \brief PasswordEntryModel::addPasswordEntry
+/// \param passwordEntry
+///
 void PasswordEntryModel::addPasswordEntry(const PasswordEntry &passwordEntry)
 {
     beginInsertRows(QModelIndex(), rowCount(), rowCount());
@@ -81,11 +130,22 @@ void PasswordEntryModel::addPasswordEntry(const PasswordEntry &passwordEntry)
     endInsertRows();
 }
 
+///
+/// \brief PasswordEntryModel::rowCount
+/// \param parent
+/// \return
+///
 int PasswordEntryModel::rowCount(const QModelIndex & parent) const {
     Q_UNUSED(parent);
     return m_passwordEntries.count();
 }
 
+///
+/// \brief PasswordEntryModel::data
+/// \param index
+/// \param role
+/// \return
+///
 QVariant PasswordEntryModel::data(const QModelIndex & index, int role) const {
     if (index.row() < 0 || index.row() >= m_passwordEntries.count())
         return QVariant();
@@ -110,6 +170,10 @@ QVariant PasswordEntryModel::data(const QModelIndex & index, int role) const {
     return QVariant();
 }
 
+///
+/// \brief PasswordEntryModel::roleNames
+/// \return
+///
 QHash<int, QByteArray> PasswordEntryModel::roleNames() const {
     QHash<int, QByteArray> roles;
     roles[TitleRole] = "title";
@@ -123,10 +187,17 @@ QHash<int, QByteArray> PasswordEntryModel::roleNames() const {
     return roles;
 }
 
+///
+/// \brief PasswordEntryModel::removeRows
+/// \param row
+/// \param count
+/// \param parent
+/// \return
+///
 bool PasswordEntryModel::removeRows(int row, int count, const QModelIndex &parent) {
         Q_UNUSED(parent);
         beginRemoveRows(QModelIndex(), row, row + count - 1);
         while (count--) m_passwordEntries.takeAt(row);
         endRemoveRows();
         return true;
-    }
+}
diff --git a/KeePit/readkeyfile.cpp b/KeePit/readkeyfile.cpp
index 109f94c..069e02d 100644
--- a/KeePit/readkeyfile.cpp
+++ b/KeePit/readkeyfile.cpp
@@ -28,10 +28,19 @@
 using namespace std;
 using namespace tinyxml2;
 
+///
+/// \brief ReadKeyFile::ReadKeyFile
+///
 ReadKeyFile::ReadKeyFile()
 {
 }
 
+///
+/// \brief ReadKeyFile::read
+/// \param memblock
+/// \param size
+/// \return
+///
 vector<char> ReadKeyFile::read(char *memblock, int size) const {
 
     XMLDocument doc;
diff --git a/KeePit/readxmlfile.cpp b/KeePit/readxmlfile.cpp
index 3c06bd5..5641d34 100644
--- a/KeePit/readxmlfile.cpp
+++ b/KeePit/readxmlfile.cpp
@@ -31,6 +31,12 @@
 
 using namespace tinyxml2;
 
+///
+/// \brief ReadXmlFile::ReadXmlFile
+/// \param xml
+/// \param size
+/// \param salsa
+///
 ReadXmlFile::ReadXmlFile(const char* xml, size_t size, Salsa20 *salsa)
 {
     m_xml = xml;
@@ -38,6 +44,9 @@ ReadXmlFile::ReadXmlFile(const char* xml, size_t size, Salsa20 *salsa)
     m_salsa = salsa;
 }
 
+///
+/// \brief ReadXmlFile::~ReadXmlFile
+///
 ReadXmlFile::~ReadXmlFile()
 {
     delete m_salsa;
@@ -46,6 +55,10 @@ ReadXmlFile::~ReadXmlFile()
     lastRead = 0;
 }
 
+///
+/// \brief ReadXmlFile::GetTopGroup
+/// \return
+///
 vector<TreeNode*> ReadXmlFile::GetTopGroup()
 {
     XMLDocument doc;
@@ -67,6 +80,12 @@ vector<TreeNode*> ReadXmlFile::GetTopGroup()
     return topLevel;
 }
 
+///
+/// \brief ReadXmlFile::ReadBranch
+/// \param node
+/// \param current
+/// \param parent
+///
 void ReadXmlFile::ReadBranch(XMLElement* node, vector<TreeNode*> &current, TreeNode *parent)
 {
     do {
@@ -81,6 +100,12 @@ void ReadXmlFile::ReadBranch(XMLElement* node, vector<TreeNode*> &current, TreeN
     while(node != 0);    
 }
 
+///
+/// \brief ReadXmlFile::ReadNode
+/// \param elem
+/// \param parent
+/// \return
+///
 TreeNode* ReadXmlFile::ReadNode(XMLElement* elem, TreeNode *parent)
 {
     TreeNode* node = 0;
@@ -108,6 +133,11 @@ TreeNode* ReadXmlFile::ReadNode(XMLElement* elem, TreeNode *parent)
     return node;
 }
 
+///
+/// \brief ReadXmlFile::ExtractEntryNode
+/// \param elem
+/// \return
+///
 TreeNode* ReadXmlFile::ExtractEntryNode(XMLElement* elem)
 {
     TreeNode* node = new TreeNode();
diff --git a/KeePit/salsa20.cpp b/KeePit/salsa20.cpp
index 016c119..77a8f17 100644
--- a/KeePit/salsa20.cpp
+++ b/KeePit/salsa20.cpp
@@ -26,6 +26,11 @@
 
 using namespace std;
 
+///
+/// \brief Salsa20::Salsa20
+/// \param pbKey
+/// \param pbIv
+///
 Salsa20::Salsa20(vector<char> pbKey, char* pbIv)
 {
     m_xpbKey = pbKey;
@@ -43,10 +48,18 @@ Salsa20::Salsa20(vector<char> pbKey, char* pbIv)
     salsa.SetKeyWithIV(key, 32, iv);
 }
 
+///
+/// \brief Salsa20::~Salsa20
+///
 Salsa20::~Salsa20()
 {
 }
 
+///
+/// \brief Salsa20::decrypt
+/// \param cipherText
+/// \return
+///
 byte* Salsa20::decrypt(vector<char> cipherText)
 {
     byte* cipherTextBytes = new byte[cipherText.size()];
diff --git a/KeePit/sha256.cpp b/KeePit/sha256.cpp
index bda17b2..53a0d14 100644
--- a/KeePit/sha256.cpp
+++ b/KeePit/sha256.cpp
@@ -25,10 +25,18 @@
 
 using namespace std;
 
+///
+/// \brief SHA256::SHA256
+///
 SHA256::SHA256()
 {
 }
 
+///
+/// \brief SHA256::computeHash
+/// \param message
+/// \return
+///
 vector<char> SHA256::computeHash(vector<char> message) {
 
     CryptoPP::SHA256 hash;
diff --git a/KeePit/treenode.cpp b/KeePit/treenode.cpp
index 4e2ef9b..54c47dc 100644
--- a/KeePit/treenode.cpp
+++ b/KeePit/treenode.cpp
@@ -23,46 +23,84 @@
 
 using namespace std;
 
+///
+/// \brief TreeNode::TreeNode
+///
 TreeNode::TreeNode()
     : m_parent(0)
 {
 }
 
+///
+/// \brief TreeNode::TreeNode
+/// \param passwordEntry
+///
 TreeNode::TreeNode(const PasswordEntry &passwordEntry)
     : m_passwordEntry(passwordEntry), m_parent(0)
 {    
 }
 
+///
+/// \brief TreeNode::TreeNode
+/// \param passwordEntry
+/// \param parent
+///
 TreeNode::TreeNode(const PasswordEntry &passwordEntry, TreeNode *parent)
     : m_passwordEntry(passwordEntry), m_parent(parent)
 {
 }
 
+///
+/// \brief TreeNode::TreeNode
+/// \param passwordEntry
+/// \param next
+/// \param parent
+///
 TreeNode::TreeNode(const PasswordEntry &passwordEntry, const vector<TreeNode*> &next, TreeNode *parent)
     : m_passwordEntry(passwordEntry), m_next(next), m_parent(parent)
 {
 }
 
+///
+/// \brief TreeNode::passwordEntry
+/// \return
+///
 PasswordEntry TreeNode::passwordEntry() const
 {
     return m_passwordEntry;
 }
 
+///
+/// \brief TreeNode::next
+/// \return
+///
 vector<TreeNode*> TreeNode::next() const
 {
     return m_next;
 }
 
+///
+/// \brief TreeNode::parent
+/// \return
+///
 TreeNode* TreeNode::parent()
 {
     return m_parent;
 }
 
+///
+/// \brief TreeNode::isFirst
+/// \return
+///
 bool TreeNode::isFirst()
 {
     return true;
 }
 
+///
+/// \brief TreeNode::isLast
+/// \return
+///
 bool TreeNode::isLast()
 {
     return true;