Algoritmo básico de criptografía -- ++ campo con beginner campo con cryptography camp codereview Relacionados El problema

Basic cryptography algorithm


6
vote

problema

Español

Escribí 2 clases para implementar algún algoritmo básico de criptografía. Intenté usar algunos conceptos orientados a objetos de C ++. Soy un principiante, por lo que cualquier comentario o sugerencia es bienvenida.

primera clase: mensaje

El encabezado:

  #ifndef MESSAGE_H #define MESSAGE_H  #include <iostream> #include <fstream> #include <string> #include <vector>  class Message {    public:        friend class Chiffre;        typedef std::vector<char> cryptoContainer;        // constructors        Message();         Message(const std::string&);         Message(const cryptoContainer&);         Message(const std::string&, const int&);         // templates for writing original and crypted messages         template<typename T>         int writeOriginalMessage(T& stream) const // return original message in an output stream         {             for (auto it = m_originalContent.begin(); it != m_originalContent.end(); it++) stream << *it;             stream.flush();             return 0;         }         template<typename T>         int writeCryptedMessage(T& stream) const // return crypted message in an output stream         {             if (m_cryptedContent.empty()) return 1;             for (auto it = m_cryptedContent.begin(); it != m_cryptedContent.end(); it++) stream << *it;             stream.flush();             return 0;         }         // getters         cryptoContainer getOriginalMessage(void) const;         cryptoContainer getCryptedMessage(void) const;         // destructor         virtual ~Message();     protected:         //protected setter         void setOriginalMessage(cryptoContainer&);         void setCryptedMessage(cryptoContainer&);         //attributes         int m_key;         cryptoContainer m_originalContent;         cryptoContainer m_cryptedContent; };  #endif // MESSAGE_H   

El archivo .cpp:

  #include "Message.h"  Message::Message(const std::string& texte):     m_key(0),     m_originalContent(texte.begin(),texte.end()) {  }  Message::Message(const Message::cryptoContainer& texte):     m_key(0), // default key is 0     m_originalContent(texte) {  }  Message::Message(const std::string& texte, const int& clef):     m_key(clef),     m_originalContent(texte.begin(),texte.end()) {  }  Message::~Message() {  }  Message::cryptoContainer Message::getOriginalMessage(void) const {     return m_originalContent; }  Message::cryptoContainer Message::getCryptedMessage(void) const {     return m_cryptedContent; }  void Message::setOriginalMessage(Message::cryptoContainer& msg) {     m_originalContent = msg;     return; }  void Message::setCryptedMessage(Message::cryptoContainer& msg) {     m_cryptedContent = msg;     return; }   

Segunda Clase: Chiffre (implementará CRYPTO ALGORITHMS)

El encabezado:

  true0  

El archivo .cpp:

  true1  
Original en ingles

I wrote 2 classes in order to implement some basic cryptography algorithm. I tried to use some object-oriented concepts of C++. I'm a beginner, so any comment or suggestion is welcome.

First class: Message

The header:

#ifndef MESSAGE_H #define MESSAGE_H  #include <iostream> #include <fstream> #include <string> #include <vector>  class Message {    public:        friend class Chiffre;        typedef std::vector<char> cryptoContainer;        // constructors        Message();         Message(const std::string&);         Message(const cryptoContainer&);         Message(const std::string&, const int&);         // templates for writing original and crypted messages         template<typename T>         int writeOriginalMessage(T& stream) const // return original message in an output stream         {             for (auto it = m_originalContent.begin(); it != m_originalContent.end(); it++) stream << *it;             stream.flush();             return 0;         }         template<typename T>         int writeCryptedMessage(T& stream) const // return crypted message in an output stream         {             if (m_cryptedContent.empty()) return 1;             for (auto it = m_cryptedContent.begin(); it != m_cryptedContent.end(); it++) stream << *it;             stream.flush();             return 0;         }         // getters         cryptoContainer getOriginalMessage(void) const;         cryptoContainer getCryptedMessage(void) const;         // destructor         virtual ~Message();     protected:         //protected setter         void setOriginalMessage(cryptoContainer&);         void setCryptedMessage(cryptoContainer&);         //attributes         int m_key;         cryptoContainer m_originalContent;         cryptoContainer m_cryptedContent; };  #endif // MESSAGE_H 

The .cpp file:

#include "Message.h"  Message::Message(const std::string& texte):     m_key(0),     m_originalContent(texte.begin(),texte.end()) {  }  Message::Message(const Message::cryptoContainer& texte):     m_key(0), // default key is 0     m_originalContent(texte) {  }  Message::Message(const std::string& texte, const int& clef):     m_key(clef),     m_originalContent(texte.begin(),texte.end()) {  }  Message::~Message() {  }  Message::cryptoContainer Message::getOriginalMessage(void) const {     return m_originalContent; }  Message::cryptoContainer Message::getCryptedMessage(void) const {     return m_cryptedContent; }  void Message::setOriginalMessage(Message::cryptoContainer& msg) {     m_originalContent = msg;     return; }  void Message::setCryptedMessage(Message::cryptoContainer& msg) {     m_cryptedContent = msg;     return; } 

