@@ -72,3 +72,4 @@ PAM_EXTERN int pam_sm_setcred (pam_handle_t *pamh, int flags, int argc,

 {

     return dc.setcred (pam_request ( pamh, flags, argc, argv));

 }

+

@@ -44,7 +44,8 @@ installer init_installer()

     int code_digits = 6;

     totp_generator generator = totp_generator (time, code_digits);

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

-    installer installer (installer::create (tokens, unistd, directory, generator));

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

+                                            generator));

     return installer;

 }

@@ -55,5 +56,7 @@ int main (int argc, char *argv[])

     class system system (init_system());

     installer tool (init_installer());

     auto generated_key_and_sample_token = tool.install_key();

-    std::cout << generated_key_and_sample_token.first << " " << generated_key_and_sample_token.second << std::endl;

+    std::cout << generated_key_and_sample_token.first << " " <<

+              generated_key_and_sample_token.second << std::endl;

 }

+

@@ -46,10 +46,10 @@ public:

         user user (found_user[0]);

-        std::string key_string = tokens_.ensure_key(user);

-        std::vector<uint8_t> key = base32().decode(key_string);

+        std::string key_string = tokens_.ensure_key (user);

+        std::vector<uint8_t> key = base32().decode (key_string);

         std::string decoded_key (key.begin(), key.end());

-        std::string token = generator_.generate_token(decoded_key);

+        std::string token = generator_.generate_token (decoded_key);

         // TODO: fix generator input

         return {key_string, token};

@@ -61,5 +61,7 @@ public:

 installer installer::create (const tokens &tokens, const unistd &unistd,

                              const directory &directory, const totp_generator &generator)

 {

-    return installer (std::make_shared<impl> (tokens, unistd, directory, generator));

+    return installer (std::make_shared<impl> (tokens, unistd, directory,

+                      generator));

 }

+

@@ -50,3 +50,4 @@ public:

 };

 #endif

+

@@ -31,12 +31,14 @@ public:

         : key_ (key)

     {}

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

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

+    {

         return key_;

     }

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

-        save(user, key_);

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

+    {

+        save (user, key_);

         return key_;

     }

@@ -76,7 +78,7 @@ public:

         expected_token (expected_token)

     {}

-    std::string generate_token(const std::string &key) const override

+    std::string generate_token (const std::string &key) const override

     {

         return expected_token;

     }

@@ -88,7 +90,8 @@ private:

     std::string expected_user_name_;

     bool has_current_user_;

 public:

-    fake_directory (const std::string &expected_user_name, bool has_current_user = true) :

+    fake_directory (const std::string &expected_user_name,

+                    bool has_current_user = true) :

         expected_user_name_ (expected_user_name),

         has_current_user_ (has_current_user)

     {

@@ -106,9 +109,11 @@ public:

     std::vector<user> get_current_user() const override

     {

         std::vector<user> result = {};

+

         if (has_current_user_) {

-            result = {find_user(expected_user_name_)};

+            result = {find_user (expected_user_name_)};

         }

+

         return result;

     }

 };

@@ -119,11 +124,12 @@ int installs_token()

     std::string user_name ("user");

     std::string key ("thekey");

     std::string token ("thetoken");

-    auto  test_tokens = std::make_shared<mock_tokens>(key);

+    auto  test_tokens = std::make_shared<mock_tokens> (key);

     tokens tokens{test_tokens};

     unistd unistd (std::make_shared<fake_unistd> (user_name));

     directory directory (std::make_shared<fake_directory> (user_name));

-    std::shared_ptr<fake_totp_generator> fake_generator = std::make_shared<fake_totp_generator> (token);

+    std::shared_ptr<fake_totp_generator> fake_generator =

+        std::make_shared<fake_totp_generator> (token);

     totp_generator generator (fake_generator );

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

@@ -131,7 +137,7 @@ int installs_token()

     //when

     std::string actual_key, actual_token;

-    std::tie(actual_key, actual_token) = installer.install_key();

+    std::tie (actual_key, actual_token) = installer.install_key();

     //then

     check (test_tokens->captured_token == key, "installed wrong key");

@@ -169,18 +175,19 @@ int unistd_does_not_find_user_name_empty_string_case()

     //given

     std::string user_name ("user");

     std::string key ("token");

-    auto  test_tokens = std::make_shared<mock_tokens>(key);

+    auto  test_tokens = std::make_shared<mock_tokens> (key);

     tokens tokens{test_tokens};

     unistd unistd (std::make_shared<fake_unistd> (""));

     directory directory (std::make_shared<fake_directory> (user_name, false));

-    totp_generator generator (totp_generator (std::make_shared<fake_totp_generator>()));

+    totp_generator generator (totp_generator (

+                                  std::make_shared<fake_totp_generator>()));

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

                           generator);

     //when

     std::string actual_key, actual_token;

-    std::tie(actual_key, actual_token) = installer.install_key();

