src/Security/Voter/ApiVoter.php line 11

Open in your IDE?
  1. <?php
  3. namespace App\Security\Voter;
  5. use Symfony\Component\Security\Core\Authentication\Token\TokenInterface;
  6. use Symfony\Component\Security\Core\Authorization\Voter\Voter;
  7. use Symfony\Component\Security\Core\User\UserInterface;
  8. use Sensio\Bundle\FrameworkExtraBundle\Configuration\IsGranted;
  9. use Symfony\Component\Security\Core\Security;
  11. class ApiVoter extends Voter
  12. {
  13.     private $security;
  14.     
  15.     public function __construct(Security $security)
  16.     {
  17.         $this->security = $security;
  18.     }
  19.     
  20.     protected function supports($attribute, $subject) : bool
  21.     {
  22.         if(in_array($attribute, ['API_PASS_THROUGH'])) {
  23.             return true;
  24.         }            
  25.         
  26.         return false;
  27.     }
  28.     
  29.     protected function voteOnAttribute($attribute, $subject, TokenInterface $token) : bool
  30.     {
  31.         $user = $token->getUser();
  32.         // if the user is anonymous, do not grant access
  33.         if (!$user instanceof UserInterface) {
  34.             return false;
  35.         }
  36.         
  37.         switch ($attribute) {
  38.             case 'API_PASS_THROUGH':
  39.                 if($this->_isCommandAllowed($subject)) {
  40.                     return $this->_isUserAllowed($subject, $user);
  41.                 }
  42.                 else {
  43.                     return false;
  44.                 }
  45.                 
  46.                 break;                    
  47.         }
  48.         
  49.         return false;
  50.     }
  51.     
  52.     private function _commandsAllowed()
  53.     {
  54.         $cmds = [];
  55.         $cmds[] = 'accountdt/'; // POST
  56.         $cmds[] = 'aliasdt/'; // POST
  57.         $cmds[] = 'account/check/'; // GET user/domain
  58.         $cmds[] = 'account/checkwithalias/'; // GET user/domain
  59.         $cmds[] = 'account/checkpasswordreq/'; // GET password
  60.         $cmds[] = 'account/get/'; // GET user/domain
  61.         $cmds[] = 'account/getinprogress/'; // GET user/domain
  62.         $cmds[] = 'account/getquota/'; // GET user/domain
  63.         $cmds[] = 'account/getroledomains/'; // GET user/domain
  64.         $cmds[] = 'account/list/'; // GET filter/filter_params
  65.         $cmds[] = 'account/isinprogress/'; // GET src/dest
  66.         $cmds[] = 'account/saveextparameters'; // POST
  67.         $cmds[] = 'account/getimapdircount/'; // GET user/domain/directory
  68.         $cmds[] = 'alias/get'; // GET src/dest
  69.         $cmds[] = 'alias/getinprogress/'; // GET src/dest
  70.         $cmds[] = 'alias/isinprogress/'; // GET src/dest
  71.         $cmds[] = 'domain/list'; // GET no params
  72.         $cmds[] = 'domain/getaliases'; // GET domain
  73.         $cmds[] = 'logs/dtprocess';
  74.         $cmds[] = 'logs/dtprocessmaster';
  75.         $cmds[] = 'charts/';
  76.         $cmds[] = 'login_msg/userdismissed';
  77.         
  78.         return $cmds;
  79.     }
  80.     
  81.     private function _isCommandAllowed($cmdData)
  82.     {
  83.         $cmd = $cmdData['command'];
  85.         foreach($this->_commandsAllowed() as $c) {
  86.             if(preg_match('/^' . str_replace('/', '\/', $c) . '/', $cmd)) {
  87.                 return true;
  88.             }
  89.         }
  90.         
  91.         return false;
  92.     }
  93.     
  94.     private function _isUserAllowed($cmdData, $user)
  95.     {
  96.         $cmd = $cmdData['command'];
  97.         
  98.         if(array_key_exists('data', $cmdData)) {
  99.             $data = $cmdData['data'];
  100.         }
  101.         else {
  102.             $data = null;
  103.         }
  104.         
  105.         $cmdParams = $this->_splitCmdParams($cmd);
  106.                     
  107.         if($this->security->isGranted('ROLE_ADMIN')) {
  108.             if($this->_checkAdminPerms($cmdParams[0], $cmdParams[1], $data, $user)) {
  109.                 return true;
  110.             }
  111.             // else - check permissions for postmaster and user
  112.         }
  113.         
  114.         if($this->security->isGranted('ROLE_POSTMASTER')) {
  115.             return $this->_checkPostmasterPerms($cmdParams[0], $cmdParams[1], $data, $user);
  116.         }
  117.         else {
  118.             if($this->security->isGranted('ROLE_POSTMASTER_MIN')) {
  119.                 return $this->_checkPostmasterMinPerms($cmdParams[0], $cmdParams[1], $data, $user);
  120.             }
  121.             else {
  122.                 if($this->security->isGranted('ROLE_GROUPMASTER')) {
  123.                     return $this->_checkGroupmasterPerms($cmdParams[0], $cmdParams[1], $data, $user);
  124.                 }
  125.                 else {
  126.                     if($this->security->isGranted('ROLE_USERMASTER')) {
  127.                         return $this->_checkUsermasterPerms($cmdParams[0], $cmdParams[1], $data, $user);
  128.                     }
  129.                     else {
  130.                         if($this->security->isGranted('ROLE_USER')) {
  131.                             return $this->_checkUserPerms($cmdParams[0], $cmdParams[1], $data, $user->getEmail());
  132.                         }
  133.                     }
  134.                 }
  135.             }
  136.         }
  138.         return false;
  139.     }
  140.     
  141.     // returns command itself in ret[0] and params in ret[1]
  142.     private function _splitCmdParams($cmd)
  143.     {
  144.         $exploded = explode('/', $cmd);
  145.         $ret = [];
  146.         $ret[0] = '';
  147.         $ret[1] = '';
  148.         
  149.         for($i = 0; $i < sizeof($exploded); $i++) {
  150.             if($i < 2) {
  151.                 $ret[0] = $ret[0] . '/' . $exploded[$i];
  152.             }
  153.             else {
  154.                 $ret[1] = $ret[1] . '/' . $exploded[$i];
  155.             } 
  156.         }
  157.         
  158.         $ret[0] = ltrim($ret[0], '/');
  159.         $ret[1] = ltrim($ret[1], '/');
  160.         return $ret;
  161.     }
  162.     
  163.     // checks if user is permitted to execute the command
  164.     private function _checkUserPerms($cmd, $params, $postData, $userEmail)
  165.     {
  166.         $userSlash = str_replace('@', '/', $userEmail);
  168.         if($cmd == 'account/checkpasswordreq') {
  169.             return true;
  170.         }
  171.         elseif($cmd == 'account/get') {
  172.             // get allowed only for its own account
  173.             if($userSlash == $params) {
  174.                 return true;
  175.             }
  176.             else {
  177.                 return false;
  178.             }
  179.         }
  180.         elseif($cmd == 'account/saveextparameters') {
  181.             if($postData['userName'] . '/' . $postData['userDomain'] == $userSlash) {
  182.                 return true;
  183.             }
  185.             return false;
  186.         }
  187.         elseif($cmd == 'account/getimapdircount') {
  188.             // demove dirname from parameters
  189.             $paramsArr = explode('/', $params);
  190.             
  191.             if(count($paramsArr) != 3) {
  192.                 return false;
  193.             }
  194.             
  195.             $userDomainFromCmd = $paramsArr[0] . '/' . $paramsArr[1];
  196.             
  197.             if($userSlash == $userDomainFromCmd) {
  198.                 return true;
  199.             }
  200.             else {
  201.                 return false;
  202.             }
  203.         }
  204.         elseif($cmd == 'login_msg/userdismissed') {
  205.             // demove msg_id from parameters
  206.             $paramsArr = explode('/', $params);
  207.             
  208.             if(count($paramsArr) != 3) {
  209.                 return false;
  210.             }
  211.             
  212.             $userDomainFromCmd = $paramsArr[0] . '/' . $paramsArr[1];
  213.             
  214.             if($userSlash == $userDomainFromCmd) {
  215.                 return true;
  216.             }
  217.             else {
  218.                 return false;
  219.             }
  220.         }
  221.         
  222.         
  223.         return false;
  224.     }
  225.     
  226.     // checks if postmaster is permitted to execute the command
  227.     private function _checkPostmasterPerms($cmd, $params, $postData, $user)
  228.     {
  229.         // check domain
  230.         switch($cmd) {
  231.             case 'account/check':
  232.             case 'account/checkwithalias':
  233.             case 'account/get':
  234.             case 'account/getinprogress':
  235.             case 'account/getquota':
  236.             case 'account/getroledomains':
  237.             case 'account/isinprogress':
  238.                 return $this->_checkDomain($params, $user->getDomains());
  239.                 
  240.             case 'account/getimapdircount':
  241.                 // in $params is also directory, give only user/domain
  242.                 return $this->_checkDomain(implode('/', array_slice(explode('/', $params), 0, 2)), $user->getDomains());
  244.             case 'account/checkpasswordreq':
  245.             case 'domain/list':
  246.                 return true;
  247.                 
  248.             case 'account/saveextparameters':
  249.                 return $this->_checkDomain($postData['userName'] . '/' . $postData['userDomain'], $user->getDomains());
  250.                 
  251.             case 'alias/get':
  252.             case 'alias/getinprogress':
  253.             case 'alias/isinprogress':
  254.                 $srcDest = explode('/', $params);
  255.                 return $this->_checkDomain(str_replace('@', '/', $srcDest[0]), $user->getDomains());
  256.                 
  257.             case 'logs/dtprocess':
  258.                 // only for current logged in user
  259.                 // in $params can be string filter/JSON_OBJECT
  260.                 
  261.                 $filterArr = explode('/', $params);
  262.                                 
  263.                 if(count($filterArr) < 2) {
  264.                     return false;
  265.                 }
  266.                 
  267.                 $filter = json_decode(urldecode($filterArr[1]));
  268.                                 
  269.                 if(!is_null($filter) && isset($filter->user)) {
  270.                     if($filter->user == $user->getEmail()) {
  271.                         return true;
  272.                     }
  273.                     else {
  274.                         return false;
  275.                     }
  276.                 }
  277.                 
  278.                 return false;
  279.                 
  280.             case 'logs/dtprocessmaster':
  281.                 return false;
  282.          
  283.             case 'account/list':
  284.             case 'accountdt/list':
  285.             case 'aliasdt/list':
  286.                 // domains may be in POST
  287.                 if(array_key_exists('filter', $postData)) {
  288.                     $filter = json_decode($postData['filter'], true);
  289.                     
  290.                     if(array_key_exists('domains', $filter)) {
  291.                         $domains = $filter['domains'];
  292.                     }
  293.                     else {
  294.                         $domains = $this->_getDomainsFromFilter($params);
  295.                     }
  297.                 }
  298.                 else {
  299.                     $domains = $this->_getDomainsFromFilter($params);
  300.                 }
  301.                 
  302.                 if(count($domains) == 0) {
  303.                     return false;
  304.                 }
  305.                 
  306.                 $userDomains = $user->getDomains();
  307.                 
  308.                 foreach($domains as $d) {
  309.                     if($this->_checkDomain('x/' . $d, $userDomains) == false) {
  310.                         return false;
  311.                     }
  312.                 }
  313.             
  314.                 return true;
  315.                 
  316.             default:
  317.                 return false;
  318.         }
  319.         
  320.         return false;
  321.     }
  323.     // checks if postmaster min is permitted to execute the command
  324.     private function _checkPostmasterMinPerms($cmd, $params, $postData, $user)
  325.     {
  326.         // check domain
  327.         switch($cmd) {
  328.             case 'account/check':
  329.             case 'account/checkwithalias':
  330.             case 'account/get':
  331.             case 'account/getinprogress':
  332.             case 'account/getquota':
  333.             case 'account/getroledomains':
  334.             case 'account/isinprogress':
  335.                 return $this->_checkDomain($params, $user->getDomains());
  336.                 
  337.             case 'account/getimapdircount':
  338.                 // in $params is also directory, give only user/domain
  339.                 return $this->_checkDomain(implode('/', array_slice(explode('/', $params), 0, 2)), $user->getDomains());
  341.             case 'account/checkpasswordreq':
  342.             case 'domain/list':
  343.                 return true;
  344.                                 
  345.             case 'alias/get':
  346.             case 'alias/getinprogress':
  347.             case 'alias/isinprogress':
  348.                 $srcDest = explode('/', $params);
  349.                 return $this->_checkDomain(str_replace('@', '/', $srcDest[0]), $user->getDomains());
  350.                 
  351.             case 'logs/dtprocess':
  352.                 // only for current logged in user
  353.                 // in $params can be string filter/JSON_OBJECT
  354.                 
  355.                 $filterArr = explode('/', $params);
  356.                                 
  357.                 if(count($filterArr) < 2) {
  358.                     return false;
  359.                 }
  360.                 
  361.                 $filter = json_decode(urldecode($filterArr[1]));
  362.                                 
  363.                 if(!is_null($filter) && isset($filter->user)) {
  364.                     if($filter->user == $user->getEmail()) {
  365.                         return true;
  366.                     }
  367.                     else {
  368.                         return false;
  369.                     }
  370.                 }
  371.                 
  372.                 return false;
  373.                 
  374.             case 'logs/dtprocessmaster':
  375.                 return false;
  376.          
  377.             case 'account/list':
  378.             case 'accountdt/list':
  379.             case 'aliasdt/list':
  380.                 // domains may be in POST
  381.                 if(array_key_exists('filter', $postData)) {
  382.                     $filter = json_decode($postData['filter'], true);
  383.                     
  384.                     if(array_key_exists('domains', $filter)) {
  385.                         $domains = $filter['domains'];
  386.                     }
  387.                     else {
  388.                         $domains = $this->_getDomainsFromFilter($params);
  389.                     }
  391.                 }
  392.                 else {
  393.                     $domains = $this->_getDomainsFromFilter($params);
  394.                 }
  395.                 
  396.                 if(count($domains) == 0) {
  397.                     return false;
  398.                 }
  399.                 
  400.                 $userDomains = $user->getDomains();
  401.                 
  402.                 foreach($domains as $d) {
  403.                     if($this->_checkDomain('x/' . $d, $userDomains) == false) {
  404.                         return false;
  405.                     }
  406.                 }
  407.             
  408.                 return true;
  409.                 
  410.             default:
  411.                 return false;
  412.         }
  413.         
  414.         return false;
  415.     }
  417.     // checks if groupmaster is permitted to execute the command
  418.     private function _checkGroupmasterPerms($cmd, $params, $postData, $user)
  419.     {
  420.         // check domain
  421.         switch($cmd) {
  422.             case 'account/check':
  423.             case 'account/checkwithalias':
  424.             case 'account/get':
  425.             case 'account/getinprogress':
  426.             case 'account/getquota':
  427.             case 'account/getroledomains':
  428.             case 'account/isinprogress':
  429.                 return $this->_checkDomain($params, $user->getDomains()) && $this->_checkAccount($params, $user->getAccounts());
  430.                 
  431.             case 'account/getimapdircount':
  432.                 // in $params is also directory, give only user/domain
  433.                 $cmdUserDomain = implode('/', array_slice(explode('/', $params), 0, 2));
  434.                 return $this->_checkDomain($cmdUserDomain, $user->getDomains()) && $this->_checkAccount($cmdUserDomain, $user->getAccounts());
  435.                 
  436.             case 'account/checkpasswordreq':
  437.             case 'domain/list':
  438.                 return true;
  439.                 
  440.             case 'account/saveextparameters':
  441.                 return $this->_checkDomain($postData['userName'] . '/' . $postData['userDomain'], $user->getDomains())
  442.                 && $this->_checkAccount($postData['userName'] . '/' . $postData['userDomain'], $user->getAccounts())
  443.                 ;
  444.                 
  445.             case 'alias/get':
  446.             case 'alias/getinprogress':
  447.             case 'alias/isinprogress':
  448.                 $srcDest = explode('/', $params);
  450.                 return $this->_checkDomain(str_replace('@', '/', $srcDest[1]), $user->getDomains())
  451.                 && $this->_checkAccount(str_replace('@', '/', $srcDest[1]), $user->getAccounts())
  452.                 ;
  453.                 
  454.             case 'logs/dtprocess':
  455.             case 'logs/dtprocessmaster':
  456.                 return false;
  457.                 
  458.             case 'account/list':
  459.             case 'accountdt/list':
  460.             case 'aliasdt/list':
  461.                 // don't allow without parameter "groupmaster"
  462.                 if($this->_getGroupmasterFromFilter($params) == "") {
  463.                     return false;
  464.                 }
  465.                 
  466.                 $domains = $this->_getDomainsFromFilter($params);
  467.                 
  468.                 if(count($domains) == 0) {
  469.                     return false;
  470.                 }
  471.                 
  472.                 $userDomains = $user->getDomains();
  473.                 
  474.                 foreach($domains as $d) {
  475.                     if($this->_checkDomain('x/' . $d, $userDomains) == false) {
  476.                         return false;
  477.                     }
  478.                 }
  480.                 return true;
  481.                 
  482.             default:
  483.                 return false;
  484.         }
  485.         
  486.         return false;
  487.     }
  488.     
  489.     // checks if usermaster is permitted to execute the command
  490.     private function _checkUsermasterPerms($cmd, $params, $postData, $user)
  491.     {
  492.         // check domain
  493.         switch($cmd) {
  494.             case 'account/check':
  495.             case 'account/checkwithalias':
  496.             case 'account/get':
  497.             case 'account/getinprogress':
  498.             case 'account/getquota':
  499.             case 'account/getroledomains':
  500.             case 'account/isinprogress':
  501.                 return $this->_checkDomain($params, $user->getDomains()) && $this->_checkAccount($params, $user->getAccounts());
  502.                 
  503.             /*case 'domain/list':
  504.                 return true;*/
  505.                 
  506.                 
  507.             case 'account/list':
  508.             case 'accountdt/list':
  509.                 // don't allow without parameter "groupmaster"
  510.                 if($this->_getGroupmasterFromFilter($params) == "") {
  511.                     return false;
  512.                 }
  513.                 
  514.                 $domains = $this->_getDomainsFromFilter($params);
  515.                 
  516.                 if(count($domains) == 0) {
  517.                     return false;
  518.                 }
  519.                 
  520.                 $userDomains = $user->getDomains();
  521.                 
  522.                 foreach($domains as $d) {
  523.                     if($this->_checkDomain('x/' . $d, $userDomains) == false) {
  524.                         return false;
  525.                     }
  526.                 }
  527.                 
  528.                 return true;
  529.                 
  530.             default:
  531.                 return false;
  532.         }
  533.         
  534.         return false;
  535.     }
  536.     // checks if admin is permitted to execute the command
  537.     // (commands specific to admins, if returns false check also postmaster permissions)
  538.     private function _checkAdminPerms($cmd, $params, $postData, $user)
  539.     {
  540.         // check command
  541.         switch($cmd) {
  542.             case 'accountdt/rolestableall':
  543.             case 'accountdt/rolestableselected':
  544.             case 'accountdt/rolestoselected':
  545.             case 'accountdt/rolesfromselected':
  546.             case 'accountdt/list':
  547.             case 'account/list':
  548.             case 'aliasdt/list':
  549.             case 'domain/getaliases':
  550.             case 'logs/dtprocess':
  551.             case 'logs/dtprocessmaster':
  552.             case 'charts/loadavg':
  553.             case 'charts/freemem':
  554.             case 'charts/usedmem':
  555.             case 'charts/diskstats':
  556.             case 'charts/mailqueue':
  557.             case 'charts/connections':
  558.                 return true;
  559.             default:
  560.                 return false;
  561.         }
  562.         
  563.         return false;
  564.     }
  565.     
  566.     // checks if domain from $userAndDomain matches any domain from $domains 
  567.     private function _checkDomain($userAndDomain, $domains)
  568.     {
  569.         $arr = explode('/', $userAndDomain);
  570.         
  571.         if(sizeof($arr) != 2) {
  572.             return false;
  573.         }
  574.         
  575.         foreach($domains as $d) {
  576.             if($arr[1] == $d) {
  577.                 return true;
  578.             }
  579.         }
  580.         
  581.         return false;
  582.     }
  583.     
  584.     // checks if $userAndDomain matches user from $accounts
  585.     private function _checkAccount($userAndDomain, $accounts)
  586.     {
  587.         $arr = explode('/', $userAndDomain);
  588.         
  589.         if(sizeof($arr) != 2) {
  590.             return false;
  591.         }
  592.         
  593.         $user = implode('@', $arr);
  594.         
  595.         foreach($accounts as $a) {
  596.             if($user == $a) {
  597.                 return true;
  598.             }
  599.         }
  600.         
  601.         return false;
  602.     }
  604.     // returns array of domains got from $params
  605.     private function _getDomainsFromFilter($params) : array
  606.     {
  607.         if(substr_count($params, 'filter/') == 0) {
  608.             return [];
  609.         }
  610.         
  611.         $paramsArr = explode('/', $params);
  612.         
  613.         for($i = 0; $i < count($paramsArr); $i++) {
  614.             if($paramsArr[$i] == 'filter') {
  615.                 $js = json_decode(urldecode($paramsArr[$i+1]));
  616.                 
  617.                 if($js == null) {
  618.                     return [];
  619.                 }
  620.                 
  621.                 if(!property_exists($js, "domains")) {
  622.                     return [];
  623.                 }
  624.                 
  625.                 return $js->domains;
  626.             }
  627.         }
  628.         
  629.         return [];
  630.     }
  631.     
  632.     // returns groupmaster from $params (or empty string if none)
  633.     private function _getGroupmasterFromFilter($params) : string
  634.     {
  635.         if(substr_count($params, 'filter/') == 0) {
  636.             return "";
  637.         }
  638.         
  639.         $paramsArr = explode('/', urldecode($params));
  640.         
  641.         for($i = 0; $i < count($paramsArr); $i++) {
  642.             if($paramsArr[$i] == 'filter') {
  643.                 
  644.                 $js = json_decode(urldecode($paramsArr[$i+1]));
  645.                 
  646.                 if($js == null) {
  647.                     return "";
  648.                 }
  649.                 
  650.                 if(!property_exists($js, "groupmaster")) {
  651.                     return "";
  652.                 }
  654.                 return $js->groupmaster;
  655.             }
  656.         }
  657.         
  658.         return "";
  659.     }
  660.     
  661. }