Get Adobe Flash playerPlugin by wpburn.com wordpress themes
« 
 »
May 31 2009

TinyPasswordManager

Posted by Deimos in Développement, Sécurité, tags: , ,

      TinyPasswordManager est un gestionnaire de mot de passe Open Source et (bientôt) multiplate-forme. Basé sur le chiffrement AES avec clé de 256bits, je l’avais initialement développé pour un usage personnel. L’objectif initial est d’obtenir un gestionnaire simple, c’est-à-dire n’utilisant pas de bibliothèques, et sécurisé. Pour l’instant, seule la version pour Windows est dévelopée entièrement, avec GUI. En ce qui concerne la version pour les systèmes dérivés d’UNIX, je prévois de poster d’ici peu de temps la version ligne de commande, puis, par la suite, envisager le développement d’une GUI avec QT ou GTK.

      Pour les spécifications “techniques”, la passphrase choisie par l’utilisateur est hashée avec SHA256. Le hash obtenu est utilisé comme clé AES. En ce qui concerne la méthode de padding, j’ai opté pour la technique décrite dans la norme ISO 10126, à savoir le remplissage avec des octets aléatoires, en spécifiant la taille du bourrage dans le dernier.

      Enfin, le mode d’opération d’AES utilisé est CBC. Pour rappel, avec un chiffrement en mode ECB, tous les blocs sont indépendants : chaque bloc est simplement chiffré avec la clé. Cela pose quelques soucis en matière de confidentialité car deux mêmes blocs auront un résultat chiffré identique, ce qui n’est pas le cas avec CBC, mode utilisé en général dans lequel chaque bloc est XORé avec le bloc chiffré précédent, puis chiffré.

Je mets à disposition le binaire ainsi que les sources :

