@@ -253,7 +253,6 @@ int logs_authentication()

            "logged authorizer should be authorizer");

     check (test_logger->logged_token() == token,

            "logged token should be token");

-    std::cout <<test_logger->logged_reason() << std::endl;

     check (test_logger->logged_reason() == reason,

            "logged reason should be reason");

     succeed();

@@ -306,4 +305,3 @@ int main (int argc, char *argv[])

 {

     return !runtests();

 }

-

@@ -39,12 +39,13 @@ installer init_installer()

     fstreams fstreams (fstreams::create());

     pwd pwd (pwd::create());

     unistd unistd (unistd::create());

-    directory directory (directory::create (unistd, pwd));

     stdlib stdlib (stdlib::get());

     sys_time time (sys_time::get());

     int code_digits = 6;

     totp_generator generator = totp_generator (time, code_digits);

-    tokens tokens (tokens::create (fstreams, generator));

+    random_source rand (random_source::create(fstreams));

+    directory directory (directory::create (unistd, pwd));

+    tokens tokens (tokens::create (fstreams, generator, rand));

     installer installer (installer::create (tokens, unistd, directory,

                                             generator));

@@ -29,9 +29,10 @@ class tokens_impl : public tokens_ifc

 private:

     fstreams fstreams_;

     totp_generator generator_;

+    random_source rand_;

 public:

-    tokens_impl (const fstreams &fstreams, const totp_generator generator) :

-        fstreams_ (fstreams), generator_ (generator) {}

+    tokens_impl (const fstreams &fstreams, const totp_generator generator, const random_source rand) :

+        fstreams_ (fstreams), generator_ (generator), rand_ (rand) {}

     std::string token (const user &user) const override

     {

         // Get key

@@ -44,7 +45,6 @@ public:

         base32 codec;

         std::vector<uint8_t> key = codec.decode (line);

-        // TODO: generate the token

         return generator_.generate_token (std::string (key.begin(), key.end()));

     }

@@ -62,18 +62,6 @@ private:

         return stream->good();

     }

-    std::string generate_key() const

-    {

-        base32 codec;

-        random_source rand = random_source::create(fstreams_);

-        // get randomness

-        int length = 10;

-        std::vector<uint8_t> random_bytes (rand.get_random_bytes(length));

-        // base32encode it

-        std::string key = codec.encode (random_bytes);

-        return key;

-    }

-

     std::string read_key (const user &user) const

     {

         std::string file_path = get_key_path (user);

@@ -91,6 +79,18 @@ private:

         return line;

     }

 public:

+    // TODO: test to make sure that generate_key's output is different for different random numbers

+    std::string generate_key() const override

+    {

+        base32 codec;

+        // get randomness

+        int length = 10;

+        std::vector<uint8_t> random_bytes (rand_.get_random_bytes(length));

+        // base32encode it

+        std::string key = codec.encode (random_bytes);

+        return key;

+    }

+

     std::string ensure_key (const user &user) const override

     {

         if (!key_exists (user)) {

@@ -102,19 +102,20 @@ public:

         }

     }

-    void save (const user &user, const std::string &token) const override

+    void save (const user &user, const std::string &key) const override

     {

         std::string file_path = get_key_path (user);

         fstreams::postream stream (fstreams_.open_ofstream (file_path,

                                    std::ios_base::trunc));

-        *stream << token << std::endl;

+        *stream << key<< std::endl;

     }

 };

 }

 tokens tokens::create (const fstreams &fstreams,

-                       const totp_generator &generator)

+                       const totp_generator &generator,

+                       const random_source &rand)

 {

     return tokens (tokens::delegate

-                   (new tokens_impl (fstreams, generator)));

+                   (new tokens_impl (fstreams, generator, rand)));

 }

@@ -19,6 +19,7 @@

 #include "user.h"

 #include "sys_fstream.h"

 #include "generator.h"

+#include "random_source.h"

 class tokens_ifc

 {

@@ -29,10 +30,13 @@ public:

     {

         return "";

     }

+    virtual std::string generate_key() const {

+        return "";

+    }

     virtual std::string ensure_key (const user &user) const

     {

         return "";

-    };

+    }

     virtual void save (const user &user, const std::string &token) const {}

 };

@@ -47,6 +51,10 @@ public:

         delegate_ (delegate) {}

     tokens() : tokens (

             delegate (new tokens_ifc)) {}

+    std::string generate_key (const user &user) const

+    {

+        return delegate_->generate_key ();

+    }

     std::string ensure_key (const user &user) const

     {

         return delegate_->ensure_key (user);

@@ -60,8 +68,8 @@ public:

         return delegate_->save (user, token);

     }

     static tokens create (const fstreams &fstreams,

-                          const totp_generator &generator);

+                          const totp_generator &generator,

+                          const random_source &rand);

 };

 #endif

-

@@ -22,6 +22,7 @@

 #include "user.h"

 #include "sys_fstream.h"

 #include "generator.h"

+#include "base32.h"

 class fake_user : public user_ifc

 {

@@ -45,6 +46,13 @@ private:

     mutable std::string captured_filename_;

     mutable std::shared_ptr<std::ostringstream> capture_stream_;

 public:

+    pstream open_fstream (const std::string &file_path) const override

+    {

+        pstream result = std::make_shared<std::istringstream>("");

+        std::string badinator (1, '\0');

+        result->read (&badinator[0], badinator.size());

+        return result;

+    }

     postream open_ofstream (const std::string &file_path,

                             std::ios_base::openmode mode) const override

     {

@@ -83,6 +91,34 @@ public:

     }

 };