+    std::tie (actual_key, actual_token) = installer.install_key();

     //then

     // TODO: rethink this...

@@ -197,10 +204,11 @@ int directory_finds_no_user_info()

 {

     std::string user_name ("user");

     std::string key ("token");

-    auto  test_tokens = std::make_shared<mock_tokens>(key);

+    auto  test_tokens = std::make_shared<mock_tokens> (key);

     tokens tokens{test_tokens};

     unistd unistd (std::make_shared<fake_unistd> (user_name));

-    directory directory (std::make_shared<fake_directory> ("not the user", false));

+    directory directory (std::make_shared<fake_directory> ("not the user",

+                         false));

     totp_generator generator (std::make_shared<fake_totp_generator>());

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

@@ -208,7 +216,7 @@ int directory_finds_no_user_info()

     //when

     std::string actual_key, actual_token;

-    std::tie(actual_key, actual_token) = installer.install_key();

+    std::tie (actual_key, actual_token) = installer.install_key();

     //then

     check (test_tokens->captured_token == "", "installed wrong key");

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

 {

     return !run_tests();

 }

+

@@ -55,3 +55,4 @@ public:

 template class std::shared_ptr<unistd_ifc>;

 #endif

+

@@ -30,72 +30,78 @@ private:

     totp_generator generator_;

 public:

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

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

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

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

     {

         // Get key

-        std::string line = read_key(user);

+        std::string line = read_key (user);

+

         if (line == "") {

             return "";

         }

         base32 codec;

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

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

         // TODO: generate the token

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

     }

 private:

-    std::string get_key_path(const user &user) const {

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

+    {

         return user.home_directory() + "/.dual_control";

     }

-    bool key_exists (const user &user) const {

+    bool key_exists (const user &user) const

+    {

         // check if file exists

-        std::string file_path = get_key_path(user);

-        fstreams::pstream stream (fstreams_.open_fstream(file_path));

+        std::string file_path = get_key_path (user);

+        fstreams::pstream stream (fstreams_.open_fstream (file_path));

         return stream->good();

     }

-    std::string generate_key() const {

+    std::string generate_key() const

+    {

         base32 codec;

         // get randomness

         std::vector<unsigned char> random_bytes (16);

         // base32encode it

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

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

         return "QWERQWERQWERQWER";

     }

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

-        std::string file_path = get_key_path(user);

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

+    {

+        std::string file_path = get_key_path (user);

         fstreams::pstream stream (fstreams_.open_fstream (file_path));

         // TODO: ignore newlines

-        std::vector<char> line_v(16);

-        stream->read(line_v.data(), line_v.size());

+        std::vector<char> line_v (16);

+        stream->read (line_v.data(), line_v.size());

         if (stream->fail()) {

             return "";

         }

-        std::string line(line_v.begin(), line_v.end());

+        std::string line (line_v.begin(), line_v.end());

         return line;

     }

 public:

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

-        if (!key_exists(user)) {

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

+    {

+        if (!key_exists (user)) {

             std::string key = generate_key();

-            save(user, key);

+            save (user, key);

             return key;

         } else {

-            return read_key(user);

+            return read_key (user);

         }

     }

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

     {

-        std::string file_path = get_key_path(user);

+        std::string file_path = get_key_path (user);

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

                                    std::ios_base::trunc));

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

@@ -103,8 +109,10 @@ public:

 };

 }

-tokens tokens::create (const fstreams &fstreams, const totp_generator &generator)

+tokens tokens::create (const fstreams &fstreams,

+                       const totp_generator &generator)

 {

     return tokens (tokens::delegate

                    (new tokens_impl (fstreams, generator)));

 }

+

@@ -29,7 +29,10 @@ public:

     {

         return "";

     }

-    virtual std::string ensure_key (const user &user) const { return ""; };

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

+    {

+        return "";

+    };

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

 };

@@ -44,8 +47,9 @@ public:

         delegate_ (delegate) {}

     tokens() : tokens (

             delegate (new tokens_ifc)) {}

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

-        return delegate_->ensure_key(user);

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

+    {

+        return delegate_->ensure_key (user);

     }

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

     {

@@ -55,7 +59,9 @@ public:

     {

         return delegate_->save (user, token);

     }

-    static tokens create (const fstreams &fstreams, const totp_generator &generator);

+    static tokens create (const fstreams &fstreams,

+                          const totp_generator &generator);

 };

 #endif

+

@@ -92,7 +92,8 @@ public:

     fake_totp_generator (std::string expected_token = "<unspecified>") :

         expected_token (expected_token)

     {}

-    std::string generate_token (const std::string &key) const override {

+    std::string generate_token (const std::string &key) const override

+    {

         return expected_token;

     }

 };

@@ -105,8 +106,10 @@ int reads_from_the_right_file ()

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

     std::string token ("AAAAAAAAAAAAAAAA");

-    fstreams test_streams (fstreams::delegate (new fake_fstreams (token_file, token)));

-    totp_generator generator (totp_generator::delegate (new fake_totp_generator (token)));

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

+                           token)));