Voici le code source de la classe principale :

  1.  
  2. // TinyPasswordManager.h
  3.  
  4. #ifndef TINY_PASSWORD_MANAGER_H
  5. #define TINY_PASSWORD_MANAGER_H
  6.  
  7. #ifdef WIN32
  8. #undef UNICODE
  9. #define _CRT_SECURE_NO_DEPRECATE 1
  10. #define _CRT_NONSTDC_NO_DEPRECATE 1
  11. #define _WIN32_WINNT 0×0502
  12. #endif
  13.  
  14. #include "identifier.h"
  15. #include "exceptions.h"
  16.  
  17. #include <string>
  18. #include <vector>
  19.  
  20. #ifdef WIN32
  21. #include <windows.h>
  22. #endif
  23.  
  24. class TinyPasswordManager {
  25. private:
  26.     TinyPasswordManager();
  27.     ~TinyPasswordManager();
  28.  
  29. public:
  30.     static TinyPasswordManager *GetInstance();
  31.     static void Kill();
  32.  
  33.     bool IsBeingUsed() const;
  34.    
  35.     void CreateEmptyDatabase(const std::string &filename = std::string("pm.db"));
  36.     void OpenDatabase(const std::string &filename = std::string("pm.db"));
  37.     void GetIdentifiers();
  38.     void AddIdentifier(const Identifier &identifier);
  39.  
  40.     unsigned int GetSize() const;
  41.     unsigned int GetIndex(const std::string &description) const;
  42.  
  43.     std::string GetLogin(unsigned int index) const;
  44.     std::string GetPassword(unsigned int index) const;
  45.     std::string GetDescription(unsigned int index) const;
  46.  
  47.     void SetPrivateKey(const unsigned char key[32]);
  48.  
  49.     static std::string GeneratePassword(unsigned int minSize, unsigned int maxSize, const std::string &charset);
  50.  
  51. private:
  52.     static bool CompareIdentifier(Identifier *ident1, Identifier *ident2);
  53.     static void AddPadding(char *message, unsigned int length);
  54.  
  55.     void Reinitialize();
  56.  
  57.     std::vector<Identifier *> m_idents;
  58.     unsigned char *m_cipheredBuff;
  59.     unsigned int m_filesize;
  60.     std::string m_filename;
  61.     unsigned char m_key[32];
  62.    
  63.     static TinyPasswordManager *m_instance;
  64. };
  65. #endif
  66.  
  67.  
  68. // TinyPasswordManager.cpp
  69.  
  70. #include "tinypasswordmanager.h"
  71. #include "aes.h"
  72. #include "sha256.h"
  73.  
  74. #include <fstream>
  75. #include <cstring>
  76. #include <algorithm>
  77. #include <sstream>
  78.  
  79. TinyPasswordManager *TinyPasswordManager::m_instance = NULL;
  80.  
  81. TinyPasswordManager::TinyPasswordManager()
  82.  : m_cipheredBuff(NULL), m_filesize(0), m_filename("") {
  83.      memset(m_key, 0, 32);
  84. }
  85.  
  86. TinyPasswordManager::~TinyPasswordManager() {
  87.     Identifier *tmp = NULL;
  88.  
  89.     while(!m_idents.empty()) {
  90.         tmp = m_idents.back();
  91.         m_idents.pop_back();
  92.         delete tmp;
  93.         tmp = NULL;
  94.     }
  95.  
  96.     if(m_cipheredBuff) {
  97.         delete[] m_cipheredBuff;
  98.         m_cipheredBuff = NULL;
  99.     }
  100. }
  101.  
  102. TinyPasswordManager *TinyPasswordManager::GetInstance() {
  103.     if(!m_instance)
  104.         m_instance = new TinyPasswordManager();
  105.  
  106.     return m_instance;
  107. }
  108.  
  109. void TinyPasswordManager::Kill() {
  110.     if(m_instance) {
  111.         delete m_instance;
  112.         m_instance = NULL;
  113.     }
  114. }
  115.  
  116. bool TinyPasswordManager::IsBeingUsed() const {
  117.     return !m_filename.empty();
  118. }
  119.  
  120. void TinyPasswordManager::CreateEmptyDatabase(const std::string &filename) {
  121.     if(IsBeingUsed())
  122.         Reinitialize();
  123.  
  124.     AES aes;
  125.     aes.SetParameters(256);
  126.     aes.StartEncryption(m_key);
  127.  
  128.     m_filesize = 32;
  129.     char plaintext[32] = "PM1";
  130.  
  131.     #ifdef WIN32
  132.     srand(GetTickCount());
  133.     #endif
  134.  
  135.     for(int i = 0; i < 13; ++i)
  136.         plaintext[3 + i] = static_cast<char>((rand() * 255) / RAND_MAX);
  137.  
  138.     AddPadding(plaintext + 16, 0);
  139.  
  140.     m_cipheredBuff = new unsigned char[m_filesize];
  141.     if(!m_cipheredBuff)
  142.         throw ExMemoryAllocationFailed(__FUNCTION__);
  143.  
  144.     aes.Encrypt(reinterpret_cast<unsigned char *>(plaintext), m_cipheredBuff, m_filesize >> 4, AES::CBC);
  145.  
  146.     std::ofstream ofs(filename.c_str(), std::ios::out | std::ios::binary);
  147.  
  148.     ofs.seekp(0, std::ios::beg);
  149.     ofs.write(reinterpret_cast<char *>(m_cipheredBuff), m_filesize);
  150.  
  151.     if(!ofs.good())
  152.         throw ExFileErrorWriting(__FUNCTION__, filename);
  153.  
  154.     ofs.close();
  155.  
  156.     m_filename = std::string(filename);
  157. }
  158.  
  159. void TinyPasswordManager::OpenDatabase(const std::string &filename) {
  160.     if(IsBeingUsed() && !filename.compare(m_filename))
  161.         return;
  162.     else if(IsBeingUsed() && filename.compare(m_filename))
  163.         Reinitialize();
  164.  
  165.     std::ifstream ifs(filename.c_str(), std::ios::in | std::ios::binary);
  166.  
  167.     if(!ifs.good())
  168.         throw ExFileNotFound(__FUNCTION__, filename);
  169.  
  170.     ifs.seekg(0, std::ios::end);
  171.     m_filesize = ifs.tellg();
  172.     ifs.seekg(0, std::ios::beg);
  173.  
  174.     m_cipheredBuff = new unsigned char[m_filesize];
  175.  
  176.     if(!m_cipheredBuff)
  177.         throw ExMemoryAllocationFailed(__FUNCTION__);
  178.  
  179.     ifs.read(reinterpret_cast<char *>(m_cipheredBuff), m_filesize);
  180.  
  181.     if(!ifs.good())
  182.         throw ExFileErrorReading(__FUNCTION__, filename);
  183.  
  184.     m_filename = std::string(filename);
  185.     ifs.close();
  186. }
  187.  
  188. void TinyPasswordManager::GetIdentifiers() {
  189.     if(!IsBeingUsed())
  190.         return;
  191.    
  192.     AES aes;
  193.     aes.SetParameters(256, 128);
  194.     aes.StartDecryption(m_key);
  195.  
  196.     char *plaintext = new char[m_filesize];
  197.  
  198.     if(!plaintext)
  199.         throw ExMemoryAllocationFailed(__FUNCTION__);
  200.  
  201.     aes.Decrypt(m_cipheredBuff, reinterpret_cast<unsigned char *>(plaintext), m_filesize >> 4, AES::CBC);
  202.  
  203.     unsigned int sizePadding = plaintext[m_filesize – 1];
  204.     if(sizePadding > 16)
  205.         throw ExBadFileFormat(__FUNCTION__, m_filename);
  206.  
  207.     plaintext[m_filesize – sizePadding] = 0;
  208.  
  209.     if(plaintext[0] != ‘P’ || plaintext[1] != ‘M’ || plaintext[2] != ’1′)
  210.         throw ExBadFileFormat(__FUNCTION__, m_filename);
  211.  
  212.     char *tmp = strtok(plaintext + 16, "\n");
  213.  
  214.     if(!tmp)
  215.         return;
  216.  
  217.     #define STAGE_LOGIN 0
  218.     #define STAGE_PASSWORD 1
  219.     #define STAGE_DESCRIPTION 2
  220.  
  221.     unsigned int stage = STAGE_LOGIN;
  222.     Identifier *identifier = NULL;
  223.  
  224.     do {
  225.         switch(stage % 3) {
  226.         case STAGE_LOGIN:
  227.             identifier = new Identifier();
  228.             identifier->SetLogin(tmp);
  229.             break;
  230.  
  231.         case STAGE_PASSWORD:
  232.             identifier->SetPassword(tmp);
  233.             break;
  234.  
  235.         case STAGE_DESCRIPTION:
  236.             identifier->SetDescription(tmp);
  237.             m_idents.push_back(identifier);
  238.             break;
  239.         }
  240.  
  241.         stage++;
  242.     } while(tmp = strtok(NULL, "\n"));
  243.  
  244.     memset(plaintext, 0, m_filesize);
  245.     delete[] plaintext;
  246.  
  247.     std::sort(m_idents.begin(), m_idents.end(), TinyPasswordManager::CompareIdentifier);
  248. }
  249.  
  250. void TinyPasswordManager::AddIdentifier(const Identifier &identifier) {
  251.     if(!IsBeingUsed())
  252.         return;
  253.  
  254.     AES aes;
  255.     aes.SetParameters(256);
  256.     aes.StartDecryption(m_key);
  257.  
  258.     std::ostringstream oss;
  259.     oss << identifier.GetLogin() << "\n" << identifier.GetPassword() << "\n" << identifier.GetDescription() << "\n";
  260.  
  261.     unsigned newFilesize = m_filesize + oss.str().size();
  262.     newFilesize += 16 – (newFilesize % 16);
  263.  
  264.     char *plaintext = new char[newFilesize];
  265.  
  266.     if(!plaintext)
  267.         throw ExMemoryAllocationFailed(__FUNCTION__);
  268.  
  269.     aes.Decrypt(m_cipheredBuff, reinterpret_cast<unsigned char *>(plaintext), m_filesize >> 4, AES::CBC);
  270.  
  271.     unsigned int sizePadding = plaintext[m_filesize – 1];
  272.     if(sizePadding > 16)
  273.         throw ExBadFileFormat(__FUNCTION__, m_filename);
  274.  
  275.     if(plaintext[0] != ‘P’ || plaintext[1] != ‘M’ || plaintext[2] != ’1′)
  276.         throw ExBadFileFormat(__FUNCTION__, m_filename);
  277.  
  278.     strncpy(plaintext + m_filesize – sizePadding, oss.str().c_str(), oss.str().size());
  279.  
  280.     newFilesize = m_filesize – sizePadding + oss.str().size();
  281.     AddPadding(plaintext, newFilesize);
  282.     newFilesize += 16 – (newFilesize % 16);
  283.  
  284.     unsigned char *cipheredtext = new unsigned char[newFilesize];
  285.  
  286.     if(!cipheredtext)
  287.         throw ExMemoryAllocationFailed(__FUNCTION__);
  288.  
  289.     aes.StartEncryption(m_key);
  290.     aes.Encrypt(reinterpret_cast<unsigned char *>(plaintext), cipheredtext, newFilesize >> 4, AES::CBC);
  291.     std::ofstream ofs(m_filename.c_str(), std::ios::out | std::ios::binary);
  292.  
  293.     ofs.seekp(std::ios_base::beg);
  294.     ofs.write(reinterpret_cast<char *>(cipheredtext), newFilesize);
  295.    
  296.     if(!ofs.good())
  297.         throw ExFileErrorWriting(__FUNCTION__, m_filename);
  298.  
  299.     ofs.close();
  300.  
  301.     m_idents.push_back(new Identifier(identifier));
  302.  
  303.     delete[] m_cipheredBuff;
  304.     m_cipheredBuff = cipheredtext;
  305.     m_filesize = newFilesize;
  306. }
  307.  
  308. unsigned int TinyPasswordManager::GetSize() const {
  309.     return static_cast<unsigned int>(m_idents.size());
  310. }
  311.  
  312. unsigned int TinyPasswordManager::GetIndex(const std::string &description) const {
  313.     std::vector<Identifier *>::const_iterator it;
  314.     unsigned int index = 0;
  315.     bool found = false;
  316.  
  317.     for(it = m_idents.begin(); it != m_idents.end(); ++it, ++index)
  318.         if((*it)->GetDescription().compare(description) == 0) {
  319.             found = true;
  320.             break;
  321.         }
  322.  
  323.     if(!found)
  324.         index = static_cast<unsigned int>(-1);
  325.  
  326.     return index;
  327. }
  328.  
  329. std::string TinyPasswordManager::GetLogin(unsigned int index) const {
  330.     return m_idents.at(index)->GetLogin();
  331. }
  332.  
  333. std::string TinyPasswordManager::GetPassword(unsigned int index) const {
  334.     return m_idents.at(index)->GetPassword();
  335. }
  336.  
  337. std::string TinyPasswordManager::GetDescription(unsigned int index) const {
  338.     return m_idents.at(index)->GetDescription();
  339. }
  340.  
  341. void TinyPasswordManager::SetPrivateKey(const unsigned char key[32]) {
  342.     memcpy(m_key, key, 32);
  343. }
  344.  
  345. std::string TinyPasswordManager::GeneratePassword(unsigned int minSize, unsigned int maxSize, const std::string &charset) {
  346.     #ifdef WIN32
  347.     srand(GetTickCount());
  348.     #endif
  349.  
  350.     unsigned int passwordSize = (static_cast<unsigned int>(rand()) % (maxSize – minSize)) + minSize;
  351.     std::string password;
  352.     unsigned int charsetIndex;
  353.  
  354.     for(unsigned int i = 0; i < passwordSize; ++i) {
  355.         charsetIndex = static_cast<unsigned int>(rand()) % charset.length();
  356.         password += charset.at(charsetIndex);
  357.     }
  358.  
  359.     return password;
  360. }
  361.  
  362. bool TinyPasswordManager::CompareIdentifier(Identifier *ident1, Identifier *ident2) {
  363.     return (ident1->GetDescription().compare(ident2->GetDescription())) > 0 ? false : true;
  364. }
  365.  
  366. void TinyPasswordManager::AddPadding(char *message, unsigned int length) {
  367.     unsigned int i;
  368.     unsigned int sizePadding = 16 – (length % 16);
  369.  
  370.     #ifdef WIN32
  371.     srand(GetTickCount());
  372.     #endif
  373.  
  374.     for(i = 0; i < sizePadding – 1; ++i)
  375.         message[length + i] = static_cast<char>((rand() * 255) / RAND_MAX);
  376.    
  377.     message[length + i] = static_cast<char>(sizePadding);
  378. }
  379.  
  380. void TinyPasswordManager::Reinitialize() {
  381.     m_filename = "";
  382.     m_filesize = 0;
  383.  
  384.     if(m_cipheredBuff) {
  385.         delete[] m_cipheredBuff;
  386.         m_cipheredBuff = NULL;
  387.     }
  388. }
  389.  

