教程 3: 保护INVO(Tutorial 3: Securing INVO)

在这一章, 我们将继续解释INVO是如何构成的, 我们将讨论认证的实施, 使用事件和插件的认证和一个由Phalcon管理的访问控制列表.

登录应用(Log into the Application)

一个 “log in” 功能将允许我们在后台控制器中工作. 后台控制器和前台之前的分离是合乎逻辑的. 所有加载的控制器都位于相同的目录 (app/controllers/).

为了进入系统, 用户必须有一个有效的用户名和密码. 用户存储在数据库 “invo” 里面的 “users” 表里面.

在我们开始会话之前, 我们需要在数据库配置数据库的连接. 一个 “db” 服务在服务容器中设置连接信息. 就自动加载器来说, 我们再一次从配置文件中读取参数来配置一个服务:

  1. <?php
  3. use Phalcon\Db\Adapter\Pdo\Mysql as DbAdapter;
  5. // ...
  7. // 数据库连接是基于配置文件已经定义的参数创建的
  8. $di->set(
  9.     "db",
  10.     function () use ($config) {
  11.         return new DbAdapter(
  12.             [
  13.                 "host"     => $config->database->host,
  14.                 "username" => $config->database->username,
  15.                 "password" => $config->database->password,
  16.                 "dbname"   => $config->database->name,
  17.             ]
  18.         );
  19.     }
  20. );

这里, 我们将会返回一个MySQL连接适配器的一个实例. 如果需要, 你可以做一些额外的操作比如添加一个日志记录, 一个分析器或者改变适配器, 设置你想要的.

下列表单(app/views/session/index.volt) 请求登录信息. 我们已经删除了一些 HTML 代码来让例子更加简洁:

  1. {{ form("session/start") }}
  2.     <fieldset>
  3.         <div>
  4.             <label for="email">
  5.                 Username/Email
  6.             </label>
  8.             <div>
  9.                 {{ text_field("email") }}
  10.             </div>
  11.         </div>
  13.         <div>
  14.             <label for="password">
  15.                 Password
  16.             </label>
  18.             <div>
  19.                 {{ password_field("password") }}
  20.             </div>
  21.         </div>
  25.         <div>
  26.             {{ submit_button("Login") }}
  27.         </div>
  28.     </fieldset>
  29. {{ endForm() }}

使用原生的PHP作为以前的教程, 我们开始使用 Volt. 这是一个内置的模板引擎受 Jinja 的影响而提供简单而又友好的语法来创建模板. 在你熟悉 Volt 之前, 它将不会花费你太多的时间.

SessionController::startAction 方法 (app/controllers/SessionController.php) 有验证表单中输入的数据包括检查在数据库中是否为有效用户的任务:

  1. <?php
  3. class SessionController extends ControllerBase
  4. {
  5.     // ...
  7.     private function _registerSession($user)
  8.     {
  9.         $this->session->set(
  10.             "auth",
  11.             [
  12.                 "id"   => $user->id,
  13.                 "name" => $user->name,
  14.             ]
  15.         );
  16.     }
  18.     /**
  19.      * 这个方法检验和记录一个用户到应用中
  20.      */
  21.     public function startAction()
  22.     {
  23.         if ($this->request->isPost()) {
  24.             // 从用户获取数据
  25.             $email    = $this->request->getPost("email");
  26.             $password = $this->request->getPost("password");
  28.             // 在数据库中查找用户
  29.             $user = Users::findFirst(
  30.                 [
  31.                     "(email = :email: OR username = :email:) AND password = :password: AND active = 'Y'",
  32.                     "bind" => [
  33.                         "email"    => $email,
  34.                         "password" => sha1($password),
  35.                     ]
  36.                 ]
  37.             );
  39.             if ($user !== false) {
  40.                 $this->_registerSession($user);
  42.                 $this->flash->success(
  43.                     "Welcome " . $user->name
  44.                 );
  46.                 // 如果用户是有效的, 转发到'invoices'控制器
  47.                 return $this->dispatcher->forward(
  48.                     [
  49.                         "controller" => "invoices",
  50.                         "action"     => "index",
  51.                     ]
  52.                 );
  53.             }
  55.             $this->flash->error(
  56.                 "Wrong email/password"
  57.             );
  58.         }
  60.         // 再一次转发到登录表单
  61.         return $this->dispatcher->forward(
  62.             [
  63.                 "controller" => "session",
  64.                 "action"     => "index",
  65.             ]
  66.         );
  67.     }
  68. }

