@@ -3,9 +3,9 @@ CFLAGS += -fPIC -fno-stack-protector

 LDFLAGS = -lpam

 INTEGRATION_OBJS = sys_syslog.o sys_fstream.o sys_unistd.o sys_pwd.o sys_pam.o dual_control_integrate.o

-OBJS = dual_control.o request.o validator.o conversation.o user.o token.o logger.o

+OBJS = dual_control.o request.o validator.o conversation.o user.o token.o logger.o session.o

 TESTS = dual_control_test validator_test conversation_test request_test user_test token_test \

-		logger_test

+		logger_test session_test

 TESTOBJS = $(patsubst %,%.o,$(TESTS))

 SRCS := $(OBJS:.o=.cc) $(TESTOBJS:.o=.cc)

new file mode 100644

@@ -0,0 +1,2 @@

+- look up requester user and fail if not found

+

@@ -82,7 +82,7 @@ private:

     pam_handle *expected_handle_;

     conversation_data conversation_data_;

     int get_response_;

-    pam_conv conv_;

+    mutable pam_conv conv_;

 public:

     fake_pam (pam_handle *expected_handle,

               const conversation_data &conversation_data)

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

           get_response_ (PAM_SUCCESS)

     {}

     fake_pam (int get_response) : get_response_ (get_response) {}

-    int get_conv (pam_handle *handle, const pam_conv **out)