This entry was posted on Sunday, May 31st, 2009 at 9:49 pm and is filed under Développement, Sécurité. You can follow any responses to this entry through the RSS 2.0 feed. You can leave a response, or trackback from your own site.

5 Responses to “TinyPasswordManager”
  1. Gui_G says:
    June 2, 2009 at 2:54 pm

    Euh… Super !
    C’est génial, je cherchais ça à l’instant, coup de chance.
    Bonne continuation.

  2. Gui_G says:
    June 2, 2009 at 3:11 pm

    Une petite remarque quand même: ça serait bien de pouvoir changer des infos de connexion. On pourrait par exemple vouloir changer nous-mêmes notre mot de passe et le re-changer dans TinyPasswordManager. Ainsi que la description.
    Merci encore.

  3. Deimos says:
    June 2, 2009 at 7:16 pm

    Merci. Effectivement, ça peut être utile, j’y ai pensé rapidement. Lorsque j’aurai d’avantage de temps (i.e. à partir de juillet) je pense créer un repo svn où sera récupérable la dernière version du logiciel, et ajouter doucement des fonctionnalités au fil du temps.

  4. Gui_G says:
    June 8, 2009 at 10:44 am

    Ça fait maintenant depuis le… 31 mai ! que j’utilise ton logiciel. Et je ne peux m’empêcher de te féliciter à nouveau ! Avec le temps, j’ai une autre remarque (je dis ça comme ça), tu pourrais faire plusieurs sessions: pour que plusieurs personnes puisse utiliser le logiciel sans mélanger les site sur le même ordinateur. Je sais pas si je suis bien clair…?

  5. JamesD says:
    June 11, 2009 at 7:06 pm

    Thanks for the useful info. It’s so interesting

  6.  
Trackbacks
  1.  
Leave a Reply

XHTML: You can use these tags: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>