为简单起见, 我们使用 “sha1” 在数据库中存储密码散列, 然而, 在实际应用中不建议采用此算法, 使用 “bcrypt” 代替.

请注意, 多个公共属性在控制器访问, 像: $this->flash, $this->request 或者 $this->session. 这些是先前在服务容器中定义的服务 (app/config/services.php). 当它们第一次访问的时候, 它们被注入作为控制器的一部分.

这些服务是”共享”的, 这意味着我们总是访问相同的地方, 无论我们在哪里调用它们.

例如, 这里我们调用 “session” 服务然后我们在变量 “auth” 中存储用户身份:

  1. <?php
  3. $this->session->set(
  4.     "auth",
  5.     [
  6.         "id"   => $user->id,
  7.         "name" => $user->name,
  8.     ]
  9. );

本节的另外一个重要方面是如何验证用户为有效的, 首先我们验证是否使用的是POST请求的:

  1. <?php
  3. if ($this->request->isPost()) {

然后, 我们接收表单中的参数:

  1. <?php
  3. $email    = $this->request->getPost("email");
  4. $password = $this->request->getPost("password");

现在, 我们需要检查是否存在一个相同的用户名或邮箱和密码的用户:

  1. <?php
  3. $user = Users::findFirst(
  4.     [
  5.         "(email = :email: OR username = :email:) AND password = :password: AND active = 'Y'",
  6.         "bind" => [
  7.             "email"    => $email,
  8.             "password" => sha1($password),
  9.         ]
  10.     ]
  11. );

注意, ‘绑定参数’的使用, 占位符 :email: 和 :password: 要放置在替换的值的位置, 然后值的’绑定’使用参数 ‘bind’. 安全的替换列的值而没有SQL注入的危险.

如果用户是有效的, 我们将会在session中注册它, 并且转发到dashboard:

  1. <?php
  3. if ($user !== false) {
  4.     $this->_registerSession($user);
  6.     $this->flash->success(
  7.         "Welcome " . $user->name
  8.     );
  10.     return $this->dispatcher->forward(
  11.         [
  12.             "controller" => "invoices",
  13.             "action"     => "index",
  14.         ]
  15.     );
  16. }

如果用户不存在,再一次转发到登录表单让用户再次操作:

  1. <?php
  3. return $this->dispatcher->forward(
  4.     [
  5.         "controller" => "session",
  6.         "action"     => "index",
  7.     ]
  8. );

后端安全(Securing the Backend)

后端是一个私有区域，只有已经注册的人可以访问. 因此, 只有注册用户才能访问控制器这样的检验是有必要的. 如果你没有登录到应用中并试图访问, 例如, products 控制器 (这是私有的) 你将会看到如下屏幕:

../_images/invo-2.png

每次有人试图访问任何controller/action, 应用将会验证当前角色(在session中)是否能够访问它, 否则就会显示一个像上面那样的消息并转发到首页.

现在, 让我们看看应用程序是如何实现的. 首先我们知道有个组件叫做 Dispatcher. 通过 Routing 组件来找到路由. 然后, 它负责加载合适的控制器和执行相应的动作方法.

正常情况下, 框架会自动创建分发器. 对我们而言, 我们想在执行请求的方法之前执行一个验证, 校验用户是否可以访问它. 要做到这一点, 我们需要在启动文件中创建一个方法来替换组件:

  1. <?php
  3. use Phalcon\Mvc\Dispatcher;
  5. // ...
  7. /**
  8.  * MVC 分发器
  9.  */
  10. $di->set(
  11.     "dispatcher",
  12.     function () {
  13.         // ...
  15.         $dispatcher = new Dispatcher();
  17.         return $dispatcher;
  18.     }
  19. );

我们现在使用完全控制的分发器用于应用程序. 在框架中需要多组件的触发事件, 允许我们能够修改内部的操作流. 依赖注入组件作为胶水的一部分, 一个新的叫做 EventsManager 的组件允许我们拦截由组件产生的事件, 路由事件到监听.

事件管理(Events Management)

一个 EventsManager 允许我们为一个特定类型的事件添加监听. 现在我们感兴趣的类型是 “dispatch”. 下列代码过滤了由分发器产生的所有事件:

  1. <?php
  3. use Phalcon\Mvc\Dispatcher;
  4. use Phalcon\Events\Manager as EventsManager;
  6. $di->set(
  7.     "dispatcher",
  8.     function () {
  9.         // 创建一个事件管理器
  10.         $eventsManager = new EventsManager();
  12.         // 监听分发器中使用安全插件产生的事件
  13.         $eventsManager->attach(
  14.             "dispatch:beforeExecuteRoute",
  15.             new SecurityPlugin()
  16.         );
  18.         // 处理异常和使用 NotFoundPlugin 未找到异常
  19.         $eventsManager->attach(
  20.             "dispatch:beforeException",
  21.             new NotFoundPlugin()
  22.         );
  24.         $dispatcher = new Dispatcher();
  26.         // 分配事件管理器到分发器
  27.         $dispatcher->setEventsManager($eventsManager);
  29.         return $dispatcher;
  30.     }
  31. );

当一个叫做 “beforeExecuteRoute” 的事件触发以下插件将会被通知:

  1. <?php
  3. /**
  4.  * 检验用户是否允许使用 SecurityPlugin 访问某些方法
  5.  */
  6. $eventsManager->attach(
  7.     "dispatch:beforeExecuteRoute",
  8.     new SecurityPlugin()
  9. );

当一个 “beforeException” 被触发然后其他插件通知:

  1. <?php
  3. /**
  4.  * 处理异常和使用 NotFoundPlugin 未找到异常
  5.  */
  6. $eventsManager->attach(
  7.     "dispatch:beforeException",
  8.     new NotFoundPlugin()
  9. );

SecurityPlugin 是一个类位于(app/plugins/SecurityPlugin.php). 这个类实现了 “beforeExecuteRoute” 方法. 这是一个相同的名字在分发器中产生的事件中的一个:

  1. <?php
  3. use Phalcon\Events\Event;
  4. use Phalcon\Mvc\User\Plugin;
  5. use Phalcon\Mvc\Dispatcher;
  7. class SecurityPlugin extends Plugin
  8. {
  9.     // ...
  11.     public function beforeExecuteRoute(Event $event, Dispatcher $dispatcher)
  12.     {
  13.         // ...
  14.     }
  15. }

钩子事件始终接收第一个包含上下文信息所产生的事件($event)的参数和第二个包含事件本身所产生的对象($dispatcher)的参数. 这不是一个强制性的插件扩展类 Phalcon\Mvc\User\Plugin, 但通过这样做, 它们更容易获得应用程序中可用的服务.

现在, 我们验证当前 session 中的角色, 验证用户是否可以通过ACL列表访问.如果用户没有权限, 我们将会重定向到如上所述的主页中去:

  1. <?php
  3. use Phalcon\Acl;
  4. use Phalcon\Events\Event;
  5. use Phalcon\Mvc\User\Plugin;
  6. use Phalcon\Mvc\Dispatcher;
  8. class SecurityPlugin extends Plugin
  9. {
  10.     // ...
  12.     public function beforeExecuteRoute(Event $event, Dispatcher $dispatcher)
  13.     {
  14.         // 检查session中是否存在"auth"变量来定义当前活动的角色
  15.         $auth = $this->session->get("auth");
  17.         if (!$auth) {
  18.             $role = "Guests";
  19.         } else {
  20.             $role = "Users";
  21.         }
  23.         // 从分发器获取活动的 controller/action
  24.         $controller = $dispatcher->getControllerName();
  25.         $action     = $dispatcher->getActionName();
  27.         // 获得ACL列表
  28.         $acl = $this->getAcl();
  30.         // 检验角色是否允许访问控制器 (resource)
  31.         $allowed = $acl->isAllowed($role, $controller, $action);
  33.         if (!$allowed) {
  34.             // 如果没有访问权限则转发到 index 控制器
  35.             $this->flash->error(
  36.                 "You don't have access to this module"
  37.             );
  39.             $dispatcher->forward(
  40.                 [
  41.                     "controller" => "index",
  42.                     "action"     => "index",
  43.                 ]
  44.             );
  46.             // 返回 "false" 我们将告诉分发器停止当前操作
  47.             return false;
  48.         }
  49.     }
  50. }

提供 ACL 列表(Providing an ACL list)

在上面的例子中我们已经获得了ACL的使用方法 $this->getAcl(). 这个方法也是在插件中实现的. 现在我们要逐步解释如何建立访问控制列表(ACL):

  1. <?php
  3. use Phalcon\Acl;
  4. use Phalcon\Acl\Role;
  5. use Phalcon\Acl\Adapter\Memory as AclList;
  7. // 创建一个 ACL
  8. $acl = new AclList();
  10. // 默认行为是 DENY(拒绝) 访问
  11. $acl->setDefaultAction(
  12.     Acl::DENY
  13. );
  15. // 注册两个角色, 用户是已注册用户和没有定义身份的来宾用户
  16. $roles = [
  17.     "users"  => new Role("Users"),
  18.     "guests" => new Role("Guests"),
  19. ];
  21. foreach ($roles as $role) {
  22.     $acl->addRole($role);
  23. }

现在, 我们分别为每个区域定义资源. 控制器名称是资源它们的方法是对资源的访问:

  1. <?php
  3. use Phalcon\Acl\Resource;
  5. // ...
  7. // 私有区域资源 (后台)
  8. $privateResources = [
  9.     "companies"    => ["index", "search", "new", "edit", "save", "create", "delete"],
  10.     "products"     => ["index", "search", "new", "edit", "save", "create", "delete"],
  11.     "producttypes" => ["index", "search", "new", "edit", "save", "create", "delete"],
  12.     "invoices"     => ["index", "profile"],
  13. ];
  15. foreach ($privateResources as $resourceName => $actions) {
  16.     $acl->addResource(
  17.         new Resource($resourceName),
  18.         $actions
  19.     );
  20. }
  22. // 公共区域资源 (前台)
  23. $publicResources = [
  24.     "index"    => ["index"],
  25.     "about"    => ["index"],
  26.     "register" => ["index"],
  27.     "errors"   => ["show404", "show500"],
  28.     "session"  => ["index", "register", "start", "end"],
  29.     "contact"  => ["index", "send"],
  30. ];
  32. foreach ($publicResources as $resourceName => $actions) {
  33.     $acl->addResource(
  34.         new Resource($resourceName),
  35.         $actions
  36.     );
  37. }

ACL现在了解现有的控制器和它们相关的操作. 角色 “Users” 由权限访问前台和后台的所有资源. 角色 “Guests” 仅允许访问公共区域:

  1. <?php
  3. // 授权user和Grant访问公共区域
  4. foreach ($roles as $role) {
  5.     foreach ($publicResources as $resource => $actions) {
  6.         $acl->allow(
  7.             $role->getName(),
  8.             $resource,
  9.             "*"
  10.         );
  11.     }
  12. }
  14. // 授权仅角色Users 访问私有区域
  15. foreach ($privateResources as $resource => $actions) {
  16.     foreach ($actions as $action) {
  17.         $acl->allow(
  18.             "Users",
  19.             $resource,
  20.             $action
  21.         );
  22.     }
  23. }

万岁!, ACL现在终于完成了. 在下一章, 我们将会看到Phalcon中的CRUD是如何实现的并且你如何自定义它.