second class: Chiffre (will implement crypto algorithms)

The header:

#ifndef CHIFFRE_H #define CHIFFRE_H  #include <vector> #include "Message.h"  class Chiffre { public:         Chiffre();         virtual ~Chiffre() = 0;          static void cesar(Message&, const int&);   // dxc3xa9cale un caractxc3xa8re xc3xa0 partir d'une clef (algorithme de Cxc3xa9sar)  };  #endif // CHIFFRE_H 

The .cpp file:

#include "Chiffre.h"  Chiffre::Chiffre() { }  Chiffre::~Chiffre() { }  void Chiffre::cesar(Message& msg, const int& clef) {     Message::cryptoContainer res;     Message::cryptoContainer orig = msg.getOriginalMessage();     for (auto it = orig.begin(); it != orig.end(); it++) res.push_back(*it + clef);     msg.Message::setCryptedMessage(res);     return; } 
        

Lista de respuestas

4
 
vote

No soy un gurú de criptografía, por lo que mis comentarios apuntarán al código en sí mismo, no los algoritmos.

Message.H / Message.CPP:

  1. No parece haber una necesidad de incluir <iostream> NOR 9988777665544331 en el archivo de encabezado. Evite importar dependencias que no usas. El costo de una inclusión está en tiempo de compilación. Uno demasiados grandes proyectos sufren con largos tiempos de compilación debido a la mala gestión de los archivos de inclusión.

  2. Mantenga sus nombres de parámetros en la función / prototipos de métodos. Esto automáticamente documentará su código. Tome este constructor, por ejemplo:

      Message(const std::string&, const int&);   

    Imposible de saber qué parámetro está haciendo qué sin consultar la implementación.

  3. cryptoContainer3 es un "tipo de alias", sin embargo, nombra un tipo. Su convención de nomenclatura para los tipos es PascalCase , por lo que CryptoContainer sería más autoconsistente.

  4. writeOriginalMessage Actualmente está devolviendo un valor entero sin sentido (siempre cero). Muy bien podría volver nada ( void ). Si existe la posibilidad de un fracaso, luego devuelva un 99887766555544338 99887766555443339 .

  5. todavía hablando de <fstream>0 y <fstream>1 , ambos tienen una bucle bastante similar dentro:

      <fstream>2  

    Puede acortarlos significativamente usando un bucle FuraCeach basado en el rango

      <fstream>3  

    AVISO El código <fstream>4 . Se debe tener cuidado para evitar copiar cosas en este estilo de iteración, ya que el valor predeterminado en C ++ es siempre una copia.

  6. Escritura <fstream>5 En la lista de parámetros de una función C ++ que no toma parámetros (como en <fstream>6 ) es un estilo C-ish. C ++ no requiere eso; <fstream>7 es igual de bueno. Así que evita la verbosidad innecesaria.

  7. <fstream>8 Los destructores solo son necesarios cuando su clase está destinada a ser heredada. En este código en particular, eso no parece ser el caso con <fstream>9 . Si lo hiciste para permitir que los usuarios de su código heredan de la clase, aconsejaría en contra, ya que la composición suele ser mucho más elegante y con menos acoplamiento. Debe eliminar virtual de la Declaración de Destructor y quizás incluso marque su clase Message(const std::string&, const int&); 0 . Mientras que lo estén en ello, hacen que la sección protegida sea privada y lanza el destructor, ya que está vacío.

  8. Veo que tienes un par de lugares con nombres no en inglés, mientras que el todo más grande está en ese idioma. Sería mejor mantener las cosas uniformes, así que reemplace las cosas como Message(const std::string&, const int&); 1 y Message(const std::string&, const int&); 2 con los términos de inglés adecuados.

  9. En funciones / métodos que devuelven Message(const std::string&, const int&); 3 , sin necesidad de explícitamente Message(const std::string&, const int&); 4 al final. E.G.: Message(const std::string&, const int&); 5 y Message(const std::string&, const int&); 6 .

  10. cuidado con comentarios ruidosos / sin sentido. Message(const std::string&, const int&); 7 y Message(const std::string&, const int&); 8 son evidentes.

chiffre.h / chiffre.cpp:

  1. de nuevo, innecesario incluye: no necesita Message(const std::string&, const int&); 9 en el archivo de encabezado.

  2. Además, las razones para cryptoContainer0 tener un destructor virtual no está claro. Si no tiene herencia, no debe ser virtual.

  3. El constructor vacío también es innecesario. Dejéelo si no tiene inicialización manual para realizar.

 

I'm no cryptography guru, so my comments will aim at the code in itself, not the algorithms.