+class fake_rand : public random_source_ifc

+{

+public:

+    fake_rand ()

+    {}

+

+    std::vector<uint8_t> get_random_bytes (int length) const override

+    {

+        return {};

+    }

+};

+

+using octet_vector = std::vector<uint8_t>;

+class fake_rand_with_specified_result : public random_source_ifc

+{

+private:

+    octet_vector expected_bytes_;

+public:

+    fake_rand_with_specified_result (octet_vector expected_bytes)

+        : expected_bytes_ (expected_bytes)

+    {}

+

+    std::vector<uint8_t> get_random_bytes (int length) const override

+    {

+        return expected_bytes_;

+    }

+};

+

 class fake_totp_generator : public token_generator_ifc

 {

 private:

@@ -110,10 +146,11 @@ int reads_from_the_right_file ()

                            token)));

     totp_generator generator (totp_generator::delegate (new

                               fake_totp_generator (token)));

+    random_source fake_rand(random_source::delegate (new class fake_rand));

     //file_reader test_file_reader (file_reader::delegate (new fake_file_reader));

     user test_user (user::delegate (new fake_user (home_directory)));

-    tokens supplier (tokens::create (test_streams, generator));

+    tokens supplier (tokens::create (test_streams, generator, fake_rand));

     //when

     std::string actual = supplier.token (test_user);

@@ -133,9 +170,10 @@ int returns_empty_string_if_file_open_fail()

                            "654321")));

     totp_generator generator (totp_generator::delegate (new

                               fake_totp_generator ()));

+    random_source fake_rand(random_source::delegate (new class fake_rand));

     user test_user (user::delegate (new fake_user (home_directory)));

-    tokens supplier (tokens::create (test_streams, generator));

+    tokens supplier (tokens::create (test_streams, generator, fake_rand));

     //when

     std::string actual = supplier.token (test_user);

@@ -158,10 +196,11 @@ int returns_empty_string_if_file_too_short()

                            token)));

     totp_generator generator (totp_generator::delegate (new

                               fake_totp_generator (token)));

+    random_source fake_rand(random_source::delegate (new class fake_rand));

     //file_reader test_file_reader (file_reader::delegate (new fake_file_reader));

     user test_user (user::delegate (new fake_user (home_directory)));

-    tokens supplier (tokens::create (test_streams, generator));

+    tokens supplier (tokens::create (test_streams, generator, fake_rand));

     //when

     std::string actual = supplier.token (test_user);

@@ -171,7 +210,7 @@ int returns_empty_string_if_file_too_short()

     succeed();

 }

-int writes_the_token ()

+int writes_the_key ()

 {

     // given

     std::string home_directory ("/somedir");

@@ -181,7 +220,8 @@ int writes_the_token ()

     totp_generator generator (totp_generator::delegate (new

                               fake_totp_generator ()));

     std::string token ("token");

-    tokens tokens (tokens::create (test_streams, generator));

+    random_source fake_rand(random_source::delegate (new class fake_rand));

+    tokens tokens (tokens::create (test_streams, generator, fake_rand));

     //when

     tokens.save (test_user, token);

@@ -198,12 +238,62 @@ int writes_the_token ()

     succeed();

 }

+int ensure_key_creates_key_file_if_not_exists ()

+{

+    // given

+    std::string home_directory ("/somedir");

+    user test_user (user::delegate (new fake_user (home_directory)));

+    mock_write_fstreams *mockfs (new mock_write_fstreams);

+

+    fstreams test_streams{fstreams::delegate (mockfs)};

+

+    totp_generator generator (totp_generator::delegate (new fake_totp_generator ()));

+

+    std::vector<uint8_t> random_bytes {4,2,4, 2,4,  2,4,2, 4,2};

+    random_source fake_rand(random_source::delegate (new fake_rand_with_specified_result(random_bytes)));

+    tokens tokens (tokens::create (test_streams, generator, fake_rand));

+

+    //when

+    std::string actual = tokens.ensure_key (test_user);

+

+    base32 codec;

+    octet_vector actual_decoded = codec.decode(actual);

+    // then

+    std::string expected_filename (home_directory + "/.dual_control");

+    check (mockfs->captured_filename() == expected_filename,

+           "filename does not match");

+    check (random_bytes == actual_decoded,

+           "key does not match");

+    succeed();

+}

+

+int ensure_key_reads_key_file_if_exists ()

+{

+    //given

+    std::string home_directory ("/somedir");

+    std::string key_file = home_directory + "/.dual_control";

+    std::string key ("AAAAAAAAAAAAAAAA");

+    user test_user (user::delegate (new fake_user (home_directory)));

+    fstreams test_streams (fstreams::delegate (new fake_fstreams (key_file,

+                           key)));

+    totp_generator generator (totp_generator::delegate (new fake_totp_generator ()));

+    random_source fake_rand(random_source::delegate (new class fake_rand));

+    tokens tokens (tokens::create (test_streams, generator, fake_rand));

+

+    //when

+    std::string actual = tokens.ensure_key (test_user);

+    //then

+    check(actual == key, "read key does not match given key");

+    succeed();

+}

+

 int run_tests()

 {

     test (reads_from_the_right_file);

     test (returns_empty_string_if_file_open_fail);

     test (returns_empty_string_if_file_too_short);

-    test (writes_the_token);

+    test (ensure_key_creates_key_file_if_not_exists);

+    test (ensure_key_reads_key_file_if_exists);

     succeed();

 }

@@ -211,4 +301,3 @@ int main (int argc, char *argv[])

 {

     return !run_tests();

 }

-