+    int get_conv (pam_handle *handle, const pam_conv **out) const

     {

         if (get_response_ != PAM_SUCCESS) {

             return get_response_;

@@ -101,7 +101,7 @@ public:

             throw std::string ("unexpected handle");

         }

-        conv_.appdata_ptr = reinterpret_cast<void *> (&conversation_data_);

+        conv_.appdata_ptr = (void *) (&conversation_data_);

         conv_.conv = fake_conv;

         *out = &conv_;

         return PAM_SUCCESS;

@@ -17,6 +17,7 @@

 #include "dual_control.h"

 #include "conversation.h"

 #include "validator.h"

+#include "session.h"

 #include "logger.h"

 int dual_control_ifc::authenticate (const pam_request &request)

@@ -37,6 +38,7 @@ private:

     conversation conversation_;

     validator validator_;

     logger logger_;

+    sessions sessions_;

 public:

     impl (const dual_control_configuration &configuration);

     int authenticate (const pam_request &request);

@@ -46,7 +48,8 @@ public:

 impl::impl (const dual_control_configuration &configuration) :

     conversation_ (configuration.conversation),

     validator_ (configuration.validator),

-    logger_ (configuration.logger) {}

+    logger_ (configuration.logger),

+    sessions_ (configuration.sessions) {}

 int impl::setcred (const pam_request &request)

 {

@@ -57,7 +60,10 @@ int impl::authenticate (const pam_request &request)

 {

     conversation_result input (conversation_.initiate (request));

-    int auth_result = validator_.validate (input.user_name,

+    sessions_.user_name (request);

+

+    auto requester_user_name = sessions_.user_name (request);

+    int auth_result = validator_.validate ("anyone", input.user_name,

                                            input.token) ? PAM_SUCCESS : PAM_AUTH_ERR;

     logger_.log (auth_result, input.user_name, input.token);

@@ -24,11 +24,13 @@

 #include "validator.h"

 #include "conversation.h"

 #include "logger.h"

+#include "session.h"

 struct dual_control_configuration {

     class validator validator;

     class conversation conversation;

     class logger logger;

+    class sessions sessions;

 };

 class dual_control_ifc

@@ -29,6 +29,7 @@

 #include "sys_fstream.h"

 #include "sys_pam.h"

 #include "sys_syslog.h"

+#include "session.h"

 namespace

 {

@@ -46,9 +47,11 @@ dual_control initialize()

     conversation conversation (conversation::create (pam));

     sys_syslog sys_syslog (sys_syslog::create());

     logger logger (logger::create (sys_syslog));

+    sessions sessions (sessions::create (pam));

     configuration.validator = validator;

     configuration.logger = logger;

     configuration.conversation = conversation;

+    configuration.sessions = sessions;

     return dual_control::create (configuration);

 }

 dual_control dc = initialize();

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

 public:

     fake_validator (const std::string &user,

                     const std::string &token): user_ (user), token_ (token) {}

-    bool validate (const std::string &user, const std::string &token)

+    bool validate (const std::string &requester, const std::string &user,

+                   const std::string &token)

     {

         return user_ == user && token_ == token;

     }

new file mode 100644

@@ -0,0 +1,41 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

+#include <memory>

+#include <string>

+

+#include "session.h"

+#include "sys_pam.h"

+#include "request.h"

+

+namespace

+{

+class impl : public sessions_ifc

+{

+private:

+    pam pam_;

+public:

+    impl (const pam &pam) : pam_ (pam) {}

+    std::string user_name (const pam_request &request)  const

+    {

+        const char *user_name;

+        pam_.get_user (request.handle(), &user_name);

+        return user_name;

+    }

+};

+

+}

+

+sessions sessions::create (const pam &pam)

+{

+    return sessions (std::make_shared<impl> (pam));

+}

+

new file mode 100644

@@ -0,0 +1,45 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

+#ifndef _SESSION_H_

+#define _SESSION_H_

+

+#include <string>

+

+#include "request.h"

+#include "sys_pam.h"

+

+class sessions_ifc

+{

+public:

+    virtual ~sessions_ifc () {}

+    virtual std::string user_name (const pam_request &request)  const

+    {

+        return "";

+    }

+};

+

+class sessions

+{

+private:

+    std::shared_ptr<sessions_ifc> delegate_;

+public:

+    sessions (std::shared_ptr<sessions_ifc> delegate =

+                  std::make_shared<sessions_ifc>()) : delegate_ (delegate) {}

+    std::string user_name (const pam_request &request) const

+    {

+        return delegate_->user_name (request);

+    }

+    static sessions create (const pam &pam);

+};

+

+#endif

+

new file mode 100644

@@ -0,0 +1,60 @@

+/* Copyright (C) CJ Affiliate

+ *

+ * You may use, distribute and modify this code under  the

+ * terms of the  GNU General Public License  version 2  or

+ * later.

+ *

+ * You should have received a copy of the license with this

+ * file. If not, you will find a copy in the "LICENSE" file

+ * at https://github.com/cjdev/dual-control.

+ */

+

+#include <string>

+#include <memory>

+

+#include "session.h"

+#include "test_util.h"

+#include "sys_pam.h"

+#include "request.h"

+

+class fake_sys_pam : public pam_ifc

+{

+private:

+    std::string user_name_;

+public:

+    fake_sys_pam (std::string user_name) : user_name_ (user_name) {}

+    int get_user (pam_handle *handle, const char **out) const

+    {

+        *out = user_name_.c_str();

+        return PAM_SUCCESS;

+    }

+};

+

+int gets_user_from_pam()

+{

+    //given

+    std::string user_name ("user");

+    pam fake_sys_pam (std::make_shared<fake_sys_pam> (user_name));

+    sessions sessions (sessions::create (fake_sys_pam));

+    pam_request request (0, 0, 0, 0);

+

+    //when

+    std::string actual = sessions.user_name (request);

+

+    //

+    //then

+    check (actual == user_name, "returned wrong user name");

+    succeed();

+}

+

+int run_tests()

+{

+    test (gets_user_from_pam);

+    succeed();

+}

+

+int main (int argc, char *argv[])

+{

+    return !run_tests();

+}

+

@@ -21,10 +21,14 @@ namespace

 class impl : public pam_ifc

 {

 public:

-    int get_conv (pam_handle *handle, const pam_conv **out)

+    int get_conv (pam_handle *handle, const pam_conv **out) const

     {

         return ::pam_get_item (handle, PAM_CONV, (const void **)out);

     }

+    int get_user (pam_handle *handle, const char **out) const

+    {

+        return ::pam_get_item (handle, PAM_USER, (const void **)out);

+    }

 };

 }

@@ -19,7 +19,11 @@ class pam_ifc

 {

 public:

     virtual ~pam_ifc() {}

-    virtual int get_conv (pam_handle *handle, const pam_conv **out)

+    virtual int get_user (pam_handle *handle, const char **out) const

+    {

+        return PAM_SERVICE_ERR;

+    }

+    virtual int get_conv (pam_handle *handle, const pam_conv **out) const

     {

         return PAM_SERVICE_ERR;

     }

@@ -33,7 +37,11 @@ private:

 public:

     pam (const delegate &delegate) : delegate_ (delegate) {}

     pam() : pam (delegate (new pam_ifc)) {}

-    int get_conv (pam_handle *handle, const pam_conv **out)

+    int get_user (pam_handle *handle, const char **out) const

+    {

+        return delegate_->get_user (handle, out);

+    }

+    int get_conv (pam_handle *handle, const pam_conv **out) const

     {

         return delegate_->get_conv (handle, out);

     }

@@ -32,7 +32,6 @@

 #define test(NAME) \

     { \

-      __reset_vars(); \

       int result = NAME (); \

       if (!result) { \

           fprintf(stderr, "test failed: %s\n", #NAME); \

@@ -26,10 +26,19 @@ public:

           const user_token_supplier user_token_supplier) :

         directory_ (directory),

         user_token_supplier_ (user_token_supplier) {}

-    bool validate (const std::string &user_name,

+    bool validate (const std::string &requester_user_name,

+                   const std::string &authorizer_user_name,

                    const std::string &token)

     {

-        std::vector<user> found_user = directory_.find_user (user_name);

+        std::vector<user> found_user = directory_.find_user (authorizer_user_name);

+

+        if (requester_user_name.empty()) {

+            return false;

+        }

+

+        if (requester_user_name == authorizer_user_name) {

+            return false;

+        }

         if (found_user.empty()) {

             return false;

@@ -22,8 +22,9 @@ class validator_ifc

 {

 public:

     virtual ~validator_ifc() {}

-    virtual bool validate (const std::string &user_name,

-                           const std::string &token)

+    virtual bool validate (const std::string &requester_user_name,

+                           const std::string &authorizer_user_name,

+                           const std::string &authorizer_token)

     {

         return false;

     }

@@ -38,9 +39,12 @@ public:

         (delegate) {}

     validator() : validator (std::shared_ptr<validator_ifc>

                                  (new validator_ifc)) {}

-    bool validate (const std::string &user_name, const std::string &token)

+    bool validate (const std::string &requester_user_name,

+                   const std::string &authorizer_user_name,

+                   const std::string &authorizer_token)

     {

-        return delegate_->validate (user_name, token);

+        return delegate_->validate (requester_user_name, authorizer_user_name,

+                                    authorizer_token);

     }

     static validator create (const directory &directory,

                              const user_token_supplier &token_supplier);

@@ -70,7 +70,7 @@ bool validator_validates()

     validator validator = validator::create (directory, user_token_supplier);

     // when

-    bool actual = validator.validate (user_name, token);

+    bool actual = validator.validate ("requester", user_name, token);

     // then

     check (actual, "should be valid");

@@ -88,7 +88,7 @@ bool validator_fails_unknown_user()

     validator validator = validator::create (directory, user_token_supplier);

     // when

-    bool actual = validator.validate ("notuser", token);

+    bool actual = validator.validate ("requester", "notuser", token);

     // then

     check (!actual, "should not be valid");

@@ -106,13 +106,55 @@ bool validator_fails_incorrect_token()

     validator validator = validator::create (directory, user_token_supplier);

     // when

-    bool actual = validator.validate (user_name, "token");

+    bool actual = validator.validate ("requester", user_name, "token");

     // then

     check (!actual, "should not be valid");

     succeed();

 }

+bool validator_fails_with_own_token()

+{

+    // given

+    std::string requester_user_name ("requester");

+    std::string authorizer_user_name (requester_user_name);

+    std::string authorizer_token ("token");

+    directory directory (share (new fake_directory (authorizer_user_name)));

+    user_token_supplier user_token_supplier (share (new

+            fake_user_token_supplier (authorizer_token)));

+    validator validator = validator::create (directory, user_token_supplier);

+

+    // when

+    bool actual = validator.validate (requester_user_name, authorizer_user_name,

+                                      authorizer_token);

+

+    // then

+    check (!actual, "should not be valid");

+    succeed();

+

+}

+

+bool validator_fails_with_unknown_requester()

+{

+    // given

+    std::string requester_user_name ("");

+    std::string authorizer_user_name ("authorizer");

+    std::string authorizer_token ("token");

+    directory directory (share (new fake_directory (authorizer_user_name)));

+    user_token_supplier user_token_supplier (share (new

+            fake_user_token_supplier (authorizer_token)));

+    validator validator = validator::create (directory, user_token_supplier);

+

+    // when

+    bool actual = validator.validate (requester_user_name, authorizer_user_name,

+                                      authorizer_token);

+

+    // then

+    check (!actual, "should not be valid");

+    succeed();

+

+}

+

 RESET_VARS_START

 RESET_VARS_END

@@ -121,6 +163,8 @@ bool run_tests()

     test (validator_validates);

     test (validator_fails_unknown_user);

     test (validator_fails_incorrect_token);

+    test (validator_fails_with_own_token);

+    test (validator_fails_with_unknown_requester);

     succeed();

 }

new file mode 100755

@@ -0,0 +1,8 @@

+#!/bin/bash

+

+if ! which fswatch > /dev/null; then

+    echo 'fswatch is required https://github.com/emcrisostomo/fswatch'

+    exit 1

+fi

+fswatch -E --exclude '.' --include='\.(cc|h)$' -o $(dirname $0) | xargs -n1 -I{} make test

+