C / C++ / MFC

yu-jian wrote:

It will resolve which problem?

a1_shay wrote:

nlogn it"s not logn

class key_generator_data;

class key_generator
{
    public:
        key_generator( const unsigned key_size );

        key_pair create_new_key() const;

    private:
        std::unique_ptr<key_generator_data> data_;
};

bool encrypt( std::istream &plain_text, std::ostream &cypher_text, const std::string &n, const std::string &e );

bool decrypt( std::istream &cypher_text, std::ostream &plain_text, const std::string &n, const std::string &d );

Aescleal wrote:

 

I'd get rid of the private member functions and use a PIMPL [1] for your key generator class. It clears a lot of stuff out of the header file and makes that a bit easier to use. If you can end up with something minimal it doesn't help people using your code. Perhaps something like:

 

C++

class key_generator_data;
 
class key_generator
{
    public:
        key_generator( const unsigned key_size );
 
        key_pair create_new_key() const;
 
    private:
        std::unique_ptr<key_generator_data> data_;
};

And that's it with key_pair, public_key and private_key being classes.

Aescleal wrote:

The only other thing I'd comment on would be what your encryption and decryption functions are called and the parameters they take. Perhaps consider having a stream interface as well?

 

C++

bool encrypt( std::istream &plain_text, std::ostream &cypher_text, const std::string &n, const std::string &e );
 
bool decrypt( std::istream &cypher_text, std::ostream &plain_text, const std::string &n, const std::string &d );

Perhaps have better naming for the public and private keys as well.

I know that you don't generally encode much with RSA but stream interfaces make it a lot easier to encrypt and decrypt stuff. You can test stuff by entering plain text at the console, reading it from a file or even over a socket without the caller having to buffer anything.

bool crypt( std::istream &in, std::ostream &out, const std::string &n, const std::string &e );

Aescleal wrote:

One final point... If you intend doing anything else it might be worth making an abstract base encryptor class and implementing your code in terms of that. Then if you ever decide to use a different asymmetric encryption algorithm or want to unit test client code you can just in a replacement.

class encryptor
{
    public:
        virtual bool encrypt( ... ) = 0;
        virtual bool decrypt( ... ) = 0;
};

class RSA_encryptor : public encryptor
{
    public:
        virtual bool encrypt( ... );
        virtual bool decrypt( ... );
};

void do_something( encryptor *enc )
{
   // Do fab and groovy stuff through the interface
}

int main()
{
    key k(...);
    RSA_encryptor rsa( &key );

    do_something( &rsa );
}