+    totp_generator generator (totp_generator::delegate (new

+                              fake_totp_generator (token)));

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

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

@@ -128,7 +131,8 @@ int returns_empty_string_if_file_open_fail()

     std::string token_file = home_directory + "/.not_dual_control";

     fstreams test_streams (fstreams::delegate (new fake_fstreams (token_file,

                            "654321")));

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

+    totp_generator generator (totp_generator::delegate (new

+                              fake_totp_generator ()));

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

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

@@ -150,8 +154,10 @@ int returns_empty_string_if_file_too_short()

     // we want a 40-byte key, so we need a 64-byte base32-encoded file.

     std::string token ("AAAAAAAAAAAAAAA");

-    fstreams test_streams (fstreams::delegate (new fake_fstreams (token_file, token)));

-    totp_generator generator (totp_generator::delegate (new fake_totp_generator (token)));

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

+                           token)));

+    totp_generator generator (totp_generator::delegate (new

+                              fake_totp_generator (token)));

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

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

@@ -172,7 +178,8 @@ int writes_the_token ()

     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 ()));

+    totp_generator generator (totp_generator::delegate (new

+                              fake_totp_generator ()));

     std::string token ("token");

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

@@ -184,8 +191,10 @@ int writes_the_token ()

     temp << token << std::endl;

     std::string expected_written = temp.str();

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

-    check (mockfs->captured_filename() == expected_filename, "filename does not match");

-    check (mockfs->captured_written() == expected_written, "token does not match");

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

+           "filename does not match");

+    check (mockfs->captured_written() == expected_written,

+           "token does not match");

     succeed();

 }

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

 {

     return !run_tests();

 }

+

@@ -56,7 +56,8 @@ public:

         return return_value;

     }

-    std::vector<user> get_current_user () const override {

+    std::vector<user> get_current_user () const override

+    {

         const char *c_user_name = unistd_.getlogin();

         if (c_user_name == nullptr) {

@@ -80,3 +81,4 @@ directory directory::create (unistd &unistd, pwd &pwd)

 {

     return directory (delegate (new directory_impl (unistd, pwd)));

 }

+

@@ -54,7 +54,8 @@ public:

     {

         return std::vector<user>();

     }

-    virtual std::vector<user> get_current_user () const {

+    virtual std::vector<user> get_current_user () const

+    {

         return {};

     };

 };

@@ -81,3 +82,4 @@ public:

 };

 #endif

+

@@ -79,7 +79,8 @@ private:

     const char *expected_username_;

     long int return_value_;

 public:

-    fake_unistd (int expected_sysconf_name, long int return_value = 0, const char *expected_username = "<unspecified>")

+    fake_unistd (int expected_sysconf_name, long int return_value = 0,

+                 const char *expected_username = "<unspecified>")

         : expected_sysconf_name_ (expected_sysconf_name),

           expected_username_ (expected_username),

           return_value_ (return_value) {}

@@ -91,7 +92,8 @@ public:

         return -1;

     }

-    const char * getlogin() const override{

+    const char *getlogin() const override

+    {

         return expected_username_;

     }

 };

@@ -167,8 +169,9 @@ int get_current_user_happy_path()

 {

     //given

     std::string user_name ("user");

-    pwd test_pwd(pwd::delegate (new fake_pwd (user_name)));

-    unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX, 0, user_name.c_str())));

+    pwd test_pwd (pwd::delegate (new fake_pwd (user_name)));

+    unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX,

+                                          0, user_name.c_str())));

     directory directory (directory::create (test_unistd, test_pwd));

     //when

@@ -176,15 +179,17 @@ int get_current_user_happy_path()

     //then

     check (!results.empty(), "user should have been found");

-    check (!(results[0].home_directory() == user_name), "user should have been found");

+    check (! (results[0].home_directory() == user_name),

+           "user should have been found");

     succeed();

 }

 int get_current_user_nullptr_path()

 {

     //given

-    pwd test_pwd(pwd::delegate (new fake_pwd ("<unspecified>")));

-    unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX, 0, nullptr)));

+    pwd test_pwd (pwd::delegate (new fake_pwd ("<unspecified>")));

+    unistd test_unistd (unistd::delegate (new fake_unistd (_SC_GETPW_R_SIZE_MAX,

+                                          0, nullptr)));

     directory directory (directory::create (test_unistd, test_pwd));

     //when

@@ -210,3 +215,4 @@ int main (int argc, char **argv)

 {

     return !run_tests();

 }

+

@@ -61,3 +61,4 @@ validator validator::create (const directory &directory,

             tokens));

     return validator (delegate);

 }

+

@@ -54,3 +54,4 @@ public:

 };

 #endif

+