Message.h / Message.cpp:

  1. There doesn't seem to be a need to include <iostream> nor <fstream> in the header file. Avoid importing dependencies that you don't use. The cost of an include is in compile-time. One too many big projects suffer with long compile times due to poor management of include files.

  2. Keep your parameter names in function/method prototypes. This will self document your code. Take this constructor for instance:

    Message(const std::string&, const int&); 

    Impossible to tell which parameter is doing what without consulting the implementation.

  3. cryptoContainer is a "type alias", nevertheless, it names a type. Your naming convention for types is PascalCase, so CryptoContainer would be more self-consistent.

  4. writeOriginalMessage is currently returning a meaningless integer value (always zero). It could very well return nothing (void). If there is a possibility of failure, then return a boolean true or false.

  5. Still talking about writeOriginalMessage and writeCryptedMessage, both have a quite similar loop inside:

    for (auto it = m_originalContent.begin(); it != m_originalContent.end(); it++) 

    You can significantly shorten them by using a range based foreach loop:

    for (const auto & item : container) {     stream << item; } 

    Notice the reference &. Care should be taken to avoid copying things in this style of iteration since the default in C++ is always a copy.

  6. Writing void in the parameter list of a C++ function that takes no parameters (as in getOriginalMessage(void)) is a C-ish style. C++ does not require that; () is just as good. So avoid the unnecessary verbosity.

  7. virtual destructors are only necessary when your class is meant to be inherited from. In this particular code, that doesn't seem to be the case with Message. If you did that to allow users of your code to inherit from the class, I would advise against, since Composition is usually much more elegant and with less coupling. You should remove virtual from the destructor declaration and perhaps even mark your class final. While your are at it, them make the protected section private and throw the destructor away, since it is empty.

  8. I see that you have a couple places with names not in English, while the bigger whole is all in that language. It would be better to keep things uniform, so replace things like texte and clef with the proper English terms.

  9. In functions/methods that return void, no need to explicitly return at the end. E.g.: setOriginalMessage and setCryptedMessage.

  10. Careful with noisy/meaningless comments. // constructors and // destructor are self evident.

Chiffre.h / Chiffre.cpp:

  1. Again, unnecessary includes: you don't need <vector> in the header file.

  2. Also, the reasons for Chiffre having a virtual destructor are not clear. If you don't have inheritance, you shouldn't be making it virtual.

  3. The empty constructor is also unnecessary. Leave it out if you have no manual initialization to perform.

 
 
   
   

Relacionados problema

7  HMAC con SHA256 / 512 en óxido  ( Hmac with sha256 512 in rust ) 
He intentado lo mejor que puedo, para implementar HMAC como se especifica en la RFC 2104 < / a>. Este es también mi primer proyecto de óxido, por lo que las ...

4  Herramienta de cifrado de archivos en terminal  ( Files encryption tool in terminal ) 
He creado una envoltura para el Simplecrypt biblioteca que permite cifrar / descifrar fácilmente una cadena. La aplicación se utiliza esto: //To encryp...

5  PYCRYPTO AES-256 CTR WRPPER SEGURO PARA USO PÚBLICO?  ( Pycrypto aes 256 ctr wrapper secure for public use ) 
He intentado escribir un envoltorio AES CTR más fácil de usar con Pycrypto, pero no estoy seguro de si está lo suficientemente seguro. Quiero decir, de forma ...

6  Java AES cbc cifrado / descifrado  ( Java aes cbc encryption decryption ) 
He examinado varios ejemplos de cifrado de modo de Java AES CBC, pero no pude encontrar una solución adecuada para usar. Terminé escribiendo mi propia clase d...

10  Clase de cifrado AES-128  ( Aes 128 encryption class ) 
Esta es la primera vez que escribí una clase en Java para hacer cifrado utilizando AES. Dado que la seguridad está involucrada, me encantaría si alguien pudie...

3  Implementación de WMSAUTH  ( Wmsauth implementation ) 
Tengo que implementar WMSAUTH en C #: http://wmsauth.org/examples // The following function was copied from http://wmsauth.org/examples public static str...

6  Formando combinaciones de palabras del archivo  ( Forming word combinations from file ) 
Estoy buscando ideas para optimizar el siguiente código para la velocidad. También estoy buscando una buena mejora en el tiempo de ejecución. Este código le...

2  Implementación T-SQL TOTP (RFC6238 SHA2_256)  ( T sql totp rfc6238 sha2 256 implementation ) 
Usando mi Función anterior Como base que he subido lo siguiente: create function dbo.Totp ( @key varbinary(8000) , @timeStep int = 90 ) returns tab...

4  C # interfaz de criptografía  ( C cryptography interface ) 
C # carece de una interfaz común de encriptación y descifrado de estantes para la inyección de dependencia. Casi todas las bases de código que he abierto tien...

51  Cifrado seguro simplificado de una cadena  ( Simplified secure encryption of a string ) 
Tengo dos ejemplos de código que escribí para las mejores prácticas cifrando una cadena que busco comentarios tanto en términos de mejores prácticas y segurid...




© 2022 respuesta.top Reservados todos los derechos. Centro de preguntas y respuestas reservados todos los derechos